[{"title":"Column Transformer","date":"Jan 1, 2022","slug":"column-transformer","excerpt":"Implement custom feature engineering code as a `scikit-learn` column transformer.","tags":["snippet","python","data science"],"status":"published","content":"

This is an example of implementing a custom feature engineer as a scikit-learn column transformer object.

# modeling/feature_engineering.py\nimport pandas as pd\n

# tests/modeling/test_feature_engineering.py\nimport unittest\nimport pandas as pd\n

"},{"title":"Python Container Classes","date":"Jan 1, 2022","slug":"python-container-classes","excerpt":"Several methods of creating a data container class in Python.","tags":["snippet","python"],"status":"published","content":"

I often want to create objects that hold several related pieces of data together in the same place - like a Book object that has an author, title, etc. Python offers several methods to do this, but it's not always clear which one to use. I'll show different patterns that I use and discuss the advantages and disadvantages of each.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Name	Description
Vanilla Class)	A plain Python class
Dictionary	A plain Python dictionary
(Typed) Dictionary	A Python dictionary with typed fields
Simple Namespace	A Python namespace object
NamedTuple	A tuple with names, from the `collections` module
Dataclass	A container class from the `dataclasses` module
`attrs` Class	The only non-standard-library solution, from the `attrs` library

Vanilla Class

class Book:\n    \"\"\"Container class for a Book and its attributes.\"\"\"\n\n    def __init__(\n        self,\n        author: str,\n        title: str,\n        publication_year: int,\n        isbn_10: Optional[str],\n        isbn_13: Optional[str],\n    ) -> None:\n        self.author = author\n        self.title = title\n        self.publication_year = publication_year\n        self.isbn_10 = isbn_10\n        self.isbn_13 = isbn_13\n\nbrothers_karamazov = Book(\n    author=\"Fyodor Dostoevsky\",\n    title=\"The Brothers Karamazov\",\n    publication_year=1880,\n    isbn_10=\"0374528373\",\n    isbn_13=\"978-0374528379\",\n)\n

(Typed) Dictionary

from typing import TypedDict\n\nclass Book(TypedDict):\n    \"\"\"Typed dictionary structure for a book object.\"\"\"\n\n    author: str\n    title: str\n    publication_year: int\n    isbn_10: Optional[str]\n    isbn_13: Optional[str]\n\nbrothers_karamazov: Book = {\n    \"author\": \"Fyodor Dostoevsky\",\n    \"title\": \"The Brothers Karamazov\",\n    \"publication_year\": 1880,\n    \"isbn_10\": \"0374528373\",\n    \"isbn_13\": \"978-0374528379\",\n}\n

SimpleNamespace

NamedTuple

from typing import NamedTuple\n\nclass Book(NamedTuple):\n    \"\"\"Container class for a Book and its attributes.\"\"\"\n\n    author: str\n    title: str\n    publication_year: int\n    isbn_10: Optional[str]\n    isbn_13: Optional[str]\n

Dataclass

from dataclasses import dataclass\n\n@dataclass\nclass Book:\n    \"\"\"Container class for a Book and its attributes.\"\"\"\n\n    author: str\n    title: str\n    publication_year: int\n    isbn_10: Optional[str]\n    isbn_13: Optional[str]\n

"},{"title":"Unit Testing in Data Science","date":"Dec 26, 2021","slug":"data-science-unit-tests","excerpt":"I've written before about how unit tests lead to better code. Some data scientists may not understand how or why unit testing should be used in their work. I'll outline steps you can take to incorporate unit testing into your data science projects and the key benefits you will get as a result.","tags":[],"status":"published","content":"

I've written before about how unit tests lead to better code. Some data scientists may not understand how or why unit testing should be used in their work. I'll outline steps you can take to incorporate unit testing into your data science projects and the key benefits you will get as a result.

If you're unfamiliar with unit testing and would prefer to see a concrete example first, read my earlier post, Unit Testing Basics before moving on.

Recap - three benefits of unit testing

In my prior post I outlined three reasons why unit tests are so valuable when writing software. Here are those reasons again.

They increase the likelihood that your functions do what you expect them to do.
They provide examples that help others understand what your functions do.
They serve as future-proof documentation for your code.

Unit Testing for Data Scientists

Now, suppose you are convinced of the benefits of unit testing. How can you apply this to your next data science project? Maybe you have messy data you need to clean, notebooks full of exploratory data analysis, several iterations of machine learning models, model scoring tools, and visualizations. Where should you start?

I recommend starting with data cleaning. This is an activity that has the most to gain and the clearest application of unit tests that I wrote about above. Whenever I start working with new data, I follow this process. It is a slightly relaxed version of test-driven-development.

Create a new .py module to store data cleaning functions, such as cleaning.py
Create a new .py module to store tests for your cleaning functions, such as test_cleaning.py.
Identify a data cleaning function you think you might need.
Gather a small sample of the input data that captures its original state, quirks, oddities, etc.
Manually transform the small sample data into the clean data you want.
Think about the data cleaning function you wish you had. Define the function, including its arguments, in your main file, but don't write the implementation yet.
Write a test for your new data cleaning function. The test should prove that this function takes the messy data from step (4) and turns it into the clean data from step (5).
Run your test suite. You should see that your newly-defined function fails. (That's ok! You haven't implemented it yet.) This step is important because it shows that your test is working.
Go back to your function definition and implement the data cleaning logic.
Run your test suite. If it passes, continue. If it fails, go back to step (9).
Consider writing more tests for your function, especially if it's complicated or has strange edge cases.
Repeat from step (3) until you have cleaned the entire dataset.

Example

Let's walk through an example for a single data cleaning function step by step. Suppose I am working with transactional data in a pandas DataFrame. I first create a file called cleaning.py and then another file called test_cleaning.py.

I notice that the data has a transaction_date column. It appears to be a string, with a timestamp down to the microsecond. However, every timestamp has TT appended to it. I check with a colleague and we confirm that this is an artifact of the original source system and it's safe to ignore. I also check the entire column and confirm every row has the same format and has the TT suffix.

2021.11.01.20:45:32.425364TT\n2021.11.02.14:18:36.874524TT\n2021.11.03.08:56:44.966523TT\n2021.11.03.09:28:11.113297TT\n

I would rather work with a Series of datetimes instead of strings, so I've identified a useful cleaning function. I convert the sample rows above into the datetime objects I know I'll want at the end.

datetime(2021, 11, 1, 20, 45, 32, 425364)\ndatetime(2021, 11, 2, 14, 18, 36, 874524)\ndatetime(2021, 11, 3, 8, 56, 44, 966523)\ndatetime(2021, 11, 3, 9, 28, 11, 113297)\n

Now I know what I want my cleaning function to do, and what the data inputs and outputs should be. I open cleaning.py and start writing the function name and some documentation, without worrying about writing the actual implementation yet.

# cleaning.py\nimport pandas as pd\n\n\ndef parse_dates(vals: pd.Series) -> pd.Series:\n    \"\"\"\n    Parse the `transaction_date` field, a Series of string values, into dates.\n\n    The data format for this column is YYYY.MM.DD.HH:MM:SS.ffffffTT, where the\n    'TT' at the end of the datetime is inconsequential. It's not needed, so we\n    remove it before using the pandas `to_datetime` function to parse the date.\n\n    Parameters\n    ----------\n    vals : pd.Series, a series of string dates with the given format.\n\n    Returns\n    -------\n    parsed : pd.Series, a series of pandas datetime objects.\n    \"\"\"\n    return vals\n

This function doesn't do much right now - it just returns my original data. But it has a good name, useful documentation, like my discovery about the TT suffix. Next, I'll write the test for my new function. All I need to do is copy my input and output data into a new test function in test_cleaning.py.

# test_cleaning.py\nfrom datetime import datetime\nimport unittest\nimport pandas as pd\n\nfrom cleaning import parse_dates\n\n\nclass TestCleaning(unittest.TestCase):\n    \"\"\"Test cleaning functions.\"\"\"\n\n    def test_parse_dates(self):\n        \"\"\"Test parsing string dates.\"\"\"\n        raw_data = pd.Series([\n            \"2021.11.01.20:45:32.425364TT\",\n            \"2021.11.02.14:18:36.874524TT\",\n            \"2021.11.03.08:56:44.966523TT\",\n            \"2021.11.03.09:28:11.113297TT\",\n        ])\n        expected = pd.Series([\n            datetime(2021, 11, 1, 20, 45, 32, 425364),\n            datetime(2021, 11, 2, 14, 18, 36, 874524),\n            datetime(2021, 11, 3, 8, 56, 44, 966523),\n            datetime(2021, 11, 3, 9, 28, 11, 113297),\n        ])\n        self.assertIsNone(pd.testing_assert_series_equal(actual, expected))\n

When I run python3 -m unittest test_cleaning.py, I see a failure. My function isn't doing what I want it to yet, but that was expected. Now that I've verified my test is failing, I need to finish writing my function. In this case, I can use the pandas string slicer and to_datetime function to handle the data conversion. I update the return value of my function to the following.

    return pd.to_datetime(vals.str[:-2], \"%Y.%m.%d.%H:%M:%S:%f\")\n

Now when I run the test suite I see my test is passing! It looks like my function is doing exactly what I want it to. For now, I'm satisfied with my work on this aspect of the data, and move on to the next messy column in my data and start the process over again.

\nIn reality, dates and times can be exceptionally tricky. You might want to write several unit tests to handle different edge cases and quirks. Some questions you should consider (and then write tests to encode your answers):\n
\n
How does this source handle daylight saving time?
\n
From what timezone is the original data? Do I want it to be localized, or UTC?
\n
If the data measures regular intervals, is it ok to have gaps or missing data?
\n
The list goes on...
\n
\n

Takeaways

Let's revisit the three benefits of unit testing in the context of this example.

They increase the likelihood that your functions do what you expect them to do. By writing a unit test for our sample data, we have much higher confidence that our code is doing what we expect. Even though we used sample data rather than the entire dataset (which is often impractical or impossible), we verified that we parsed the expected data format correctly.

They provide examples that help others understand what your functions do. I love seeing tests from the data scientists on my team. I can see from the tests what types of issues they are solving in the data with clear, short examples of before and after. Furthermore, it helps break down the data cleaning process into a series of small, logical, repeatable steps that are easy for others to use.

They serve as future-proof documentation for your code. This is one of my favorite hidden benefits of unit testing. Remember that conversation I had with my colleague about the TT suffix? I can clearly see from the unit test that the TT part of the string shouldn't be included in the final, clean data. The unit test by itself is not sufficient documentation - for example, it doesn't explain why we made this choice - but anyone reading our code knows that it's intentional to parse the strings this way. In this case I highly recommend adding comments to the code or a sentence in the function docstring to provide more detail.

I mentioned before that data cleaning functions can be a great starting point for writing unit tests in your data science code. In future posts, I'll discuss other testing techniques for the latter parts of a data science project, which will be part of an overall series on how to approach data science like a software engineer.

"},{"title":"Unit Testing Basics","date":"Dec 23, 2021","slug":"unit-testing-basics","excerpt":"Unit tests are a critical part of quality code. However, it's not always clear how or what you should be testing in your code. I'll walk through a unit testing example, then outline three reasons why I think unit testing will improve your code.","tags":[],"status":"published","content":"

Unit tests are a critical part of quality code. However, it's not always clear how or what you should be testing in your code. I'll walk through a unit testing example, then outline three reasons why unit testing will improve your code.

First, let's define a unit test. A unit test is a piece of code whose purpose is to verify whether or not another piece of code is doing its job correctly - hence the name \"test\". The \"unit\" part of \"unit test\" means that we should strive to test the smallest component we possibly can.

Unit Testing Example

In this post, we'll start with a sample function that we want to test. We'll create a file called string_things.py and write a function that returns a list of lowercase letters from a string.

# string_things.py\nfrom typing import List\n\ndef get_lowercase_letters(val: str) -> List[str]:\n    \"\"\"Return a list of lowercase letters from an input string.\"\"\"\n    return [x for x in val if x.lower() == x]\n

If I provide the string \"aBcDe\" I expect to get [\"a\", \"c\", \"e\"]. In fact, this is exactly what I need to write my first unit test. Python has several ways of writing unit tests, but let's use the standard library's unittest package for this example. In a separate file, test_string_things.py, we'll create a test class and a single test function with the example we just described.

# test_string_things.py\nimport unittest\nfrom string_things import get_lowercase_letters\n\nclass TestStringThings(unittest.TestCase):\n    \"\"\"Test the functions from the string_things module.\"\"\"\n\n    def test_get_lowercase_letters(self):\n        \"\"\"Test an example of extracting lowercase letters from a string.\"\"\"\n        actual = get_lowercase_letters(\"aBcDe\")\n        expected = [\"a\", \"c\", \"e\"]\n        self.assertEqual(actual, expected)\n

Now in a terminal we can run

> python3 -m unittest test_string_things.py\n

And we should see the following output.

.\n----------------------------------------------------------------------\nRan 1 test in 0.000s\n\nOK\n

Everything looks great! Our function passed the unit test by successfully matching the result we expected.

On the other hand, this example wasn't very complicated, because the input string only contained a few letters. How would our function respond if a user passed a string with numbers, spaces, or characters like & or #? What if the user passed an empty string, or didn't pass a string at all? The advantage of unit tests is that we can write as many as we want, and each test can verify the behavior of our original function under various corner cases.

Let's expand our test suite by writing another test that defines what should happen if the user passes a string that contains numbers. My original intent was that only the lowercase letters \"a-z\" should be included in the output: the function should ignore numbers. Therefore if I pass the string \"123aBc456\", I expect the function to return [\"a\", \"c\"].

# test_string_things.py\nimport unittest\nfrom string_things import get_lowercase_letters\n\nclass TestStringThings(unittest.TestCase):\n    \"\"\"Test the functions from the string_things module.\"\"\"\n\n    def test_get_lowercase_letters(self):\n        \"\"\"Test an example of extracting lowercase letters from a string.\"\"\"\n        actual = get_lowercase_letters(\"aBcDe\")\n        expected = [\"a\", \"c\", \"e\"]\n        self.assertEqual(actual, expected)\n\n    def test_get_lowercase_letters_with_numbers(self):\n        \"\"\"Test that we ignore numbers when extracting letters from a string.\"\"\"\n        actual = get_lowercase_letters(\"123aBc456\")\n        expected = [\"a\", \"c\"]\n        self.assertEqual(actual, expected)\n

Now, running the test file as before, we see this output:

.F\n======================================================================\nFAIL: test_get_lowercase_letters_with_numbers (test_string_things.TestStringThings)\nTest ignoring numbers when extracting letters from a string.\n----------------------------------------------------------------------\nTraceback (most recent call last):\n  File \"test_string_things.py\", line 19, in test_get_lowercase_letters_with_numbers\n    self.assertEqual(actual, expected)\nAssertionError: Lists differ: ['1', '2', '3', 'a', 'c', '4', '5', '6'] != ['a', 'c']\n\nFirst differing element 0:\n'1'\n'a'\n\nFirst list contains 6 additional elements.\nFirst extra element 2:\n'3'\n\n- ['1', '2', '3', 'a', 'c', '4', '5', '6']\n+ ['a', 'c']\n\n----------------------------------------------------------------------\nRan 2 tests in 0.000s\n\nFAILED (failures=1)\n

It turns out that our original function doesn't handle numbers the way we thought. (Why? \"1\".lower() == \"1\", so \"1\" gets included in the output list.) For reference, here is the function I intended to write.

# string_things.py\nfrom string import ascii_lowercase\nfrom typing import List\n\ndef get_lowercase_letters(val: str) -> List[str]:\n    \"\"\"Return a list of lowercase ascii letters from an input string.\"\"\"\n    return [x for x in val if x in ascii_lowercase]\n

I view each unit test failure as a win - it's an opportunity to better align our code with the expectations we have for it. (Of course, that still means we have to fix our failing tests!) Before, it was ambiguous how the original function should handle numbers. By writing several unit tests, we were able to identify a discrepancy between our expectations and reality, and we could improve our code by clarifying our original intent and rewriting our function.

Even though this is a simple example, I think it does a good job of illustrating the process that most software developers go through as they write code. And for me it highlights three reasons why unit tests are critical in writing quality software.

Why use unit tests?

By now, it should be somewhat obvious why we would want to use unit tests when we're writing code: they help make sure our code does what we want it to do! But unit tests do much more than that. Here are three reasons why unit tests lead to better code. I'll elaborate on each point below.

They increase the likelihood that your functions do what you expect them to do.
They provide examples that help others understand what your functions do.
They serve as future-proof documentation for your code.

They increase the likelihood that your functions do what you expect them to do. The example above showed how unit tests helped us identify a discrepancy between our expectations for the code: numbers should be ignored, and the reality: numbers were included.

They provide examples that help others understand what your functions do. When I look at someone else's code, I love seeing extensive tests. Of course it gives me greater confidence in the reliability of the code, but it also has another benefit. I often use tests to quickly understand how the functions work. Just like showing is better than telling, sometimes seeing an example of a function in action is the fastest way to understand how it works. The docstring of our function above said \"\"\"Return a list of lowercase letters from an input string.\"\"\". In this case, that's pretty helpful, but it's also nice to look at the tests and see: \"aBcDe\" becomes [\"a\", \"c\", \"e\"]. In this sense, your tests help provide more clues about how your code works, which helps other people get up to speed faster.

They serve as future-proof documentation for your code. Documentation is great. There's rarely enough of it, but even the best documentation can become obsolete. Function docstrings and code comments, however helpful, don't actually code while it's running. It's possible for code to execute instructions totally different than what the docstring promises. This is why unit tests are some of the best documentation. Unit tests provide a contract that guarantees the behavior of your functions, because they always test the latest version of your code. When I see a unit test that says \"aBcDe\" becomes [\"a\", \"c\", \"e\"] I know for a fact that the function must have that behavior, even if the function's documentation is slightly out of date.

Key Takeaways

In my experience, unit tests are one of the most valuable tools for writing quality code in the software engineering arsenal. Even though writing tests takes a bit more time - after all, you end up writing quite a bit more code, I've found that I can iterate on my existing code much faster if I have a comprehensive unit testing suite. For example, I can make changes more confidently to small chunks of existing code while ensuring I don't change parts of the logic I didn't intend to. I hope this post gave you some concrete steps to apply unit testing to your next software project!

"},{"title":"Riddler Lingo","date":"Jan 29, 2021","slug":"riddler-lingo","excerpt":"It's the 256th edition of the Riddler, and though I've taken many weekends off to spend time with my newborn, I became obsessed with this week's puzzle! We're asked to play the word guessing game from Lingo, a game show. It reminds me of another one of my favorite Riddlers where we identify the best strategy for playing the math game from Countdown, another game show. The puzzle is extremely challenging, and I couldn't find an exact solution. Instead, I used Python to implement the game engine, and used some heuristics to choose words that resulted in a high score.","tags":[],"status":"published","content":"

Introduction

It's the 256th edition of the Riddler, and though I've taken many weekends off to spend time with my newborn, I became obsessed with this week's puzzle! We're asked to play the word guessing game from Lingo, a game show. It reminds me of another one of my favorite Riddlers where we identify the best strategy for playing the math game from Countdown, another game show. The puzzle is extremely challenging, and I couldn't find an exact solution. Instead, I used Python to implement the game engine, and used some heuristics to choose words that resulted in a high score.

\nYou are a contestant on the game show Lingo, where your objective is to determine a five-letter mystery word. You are told this word’s first letter, after which you have five attempts to guess the word. You can guess any five-letter word, even one that has a different first letter. After each of your guesses, you are told which letters of your guess are also in the mystery word and whether any of the letters are in the correct position.\n
As a contestant, your plan is to make a mockery of the game show by adopting a bold strategy: No matter what, before you are even told what the first letter of the mystery word is, you have decided what your first four guesses will be. Then, with your fifth guess, you will use the results of your first four guesses (and your encyclopedic knowledge of five-letter words!) to determine all remaining possibilities for the mystery word. If multiple mystery words are still possible, you will pick one of these at random.
\n
Which four five-letter words would you choose to maximize your chances of victory? Assume that the mystery word is selected randomly from this word list, which is also the list your guesses must be chosen from.
\n
Extra credit: For the four five-letter words you chose, what are your chances of victory?
\n

Note: the word pool for this puzzle contains 8636 words. A brute force solution to this puzzle would need to test all combinations of four words. This would mean testing

8636\\times8635\\times8634\\times8633=5,558,386,740,958,920

combinations. That's 5 quadrillion! If each combination took 1 second to test, we'd need to wait around for 176 million years. So... we'll have to try something different!

Solution

I couldn't find a perfect solution this week, so instead I developed some heuristics for choosing words until I was able to get a score that seemed good. Ultimately, I landed on these four words:

hater, funds, pigmy, block

With these four words, I was able to achieve a 94.7% win rate.

This strategy guesses perfectly for 7803 of the 8636 total words. When we can't guess the secret word exactly, we have to guess randomly from the possible secret words we've narrowed it down to.

You might notice something interesting about these four words: out of the 20 letters total, there are no repeats. This is one of the key components for the strategy. Here are some of the things I considered to arrive at these four words.

Choose as many unique letters as possible in your four guesses. Unique letters tell you the most about what is included in the secret word. If you can identify all 5 letters in the secret word, even out of order, it can reduce the possibilities significantly.
Guess letters that appear the most in the word pool. My guesses skipped over j, q, v, w, x, z because they are rarer than other letters.
Try to guess letters where they most often appear. For example, if a word has the letter a, if most often appears in the second position, like in the word tacit.

None of these rules may seem surprising. There are a few more things that I considered, but it's hard to tell exactly how these should factor into your guesses.

We are given the first letter of the secret word. I interpret this to mean that rule 3 above becomes less important for the first letter. For example, many words start with s, but many words also end with s. Each guess should try to get us as much new information as possible. If the word started with the letter s, we would know from the beginning, so it's more valuable to try to learn whether the word ends with s instead.
Try not to guess combinations of letters that logically follow from other things you know. For example, consider guessing the word thing. We are guessing that the secret word ends in the letter g. But if the secret word ends in the letter g, then it's very likely the second-to-last letter will be an n, and also likely the third-to-last letter will be i. (In fact, there are 88 words that end with the letter g, and 63 of those words also end in ng. 34 of them end in ing!) By guessing ing at the end of the word, we're duplicating what we could learn about the secret word. Instead, to learn as much as possible I think it makes more sense to guess irregular letter combinations, like bourg, which gets us the g ending but also adds a valuable r in the mix.
Try LOTS of combinations/anagrams of words :) There's probably a few small improvements I could make to these four words by jittering letters here and there.

Methodology

I relied heavily on the computer to determine my four guesses. As I wrote above, a brute force solution is infeasible, so we'll have to rely on a hybrid approach, with code and intelligent guessing (fitting, for a puzzle about guessing words!)

First, I wrote a game engine in Python that plays the game. Given a secret word and a guess, the engine identifies the correct letters, the misplaced letters, letters than must be included in the secret word, and letters that must be excluded in the secret word. Later, the program returns a set of words that match all the criteria. Ultimately, if this list is narrowed down to a single word, then we know we can guess the secret word exactly.

For example, you write the following to show the facts you learn after guessing a single word.

# example from the puzzle description\ncorrect_letters(target=\"misos\", guess=\"mosso\")\n# ('m', '', 's', '', '')\n# first and third letters of our guess are correct\n\nmisplaced_letters(target=\"misos\", guess=\"mosso\")\n# ('', 'o', '', 's', '')\n# second and fourth letters are in the secret word, but not in those positions\n\nincluded_letters(target=\"misos\", guess=\"mosso\")\n# ('m', 'o', 'ss')\n# this means the target word must have one `m`, one `o` and two `s`\n\nexcluded_letters(target=\"misos\", guess=\"mosso\")\n# ('oo', )\n# this means the target word cannot contain two 'o'\n

Then the game is played using a function called solutions. This function returns all the words that your guesses still permit. If there is only one word returned, then you know the secret word with certainty.

words = get_words()  # get the list of 8636 5-letter words\n\n# arguments are target word, any number of guesses, then a word list.\nsolutions(\"misos\", \"mosso\", words=words)\n# {'misos'}\n# in this case, just guessing \"mosso\" was enough to solve the puzzle!\n\nsolutions(\"tacos\", \"teach\", words=words)\n# {'tacit', 'tacks', 'tacky', 'tacos', 'tacts', 'taroc', 'tical', 'triac'}\n# in this case, guessing \"teach\" narrows down the search to 8 potential words\n

You can also write code to check how your four guesses perform on the entire word list. This is how I calculated the 94% accuracy and 7697 guaranteed correct guesses. Unfortunately, running through the entire word list takes ~15 seconds. (Work for the future!)

words = get_words()  # get the list of 8636 5-letter words\n\n# return a dictionary of all secret words and the list we narrow down to\nresults = {\n    word: solutions(word, \"hater\", \"funds\", \"pigmy\", \"block\" words=words)\n    for word in words\n}\n\n# how many can we guess correctly?\ncorrect = sum(len(v) == 1 for v in results.values())\n# 7803\n\n# what is our accuracy? If there are multiple candidates, we guess randomly\naccuracy = sum(1 / len(v) for v in results.values()) / len(words)\n# 0.94719777\n\n# what word was the hardest to guess?\nstumper = max(results, key=lambda x: len(results[x]))\nresults[stumper]\n# {'codec', 'coded', 'codex', 'coved', 'cowed', 'coxed'}\n# any of these secret words can only be narrowed down to six alternatives\n

As for coming up with my words, I did a fair bit of data analysis:

Check for the most common letters overall
Check for the most common letters per position (first, second, ... fifth)
Use gibberish words to try to get a possible upper limit for the answer
Try to form valid words from the letters I want to use
Iterate... try new anagrams hoping for small improvements

Step 3 was interesting. I knew I wanted to use the 20 most common letters, and I was curious how good my score would be if I could guess any letter in any position. Here was the best solution I came up with:

results = {\n    word: solutions(word, \"tares\", \"vbopd\", \"ynikl\", \"gmuch\", words=words)\n    for word in words\n}\n# accuracy: 0.94789\n# n_correct: 7803\n

Without any real sense of the maximum possible score, I felt like this was a good benchmark to try to hit. After all, coming up with real words that contained exactly one of those letters, and to try to get the right letters in the right spots, was not easy!

As it happens, with my four real words, I was able to exactly match the number of secrets guessed exactly (7803), but my accuracy is just a few basis points shy, likely because of a few shorter lists when we had to guess.

This puzzle captivated me over the weekend! Writing the code and coming up with the guess words were both incredibly fun - and totally different - challenges. Great hallmarks of a wonderful puzzle. Now the question is whether my skills might translate to playing on the show itself!

Full Code

I'm sure there are some efficiencies to be gained here. It currently takes ~15 seconds to check a set of guesses against every secret word in the dictionary, so iterating on new guessing ideas is very time consuming. Fortunately, playing the game for fun with single words works great! You can run a single secret word with guesses in a few milliseconds, so you can use this code to play with your friends!

Future work I might like to tackle someday:

create better data structures for some of the repeated tasks (e.g. matching words by the first letter, sorting letters in a word, etc.)
Try to map the underlying words more intelligently, identifying some of the correlated information embedded in the words, like pairs of letters that always go together. Try to fine tune the guess words not to waste time searching highly correlated spaces.

\"\"\"\nThis module solves the Riddler Classic from January 29, 2020\nhttps://fivethirtyeight.com/features/can-you-guess-the-mystery-word/\n\"\"\"\nfrom itertools import groupby\nfrom urllib.request import urlopen\nfrom typing import Iterable, Optional, Set, Tuple\n\n\n# container for tuple of letters with the same length as the target word\nLetters = Tuple[str, ...]\n\n\ndef get_words(length: int = 5) -> Set[str]:\n    \"\"\"Return a set of n-letter words from a large word list hosted online.\"\"\"\n    response = urlopen(\"https://norvig.com/ngrams/enable1.txt\")\n    words = response.read().decode(\"utf-8\").split(\"\\n\")\n    return set(word.lower() for word in words if len(word) == length)\n\n\ndef correct_letters(target: str, guess: Optional[str] = None) -> Letters:\n    \"\"\"\n    Return a tuple identifying which letters in the target were correctly guessed.\n\n    Examples\n    --------\n    >>> correct_letters(\"tacos\")\n    ('', '', '', '', '')\n    >>> correct_letters(\"tacos\", \"tails\")\n    ('t', 'a', '', '', 's')\n    >>> correct_letters(\"misos\", \"mosso\")\n    ('m', '', 's', '', '')\n    >>> correct_letters(\"misos\", \"sassy\")\n    ('', '', 's', '', '')\n    \"\"\"\n    if guess is None:\n        return tuple('' for _ in target)\n    return tuple(t if t == g else '' for t, g in zip(target, guess))\n\n\ndef misplaced_letters(target: str, guess: Optional[str] = None) -> Letters:\n    \"\"\"\n    Return a tuple identifying which letters are present, but misplaced, in the target.\n\n    When identifying misplaced letters, we only consider the first instance of a letter\n    in the target. For example, with target 'misos' and guess 'mosso', the first 'o' in\n    the guess is identified as a misplaced letter, but the second 'o' is ignored.\n\n    Examples\n    --------\n    >>> misplaced_letters(\"tacos\")\n    ('', '', '', '', '')\n    >>> misplaced_letters(\"tacos\", \"teach\")\n    ('', '', 'a', 'c', '')\n    >>> misplaced_letters(\"misos\", \"sumps\")\n    ('s', '', 'm', '', '')\n    >>> misplaced_letters(\"misos\", \"mosso\")\n    ('', 'o', '', 's', '')\n    >>> misplaced_letters(\"misos\", \"sassy\")\n    ('s', '', '', '', '')\n    \"\"\"\n    if guess is None:\n        return tuple('' for _ in target)\n\n    # before identifying misplaced letters, we need to account for correct letters\n    # we only want to consider letters in the target that aren't in the correct spot.\n    correct = correct_letters(target=target, guess=guess)\n    available = [t for t, c in zip(target, correct) if c == '']\n\n    misplaced = []\n    for t, g in zip(target, guess):\n        if t != g and g in available:\n            # find misplaced letters in the target we haven't already counted\n            misplaced.append(g)\n            available.remove(g)\n        else:\n            misplaced.append('')\n    return tuple(misplaced)\n\n\ndef included_letters(target: str, guess: Optional[str] = None) -> str:\n    \"\"\"\n    Return a string of the letters that must be in the target, sorted alphabetically.\n\n    If multiple of the same letter are included in the target, then we represent those\n    letters together, e.g. 'ss' to mean the target includes at least two known 's'.\n\n    Examples\n    --------\n    >>> included_letters(\"tacos\")\n    ('t',)\n    >>> included_letters(\"tacos\", \"teach\")\n    ('a', 'c', 't')\n    >>> included_letters(\"misos\", \"sumps\")\n    ('m', 'ss')\n    >>> included_letters(\"misos\", \"mosso\")\n    ('m', 'o', 'ss')\n    >>> included_letters(\"misos\", \"sassy\")\n    ('m', 'ss')\n    \"\"\"\n    if guess is None:\n        return tuple(target[0])\n\n    # correct letters and misplaced letters are mutually exclusive groups that must be\n    # present in the final word, so we include the union of both sets\n    correct = correct_letters(target=target, guess=guess)\n    misplaced = misplaced_letters(target=target, guess=guess)\n    letters = sorted(letter for letter in correct + misplaced if letter)\n    included = [k * len(list(v)) for k, v in groupby(letters)]\n\n    # finally, before returning, ensure we include the starting letter of the target if\n    # it's not already there, because it's known to the player from the start.\n    if target[0] not in included:\n        included = sorted(included + [target[0]])\n    return tuple(included)\n\n\ndef excluded_letters(target: str, guess: Optional[str] = None) -> str:\n    \"\"\"\n    Return a string of the letters that are not in the target, sorted alphabetically.\n\n    Typically, letters that are not 'correct' or 'misplaced' will be excluded, as in\n    letters 'e' and 'h' from target 'tacos' and guess 'teach'. However, we may also be\n    able to exclude second or third occurrences of letters, like with target 'misos'\n    and guess 'mosso': we know that the target word must contain exactly one 'o'. We\n    express this by excluding 'oo', which must not occur in the sorted target word.\n\n    Examples\n    --------\n    >>> excluded_letters(\"tacos\")\n    ()\n    >>> excluded_letters(\"tacos\", \"teach\")\n    ('e', 'h')\n    >>> excluded_letters(\"misos\", \"sumps\")\n    ('p', 'u')\n    >>> excluded_letters(\"misos\", \"mosso\")\n    ('oo',)\n    >>> excluded_letters(\"misos\", \"sassy\")\n    ('a', 'sss', 'y')\n    \"\"\"\n    if guess is None:\n        return tuple()\n\n    guessed = set(k * len(list(v)) for k, v in groupby(sorted(guess)))\n    included = set(included_letters(target=target, guess=guess))\n    return tuple(sorted(guessed - included))\n\n\ndef solutions(target: str, *guesses: str, words: Iterable[str]) -> Set[str]:\n    \"\"\"\n    Return a set of the possible solutions, given any number of guesses and a target.\n\n    Internally, this function will check each guess for the following:\n        1. correct letters - letters in the right place\n        2. misplaced letters - letters present in the target but in the wrong place\n        3. included letters - letters we know must be in the target word\n        4. excluded letters - letters we know must not be in the target word\n\n    Then we take what we know from steps 1-4 and apply it to the word list, returning\n    the set of words that meet all the criteria we identified.\n    \"\"\"\n    # proceed recursively, one guess at a time, through each of the criteria, shrinking\n    # the word list each time until we narrow down the surviving candidate words.\n    if len(guesses) == 0:\n        guesses = [None]\n\n    for guess in guesses:\n        correct = correct_letters(target=target, guess=guess)\n        misplaced = misplaced_letters(target=target, guess=guess)\n        included = included_letters(target=target, guess=guess)\n        excluded = excluded_letters(target=target, guess=guess)\n        words = {\n            w for w in words if\n            w[0] == target[0]\n            and all(x in \"\".join(sorted(w)) for x in included)\n            and all(x not in \"\".join(sorted(w)) for x in excluded)\n            and all((x or z) == z and y != z for x, y, z in zip(correct, misplaced, w))\n        }\n    return words\n

"},{"title":"Riddler Chocolates","date":"Oct 2, 2020","slug":"riddler-chocolates","excerpt":"I've taken a short break from solving the Riddlers because I've recently become a father! Our daughter, Emerson, was born in September, and I've been working on a new set of puzzles related to parenthood. However, a classic probability question from the Riddler drew me back in with the prospect of writing a dynamic programming solution.","tags":[],"status":"published","content":"

Introduction

I've taken a short break from solving the Riddlers because I've recently become a father! Our daughter, Emerson, was born in September, and I've been working on a new set of puzzles related to parenthood. However, a classic probability question this week drew me back in with the prospect of writing a dynamic programming solution.

\nI have 10 chocolates in a bag: Two are milk chocolate, while the other eight are dark chocolate. One at a time, I randomly pull chocolates from the bag and eat them — that is, until I pick a chocolate of the other kind. When I get to the other type of chocolate, I put it back in the bag and start drawing again with the remaining chocolates. I keep going until I have eaten all 10 chocolates.\n
For example, if I first pull out a dark chocolate, I will eat it. (I’ll always eat the first chocolate I pull out.) If I pull out a second dark chocolate, I will eat that as well. If the third one is milk chocolate, I will not eat it (yet), and instead place it back in the bag. Then I will start again, eating the first chocolate I pull out.
\n
What are the chances that the last chocolate I eat is milk chocolate?
\n

Solution

The result this week certainly surprised me (assuming I answered correctly...) The probability of drawing a milk chocolate last from the bag is 50%! That's higher than I thought it would be. What's even more interesting is that once we have more than a few chocolates of each kind in the bag, the results are almost always the same. A bag of 4 chocolates each? 50%! 10 chocolates each? 50%! 20 dark chocolates and 5 milk chocolates? 50%! Unless I'm missing something, the dynamics of this puzzle seem to be remarkably insensitive to starting conditions.

As with many other prior puzzles, I approached this with possibly my favorite solving technique: dynamic programming. Rather than solving for a bag of 10 chocolates right away, we can solve the problem for a bag of 1 chocolate, 2 chocolates, and other small numbers first. Then, once we have those building blocks in place, we can start to tackle larger and more complicated situations.

For example, a bag of 4 dark chocolates and 4 milk chocolates with the last chocolate being \"dark\" could become a bag of 3 dark chocolates and 4 milk chocolates if we drew a dark chocolate, or could stay as a bag of 4 each if we draw a milk chocolate. Each of those two outcomes leads to two more outcomes each, on and on, until we eventually reach the terminating states in those chains where only one kind of chocolate remains.

This is a problem that didn't take a lot of time to code, but will certainly occupy a lot of my time trying to understand. Well done to the puzzle's creator, Henk Tijms!

Code

This is a classic example of dynamic programming. We create a function that calls itself recursively until it reaches a state where the outcome is known. Once that happens, we can calculate the expected value of the chain of events that led to that outcome, which is our answer. A problem like this often benefits from memoization, where the results from sub-problems are saved and looked up rather than recalculated, but wasn't necessary for this problem because of the low number of calculations.

from typing import Optional\n\n\ndef model(dark: int, milk: int, last: Optional[str] = None) -> float:\n    \"\"\"\n    Solves the Riddler Classic using dynamic programming. We start with a given number\n    of chocolates in the bag, and we draw one at a time. We track the last chocolate we\n    drew, and if we draw the same one, we eat it. Otherwise, we put it back in the bag\n    and reset the \"last\" value to None.\n\n    For example, `model(8, 2, None)` will return the probability of drawing a milk\n    chocolate last if we start with a bag of 8 dark and 2 milk chocolates.\n\n    Parameters\n    ----------\n    dark : int, the number of dark chocolates\n    milk : int, the number of milk chocolates\n    last : Optional[str], the type of chocolate we drew last, either \"dark\", \"milk\", or\n        None (for example, if we're starting fresh)\n\n    Returns\n    -------\n    expected_value : float, the probability of drawing a milk chocolate last, given our\n        strategy of choosing chocolates.\n    \"\"\"\n    if dark == 0:\n        return 1.0\n    if milk == 0:\n        return 0.0\n    p = dark / (dark + milk)\n    if last == \"dark\":\n        return p * model(dark - 1, milk, \"dark\") + (1 - p) * model(dark, milk, None)\n    if last == \"milk\":\n        return p * model(dark, milk, None) + (1 - p) * model(dark, milk - 1, \"milk\")\n    return p * model(dark - 1, milk, \"dark\") + (1 - p) * model(dark, milk - 1, \"milk\")\n

"},{"title":"Riddler Solstice Coin","date":"Jun 19, 2020","slug":"riddler-solstice-coin","excerpt":"As a self-professed Bayesian enthusiast, this week's Riddler Express is right up my alley! We want to calculate the odds that a coin is magical after flipping it a given number of times. Specifically, we want to calculate the number of flips before we're 99% certain the coin is actually magical. We'll use Bayes's formula to find an exact solution.","tags":[],"status":"published","content":"

Introduction

As a self-professed Bayesian enthusiast, this week's Riddler Express is right up my alley! We want to calculate the odds that a coin is magical after flipping it a given number of times. Specifically, we want to calculate the number of flips before we're 99% certain the coin is actually magical. We'll use Bayes's formula to find an exact solution.

\nI have a coin with a sun on the front and a moon on the back. I claim that on most days, it’s a fair coin, with a 50 percent chance of landing on either the sun or the moon.\n
But once a year, on the summer solstice, the coin absorbs the sun’s rays and exhibits a strange power: It always comes up the opposite side as the previous flip.
\n
Of course, you are skeptical of my claim. You figure there’s a 1 percent chance that the coin is magical and a 99 percent chance that it’s just an ordinary fair coin. You then ask me to “prove” the coin is magical by flipping it some number of times.
\n
How many successfully alternating coin flips will it take for you to think there’s a 99 percent chance the coin is magical (or, more likely, that I’ve rigged it in some way so it always alternates)?
\n

Solution

It will take 14 consecutive alternating flips before we are at least 99% sure the coin is magical. This problem is a classic fit for Bayesian methods. (We've seen another great example in a prior Riddler based on \"Who wants to be a millionaire\") Let's start by reviewing Bayes's formula, then we'll parse the problem text to identify the information we need to solve it.

P(A|B) \\times P(B) = P(B|A) \\times P(A)

Typically, a problem like this will give us three of the four variables, and we'll need to solve for the fourth. As we go, we'll identify what we mean when we say $A$ and $B$ in the context of this problem. Let's write down the information we have:

We want to find the number of flips it will take to be 99% sure the coin is magical. Let's use a variable, $N$ , to represent this unknown number. In probability notation, this means we want to find $N$ such that $P(\\text{magical coin | N alternating flips}) = 0.99$ .
Before we flip any coins, we believe the probability of a magical coin is 1%. We'll write this as $P(\\text{magical coin}) = 1\\%$ .
We know that if the coin is magical, it will always alternate flips, no matter how many times we flip the coin. We'll re-use our variable $N$ and write $P(\\text{N alternating flips | magical coin}) = 100\\%$ .
Finally, we need to calculate the probability of observing $N$ alternating flips in a row. This depends on whether we are using a fair or a magical coin, so we'll take the weighted average of both possibilities: $P(\\text{N alternating flips}) = 99\\% \\times \\frac{1}{2^N} + 1\\% \\times 1$ .

Now we've identified all four variables required for Bayes's formula above. Written out, we have:

P(\\text{magic | N flips}) \\times P(\\text{N flips}) = P(\\text{N flips | magic}) \\times P(\\text{magic})

When we plug in our values, we get:

0.99 \\times (\\frac{0.99}{2^N} + 0.01) = 1 \\times 0.01

Rearranging so we have $N$ on one side, we get:

2^N = \\frac{\\frac{99}{100}}{\\frac{1}{99} - \\frac{1}{100}}

Conveniently, the fraction on the right equals $9801$ . So we have:

2^N = 9801

We take the log of both sides to solve for $N$ , which gives us $N=13.26$ . Because we can't have fractions of coin flips, and we want to be at least 99% sure before stopping, we should err on the side of caution and flip 14 times. This means that after 14 consecutive, alternating flips we can be 99.4% certain the coin is magical.

"},{"title":"Riddler Bacteria","date":"Jun 12, 2020","slug":"riddler-bacteria","excerpt":"We're studying simulated petri dishes in this week's Riddler! We want to figure out how likely a colony of bacteria is to survive, given what we know about how often its cells divide. This is a classic problem that can be modeled with a stochastic process, but we'll try a different approach with very large markov transition matrices built in python and numpy.","tags":[],"status":"published","content":"

Introduction

We're studying simulated petri dishes in this week's Riddler! We want to figure out how likely a colony of bacteria is to survive, given what we know about how often its cells divide. This is a classic problem that can be modeled with a stochastic process, but we'll try a different approach with very large markov transition matrices built in python and numpy.

\nYou are studying a new strain of bacteria, Riddlerium classicum (or R. classicum, as the researchers call it). Each R. classicum bacterium will do one of two things: split into two copies of itself or die. There is an 80 percent chance of the former and a 20 percent chance of the latter.\n
If you start with a single R. classicum bacterium, what is the probability that it will lead to an everlasting colony (i.e., the colony will theoretically persist for an infinite amount of time)?
\n
Extra credit: Suppose that, instead of 80 percent, each bacterium divides with probability p. Now what’s the probability that a single bacterium will lead to an everlasting colony?
\n

Solution

With its 80% doubling rate, the R. classicum bacteria has a 75% chance to survive indefinitely. (It's unclear if its sibling bacteria, Riddler Expressum, would be so resilient...)

The survival rate is highly dependent on the doubling rate, as the chart below shows. For doubling rates less than 50%, a colony of bacteria will surely go extinct, but for doubling rates above 50%, the survival odds improve substantially.

This class of problem, called a \"birth-death process\", can get very complicated, but for this simple case of cells doubling or dying, there is a formula for the survival rate as a function of $p$ :

\\text{Survival Rate}(p) = max(0, 1 - \\frac{1 - p}{p})

This tells us that the survival rate for a colony with an 80% doubling rate is $1 - \\frac{0.2}{0.8}$ , or 75%. It also tells us that it's impossible for a colony of bacteria to survive if the doubling rate is less than 50%.

Methodology

Birth-death problems can get pretty gnarly, but this particular version is one of the simpler cases: a cell may only divide or die, and cells can't leave or enter the closed system. In continuous time, the colony can be modeled using a stochastic process, which is a mathematical model that lets us simulate the behavior of systems which behave randomly over time.

\n
Small plug: I've actually been working on an open source python library to model stochastic processes in the financial markets, called pyesg. This library lets you simulate random processes like stocks, interest rates, or energy prices, which you could use to simulate investment portfolios, decide which mortgage to choose, or plan for market downturns. Check it out on github!
\n

There's also another way to model this process. We can model time in discrete steps, simulating whether each cell in the colony divides or dies, and track the population size over time. For example, a starting population of 6 could become a population of $\\{0,\\ 2,\\ 4,\\ 6,\\ 8,\\ 10,\\, 12\\}$ , based on which cells divide or die. The odds of each new population are called transition probabilities. We want to create a matrix of these transition probabilities to be able to determine the long term behavior of the system, which is a technique I've used on many prior Riddler puzzles.

The difference here is that the colony population can theoretically grow to infinite size, and the typical markov chain transition matrix approach only works for finite-sized matrices. While it might seem like this is a dead end, we can work around it.

We are interested in three possible states: permanent colony extinction (☠), indefinite colony survival, or a transient state between the two. Rather than trying to model an infinite population, we'll assume that a sufficiently large population, e.g. 500 or 1000 cells, eventually leads to survival. In other words, with a large enough finite matrix, our answer should approach the true answer.

In my experiments, a matrix with size 500 seemed to converge nicely to the true result, and was quick to compute. Ultimately, the survival_probability function tells us how likely it is for a colony to reach a given size before going extinct. For example, here's the calculation for the original problem, with the 80% doubling rate.

survival_probability(n=500, p=0.8)\n# 0.7500000000000211\n

Full Code

This week's code is almost entirely linear-algebra-as-code. There's a function that generates a markov transition matrix of any size, and a function that uses the transition matrix to calculate the expected probability that the colony survives indefinitely.

My chart was made by calling the survival_probability function in a list comprehension to evaluate the survival probabilities at many values between 0 and 1.0.

from typing import Dict\nimport numpy as np\nfrom scipy.stats import binom\n\n\ndef transition_matrix(n: int, p: float = 0.8) -> np.ndarray:\n    \"\"\"\n    Generates a transition matrix for a maximum population of size n, where\n    the population can take even number values from 0 to n or ∞. The matrix\n    will have size (n // 2 + 3, n // 2 + 3), where each row represents the\n    transition probability from state X to state Y, and the absorbing states\n    are either 0 (extinction) or ∞ (everlasting survival). As n -> ∞, we can\n    create better estimates of the true rate of everlasting survival.\n\n    The matrix is ordered by: [1, n, n - 2, n - 4, ..., 0, ∞], where each\n    value represents a possible population size, and this particular ordering\n    (called the canonical form) makes some of the linear algebra easier later\n\n    Parameters\n    ----------\n    n : int, the maximum population size to model\n    p : float, the probability of dividing into two cells\n\n    Returns\n    -------\n    M : np.ndarray, the transition matrix with size (n // 2 + 3, n // 2 + 3)\n\n    Examples\n    --------\n    >>> transition_matrix(n=4)\n    array([[0.    , 0.    , 0.8   , 0.2   , 0.    ],\n           [0.    , 0.1536, 0.0256, 0.0016, 0.8192],\n           [0.    , 0.64  , 0.32  , 0.04  , 0.    ],\n           [0.    , 0.    , 0.    , 1.    , 0.    ],\n           [0.    , 0.    , 0.    , 0.    , 1.    ]])\n    \"\"\"\n    # create the transition matrix one row at a time, from n == 2 to n == n\n    # then stack each of those on top of two absorbing states at 0 and ∞.\n    # for transitions to values greater than n we group them into the ∞ row.\n    M = np.zeros(shape=(n // 2 + 3, n // 2 + 3), dtype=np.float64)\n    idx = np.arange(n + 1)[::-1]\n\n    for x in range(1, n // 2 + 1):\n        pmf = binom(n=x * 2, p=p).pmf(idx)\n        M[-x - 2, 1:-1] = pmf[-n // 2 - 1:]\n        M[-x - 2, -1] = pmf[:-n // 2 - 1].sum()\n\n    M[:, 0] = 0.0\n    M[0, :] = 0.0\n    M[-2:, :] = 0.0\n    M[[-2, -1], [-2, -1]] = 1.0\n    M[0, -3] = p\n    M[0, -2] = 1 - p\n    return M\n\n\ndef survival_probability(n: int, p: float = 0.8) -> float:\n    \"\"\"\n    Returns the survival probability for a population with a max size of n,\n    which represents the probability that a cell colony starting with one\n    cell will eventually survive or become extinct.\n\n    Parameters\n    ----------\n    n : int, the maximum population size to model\n    p : float, the probability of dividing into two cells\n\n    Returns\n    -------\n    result : float, the probability of the colony surviving indefinitely\n\n    Examples\n    --------\n    >>> survival_probability(n=6)\n    0.7500074825177829\n\n    >>> survival_probability(n=500)\n    0.7500000000000211\n    \"\"\"\n    M = transition_matrix(n=n, p=p)\n    Q = np.linalg.inv(np.eye(len(M) - 2) - M[:-2, :-2])\n    R = M[:-2, -2:]\n    return (Q @ R)[0, 1]\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Bowling Dice","date":"Jun 12, 2020","slug":"riddler-bowling-dice","excerpt":"I can never resist a good dice problem, and this week's Riddler Express is no different. In a technique called \"bowling\", you can try to throw a dice so it lands on one of four sides, rather than six. How could we use this to our advantage in a simplified game of craps? We'll solve this with a bit of dynamic programming - my favorite!","tags":[],"status":"published","content":"

Introduction

I can never resist a good dice problem, and this week's Riddler Express is no different. In a technique called \"bowling\", you can try to throw a dice so it lands on one of four sides, rather than six. How could we use this to our advantage in a simplified game of craps? We'll solve this with a bit of dynamic programming - my favorite!

\nThere’s a technique for rolling dice called “bowling,” in which you place your index finger and thumb on two opposite sides of the die and roll it along the table. If done correctly, the die will never land on the faces on which you were holding the die, leaving you with a 25 percent chance of landing on each of the remaining four faces.\n
You’d like to apply this technique to improve your chances of winning a simplified game of craps, in which your goal is simply to roll a 7 or 11 using two dice. With a standard rolling technique, your chances of rolling a 7 or 11 are 2/9, or about 22.2 percent.
\n
Now suppose you’re using your bowling technique, and you roll the dice one at a time (i.e., you know the outcome of the first die before rolling the second). If you play to maximize your chances of rolling a 7 or 11, what will be your chances of winning?
\n
Extra credit: Suppose you get one point for rolling a 7 or 11, but now you lose a point for rolling a 2, 3 or 12. With a standard rolling technique, you’d average 1/9 of a point. But if you “bowl” to maximize your expected score, what will that average be?
\n

Solution

With proper technique, your expected odds of rolling 7 or 11 are 37.5%. If you lose points for rolling a 2, 3, or 12, your expected value falls to 31.25%. Both results are substantially higher than the standard odds from the prompt, which means bowling is a significant advantage.

In the game with no losing rolls, the best numbers to start with are 5 and 6. Each of these gives a 50% chance of winning once thrown, compared to a 25% chance of winning with starting values of 1, 2, 3, or 4. Therefore, we should start by placing our fingers on the 3 and 4 sides of the dice, which gives us the best chances of rolling a 5 or 6.

If we roll a 5 first, we should use the same technique, and roll for 1, 2, 5, or 6. This will win 50% of the time, either with a 2 (for 7 total) or a 6 (for 11 total). If we roll a 6 first, we also have 50% odds of winning, by rolling a 1 or a 5. Averaged out, we have a 37.5% chance of winning.

When we factor in losing numbers, we want to change strategy. Low numbers hurt us, so we want to roll with the 1 and 6 covered, for possible values of 2, 3, 4, or 5. A 5 is the best outcome again, giving us 50% odds of winning, while 2, 3, or 4 give us a 25% chance to win. Averaged out, we have a 31.25% expected value.

Methodology

We want to work this problem backwards, from end to start. This technique is called dynamic programming, which I've used to solve several prior puzzles.

We want to determine what strategy to use, conditioned on the fact that we roll a particular starting number. For example, if our first number is 5, then we know how likely we will be to win or lose for each of the bowling arrangements. We do this for each possible starting number until we have a table like this (the expected value here is for the extra credit, with both winning and losing numbers.)

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

First Roll	Bowling Dice	Expected Value
1	{2, 3, 4, 5}	-0.25
1	{1, 3, 4, 6}	0.0
1	{1, 2, 5, 6}	-0.25
2	{2, 3, 4, 5}	0.25
2	{1, 3, 4, 6}	-0.25
2	{1, 2, 5, 6}	0.0
3	{2, 3, 4, 5}	0.25
3	{1, 3, 4, 6}	0.25
3	{1, 2, 5, 6}	0.0
4	{2, 3, 4, 5}	0.25
4	{1, 3, 4, 6}	0.25
4	{1, 2, 5, 6}	0.0
5	{2, 3, 4, 5}	0.25
5	{1, 3, 4, 6}	0.25
5	{1, 2, 5, 6}	0.5
6	{2, 3, 4, 5}	0.25
6	{1, 3, 4, 6}	0.0
6	{1, 2, 5, 6}	0.25

Importantly, we get to choose how to roll after we've seen the first number. This means we can choose the type of roll that gives the highest expected value. With a starting roll of 5, for example, we should choose to roll the {1, 2, 5, 6}, which wins 50% of the time. On the other hand, with a starting roll of 1, we should chose to roll the {1, 3, 4, 6} for an expected value of 0.

Now that we know 5 is a great starting roll, and 1 is not so great, we can choose the first roll that gives us the best chances of seeing a 5 and the lowest chances of seeing a 1. This means we should start the game by rolling for {2, 3, 4, 5}. If we do, our expected win percent is 31.25%.

These problems are often very fun to program, and can be extended to any number of rolls. The expected_value function takes a number of rolls and sets of winning and losing numbers and returns the expected value for optimal play. We can see the results from above verified in code, and we can even try something more complicated, like 4 rolls and different winning and losing numbers, or 15 rolls with a target of 50!

>>> # expected value of two sequential rolls with no losing numbers\n>>> expected_value(n_rolls=2, winners=(7, 11), losers=())\n0.375\n\n>>> # expected value of two sequential rolls with a few losing numbers\n>>> expected_value(n_rolls=2, winners=(7, 11), losers=(2, 3, 12))\n0.3125\n\n>>> # something more complicated: four rolls and doubled-targets\n>>> expected_value(n_rolls=4, winners=(14, 22), losers=(4, 6, 24))\n0.2265625\n\n>>> # what if we want to hit 50 after 15 rolls?\n>>> expected_value(n_rolls=15, winners=(50,), losers=())\n0.1427854159846902\n

Full Code

This problem can be solved with a single function. Essentially we play the game from end to start, assuming we make the optimal decision for each roll. Finally, we return the expected win percentage.

from functools import lru_cache\n\n\n@lru_cache()\ndef expected_value(\n    n_rolls: int = 2,\n    winners: Tuple[int] = (7, 11),\n    losers: Tuple[int] = (2, 3, 12),\n) -> float:\n    \"\"\"\n    Returns the expected value of the simplified craps game, where we use\n    the bowling technique for a number of rolls in a row, and win or lose\n    depending on the total of the dice once they've been rolled.\n\n    Using the bowling technique, we \"guarantee\" the dice will land on one\n    of four sides, rather than one of six. On a normal dice, the opposite\n    sides add up to seven, so the three bowling options are to roll with\n    sides {2, 3, 4, 5}, {1, 3, 4, 6}, or {1, 2, 5, 6}.\n\n    Parameters\n    ----------\n    n_rolls : int, the number of dice to roll. We roll sequentially\n    winners : Tuple[int], the winning numbers, each worth 1 point\n    losers : Tuple[int], the losing numbers, each worth -1 point\n\n    Examples\n    --------\n    >>> # verify a simple example with one roll\n    >>> expected_value(n_rolls=1, winners=(5, 6), losers=(1,))\n    0.25\n\n    >>> # expected value with two rolls and no losing numbers\n    >>> expected_value(n_rolls=2, winners=(7, 11), losers=())\n    0.375\n\n    >>> # expected value with two rolls and some losing numbers\n    >>> expected_value(n_rolls=2, winners=(7, 11), losers=(2, 3, 12))\n    0.3125\n    \"\"\"\n    # these are the rolling options available to us at every step\n    options = ((2, 3, 4, 5), (1, 3, 4, 6), (1, 2, 5, 6))\n\n    # with just one roll remaining, we choose the best option\n    if n_rolls == 1:\n        totals = [\n            sum(n in winners for n in option)\n            - sum(n in losers for n in option)\n            for option in options\n        ]\n        return max(totals) / 4\n\n    # if we have more than one roll remaining, we want to \"try\" each\n    # option to see which produces the best outcome, recursively.\n    return max(\n        sum(expected_value(\n            n_rolls - 1,\n            tuple(x - n for x in winners),\n            tuple(x - n for x in losers),\n        ) for n in option) / 4\n        for option in options\n    )\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Painting","date":"Jun 5, 2020","slug":"riddler-painting","excerpt":"We are carefully coloring a poster in this week's Riddler. We want to draw horizontal lines with a marker in order to fill the poster with ink as evenly as possible. How far apart should each marker line be? We'll use numpy for a computational approach that minimizes the standard deviation of our coloring scheme.","tags":[],"status":"published","content":"

Introduction

We are carefully coloring a poster in this week's Riddler. We want to draw horizontal lines with a marker in order to fill the poster with ink as evenly as possible. How far apart should each marker line be? We'll use numpy for a computational approach that minimizes the standard deviation of our coloring scheme.

\nSome friends have invited you to a protest, and you’ll be making a sign with large lettering. You’re filling in the sign’s letters by drawing horizontal lines with a marker. The marker has a flat circular tip with a radius of 1 centimeter, and you’re holding the marker so that it’s upright, perpendicular to the sign.\n
Since the diameter of the marker’s tip is 2 centimeters, you decide to fill in the letters by drawing lines every 2 centimeters. However, this is the pattern you get:
\n\n
The shading doesn’t look very uniform — each stroke is indeed 2 centimeters wide, but there appear to be gaps between the strokes. Of course, if you drew many, many lines all bunched together, you’d have a rather uniform shading.
\n
But you don’t have all day to make this sign. If the lines can’t overlap by more than 1 centimeter — half the diameter of the marker tip — what should this overlap be, in order to achieve a shading that’s as uniform as possible? And how uniform will this shading be, say, as measured by the standard deviation in relative ink on the sign?
\n

Solution

The ideal spacing between marker strokes is roughly 1.7cm. Assuming you could be that precise, the standard deviation of ink should be roughly 0.217. I made the following assumptions in order to calculate this result.

The top and bottom strokes are set 1cm away from the edge so you're still coloring within the lines. Each stroke between those will be spaced $x$ centimeters apart, where we try to solve for the value of $x$ that minimizes the overall standard deviation.
Somewhat arbitrarily, I've chosen 15 marker strokes between the top and bottom. This affects the standard deviation value I calculated, but shouldn't affect the ideal spacing.
I assumed ink is perfectly additive: if you color a section of the poster twice, the total ink on that spot is the sum of ink from both marker strokes with no loss.
The amount of ink deposited by a marker stroke is equal to the cross sectional area of the marker tip, which is a circle.
The standard deviation of a particular spacing is equal to the standard deviation of marker ink along a vertical slice of the poster.

The chart below illustrates how the standard deviation changes as a function of the marker spacing. The dark wavy line in the middle represents the standard deviation for a given spacing on the x-axis. This line is minimized when spacing is 1.7cm, and is maximized at 1.07cm. The insets in the chart show a vertical cross section of ink for a slice of the poster. Standard deviation at each point is calculated based on the values in the inset charts. We can see that the values of the upper right inset chart are more consistent overall, which is reflected in the lower standard deviation. The other inset chart has more variance in the ink values, so its standard deviation is higher.

Full Code

I took a purely computer-based approach to solve this week's problem. While it's probably possible to write the equation for the lines in my chart above, it gets complicated quickly. Instead, I used numpy to simulate one million points across a vertical slice of the poster and tally the ink at each point on the slice.

I assumed the marker leaves ink on the poster in proportion to the slice of marker tip at each point. So the cross_section function is essentially the equation for a circle. The ink_weight function returns the array for the inset charts above, which is the basis for calculating the standard deviations. I added a quick plotting method called plot_ink as well to visualize any given spacing.

Finally, I used a list comprehension to calculate the standard deviation for 500 different spacing values from 1.0 to 2.0, and found the minimum at roughly 1.7cm.

from typing import Optional\nfrom matplotlib import pyplot as plt\nimport numpy as np\n\n\ndef cross_section(\n   x: np.ndarray,\n   center: np.ndarray,\n   radius: float = 1.0\n) -> np.ndarray:\n    \"\"\"\n    Returns the length of the cross section of a circle at a position, x,\n    centered at a given point with a given radius. If x == center, then this\n    returns the diameter of the circle. If x == center + radius, then this\n    returns zero.\n\n    Examples\n    --------\n    >>> cross_section(x=np.array([1.0]), center=np.array([1.0]))\n    array([[2.]])\n\n    >>> cross_section(x=np.array([0.0]), center=np.array([1.0]))\n    array([[0.]])\n    \"\"\"\n    return 2 * np.maximum(0, (1 - (x - center[:, None]) ** 2)) ** 0.5\n\n\ndef ink_weight(\n    spacing: float,\n    strokes: int,\n    radius: float = 1.0,\n    points: int = 1000000,\n) -> np.ndarray:\n    \"\"\"\n    Returns an array of values with shape (points,) that represents the total\n    ink weight of that slice of the poster. It's essentially a vertical slice\n    of the ink on the poster from top to bottom, which sums the amount of ink\n    from each marker stroke.\n\n    Parameters\n    ----------\n    spacing : float, must be in the range [radius, 2*radius].\n    strokes : int, the number of marker strokes used on the poster\n    radius : float, default 1.0, the radius of the marker\n    points : int, the number of points to measure; more points gives a more\n        accurate answer, but may take slightly longer to compute\n\n    Returns\n    -------\n    x : np.ndarray, an array of the x-coordinates of the ink_weight array\n    ink_weight : np.ndarray, an array of total marker weight from each stroke\n\n    Raises\n    ------\n    ValueError, if the spacing arguments is not within an acceptable range\n    \"\"\"\n    # raise an error if spacings are closer than 1cm (not allowed)\n    if spacing < radius or spacing > 2 * radius:\n        raise ValueError(\n            f\"Spacing must be between {radius} and {2 * radius}; \"\n            f\" you provided {spacing}.\"\n        )\n\n    x = np.linspace(0, 2 * radius + spacing * strokes, points)\n    centers = np.arange(radius, radius + spacing * (strokes + 1), spacing)\n    weights = cross_section(x, centers).sum(0)\n    return x, weights\n\n\ndef plot_ink(\n    spacing: float,\n    strokes: int,\n    radius: float = 1.0,\n    points: int = 1000000,\n    output: Optional[str] = None,\n) -> None:\n    \"\"\"\n    Plot the slice of ink weight on the poster\n\n    Parameters\n    ----------\n    spacing : float, must be in the range [radius, 2*radius].\n    strokes : int, the number of marker strokes used on the poster\n    radius : float, default 1.0, the radius of the marker\n    points : int, the number of points to measure; more points gives a more\n        accurate answer, but may take slightly longer to compute\n    output : Optional[str], default None, if provided, the string name that\n        should be used to save the file, e.g. \"path/to/plot.png\"\n    \"\"\"\n    fig, ax = plt.subplots(figsize=(8, 4.5))\n\n    x, weight = ink_weight(spacing, strokes, radius, points)\n    ax.plot(x, weight, color=\"0.2\")\n\n    ax.set_ylim(0, weight.max() * 1.05)\n    for s in [\"top\", \"right\", \"left\"]:\n        ax.spines[s].set_visible(False)\n    if output:\n        plt.savefig(output, bbox_inches=\"tight\", dpi=300)\n    return None\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Video Call","date":"May 29, 2020","slug":"riddler-video-call","excerpt":"Suppose everyone in the United States wanted to join the same video call? If each of the 330 million participants joins and drops at a random time, how likely is it that at least one person overlaps with everyone else? This problem easily exceeds the limits of a practical simulation, but we'll write some code to develop intuition about the results before attempting to solve it analytically.","tags":[],"status":"published","content":"

Introduction

Suppose everyone in the United States wanted to join the same video call? If each of the 330 million participants joins and drops at a random time, how likely is it that at least one person overlaps with everyone else? This problem easily exceeds the limits of a practical simulation, but we'll write some code to develop intuition about the results before attempting to solve it analytically. Here's the full problem text from this week's Riddler.

\nOne Friday morning, suppose everyone in the U.S. (about 330 million people) joins a single Zoom meeting between 8 a.m. and 9 a.m. — to discuss the latest Riddler column, of course. This being a virtual meeting, many people will join late and leave early.\n
In fact, the attendees all follow the same steps in determining when to join and leave the meeting. Each person independently picks two random times between 8 a.m. and 9 a.m. — not rounded to the nearest minute, mind you, but any time within that range. They then join the meeting at the earlier time and leave the meeting at the later time.
\n
What is the probability that at least one attendee is on the call with everyone else (i.e., the attendee’s time on the call overlaps with every other person’s time on the call)?
\n
Extra credit: What is the probability that at least two attendees are on the call with everyone else?
\n

Solution

This is a challenging problem, in part because it exceeds the limits of a simulation that could run in reasonable time, and also because the underlying probability distributions are a little tricky. I'm still working on an analytical solution.

The following image helped me think about the probability distributions involved. Each blue bar represents one participant's time on the call, and we quickly build a stack of participants joining and dropping over time. However, we are especially interested in two participants: the person that leaves the call first, and the person that arrives to the call last.

These two people set the boundary on the minimum overlap time. In order to overlap with everyone, at least one person must join the call before the first person leaves, and must stay on the call until the last person joins. If those two conditions are met, then we're guaranteed to have at least one overlap.

\n\n

Sample Simulation

While it's impractical to simulate the entire 330-million-person call, I found that simulations with smaller values (100,000 to 50 million or more) consistently yielded values around 66% for at least one overlap, and around 40% for at least two overlaps.

I also had some fun this week playing with dask to run large simulations on my machine. Dask lets you create a \"local cluster\" on your computer that can parallelize certain operations and run them much faster than you could on a single thread.

The code below creates a dask local cluster, then runs a large batch of simulations that align with the analytical results above.

from dask import array as da\nfrom dask.distributed import Client\n\n# start a local cluster using all CPU threads\nclient = Client()\n\n\ndef model(trials: int, participants: int):\n    \"\"\"\n    Returns the number of participants on a call who overlap\n    with every other participant. This is solved efficiently\n    using dask arrays for parallel simulations:\n\n    1. Generate each person's start and end times. The start\n       time is the min and the end time is the max.\n    2. For a group of participants, find the latest start\n       time and the earliest end time.\n    3. Identify any participants that have a starting time\n       before than the earliest end time and an end time\n       after the latest start time.\n\n    Returns\n    -------\n    result : an array of the number of participants in each\n        trial who overlap every other participant.\n    \"\"\"\n    times = da.random.uniform(size=(trials, participants, 2))\n    starts = times.min(axis=2)\n    ends = times.max(axis=2)\n\n    latest_start = starts.max(axis=1)\n    earliest_end = ends.min(axis=1)\n\n    # check if any participants arrive before the first person\n    # leaves and leave after the last person arrives.\n    cond1 = starts.T < earliest_end\n    cond2 = ends.T > latest_start\n    return (cond1 & cond2).sum(axis=0)\n\n\n# results here is a delayed object. Call `compute() for values\n# here we run 1000 trials with 10 million participants\nresults = model(trials=1000, participants=10000000)\nresults.compute()\n

"},{"title":"Riddler Mackerels","date":"May 22, 2020","slug":"riddler-mackerels","excerpt":"This week's Riddler starts with a peculiar fact - \"Ohio\" doesn't share any letters with the word \"mackerel\", and it's the only state for which that is true. How many other state/word combinations can we find, and which states match with the longest words? We'll use python's super efficient sets, lists, and dictionaries to crunch millions of combinations in under two seconds to find the answer.","tags":[],"status":"published","content":"

Introduction

This week's Riddler starts with a peculiar fact - \"Ohio\" doesn't share any letters with the word \"mackerel\", and it's the only state for which that is true. How many other state/word combinations can we find, and which states match with the longest words? We'll use python's super efficient sets, lists, and dictionaries to crunch millions of combinations in under two seconds to find the answer.

\nOhio is the only state whose name doesn’t share any letters with the word “mackerel.” It’s strange, but it’s true.\n
But that isn’t the only pairing of a state and a word you can say that about — it’s not even the only fish! Kentucky has “goldfish” to itself, Montana has “jellyfish” and Delaware has “monkfish,” just to name a few.
\n
What is the longest “mackerel?” That is, what is the longest word that doesn’t share any letters with exactly one state? (If multiple “mackerels” are tied for being the longest, can you find them all?)
\n
Extra credit: Which state has the most “mackerels?” That is, which state has the most words for which it is the only state without any letters in common with those words?
\n

Solution

Fortunately I have a list of US states handy from a prior Riddler, so that should save a bit of time :)

First, a comment on the word list: it contains 263,533 words, including such vernacular staples as \"aa\" (a form of lava flow), and \"zzz\" (a snoring sound), both of which are valid in Scrabble. If there's a better validation of a word than its inclusion in the Scrabble dictionary, I'm not aware of it!

Of those 263,533 words, the longest \"mackerel\" is a tie between the 23-letter powerhouses counterproductivenesses, which belongs to Alabama, and hydrochlorofluorocarbon, which belongs to Mississippi. (Sorry pneumonoultramicroscopicsilicovolcanoconiosis, your 45 letters were claimed by all 50 states.)

As for the extra credit, the mackereliest (not a valid scrabble word) state is... Ohio! It is the proud owner of 11,342 mackerels, ranging from \"man\" to \"untranslatablenesses\" (much like some of the longest words on this list.)

Methodology

Like other word puzzles we've seen before, I was amazed at the power of my computer to solve this problem using brute force. The brute force approach tests the overlap between each word (263k) and each state (50) for more than 13 million comparisons in total. Fortunately, on my computer, these comparisons took less than two seconds! Here's how to solve it with efficient python code.

First, the setup: we need to download the word list. I'll use urllib to request the words and parse them into a list.

from urllib.request import urlopen\n\ndef get_words(url: str = \"https://norvig.com/ngrams/word.list\") -> List[str]:\n    \"\"\"Downloads and returns a set of words from the web\"\"\"\n    response = urlopen(url)\n    return response.read().decode(\"utf-8\").split(\"\\n\")\n

For the actual work, I took advantage of a few data structures in python that are well suited to this task: sets, lists, and dictionaries. For example, instead of comparing \"Alabama\" with \"ambulance\", it is much faster to compare the set of letters in each word. Sets are data containers with unique elements, so the set of letters in \"alabama\" is {'a', 'b', 'l', 'm'}. We can quickly test whether sets have any overlap in a lightning fast built-in function called isdisjoint.

set(\"alabama\")\n# {'a', 'b', 'l', 'm'}\n\nset(\"ambulance\")\n# {'a', 'b', 'c', 'e', 'l', 'm', 'n', 'u'}\n\n# isdisjoint returns a boolean indicating if the sets have any overlap\n# we should expect False here, because they share at least one letter.\nset(\"alabama\").isdisjoint(set(\"ambulance\"))\n# False\n\n# verify that \"ohio\" doesn't share letters with \"mackerel\"\nset(\"ohio\").isdisjoint(set(\"mackerel\"))\n# True\n

Because we want to test every state for every word, it makes sense to store the sets of letters for each state. This saves a bit of time because we only convert the state names into sets of letters once. If we didn't do this small optimization, the program would take roughly four seconds instead of two. Still a small number, but worth a 50% speedup!

# STATES is a list of states [\"Alabama\", \"Alaska\", ...]\n# create sets of letters: case sensitive, so we call .lower(), and remove spaces\nSTATES = {state: set(state.lower().replace(\" \", \"\")) for state in STATES}\n

Now, for a given word we want to find all the states that don't share any letters with it. If the result of disjoint_states is a list with a single state, then we know we've found a \"mackerel\". All that remains is to loop through the entire word list and filter for the words that only match with a single state, which we do in get_mackerels.

def disjoint_states(word: str) -> List[str]:\n    \"\"\"\n    Returns a list of states that share no letters with the given word.\n    If no states meet the criteria, then returns an empty list, [].\n\n    Examples\n    --------\n    >>> disjoint_states(\"mackerel\")\n    ['Ohio']\n\n    >>> disjoint_states(\"abcdefghijklmnopqrstuvwxyz\")\n    []\n    \"\"\"\n    word_letters = set(word)\n    return [\n        state for state, state_letters in STATES.items()\n        if word_letters.isdisjoint(state_letters)\n    ]\n\n\ndef get_mackerels() -> Dict[str, str]:\n    \"\"\"\n    Returns a dictionary of \"mackerels\" - words that share letters with only one\n    state and no others. Output will be {word: state} for all mackerel words.\n    \"\"\"\n    # loop through the whole word list - it is still pretty quick for 250k words\n    mackerels = {word: disjoint_states(word) for word in get_words()}\n    return {word: state[0] for word, state in mackerels if len(state) == 1}\n

These functions create a dictionary of {word: state}, for the words that have no overlap with a single state. The puzzle asked for the longest of these words, so we need to do a little post-processing. Here we take the dictionary and sort it by the longest word. This snippet shows the top-10 longest words and the single state with which they have no overlap.

results = get_mackerels()  # returns a dictionary of words and their states\nsorted(results.items(), key=lambda x: len(x[0]), reverse=True)[:10]\n# [('counterproductivenesses', 'Alabama'),\n#  ('hydrochlorofluorocarbon', 'Mississippi'),\n#  ('counterproductiveness', 'Alabama'),\n#  ('unconscientiousnesses', 'Alabama'),\n#  ('counterconditionings', 'Alabama'),\n#  ('deoxycorticosterones', 'Alabama'),\n#  ('expressionlessnesses', 'Utah'),\n#  ('hyperconsciousnesses', 'Alabama'),\n#  ('hypersensitivenesses', 'Alabama'),\n#  ('incompressiblenesses', 'Utah')]\n

And lastly, to answer the extra credit, we want to count the number of times each state shows up in our dictionary. We run through the states in the dictionary, grouping them together and summing the number of occurrences for each. Lastly, we sort the results by the highest count, and show the top-10 results.

from itertools import groupby\n\nextra_credit = {k: len(list(v)) for k, v in groupby(sorted(results.values()))}\nsorted(out.items(), key=lambda x: x[1], reverse=True)[:10]\n# [('Ohio', 11342),\n#  ('Alabama', 8274),\n#  ('Utah', 6619),\n#  ('Mississippi', 4863),\n#  ('Hawaii', 1763),\n#  ('Kentucky', 1580),\n#  ('Wyoming', 1364),\n#  ('Tennessee', 1339),\n#  ('Alaska', 1261),\n#  ('Nevada', 1229)]\n

"},{"title":"Riddler Dungeon Dice","date":"May 15, 2020","slug":"riddler-dungeon-dice","excerpt":"This week's Riddler asks us to determine the best dice-rolling strategy for our weekly Dungeons and Dragons game. With the option to roll once, or roll multiple times with various combinations of maximums and minimums, how can we optimize the odds of rolling the number we want?","tags":[],"status":"published","content":"

Introduction

This week's Riddler asks us to determine the best dice-rolling strategy for our weekly Dungeons and Dragons game. With the option to roll once, or roll multiple times with various combinations of maximums and minimums, how can we optimize the odds of rolling the number we want?

\nThe fifth edition of Dungeons & Dragons introduced a system of “advantage and disadvantage.” When you roll a die “with advantage,” you roll the die twice and keep the higher result. Rolling “with disadvantage” is similar, except you keep the lower result instead. The rules further specify that when a player rolls with both advantage and disadvantage, they cancel out, and the player rolls a single die. Yawn!\n
There are two other, more mathematically interesting ways that advantage and disadvantage could be combined. First, you could have “advantage of disadvantage,” meaning you roll twice with disadvantage and then keep the higher result. Or, you could have “disadvantage of advantage,” meaning you roll twice with advantage and then keep the lower result. With a fair 20-sided die, which situation produces the highest expected roll: advantage of disadvantage, disadvantage of advantage or rolling a single die?
\n
Extra Credit: Instead of maximizing your expected roll, suppose you need to roll N or better with your 20-sided die. For each value of N, is it better to use advantage of disadvantage, disadvantage of advantage or rolling a single die?
\n

Solution

There are a few questions we have to answer this week. First, which of the three rolls produces the highest expected value? Rolling \"disadvantage of advantage\" produces an expected roll of 11.17 - the highest among our three options. Here, we roll 4 dice, taking the maximum of each group of two, then the minimum of those results.

For the extra credit, it is easiest to view the results in a table. Below, the bold number in each row represents the highest odds of rolling at least that value. If we're trying to roll 14 or more, we should choose a single dice. Otherwise, we should choose the \"disadvantage of advantage\" technique.

Metric	Single Roll	Advantage of Disadvantage	Disadvantage of Advantage
Expected Value	10.5	9.8333375	11.1666625
Roll 1 or greater	100%	100%	100%
Roll 2 or greater	95%	99.0%	99.5%
Roll 3 or greater	90%	96.4%	98.0%
Roll 4 or greater	85%	92.3%	95.6%
Roll 5 or greater	80%	87.0%	92.2%
Roll 6 or greater	75%	80.9%	87.9%
Roll 7 or greater	70%	74.0%	82.8%
Roll 8 or greater	65%	66.6%	77.0%
Roll 9 or greater	60%	59.0%	70.1%
Roll 10 or greater	55%	51.3%	63.6%
Roll 11 or greater	50%	43.8%	56.3%
Roll 12 or greater	45%	36.4%	48.7%
Roll 13 or greater	40%	29.4%	41.0%
Roll 14 or greater	35%	23.0%	33.4%
Roll 15 or greater	30%	17.2%	26.0%
Roll 16 or greater	25%	12.1%	19.1%
Roll 17 or greater	20%	7.8%	13.0%
Roll 18 or greater	15%	4.4%	7.7%
Roll 19 or greater	10%	2.0%	3.6%
Roll 20 or greater	5%	0.5%	1.0%

We can also visualize these results. The first chart shows the probability mass function - the probability of rolling exactly N. Each of the sub-charts' bars sums to 100%. We would use this chart to select the type of roll that gives us the best chance of rolling exactly N.

And for the extra credit, we can visualize the probability of rolling at least N. Each sub-chart starts at 100%, because a roll is guaranteed to produce at least 1. Then each type of roll decreases from there, with the curves differing slightly by the type of roll. For situations where we need a number of 14 or above, we should roll a single dice for the best odds. Otherwise, we should roll \"disadvantage of advantage\".

Methodology

There are lots of ways to solve this week's Riddler. I used python, but pen and paper, spreadsheets, or other software would work just as well. Here are a few functions that I used.

from itertools import groupby, product\n\n\n# here is an example of calculating the \"advantage\" roll. We simulate all\n# combinations of rolls: (1, 1), (1, 2), ..., (20, 19), (20, 20), then we\n# calculate the outcome by taking the maximum. We group the results by the\n# outcomes and sum the occurrences of each. We get a result that looks like\n# {1: 1, 2: 3, 3: 5, ..., 19: 37, 20: 39}.\nadvantage = (max(x) for x in product(range(1, 21), repeat=2))\nadvantage = {k: len(list(v)) for k, v in groupby(sorted(advantage))}\n\n\n# here is an example of calculating the \"disadvantage of advantage\" roll,\n# abbreviated as \"d_upon_a\". We simulate rolling four dice, taking the max\n# of each group of two, then the min of those. As before, we group the\n# results by the number we get, counting the number of occurrences. We get\n# a result that looks like {1: 799, 2: 2385, ..., 19: 4255, 20: 1521}.\nd_upon_a = (min(max(x[:2]), max(x[2:])) for x in product(range(1, 21), repeat=4))\nd_upon_a = {k: len(list(v)) for k, v in groupby(sorted(d_upon_a))}\n\n\n# then, given these dictionaries, we can calculate things like expected value.\n# if we call >>> expected_value(advantage), it returns 13.825.\ndef expected_value(rolls: dict) -> float:\n    \"\"\"Returns the expected value of a dictionary of rolls\"\"\"\n    return sum(k*v for k, v in rolls.items()) / sum(rolls.values())\n

"},{"title":"Riddler Apples","date":"May 8, 2020","slug":"riddler-apples","excerpt":"This was a challenging Riddler about a toddler's inefficient eating habits. Our picky toddler takes a bite from an Apple once every minute, and only if the randomly chosen spot has skin left on it. How long will it take to eat the entire apple? Spoiler - it's likely to outlast the toddler's attention span by quite some time.","tags":[],"status":"published","content":"

Introduction

This was a challenging Riddler about a toddler's inefficient eating habits. Our picky toddler takes a bite from an Apple once every minute, and only if the randomly chosen spot has skin left on it. How long will it take to eat the entire apple? Spoiler - it's likely to outlast the toddler's attention span by quite some time. Here is the problem text with full details of this disastrously slow process.

\nA certain 2-year-old is eating his favorite snack: an apple. But he eats it in a very particular way. When he first receives the apple, and every minute thereafter, he rotates the apple to a random position and then looks down. If there’s any skin of the apple left in the spot where he plans to take a bite, then he will indeed take that bite. But if there’s no skin there (i.e., he’s already taken bites at that spot), he won’t take a bite and will rotate the apple for another minute. Once he has bitten off all the skin of the apple, he’s done eating.\n
Suppose the apple is a sphere with a radius of 4 centimeters, and that each bite of the apple is a circle of the sphere whose radius, as measured along the apple’s curved surface, is 1 centimeter. On average, how many minutes will it take this 2-year-old to eat the apple?
\n

Solution

This week's answer is not perfectly precise, as I used a monte carlo simulation. Furthermore, because of the complexity of the problem, I was only able to run 10,000 scenarios, which means there is likely some variance in my answer compared to the \"true\" result. In any case, I can say with confidence that the toddler will be eating this apple for quite some time: on average, it will take roughly 550 minutes (more than 9 hours), to completely finish the snack.

Of course, because the process is random, each apple will be eaten differently. I've illustrated one scenario in the gif below. The apple is projected onto 2-dimensions (just like a map of the globe). Each red dot represents a point of skin on the apple's surface. At each step, the toddler chooses a random location, takes a bite, and the points in a nearby circle turn yellow. This gif shows just the first 150 bites, and it's not nearly enough to finish the apple. In fact this particular simulation doesn't finish until the 557th bite!

(I also found it fascinating to note how each bite is projected in two dimensions. Obviously each bite is a perfect circle on the 3-dimensional apple, but in this 2-dimensional projection, the bites can becomes distorted. Bites near the equator are nearly circular in shape, but bites near the poles become increasingly stretched out, owing to this particular method of projecting the globe into two dimensions. This is the exact same phenomena that makes Greenland look enormous on some maps of the world.)

In addition to this single scenario, we can also view the distribution of all 10,000 simulations. This chart shows a histogram of the number of bites it took for every apple to be eaten. The results range from roughly 200 minutes (3+ hours), to 1200 minutes (20 hours!)

Methodology

This was a challenging problem, and the only way I could think to tackle it was to simulate the process. In addition, rather than modeling the apple as a continuous, smooth sphere, I modeled a network of \"sensors\" scattered randomly and uniformly across its surface. I tracked whether each sensor still contained skin, and the simulation ended once all sensors had been \"eaten\". With a large enough number of sensors, e.g. 50,000, there should be little accuracy lost compared to a continuous model, and counting the sensors simplifies the problem significantly.

Before I dive into the details, I also found it helpful to list the steps needed to solve this problem. These are like \"sub-problems\" that each contribute to the overall solution. Each of these problems presented its own unique challenges.

Choose a point randomly and uniformly on the apple's surface.
Once a point is chosen, determine the area of the \"bite\".
After each bite, track the total area of skin remaining.

Let's review how to solve each of these.

Choose a random point on the apple's surface

A pitfall to avoid here is that many algorithms for choosing uniform points in two dimensions will not be uniform in three dimensions. As an example, suppose you start by generating a random latitude (-90° to 90°) and longitude (-180° to 180°), then plotting that point on the sphere. After many iterations, you will find that your points are concentrated near the poles, and not uniformly distributed across the sphere's surface. This happens because each ring of latitude (which is chosen with the same probability) is a different size on the sphere: the rings near the equator are much larger, and points will be more spread out than the rings near the poles, which are smaller and more dense.

Fortunately, this problem is well known, and many algorithms exist to choose uniform points on the surface of a sphere. The next decision we have to make is what coordinate system we want to use. I chose cartesian coordinates, expressed as $(x, y, z)$ , in particular because it makes the next step easier.

In the python program I wrote, you can generate a random point on the surface of the apple easily. However, it's not quite as easy to imagine where those points are on the surface. I also included a method to be able to translate between cartesian and latitude/longitude systems.

# set a random seed for reproducibility\nnp.random.seed(42)\n\n# create a new Apple object\napple = Apple()\n\n# generate random points using cartesian coordinates (x, y, z)\npoints = apple.uniform_cartesian_samples(n_samples=2)\n# array([[-3.41545755, -1.81930207, -1.01231898],\n#        [ 0.48038245,  3.28718639,  2.22792243]])\n\n# convert to latitude/longitude (values in radians)\ncoords = apple.cartesian_to_lat_lon(points)\n# array([[-2.65215412, -0.25586232],\n#        [ 1.42568564,  0.59074583]])\n

Determine the bite area

I chose to operate primarily in cartesian coordinates because it is easy to calculate \"great circle distance\". Great circle distance is the shortest distance between two points along the surface of the sphere. It's the path that an ant would take to walk from A to B. In this problem, a bite includes points up to 1cm away from the initial point. I wrote a method that returns all points within a certain radius, which will give us the points affected by a bite.

# set a random seed for reproducibility\nnp.random.seed(42)\n\n# create a new Apple object\napple = Apple()\n\n# select a random point to bite\nbite_center = apple.random_sensor()\n# array([-3.22979111,  2.21487782, -0.81410417])\n\n# identify all the points within a 1cm radius\nbite_points = apple.nearby_sensors(bite_center, radius=1.0)\n# array([[-3.13397650e+00,  2.47674898e+00, -2.09537066e-01],\n#        [-2.96055610e+00,  2.67557705e+00, -2.76396469e-01],\n#        [-3.40621913e+00,  1.98721351e+00, -6.69816170e-01],\n#        ...\n#        [-2.81781602e+00,  2.32745616e+00, -1.62568777e+00],\n#        [-3.49884821e+00,  1.82905212e+00, -6.42362473e-01],\n#        [-2.86722633e+00,  2.76529043e+00, -3.63568444e-01]])\n

Track the total area of skin remaining

Now that we have a way to choose random points and calculate the size of a bite, we need a way to track the status of each sensor. One way to do this is to keep a set of sensors on the apple's surface that still have skin. Every time we take a bite, some sensors may be removed from this set if they are included in the bite. Once the set has zero elements (no more skin on the apple), then the simulation ends. In python, the eat method performs one simulation and returns the number of bites it took to eat the apple.

# set a random seed for reproducibility\nnp.random.seed(42)\n\n# create an Apple object with 50,000 points tracked on its surface\napple = Apple(radius=4.0, n_sensors=50000)\n\n# simulate one apple being eaten - returns the number of bites\nresults = apple.eat()  # returns 577 - nearly 10 hours to eat!\n

Full Code

This week's solution is brute force and inefficient. It took several hours to generate 10,000 simulations. However, I think the logical flow of the program makes sense, and could be improved in the future. I created a Sphere class that has methods related to spheres, and an Apple class that inherits these methods in order to solve the problem. In particular there are methods for each of the steps above, like choosing random points, converting between coordinate systems, and simulating an apple being eaten.

\"\"\"Classes and functions to solve the Riddler Classic from May 8, 2020\"\"\"\nimport numpy as np\n\n\nclass Sphere:\n    \"\"\"\n    This class is used to model various properties of a sphere. For example, it\n    contains methods to calculate surface area, generate random, uniformly dist-\n    ributed points on the sphere's surface, calculate great circle distance bet-\n    ween points, and convert between coordinate systems such as cartesian, lati-\n    tude/longitude, etc.\n\n    Examples\n    --------\n    >>> sphere = Sphere(radius=4.0)\n    >>> sphere\n    <Sphere(radius=4.0)>\n\n    >>> np.random.seed(42)\n    >>> points = sphere.uniform_cartesian_samples(2)\n    >>> points\n    array([[ 2.40000818, -0.6680612 ,  3.12948158],\n           [ 3.90868531, -0.60092837, -0.60088624]])\n\n    >>> sphere.cartesian_to_lat_lon(points)\n    array([[-0.27148532,  0.89846272],\n           [-0.1525474 , -0.15079237]])\n    \"\"\"\n\n    def __init__(self, radius: float) -> None:\n        self.radius = radius\n\n    def __repr__(self) -> str:\n        return f\"<Sphere(radius={self.radius:,.1f})>\"\n\n    def uniform_cartesian_samples(self, n_samples: int) -> np.ndarray:\n        \"\"\"\n        Returns an array of uniformly distributed points on the surface of this\n        sphere, expressed as cartesian coordinates, (x, y, z). The output array\n        will have shape (n_samples, 3).\n        \"\"\"\n        # we generate these points by sampling from a standard normal\n        # distribution for x, y, z, then normalizing each vector\n        points = np.random.normal(size=(n_samples, 3))\n        factor = (points ** 2).sum(1) ** 0.5\n        return self.radius * points / factor[:, None]\n\n    def great_circle_distance(\n        self, point: np.ndarray, points: np.ndarray\n    ) -> np.ndarray:\n        \"\"\"\n        Returns the great circle distance between a single point and an array of\n        points. Points should be expressed in cartesian coordinates, (x, y, z).\n        \"\"\"\n        # ensure factor is between -1 and 1 before passing to arccos\n        factor = points @ point / self.radius ** 2\n        factor = np.clip(factor, a_min=-1.0, a_max=1.0)\n        return self.radius * np.arccos(factor)\n\n    def cartesian_to_lat_lon(self, points: np.ndarray) -> np.ndarray:\n        \"\"\"\n        Converts an array of cartesian points to an array of latitude/longitude.\n        The input array should have shape (n_samples, 3), and the output array\n        will have shape (n_sample, 2).\n        \"\"\"\n        latitude = np.arcsin(points[:, 2] / self.radius)\n        longitude = np.arctan2(points[:, 1], points[:, 0])\n        return np.vstack([longitude, latitude]).T\n\n\nclass Apple(Sphere):\n    \"\"\"\n    This class represents an Apple as a sphere with radius r. This class will be\n    used to solve the Riddler Classic from May 8, 2020, found here:\n    fivethirtyeight.com/features/can-you-eat-an-apple-like-a-toddler/\n\n    The basic approach is to model the Apple as a sphere with a fixed number of\n    discrete \"sensor\" points spread uniformly and randomly across its surface.\n    The sensors are used to track whether that particular point on the Apple\n    still contains skin. With enough sensors, we approach a continuous model of\n    the Apple's surface.\n\n    Ultimately, to answer the Riddler, call the `eat` method, which will run a\n    monte carlo simulation of taking bites until all skin has been eaten.\n\n    Examples\n    --------\n    >>> np.random.seed(42)\n\n    >>> apple = Apple(radius=4)\n    >>> apple\n    <Apple(radius=4.0, n_sensors=10,000)>\n\n    >>> apple.sensors[:5]\n    array([[ 2.40000818, -0.6680612 ,  3.12948158],\n           [ 3.90868531, -0.60092837, -0.60088624],\n           [ 3.47558777,  1.68899767, -1.03323594],\n           [ 2.54700647, -2.17547878, -2.18633257],\n           [ 0.37406549, -2.95786657, -2.66666465]])\n\n    >>> apple.random_sensor()\n    array([-3.22979111,  2.21487782, -0.81410417])\n\n    >>> # run a single simulation of the bites it takes to finish the apple\n    >>> apple.eat()\n    425\n    \"\"\"\n\n    def __init__(self, radius: float = 4.0, n_sensors: int = 10000) -> None:\n        super().__init__(radius=radius)\n        self.n_sensors = n_sensors\n        self.sensors = self.uniform_cartesian_samples(n_samples=n_sensors)\n\n    def __repr__(self) -> str:\n        return (\n            f\"<Apple(\"\n            f\"radius={self.radius:,.1f}, \"\n            f\"n_sensors={self.n_sensors:,.0f})>\"\n        )\n\n    def random_sensor(self) -> np.ndarray:\n        \"\"\"Returns a randomly selected sensor from the surface of the Apple\"\"\"\n        return self.sensors[np.random.choice(self.n_sensors)]\n\n    def nearby_sensors(\n        self, point: np.ndarray, radius: float = 1.0\n    ) -> np.ndarray:\n        \"\"\"\n        Returns all sensors within a given radius of a point, measured along the\n        surface of the Apple (i.e. the great circle distance).\n        \"\"\"\n        distance = self.great_circle_distance(point, self.sensors)\n        return self.sensors[distance < radius]\n\n    def eat(self, bite_radius: float = 1.0) -> int:\n        \"\"\"\n        Solves the Riddler by simulating eating this Apple. Start with a fresh\n        Apple, where every \"sensor\" on the Apple's surface contains skin. Then\n        we simulate taking a bite with a given radius, measured on the Apple's\n        surface. Each sensor within the bite radius is removed from the set of\n        sensors containing skin. Continue this process until no skin remains.\n        \"\"\"\n        n = 0\n        skin = set(tuple(sensor) for sensor in self.sensors)\n        while skin:  # keep going if at least one sensor has skin remaining\n            location = self.random_sensor()\n            eaten = self.nearby_sensors(point=location, radius=bite_radius)\n            skin -= set(tuple(sensor) for sensor in eaten)\n            n += 1\n        return n\n\n    def write_results(self, output_file: str) -> None:\n        \"\"\"Run simulations and write to a file until KeyboardInterrupt\"\"\"\n        with open(output_file, \"w\") as output:\n            try:\n                while True:\n                    trial = self.eat()\n                    output.write(f\"{trial}\\n\")\n                    print(trial)\n            except KeyboardInterrupt:\n                pass\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n\n    # these simulations are quite slow: about 2 per second. As a result, I'll\n    # write the results to a file and run them in the background for a while.\n    apple = Apple(radius=4.0, n_sensors=25000)\n    apple.write_results(\"20200508-riddler-results.txt\")\n

"},{"title":"Riddler Prisoners","date":"May 1, 2020","slug":"riddler-prisoners","excerpt":"This week's Riddler uses probability to design the ultimate jailbreak. Prisoners are given the opportunity to flip coins, and if all flipped coins are heads, each prisoner is released. Without communicating, what strategy should the prisoners use to maximize their odds of success?","tags":[],"status":"published","content":"

Introduction

This week's Riddler uses probability to design the ultimate jailbreak. Prisoners are given the opportunity to flip coins, and if all flipped coins are heads, each prisoner is released. Without communicating, what strategy should the prisoners use to maximize their odds of success? Here is the full problem text.

\nYou are locked in the dungeon of a faraway castle with three fellow prisoners (i.e., there are four prisoners in total), each in a separate cell with no means of communication. But it just so happens that all of you are logicians (of course).\n
To entertain themselves, the guards have decided to give you all a single chance for immediate release. Each prisoner will be given a fair coin, which can either be fairly flipped one time or returned to the guards without being flipped. If all flipped coins come up heads, you will all be set free! But if any of the flipped coins comes up tails, or if no one chooses to flip a coin, you will all be doomed to spend the rest of your lives in the castle’s dungeon.
\n
The only tools you and your fellow prisoners have to aid you are random number generators, which will give each prisoner a random number, uniformly and independently chosen between zero and one.
\n
What are your chances of being released?
\n
Extra credit: Instead of four prisoners, suppose there are N prisoners. Now what are your chances of being released?
\n

Solution

The ideal strategy allows the four prisoners to escape 28.5% of the time. To achieve this outcome, each prisoner generates a random number. If the prisoner's random number is less than 0.34, the prisoner should flip a coin. Otherwise, the prisoner should return the coin unflipped. This strategy seeks to minimize the total number of coins flipped (because that gives the greatest odds that all coins flipped will be heads), while seeking to ensure that at least one coin is flipped.

Why the threshold of 0.34? This maximizes the overall probability of success. The chart below shows how the odds of success (the lines) change for different threshold values on the x-axis. We see that the odds of success for a group of four prisoners is maximized when x = 0.34.

We also see that larger groups of prisoners should choose smaller thresholds, because they want to keep the total number of coins low. Ultimately, large groups of N prisoners should expect roughly 25% odds of success.

Methodology

In a perfect world, with full communication, a group of prisoners would flip just one coin, giving overall odds of success of 50%. (For example, they would nominate the oldest prisoner to be the only one to flip a coin.) However, without the ability to communicate, the prisoners have to design a system to minimize the number of coins flipped without being so stingy that no coins are flipped. Fortunately, because our prisoners are all logicians, they can design a strategy that relies on perfect group behavior.

To limit the number of coins, a prisoner only flips if their random number is less than some value, $p$ . Then the total number of coins flipped is a binomial distribution. For four prisoners and a threshold of $p$ , the likelihood of k coins being flipped is:

P(k\\ \\text{coins}\\ |\\ \\text{threshold}=p)={N \\choose k}p^k(1-p)^{N-k}

So, for example, if $p=0.3$ , the probability of 2 coins being flipped is

P(2\\ \\text{coins}\\ |\\ \\text{threshold}=0.3)={4 \\choose 2}0.3^2(0.7)^{2} = 0.2646

In python, we do the same thing with the binom distribution from scipy.stats. Here, the pmf method represents the probability mass function, which is the probability that a distribution takes a certain discrete value.

>>> from scipy.stats import binom\n>>> binom(p=0.3, n=4).pmf(2)\n0.2646\n

We also know that if we flip 2 coins, the probability of both being heads is 25%. Therefore, if we set a threshold of 0.3, we flip 2 coins with probability 0.2646 and both of them are heads with probability 0.25. The probability of success is their product, 0.06615. Of course, we could have flipped 0, 1, 2, 3, or 4 coins, so we do the same calculation for each number. The only exception is that 0 coins is a guaranteed failure, so we can omit it. The sum of all possible numbers of coins is our final answer.

Mathematically, we want to find the value of $p$ that maximizes this function, where $N$ is the number of prisoners.

P(\\text{success}\\ |\\ \\text{threshold}=p)=\\sum_{k=1}^{N} \\frac{{N \\choose k}p^k(1-p)^{N-k}}{2^k}

Usually, we find the maximum of a function by taking its derivative and solving for the point where the derivative equals zero. However, this equation is somewhat unwieldy. We can turn to a calculator instead. We find that four prisoners maximize their odds of success when $p\\approx0.342$ .

In python, I wrote a function that calculates the odds of success, given a threshold, $p$ , and a number of prisoners, $N$ . By calculating this function for many values of $p$ , we generate the lines in the chart above, and can use any solver to identify the value of $p$ that maximizes the output. We can also change the value of $N$ to explore strategies for larger numbers of prisoners. These larger groups pursue similar strategies, but the threshold value, $p$ , gets lower and lower. Ultimately, the probability of success for an infinitely large groups appears to converge to 25%.

from scipy.stats import binom\n\n\ndef model(threshold: float, prisoners: int = 4):\n    \"\"\"\n    Returns the probability that the prisoners will be released.\n\n    Solves the Riddler Classic from May 1, 2020:\n    fivethirtyeight.com/features/can-you-flip-your-way-to-freedom/\n\n    The prisoners will be released if every coin flipped by a\n    prisoner is heads. Each prisoner decides to flip a coin if\n    they draw a random number less than `threshold`; otherwise,\n    they will decide not to flip a coin. If no prisoners flip\n    a coin, which occurs when `threshold == 0`, then it results\n    in a failure.\n\n    Examples\n    --------\n    >>> # no prisoners flip coins; should be a failure\n    >>> model(0.0)\n    0.0\n\n    >>> # all prisoners flip coins; should be 2**-prisoners\n    >>> model(1.0, prisoners=4)\n    0.0625\n\n    >>> # one prisoner should always flip a coin\n    >>> model(1.0, prisoners=1)\n    0.5\n    \"\"\"\n\n    # determine the number of coins that will be flipped based\n    # on the threshold value. This is a binomial distribution,\n    # with p=threshold and n=prisoners. As a shortcut, we omit\n    # the possibility of zero dice, because it would result in\n    # an automatic loss. For each number of coins we multiply\n    # by the probability of flipping all heads: 2 ** -k.\n    dist = binom(p=threshold, n=prisoners)\n    return sum(\n        dist.pmf(k) / 2 ** k for k in range(1, prisoners + 1)\n    )\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Monty Hall","date":"Apr 24, 2020","slug":"riddler-monty-hall","excerpt":"The original Monty Hall Show featured three doors, two goats, and a brand new car. Contestants choose a door, Monty reveals a goat behind another door, and contestants are offered the chance to switch their original choice. After heated debate among probability nerds, it was eventually agreed that switching is the optimal strategy, which wins two out of three games. In this week's Riddler, we examine a variation of this game in which the number of goats is random. Does it change the decision to switch?","tags":[],"status":"published","content":"

Introduction

The original Monty Hall Show featured three doors, two goats, and a brand new car. Contestants choose a door, Monty reveals a goat behind another door, and contestants are offered the chance to switch their original choice. After heated debate among probability nerds, it was eventually agreed that switching is the optimal strategy, which wins two out of three games. In this week's Riddler, we examine a variation of this game in which the number of goats is random. Does it change the decision to switch? Here is the full problem text.

\nThe Monty Hall problem is a classic case of conditional probability. In the original problem, there are three doors, two of which have goats behind them, while the third has a prize. You pick one of the doors, and then Monty (who knows in advance which door has the prize) will always open another door, revealing a goat behind it. It’s then up to you to choose whether to stay with your initial guess or to switch to the remaining door. Your best bet is to switch doors, in which case you will win the prize two-thirds of the time.\n
Now suppose Monty changes the rules. First, he will randomly pick a number of goats to put behind the doors: zero, one, two or three, each with a 25 percent chance. After the number of goats is chosen, they are assigned to the doors at random, and each door has at most one goat. Any doors that don’t have a goat behind them have an identical prize behind them.
\n
At this point, you choose a door. If Monty is able to open another door, revealing a goat, he will do so. But if no other doors have goats behind them, he will tell you that is the case.
\n
It just so happens that when you play, Monty is able to open another door, revealing a goat behind it. Should you stay with your original selection or switch? And what are your chances of winning the prize?
\n

Solution

As in the original Monty Hall problem, once the goat is revealed, the optimal decision is to switch doors, leading to an expected win percentage of 50%. Staying with our original door would result in an expected win percentage of 37.5%. In a fresh game, without the reveal of the goat, our odds of winning with a switching strategy are two thirds - the same as in the original game. However, once the first goat is revealed, we learn more about the game: in this case we've eliminated some favorable scenarios, notably the one where there are zero goats, so we must revise our expected win rate down.

Methodology

This problem is concise enough to list all outcomes with their probabilities. The total probability in our table adds up to 100%, which ensures we counted all the possible scenarios. The outcome for a scenario, given our decision to switch or stay, is either a zero or a one - a loss or a win. Then the expected value of a given strategy is the product of the outcome and the probability summed over all scenarios. Here they are:

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

# Goats	Original Choice	Goat Revealed?	Switch Value	Stay Value	Probability
0	🚗	No	$1$	$1$	25.0%
1	🚗	Yes	$1$	$1$	16.6%
1	🐐	No	$1$	$0$	8.3%
2	🚗	Yes	$0$	$1$	8.3%
2	🐐	Yes	$1$	$0$	16.6%
3	🐐	Yes	$0$	$0$	25.0%
		Expected Value	66.6%	50.0%	100.0%

This table tells us that the overall expected value of the switching strategy is 66.6%. This means if we switch doors, we win the prize two thirds of the time. If we stay with our original door, we win half the time. We get these expected values by multiplying the outcomes of each scenario with the probability of each scenario occurring.

However, that wasn't exactly what the question asked us. Instead, it asked how we should play, given that a goat is revealed. As a result, we want to narrow our set of possible scenarios to only those in which a goat is revealed. We still use the table above, but we throw away the rows where \"Goat Revealed\" is \"No\". After we do that, our probabilities will no longer sum to 100%, but that's ok. What we're doing is taking a conditional probability, which means we're interested in the scenarios where a certain condition has occurred: \"goat revealed\". Once we remove the scenarios we don't care about, we can rescale (or normalize) the probabilities, which means we we divide each one by the total of the remaining rows. After we do that, the new, scaled probabilities will sum to 100%.

Once we have the normalized probabilities, we can repeat the multiplication from before. We multiply the outcomes from switching and staying with the probability of each scenario, and we can answer the original question.

Value of Staying, given a goat has been revealed: 37.5%
Value of Switching, given a goat has been revealed: 50.0%

As we can see, the correct choice is still to switch doors, but our overall expected win percentage is lower. This is because we have eliminated the possibility of being in the \"zero goat\" universe, which would have been a guaranteed win. (That is, of course, if you didn't want a goat to begin with...)

"},{"title":"Riddler Game of Life","date":"Apr 17, 2020","slug":"riddler-game-of-life","excerpt":"In memory of John Conway, we explore a modified version of the famous \"Game of Life\" in this week's Riddler. I implemented the Game in python, which ended up being so much fun that many of the features aren't strictly required to solve the problem. Instead, they were amusing diversions that helped me explored this surprisingly nuanced game. It's probably just as Conway would have intended.","tags":[],"status":"published","content":"

Introduction

In memory of John Conway, we explore a modified version of the famous \"Game of Life\" in this week's Riddler Classic. I implemented the Game in python, which ended up being so much fun that many of the features aren't strictly required to solve the problem. Instead, they were amusing diversions that helped me explored this surprisingly nuanced game. It's probably just as Conway would have intended.

\nRiddler Nation was deeply saddened to hear of the loss of John Conway last week. It is only fitting that this week’s Classic is a spin on Conway’s Game of Life.\n
In the most common version of the game, there is an infinite grid of square cells, which are initially either alive or dead. Each square has eight neighbors — the eight squares that surround it. And after every step in time, or “tick,” all the cells are simultaneously updated according to the following rules:
\n
\n
A living cell with two or three living neighbors remains living.
\n
A living cell with any other number of living neighbors dies (due to under- or overpopulation).
\n
A dead cell with exactly three living neighbors comes alive (due to reproduction).
\n
\n
These relatively simple rules lead to some startlingly complex, emergent behaviors. For example, some formations of living cells are known as “oscillators,” which change form from one tick to the next, ultimately returning back to their original formation.
\n
Now suppose we were to replace the infinite grid with a finite grid that has periodic boundary conditions, so that cells in the first row are neighbors with cells in the last row, and cells in the first column are neighbors with cells in the last column. If there are three rows and N columns, what is the smallest value of N that can support an oscillator?
\n

Solution

The smallest grid with an oscillation has just three rows and four columns, and there are two variations. Each of these grids oscillates every other evolution, as shown in the gifs below.

Methodology

One way of completing this puzzle was to build a \"Game of Life\" simulator, then test all the different starting grids we might expect. This turned out to be a fun programming challenge. I implemented the game using a class called Grid, which tracks alive and dead cells in an array and provides many different utility methods to evaluate the game.

Each Grid object takes a starting array of cells, coded by zeros and ones. The __repr__ object of each Grid returns a unicode representation of the alive (black) and dead (white) cells. For example, this code snippet creates a Grid with four alive cells.

cells = np.array([[0, 1, 0], [1, 0, 1], [0, 1, 0]])\nGrid(cells)\n

⬜⬛⬜
\n⬛⬜⬛
\n⬜⬛⬜

There are also a few convenience constructors. For example, we can create a randomly-generated Grid by calling the random classmethod.

Grid.random(size=(5, 10), random_state=42)\n

⬜⬛⬜⬜⬜⬛⬜⬜⬜⬛
\n⬜⬜⬜⬜⬛⬜⬛⬛⬛⬜
\n⬛⬜⬛⬛⬛⬛⬛⬛⬛⬛
\n⬜⬜⬛⬛⬛⬜⬛⬜⬜⬜
\n⬜⬜⬛⬛⬛⬛⬛⬜⬛⬛

Once we have a Grid object, we can move forward in time using the evolve method. This method moves forward by n ticks and returns the updated Grid, following the well established rules of the Game.

grid = Grid.random(size=(5, 10), random_state=42)\ngrid.evolve(1)\n

⬛⬜⬛⬜⬜⬜⬜⬜⬜⬛
\n⬜⬛⬛⬜⬜⬜⬜⬜⬜⬜
\n⬜⬛⬛⬜⬜⬜⬜⬜⬜⬛
\n⬛⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬛⬛⬜⬜⬜⬜⬛⬛⬛⬛

All of this is implemented behind the scenes, as it were, by using a padded_cells array that handles the wrapping logic specified in the problem. The padded_cells array links the top row of cells to the bottom, the left to the right, and each corner to its opposite corner. To calculate each cell's \"score\" (the number of live neighbors), we use the convolve2d function from scipy, which is typically used to scan images and group boxes of pixels together in a process called convolution. (It's commonly used in deep learning for image recognition in Convolutional Neural Networks.) Once we know each cell's \"score\", we can simulate whether it lives or dies in the next evolution.

There are a few other convenience methods, like plotting the Grid and creating a .gif out of its evolutions.

For example, it can be fun to view the evolution of a larger grid to see what patterns emerge. This code generates a 30x30 cell array and lets it run for 100 iterations. You can see several static clumps of cells, and a few oscillators - notably the \"blinker\".

However, my favorite feature, which has very little to do with the original problem, is a special constructor. You may have seen the xkcd tribute to John Conway. Calling Grid.conway() creates a Grid that follows this pattern.

Grid.conway()\n

⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬛⬛⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬛⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬛⬜⬛⬛⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬛⬜⬛⬜⬛⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬛⬜⬜⬛⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜
\n⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜

And the .gif of this Grid's evolution matches the original comic. It was a fantastic tribute.

Full Code

This code technically solves the Riddler Classic, but I had much more fun trying to implement a more complete version of the Game of Life that accepts a grid of any size. It still implements the wrapping (see Grid.padded_cells), and also implements a few visualization methods, like plotting and creating .gifs.

\"\"\"Solution to the Riddler Classic from April 17, 2020\"\"\"\nfrom itertools import product\nfrom typing import Iterator, Optional, Tuple\nimport gif  # https://github.com/maxhumber/gif, `pip install gif`\nfrom matplotlib import pyplot as plt\nimport numpy as np\nfrom scipy.signal import convolve2d\n\n\nclass Grid:\n    \"\"\"\n    Grid object representing Conway's Game of Life. Can model the Riddler\n    variation of the game by passing `wrapped=True`, which will connect the\n    edges of the grid with the opposite sides, creating a continuous surface.\n\n    Parameters\n    ----------\n    cells : np.ndarray with integer or boolean dtype, specifies the size of the\n            grid and alive cells (1) and dead cells (0)\n    wrapped : boolean, default True, indicates whether the Riddler wrapping\n              conditions apply to this Grid. If True, then the grid \"wraps\" so\n              edges connect to opposite edges and corners connect to opposite\n              corners. If False, the grid is assumed to be infinite and empty\n              outside of the array passed when the Grid is instantiated.\n\n    Examples\n    --------\n    >>> cells = np.array([[0, 1, 1, 0, 0],\n    ...                   [0, 0, 0, 1, 1],\n    ...                   [1, 1, 0, 1, 0]])\n    >>> Grid(cells)\n    ⬜⬛⬛⬜⬜\n    ⬜⬜⬜⬛⬛\n    ⬛⬛⬜⬛⬜\n\n    >>> Grid(cells) == Grid(cells)\n    True\n\n    >>> # initialize a random grid, but set a seed for reproducibility\n    >>> grid = Grid.random((3, 5), random_state=42)\n    >>> grid\n    ⬜⬛⬜⬜⬜\n    ⬛⬜⬜⬜⬛\n    ⬜⬜⬜⬜⬛\n\n    >>> # iterate one step and return a new Grid object\n    >>> grid.evolve(1)\n    ⬜⬜⬜⬜⬛\n    ⬛⬜⬜⬜⬛\n    ⬜⬜⬜⬜⬛\n    \"\"\"\n\n    def __init__(self, cells: np.ndarray, wrapped: bool = True) -> None:\n        self.cells = cells\n        self.wrapped = wrapped\n\n    def __repr__(self) -> str:\n        \"\"\"Represent each element of the grid as a 'pixel'\"\"\"\n        read_row = lambda row: \"\".join(\"⬛\" if x else \"⬜\" for x in row)\n        return \"\\n\".join(read_row(row) for row in self.cells)\n\n    def __eq__(self, other) -> bool:\n        \"\"\"Two Grids are equal if they have the same `cells` array\"\"\"\n        return (self.cells == other.cells).all()\n\n    @classmethod\n    def conway(cls, wrapped: bool = False):\n        \"\"\"\n        Specific constructor that creates a Grid object in the shape of the xkcd\n        tribute to John Conway, found here: https://xkcd.com/2293/\n\n        Examples\n        --------\n        >>> Grid.conway()\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬛⬛⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬛⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬛⬜⬛⬛⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬛⬜⬛⬜⬛⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬛⬜⬜⬛⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬛⬜⬛⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜⬜\n        \"\"\"\n        x = [6, 7, 8, 6, 8, 6, 8, 7, 4, 6, 7, 8, 5, 7, 9, 7, 10, 6, 8, 6, 8]\n        y = [\n            9, 9, 9, 10, 10, 11, 11, 12, 13, 13, 13,\n            13, 14, 14, 14, 15, 15, 16, 16, 17, 17\n        ]\n        cells = np.zeros(shape=(21, 15))\n        cells[y, x] = 1\n        return Grid(cells, wrapped=wrapped)\n\n    @classmethod\n    def random(\n        cls,\n        size: Tuple[int, int],\n        wrapped: bool = True,\n        random_state: Optional[int] = None\n    ):\n        \"\"\"\n        Create a randomly-initialized Grid of a given size\n\n        Examples\n        --------\n        >>> grid = Grid.random((3, 5), random_state=42)\n        >>> grid\n        ⬜⬛⬜⬜⬜\n        ⬛⬜⬜⬜⬛\n        ⬜⬜⬜⬜⬛\n        \"\"\"\n        np.random.seed(random_state)\n        return Grid(np.random.randint(2, size=size), wrapped=wrapped)\n\n    @property\n    def padded_cells(self) -> np.ndarray:\n        \"\"\"\n        Helper attribute that adds a padding layer around the cells in the grid.\n        This padded  array is used later for calculating the score of each cell,\n        and also handles the wrapping methodology if applicable.\n\n        Examples\n        --------\n        >>> grid = Grid.random((3, 5), random_state=123)\n        >>> grid\n        ⬜⬛⬜⬜⬜\n        ⬜⬜⬛⬛⬜\n        ⬛⬛⬜⬛⬜\n        >>> grid.padded_cells\n        array([[0, 1, 1, 0, 1, 0, 1],\n               [0, 0, 1, 0, 0, 0, 0],\n               [0, 0, 0, 1, 1, 0, 0],\n               [0, 1, 1, 0, 1, 0, 1],\n               [0, 0, 1, 0, 0, 0, 0]])\n        >>> Grid(grid.padded_cells, wrapped=True)\n        ⬜⬛⬛⬜⬛⬜⬛\n        ⬜⬜⬛⬜⬜⬜⬜\n        ⬜⬜⬜⬛⬛⬜⬜\n        ⬜⬛⬛⬜⬛⬜⬛\n        ⬜⬜⬛⬜⬜⬜⬜\n        >>> grid = Grid.random((3, 5), random_state=123, wrapped=False)\n        >>> Grid(grid.padded_cells)\n        ⬜⬜⬜⬜⬜⬜⬜\n        ⬜⬜⬛⬜⬜⬜⬜\n        ⬜⬜⬜⬛⬛⬜⬜\n        ⬜⬛⬛⬜⬛⬜⬜\n        ⬜⬜⬜⬜⬜⬜⬜\n        \"\"\"\n        # first we create an array with an extra padding layer\n        rows, cols = self.cells.shape\n        padded = np.zeros(shape=(rows + 2, cols + 2), dtype=int)\n\n        # copy the original cell values into the middle\n        padded[1:-1, 1:-1] = self.cells\n\n        # if we aren't wrapping the grid, just return this padded array\n        if not self.wrapped:\n            return padded\n\n        # otherwise, handle wrapping conditions\n        # first, copy each edge onto the opposite (padded) side\n        padded[0, 1:-1] = self.cells[-1]     # bottom to top\n        padded[-1, 1:-1] = self.cells[0]     # top to bottom\n        padded[1:-1, 0] = self.cells[:, -1]  # right to left\n        padded[1:-1, -1] = self.cells[:, 0]  # left to right\n\n        # copy each corner to the opposite corner\n        padded[0, 0] = self.cells[-1, -1]\n        padded[0, -1] = self.cells[-1, 0]\n        padded[-1, 0] = self.cells[0, -1]\n        padded[-1, -1] = self.cells[0, 0]\n\n        return padded\n\n    def cell_score(self):\n        \"\"\"\n        Returns the number of living neighbor cells for each cell on the grid.\n\n        Examples\n        --------\n        >>> grid = Grid.random((3, 5), random_state=123)\n        >>> grid\n        ⬜⬛⬜⬜⬜\n        ⬜⬜⬛⬛⬜\n        ⬛⬛⬜⬛⬜\n        >>> grid.cell_score()\n        array([[3, 3, 5, 3, 3],\n               [3, 4, 4, 2, 3],\n               [2, 3, 5, 2, 3]])\n        \"\"\"\n        # the convolution scanner is a 3x3 array of ones, expect a middle zero\n        scanner = np.ones(shape=(3, 3), dtype=int)\n        scanner[1, 1] = 0\n        return convolve2d(self.padded_cells, scanner, mode=\"same\")[1:-1, 1:-1]\n\n    def evolve(self, steps: int = 1):\n        \"\"\"\n        Move the simulation forward by n steps, default 1\n\n        Examples\n        --------\n        >>> grid = Grid.random((3, 5), random_state=123)\n        >>> grid\n        ⬜⬛⬜⬜⬜\n        ⬜⬜⬛⬛⬜\n        ⬛⬛⬜⬛⬜\n        >>> grid.evolve(1)\n        ⬛⬛⬜⬛⬛\n        ⬛⬜⬜⬛⬛\n        ⬛⬛⬜⬛⬛\n        >>> grid.evolve(2)\n        ⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜\n        \"\"\"\n\n        def _evolve(grid):\n            \"Iterate a single step\"\n            scores = grid.cell_score()\n            evolution = np.zeros_like(grid.cells)\n\n            # live cells stay alive if they have exactly 2 or 3 alive neighbors\n            idx = (grid.cells == 1) & (scores > 1) & (scores < 4)\n            evolution[idx] = 1\n\n            # live cells die if they have any other number of neighbors\n            idx = (grid.cells == 1) & (scores < 2) & (scores > 3)\n            evolution[idx] = 0\n\n            # dead cells spawn if they have exactly three live neighbors\n            idx = (grid.cells == 0) & (scores == 3)\n            evolution[idx] = 1\n\n            return Grid(evolution, wrapped=self.wrapped)\n\n        grid = self\n        for _ in range(steps):\n            grid = _evolve(grid)\n        return grid\n\n    def period(self, limit: int = 20) -> int:\n        \"\"\"\n        If this Grid produces an identical grid after `n` evolutions, then\n        its period is equal to `n`. If it does not, then return -1.\n\n        `n` may be one for a grid that doesn't change after an evolution.\n\n        Parameters\n        ----------\n        limit : int, the maximum number of evolutions to search for a pattern\n\n        Examples\n        --------\n        >>> cells = np.zeros(shape=(4, 4), dtype=int)\n        >>> cells[1:-1, 1:-1] = 1\n        >>> grid = Grid(cells)\n        >>> grid\n        ⬜⬜⬜⬜\n        ⬜⬛⬛⬜\n        ⬜⬛⬛⬜\n        ⬜⬜⬜⬜\n        >>> grid.period()\n        1\n\n        >>> cells = np.zeros(shape=(5, 5), dtype=int)\n        >>> cells[2, 1:-1] = 1\n        >>> grid = Grid(cells)\n        >>> grid\n        ⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜\n        ⬜⬛⬛⬛⬜\n        ⬜⬜⬜⬜⬜\n        ⬜⬜⬜⬜⬜\n        >>> grid.period()\n        2\n        \"\"\"\n        for i in range(1, limit + 1):\n            if self == self.evolve(i):\n                return i\n        return -1\n\n    def plot(self):\n        \"\"\"Plot the grid in matplotlib\"\"\"\n        _, ax = plt.subplots(figsize=(7, 7))\n        plt.axis('equal')\n\n        ax.pcolor(\n            self.cells[::-1], edgecolors=\"0.92\", linewidth=1.2, cmap=\"Blues\"\n        )\n\n        ax.xaxis.set_visible(False)\n        ax.yaxis.set_visible(False)\n        for s in [\"top\", \"bottom\", \"left\", \"right\"]:\n            ax.spines[s].set_visible(False)\n\n        return ax\n\n    def create_gif(self, frames: int, filename: str, duration: int):\n        \"\"\"\n        Creates a .gif file with each frame moving forward one evolution.\n        Adds a few extra frames of the starting position to the beginning.\n        Uses the `gif` library: https://github.com/maxhumber/gif\n\n        Parameters\n        ----------\n        frames : int, the number of evolutions to simulate\n        filename : str, the name of the file, e.g. \"life.gif\"\n        duration : int, the delay between frames, in microseconds\n        \"\"\"\n\n        @gif.frame\n        def _plot(grid):\n            return grid.plot()\n\n        start = [_plot(self.evolve(0)) for _ in range(5)]\n        images = [_plot(self.evolve(n)) for n in range(frames)]\n        gif.save(start + images, filename, duration=duration)\n\n\ndef grid_generator(columns: int, rows: int = 3) -> Iterator[Grid]:\n    \"\"\"\n    Generator function that yields all permutations of Grids\n    that could be made with a (rows x columns) shape.\n\n    Examples\n    --------\n    >>> list(grid_generator(2, 1))\n    [⬜⬜, ⬜⬛, ⬛⬜, ⬛⬛]\n    \"\"\"\n    generator = product((0, 1), repeat=rows*columns)\n    for cells in generator:\n        yield Grid(np.array(cells).reshape(rows, columns))\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Spam","date":"Apr 10, 2020","slug":"riddler-spam","excerpt":"We're tracking spam messages in this week's Riddler. Spammers post messages on the column's comment board, and they also reply to each other's messages. Over a three-day time period, how many spam messages and replies should we expect to see? It turns out there are some fascinating connections with continuously compounding interest rates, which we'll derive from the differential equation. I'll also write a simulation using numpy and poisson distributions to verify our analytical approach.","tags":[],"status":"published","content":"

Introduction

We're tracking spam messages in this week's Riddler Classic. Spammers post messages on the column's comment board, and they also reply to each other's messages. Over a three-day time period, how many spam messages and replies should we expect to see? It turns out there are some fascinating connections with continuously compounding interest rates, which we'll derive from the differential equation. I'll also write a simulation using numpy and poisson distributions to verify our analytical approach.

\nLast week’s Riddler column garnered six comments on Facebook. However, every single one of those comments was spam. Sometimes, spammers even reply to other spammers’ comments with yet more spam. This got me thinking.\n
Over the course of three days, suppose the probability of any spammer making a new comment on this week’s Riddler column over a very short time interval is proportional to the length of that time interval. (For those in the know, I’m saying that spammers follow a Poisson process.) On average, the column gets one brand-new comment of spam per day that is not a reply to any previous comments. Each spam comment or reply also gets its own spam reply at an average rate of one per day.
\n
For example, after three days, I might have four comments that were not replies to any previous comments, and each of them might have a few replies (and their replies might have replies, which might have further replies, etc.).
\n
After the three days are up, how many total spam posts (comments plus replies) can I expect to have?
\n

Solution

Over a three-day period, we should expect just over 19 total spam messages, including original posts and replies.

Why isn't the answer 7? At first glance, it might seem like we could estimate the spam messages by counting:

Day 1: we expect one fresh spam message.
Day 2: we expect one fresh spam message and one reply to the existing message. Three total.
Day 3: we expect one fresh spam message and one reply each to our previous three. Seven total.

However, this approach oversimplifies the continuous nature of the problem. I'll try to explain in the next section.

Analytical Approach

Instead of counting messages per day, we want to be slightly more nuanced. The process we're modeling is continuous, meaning there is a small probability of a message appearing at every instant over the three days. So instead of modeling days, we could model hours to be more accurate. Or instead of modeling hours, we could model minutes, and then seconds, and so on. Eventually, the intervals become infinitesimal (vanishingly small), and we think in terms of \"continuous spam rates\" rather than \"messages per day\".

At any instant, our spam rate is equal to $s+1$ , where $s$ is the number of spam messages we've already received. This means that if we currently have 5 messages, our new spam rate is 6 per day. It's as if each spam message creates a new \"channel\" for other spammers to reply to, which increases the total rate of spam we expect.

We are dealing with instantaneous rates of change, so we can use notation like $\\Delta s$ to indicate the rate of change of $s$ . Our model can be written as: $\\Delta s = \\lambda(s+1)\\Delta t$ , meaning that the rate of spam ( $\\Delta s$ ) is equal to the base spam rate ( $\\lambda$ ) times the number of spam messages we've received plus one ( $s + 1$ ) times the change in time ( $\\Delta t$ ).

We can rewrite this relationship as a differential equation: $\\frac{\\delta s}{\\delta t} = \\lambda (s + 1)$ . But instead of $\\frac{\\delta s}{\\delta t}$ , we want $\\frac{\\delta t}{\\delta s}$ , which represents the derivative of time with respect to spam, so we have $\\frac{\\delta t}{\\delta s} = \\frac{1}{\\lambda (s + 1)}$ , also written as $t'(s) = \\frac{1}{\\lambda (s + 1)}$ .

Now, to calculate $t$ we integrate $\\frac{1}{\\lambda (s + 1)}$ , which, for constant $\\lambda$ is equal to $\\frac{ln(s+1)}{\\lambda}$ , which gives us $t=\\frac{ln(s+1)}{\\lambda}$ . Solving for $s$ gives us $s=e^{\\lambda t} - 1$ . When $t=3$ (for a three day time period), we calculate an expected spam total of 19.0855.

It is not surprising that $e$ shows up in our answer. This problem is exactly like continuously compounding interest, where the spam rate is the interest rate, and each spam message earns \"interest\" (i.e. attracts additional spam) continuously at a constant rate.

Simulation

We can also simulate this process. While it is impossible to simulate a continuous process exactly, we can discretize the process into many small, finite steps. The more steps we have, the more accurate our model will be.

Assume we want to model the likelihood of receiving a spam message or reply during each second of each of the three days. We will model 259,200 intervals (the number of seconds in three days.) During each second, the rate of spam we expect is equal to the number of messages we've received so far plus one, divided by the length of the interval (in days) $\\frac{s+1}{\\text{interval length}}$ . During the first second, the probability we receive a spam message is $\\frac{1}{86,400}$ , or roughly 0.000012. In the simulation code, we flip a theoretical coin, and if it lands on heads (with probability 0.000012), we add one spam message to our total. Then the next interval will have a different spam rate, and we continue the process for all the intervals, adding the spam messages as we go.

When the number of intervals is sufficiently large (e.g. 100 or more intervals per day), and the number of simulations is also large (e.g. 1000 or more), we find that the average number of spam messages converges to $e^{\\lambda t} - 1$ , or 19.0855.

# using the `model` function (source code below)\n# results will vary because of the random nature of the simulation\n# the output is an array of samples - the mean tells us the expected value\n>>> model(trials=100000, intervals_per_day=1000).mean()\n19.03231\n

Full Code

The code this week is a partly vectorized simulation function. We break the three-day time period into thousands of small intervals and simulate the spam messages received in each interval. It runs relatively quickly up to roughly one million trials and converges very closely to the analytical solution, $e^x-1$ for $x=3$ .

\"\"\"\nSolution to the Riddler Classic from April 10, 2020\nhttps://fivethirtyeight.com/features/can-you-catch-the-free-t-shirt/\n\"\"\"\nimport numpy as np\n\n\ndef model(\n    trials: int,\n    spam_rate: float = 1.0,\n    n_days: int = 3,\n    intervals_per_day: int = 1000,\n) -> np.ndarray:\n    \"\"\"\n    Solves the Riddler Classic via simulation. Breaks each day into intervals,\n    then draws from a poisson distribution for each interval, summing the total\n    spam messages over the course of n_days. The simulation is vectorized across\n    trials, and is quite fast for 1+ million trials.\n\n    Parameters\n    ----------\n    trials : int, the number of simulations to run, e.g. 1000\n    spam_rate : float, default 1.0, the average number of spam messages received\n        over the course of a full day\n    n_days : int, default 3, the number of days to simulate\n    intervals_per_day : int, default 1000, the number of intervals each day is\n        broken into for the purposes of simulation\n\n    Returns\n    -------\n    spam : np.ndarray of the total number of spam received over the time period\n        for each trial; will have shape == (trials,)\n    \"\"\"\n\n    # we want to loop through each interval of the simulation, keeping track of\n    # how many spam messages we receive and what the current spam rate is (which\n    # goes up as we receive more spam.) At each interval, we randomly draw from\n    # a poisson distribution to determine how much more spam we receive.\n    spam = np.zeros(trials)\n\n    for _ in range(n_days * intervals_per_day):\n        lam = (spam + 1) * spam_rate / intervals_per_day\n        spam += np.random.poisson(lam=lam)\n\n    return spam\n\n\nif __name__ == \"__main__\":\n    results = model(1_000_000)\n    print(f\"Average spam: {results.mean():,.4f}\")  # ~19.0512 depending on seed\n

"},{"title":"Riddler Snowplow","date":"Apr 3, 2020","slug":"riddler-snowplow","excerpt":"This week's Riddler was a fun calculus problem. Time to brush off our integrals! On a snowy day we try to pinpoint the moment the snow started based on how long it takes the plows to clear the roads.","tags":[],"status":"published","content":"

Introduction

This week's Riddler was a fun calculus problem. Time to brush off our integrals! On a snowy day we try to pinpoint the moment the snow started based on how long it takes the plows to clear the roads.

\nOne morning, it starts snowing. The snow falls at a constant rate, and it continues the rest of the day.\n
At noon, a snowplow begins to clear the road. The more snow there is on the ground, the slower the plow moves. In fact, the plow’s speed is inversely proportional to the depth of the snow — if you were to double the amount of snow on the ground, the plow would move half as fast.
\n
In its first hour on the road, the plow travels 2 miles. In the second hour, the plow travels only 1 mile.
\n
When did it start snowing?
\n

Solution

It must have started snowing at 11:23am. Amazingly, we don't need to calculate the rate of snowfall to solve the problem! We just need to use what we know about rates of change to compare the distances traveled by the snow plows over two periods of time.

Methodology

Let's start with what we know.

The snow is falling at a constant rate, which we can call $c$ . Over time, the amount of snow builds, and we can measure the amount of total snow by taking the integral of $c$ with respect to time.
The snow plows move half as fast when there is twice as much snow. We know from the problem that the plow covers 2 miles in the first hour and 1 mile in the second hour. We can model the speed of the plows as $\\frac{c}{x}$ . This is a velocity, so if we integrate it with respect to time we can calculate the distance covered.
The snow started falling at an unknown time, which we will call $t_0 = 0$ . The plow started at noon, which we will call $t_s$ . In other words, the value of $t_s$ tells us how many hours passed before the plows started.

We know that the plow's velocity at any time is equal to $\\frac{c}{x}$ . Therefore, we can solve for the distance covered by a plow by integrating velocity over time. Specifically, we know the plow traveled two miles from time $t_s$ to time $t_s + 1$ , and one mile from time $t_s + 1$ to time $t_s + 2$ . Now we can write both of those as integrals.

\\int_{t_s}^{t_s + 1} \\frac{c}{x} \\ dx = 2 \\text{ and } \\int_{t_s + 1}^{t_s + 2} \\frac{c}{x} \\ dx = 1

We can simplify both integrals by pulling the constant, $c$ out of both.

c \\times \\int_{t_s}^{t_s + 1} \\frac{1}{x} \\ dx = 2 \\text{ and } c \\times \\int_{t_s + 1}^{t_s + 2} \\frac{1}{x} \\ dx = 1

And solve them both, creating a system of equations with two unknown variables, $c$ and $t_s$ .

c \\times ln(x) \\Big\\vert_{t_s}^{t_s + 1} = 2 \\text{ and } c \\times ln(x) \\Big\\vert_{t_s + 1}^{t_s + 2} = 1

If we divide the two equations, the $c$ term cancels out, so we're left with a single equation and a single variable, $t_s$ .

2 \\times ln\\Big(\\frac{t_s + 2}{t_s + 1}\\Big) = ln\\Big(\\frac{t_s + 1}{t_s}\\Big)

Remembering that $a \\times ln(b) = ln(b^a)$ , and removing the logs on both sides, we arrive at:

\\Big(\\frac{t_s + 2}{t_s + 1}\\Big)^2 = \\frac{t_s + 1}{t_s}

And for the lazy among us, we find that:

t_s = \\frac{\\sqrt{5} - 1}{2} \\approx 0.618 \\text{ hours}

Now we know that noon was roughly 0.618 hours after the snow started. That's about 37 minutes, which means the snow started falling around 11:23am.

"},{"title":"Riddler Unstable Dice","date":"Mar 27, 2020","slug":"riddler-unstable-dice","excerpt":"Rolling and re-rolling dice is our task for this week's Riddler Classic. Each time we roll, we replace the sides of the dice with the values of our previous roll. This makes for a tricky probability space, but a very fun Python class to write and some markov chain analysis to crunch in order to solve it.","tags":[],"status":"published","content":"

Introduction

Rolling and re-rolling dice is our task for this week's Riddler Classic. Each time we roll, we replace the sides of the dice with the values of our previous roll. This makes for a tricky probability space, but a very fun Python class to write and some markov chain analysis to crunch in order to solve it. Here's the full prompt.

\nYou start with a fair 6-sided die and roll it six times, recording the results of each roll. You then write these numbers on the six faces of another, unlabeled fair die. For example, if your six rolls were 3, 5, 3, 6, 1 and 2, then your second die wouldn’t have a 4 on it; instead, it would have two 3s.\n
Next, you roll this second die six times. You take those six numbers and write them on the faces of yet another fair die, and you continue this process of generating a new die from the previous one.
\n
Eventually, you’ll have a die with the same number on all six faces. What is the average number of rolls it will take to reach this state?
\n
Extra credit: Instead of a standard 6-sided die, suppose you have an N-sided die, whose sides are numbered from 1 to N. What is the average number of rolls it would take until all N sides show the same number?
\n

Solution

In the game starting with a fair, six-sided die, it takes an average of 9.66 rolls to reach a single number on all sides.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Sides	Expected Rolls
2	2.0
3	3.85714
4	5.77931
5	7.71198
6	9.65599
7	11.60815
8	13.56629
9	15.52909

While I haven't explicitly derived a formula for an $N$ -sided dice, it feels reasonable to speculate that the pattern of \"two extra turns per additional side of the dice\" could continue for some time, though it likely falls off in magnitude as we increase the number of sides substantially. I'll have to save the formal analysis for another time.

Methodology

Starting with a six-sided dice is computationally difficult, but solvable. The key challenge is calculating the many combinations of probabilities for the intermediate positions of the game. For example, when we start with a standard dice, we could end up with over 46,000 different roll permutations! Of course, many of those permutations can be treated the same for the sake of our game (e.g. [3, 3, 4, 4, 5, 5] is the same as [5, 4, 3, 3, 4, 5]), but grouping the probabilities is not easy.

The workhorse of this week's puzzle is the Multinomial Distribution. The Multinomial Distribution lets us calculate the probability of various combinations of observed dice throws. For example, it can tell us the probability of observing $x_1$ ones, $x_2$ twos, $x_3$ threes, and so on, from six throws of a standard dice.

In a fairly simple case, suppose we have thrown the dice several times and now have two numbers remaining. Suppose those numbers are one and six, and we have 2 ones and 4 sixes on the sides of the dice. We can use the Multinomial Distribution to tell us the likelihood of observing different combinations of throws. In python, we use it like this.

from scipy.stats import multinomial\n\n# a six-sided dice with 2 ones and 4 sixes on the sides\n# n is the number of sides; p is the probability of each number being rolled\ndice = multinomial(n=6, p=[2/6, 4/6])\n\n# what is the probability of rolling 6 sixes? Use the probability mass function\ndice.pmf([0, 6])  # 0.08779149519890264\n\n# what about rolling 6 ones?\ndice.pmf([6, 0])  # 0.0013717421124828531\n\n# what about rolling 4 ones and 2 sixes?\ndice.pmf([4, 2])  # 0.0823045267489711\n

What we learn from this is that with this dice, we win the game roughly 9% of the time in one more turn. This represents the probability of rolling all 6 sixes plus the probability of rolling all six ones. Otherwise, we continue the game with the new number of ones and sixes according to our roll.

To make this easier, I wrote a class in Python called Dice, that handles all the probability calculations behind the scenes. A new game is started by creating a Dice with six sides, where each value on the sides shows up once:

# create a six-sided dice with one of each number\nDice([1, 1, 1, 1, 1, 1])\n\n# or we could create a six sided dice with 2 ones and 4 sixes, like before\n# the actual numbers don't matter - what matters is the number of unique values\nDice([2, 4])\n\n# we can calculate the probability of moving from one Dice to another easily\nDice([2, 4]).transition_vector()\n# output is below, where Dice([1, 5]) is added to Dice([5, 1]) for simplicity\n# {<Dice(6,)>: 0.0891632373113855,\n#  <Dice(1, 5)>: 0.2798353909465022,\n#  <Dice(2, 4)>: 0.4115226337448561,\n#  <Dice(3, 3)>: 0.2194787379972568}\n\n# we can also calculate the number of steps expected before the game ends\nDice([4, 2]).expected_value()\n# we expect to have to roll 6.58 more times before the game ends\n# 6.584840446909428\n

Ultimately, to answer the question for a six-sided Dice, we use just one line:

>>> Dice([1, 1, 1, 1, 1, 1]).expected_value()\n9.655991483885606\n

Full Code

Quite a bit of code for this week's solution. We have a utility function, multinomial_domain that lists all the possible permutations of dice rolls we could see. But the heavy lifting is done by the Dice class, which has methods for calculating roll probabilities, state transitions, a complete directed graph of nodes and edges, a transition matrix, and ultimately an expected_value method, which returns the number of expected rolls to end the game.

At this point, the code works well for small dice, but for anything more than 10 sides, the brute force nature of calculating probabilities breaks down.

\"\"\"\nSolution to the Riddler Classic from March 27, 2020\nhttps://fivethirtyeight.com/features/can-you-get-the-gloves-out-of-the-box/\n\"\"\"\nfrom typing import Iterator, List, Tuple, Union\nimport networkx as nx\nimport numpy as np\nfrom scipy.stats import multinomial\n\n\ndef multinomial_domain(n: int, k: int) -> Iterator[list]:\n    \"\"\"\n    Yields all lists of length `k` whose values sum to `n`. This comprises the\n    entire domain space of the multinomial distribution. For example, if we have\n    n=2 and k=3, we want to generate all lists of length 3 with values that sum\n    to 2, including all permutations which is\n    [[0, 0, 2], [0, 1, 1], [0, 2, 0], [1, 0, 1], [1, 1, 0], [2, 0, 0]]\n\n    Parameters\n    ----------\n    n : int, the number of multinomial trials to run\n    k : int, the number of categories that could be chosen for each trial\n\n    Yields\n    ------\n    x : a list of integers\n\n    Examples\n    --------\n    >>> list(multinomial_domain(n=2, k=3))\n    [[0, 0, 2], [0, 1, 1], [0, 2, 0], [1, 0, 1], [1, 1, 0], [2, 0, 0]]\n\n    >>> list(multinomial_domain(n=6, k=2))\n    [[0, 6], [1, 5], [2, 4], [3, 3], [4, 2], [5, 1], [6, 0]]\n    \"\"\"\n    # we solve this recursively, so if we have only one slot remaining, then we\n    # fill it with whatever value is left. Otherwise, we loop backwards through\n    # all permutations calling this function to fill lists of smaller sizes\n    if k == 1:\n        yield [n]\n    else:\n        for value in range(n + 1):\n            for permutation in multinomial_domain(n - value, k - 1):\n                yield [value] + permutation\n\n\nclass Dice:\n    \"\"\"\n    Models an n-sided dice for the purposes of solving the Riddler Classic.\n\n    We construct a dice by specifying the number of unique values written on the\n    sides. For example, if we call Dice([1, 1, 1, 1, 1, 1]), then it means we\n    have a dice with six sides and each side has a unique value. Dice([2, 2, 2])\n    also represents a six-sided dice, but with only three unique values.\n\n    We track the number of unique values rather than the values themselves\n    because it lets us calculate transition probabilities from one state to the\n    next. A transition probability tells us the probability that we end up with\n    a Dice with X unique values, given that we start with a Dice with Y uniques.\n\n    Behind the scenes we model this dice using a multinomial distribution, where\n    each side of the dice has an equal likelihood (but each value's probability\n    is in proportion to the number of occurrences on the sides of the dice.)\n\n    For example, suppose we have a standard 6-sided Dice. We create a new Dice\n    instance by calling `Dice([1, 1, 1, 1, 1, 1])`. We want to solve for the\n    expected number of throws until the Dice only has one unique value remaining\n    which is a Dice([6]) instance.\n\n    We call `Dice([1, 1, 1, 1, 1, 1]).expected_value()`, which gives the result\n    of 9.655991483885606, meaning it takes 9.66 turns on average to reach the\n    end of the game.\n\n    Parameters\n    ----------\n    uniques : Tuple[int, ...] a tuple containing the number of unique values on\n        the sides of the dice. The sum of the values in `uniques` should match\n        the number of sides of the dice. For example, a six-sided dice with the\n        values [1, 2, 2, 4, 5, 5] would be passed as uniques=(1, 1, 2, 2)\n\n    Examples\n    --------\n    >>> # unique values are sorted and zeros are dropped upon instantiation\n    >>> Dice([2, 1, 2, 1, 0, 0]).uniques\n    (1, 1, 2, 2)\n\n    >>> # two dice with the same unique sides are equal\n    >>> a = Dice([1, 1, 2, 0, 1])\n    >>> b = Dice([0, 2, 1, 1, 1])\n    >>> a == b\n    True\n\n    >>> Dice([1, 1, 1, 1, 1, 1]).expected_value()\n    9.655991483885606\n    \"\"\"\n\n    def __init__(self, uniques: Union[List[int], Tuple[int, ...]]):\n        self.uniques = tuple(sorted(u for u in uniques if u > 0))\n        self.total_sides = sum(self.uniques)\n        self.unique_sides = len(self.uniques)\n        self.distribution = multinomial(\n            n=self.total_sides, p=[u / self.total_sides for u in self.uniques]\n        )\n\n    def __eq__(self, other) -> bool:\n        \"\"\"Ensure that two Dice with the same sorted unique sides are equal\"\"\"\n        return self.uniques == other.uniques\n\n    def __lt__(self, other) -> bool:\n        \"\"\"Sort Dice objects by their `uniques` tuple values\"\"\"\n        return self.uniques < other.uniques\n\n    def __hash__(self) -> int:\n        \"\"\"\n        The Dice hash is the same as the hash for the uniques tuple. We need to\n        define the hash for this object so it can be used as a dictionary key.\n        \"\"\"\n        return hash(self.uniques)\n\n    def __repr__(self) -> str:\n        \"\"\"String representation of the Dice object\"\"\"\n        return f\"<Dice{self.uniques}>\"\n\n    def domain_permutations(self) -> Iterator[list]:\n        \"\"\"\n        Yields all permutations of the domain of this dice. For example, suppose\n        we have a six-sided dice with only two numbers left. We yield all valid\n        orderings of the rolls we could get\n        \"\"\"\n        return multinomial_domain(n=self.total_sides, k=self.unique_sides)\n\n    def domain(self) -> set:\n        \"\"\"\n        Returns a set of sorted tuples that fully describe the possibility space\n        of rolling the Dice. For example, if we have a six-sided Dice with two\n        unique values on the sides, then the domain set is all permutations of\n        the numbers we could roll. We return Dice objects for each possibility.\n\n        Examples\n        --------\n        >>> # a dice with two unique sides and six sides total\n        >>> Dice((2, 4)).domain()\n        {<Dice(1, 5)>, <Dice(3, 3)>, <Dice(6,)>, <Dice(2, 4)>}\n        \"\"\"\n        return {Dice(p) for p in self.domain_permutations()}\n\n    def transition_vector(self) -> dict:\n        \"\"\"\n        Returns a dictionary of the domain set and the transition probabilities\n        to each one. Keys are Dice objects, and values are floats that sum to 1.\n\n        Examples\n        --------\n        >>> # a dice with two unique sides and six sides total\n        >>> vector = Dice((2, 4)).transition_vector()\n        >>> for key, probability in vector.items():\n        ...     print(f\"{key}: {probability:.6f}\")\n        <Dice(6,)>: 0.089163\n        <Dice(1, 5)>: 0.279835\n        <Dice(2, 4)>: 0.411523\n        <Dice(3, 3)>: 0.219479\n        \"\"\"\n        vector: dict = {}\n        for p in self.domain_permutations():\n            key = Dice(p)\n            vector[key] = vector.get(key, 0.0) + self.distribution.pmf(p)\n        return vector\n\n    def graph(self) -> nx.DiGraph:\n        \"\"\"\n        Returns a directed graph mapping the transition from each Dice object to\n        other Dice objects. Edge weights are transition probabilities.\n        \"\"\"\n        def _graph(dice) -> nx.DiGraph:\n            G = nx.DiGraph()\n            for new_state, probability in dice.transition_vector().items():\n                G.add_edge(dice, new_state, weight=probability)\n            return G\n\n        G = nx.DiGraph()\n        for new_state in self.transition_vector():\n            G = nx.compose(G, _graph(new_state))\n\n        return G\n\n    def transition_matrix(self) -> Tuple[np.array, list]:\n        \"\"\"\n        Returns a square transition matrix that defines transition probabilities\n        from each Dice to each other dice. The matrix is sorted from high unique\n        values to low unique values, meaning the right-most column is the ending\n        state. Rows sum to one. Also returns the node index as an array.\n\n        Examples\n        --------\n        >>> values, idx = Dice((3, 3)).transition_matrix()\n        >>> values\n        array([[0.40252058, 0.20897634, 0.05358368, 0.33491941],\n               [0.27983539, 0.41152263, 0.21947874, 0.08916324],\n               [0.1875    , 0.46875   , 0.3125    , 0.03125   ],\n               [0.        , 0.        , 0.        , 1.        ]])\n        >>> idx\n        [<Dice(1, 5)>, <Dice(2, 4)>, <Dice(3, 3)>, <Dice(6,)>]\n        \"\"\"\n        G = self.graph()\n        nodelist = sorted(G.nodes)\n        return nx.to_numpy_array(G, nodelist=nodelist), nodelist\n\n    def expected_value(self) -> float:\n        \"\"\"\n        Return the expected number of throws before all sides of this dice have\n        the same value. Uses the Dice's directed graph to perform a markov chain\n        analysis of the time it takes to reach the end of the game.\n\n        Examples\n        --------\n        >>> Dice((1, 1, 1, 1, 1, 1)).expected_value()\n        9.655991483885606\n\n        >>> Dice((1, 5)).expected_value()\n        4.623000562655744\n\n        >>> Dice((2, 4)).expected_value()\n        6.584840446909428\n\n        >>> Dice((3, 3)).expected_value()\n        7.205027730889816\n        \"\"\"\n        if self.unique_sides == 1:\n            return 0.0\n\n        # here we solve the expected number of rolls to end with a single-value\n        # dice using a transition matrix and some linear algebra\n        M, nodelist = self.transition_matrix()\n        results = np.linalg.inv(np.eye(len(M) - 1) - M[:-1, :-1]).sum(1)\n        return results[nodelist.index(self)]\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Guess Who","date":"Mar 6, 2020","slug":"riddler-guess-who","excerpt":"We take all the \"guess work\" out of a classic board game in this week's Riddler - solving for the optimal strategy in Guess Who! My trusted technique of dynamic programming makes a (predictable) reappearance.","tags":[],"status":"published","content":"

Introduction

We take all the \"guess work\" out of a classic board game in this week's Riddler - solving for the optimal strategy in Guess Who! My trusted technique of dynamic programming makes a (predictable) reappearance.

\nIn the game of “Guess Who,” each player first randomly (and independently of their opponent) selects one of N character tiles. While it’s unlikely, both players can choose the same character. Each of the N characters is distinct in appearance — for example, characters have different skin tones, hair color, hair length and accessories like hats or glasses.\n
Each player also has access to a board with images of all N characters. The players alternate taking turns, and during each turn a player has two options:
\n
\n
Make a specific guess as to their opponent’s selected character. If correct, the player who made the guess immediately wins. Otherwise, that player immediately loses.
\n
Ask a yes-or-no question about their opponent’s chosen character, in order to eliminate some of the candidates. Importantly, if only one possible character is left after the question, the player must still wait until their next turn to officially guess that character.
\n
\n
Assume both players are highly skilled at choosing yes-or-no questions, so that they can always craft a question to potentially rule out (or in) any desired number of candidates. Also, both are playing to maximize their own probability of winning.
\n
Let’s keep things (relatively) simple, and suppose that N = 4. How likely is it that the player who goes first will win?
\n
Extra credit: If N is instead 24 (the number of characters in the original “Guess Who” game), now how likely is it that the player who goes first will win?
\n
Extra extra credit: If N is instead 14, now how likely is it that the player who goes first will win?
\n

Solution

Going first is a meaningful advantage in this game. For the 4-card variant, the player going first is expected to win 56.25% of games played. For 24 cards, it is 55.56%, and for 14 cards it is 56.12%.

How can we make this a bit more equitable? One option is to assign more cards to the player going first. For example, if the player going second has 24 cards, then the player going first would need 32 cards to make it a fair game.

Strategy

Now that we know the optimal win percentages, what moves should we actually play?

4 vs. 4: The ideal strategy if going first is to ask a question to rule out either 1 or 3 characters. This results in a 75% win percent if we eliminate 3 characters (33% chance), and a 50% win rate if we only eliminate 1 character (66% chance). Therefore the expected value of this move is a win percentage of 56.25%. On the other hand, if we eliminated two characters instead, we would win just 50% of the time.
24 vs. 24: We have some flexibility in our approach for this game. Our best play is to ask a question to eliminate anywhere from 8 to 16 characters. Any of those choices results in a 55.56% expected win percent. Suppose we choose $n=12$ . Then we will have 12 characters face up, our opponent will have 24, and it will be their turn. Their best move is also to ask $n=12$ , and we'll have a new turn with 12 cards up each. This time, any $n$ from 4 to 8 keeps our win percent at 55.56%. If we choose $n=6$ , our opponent will do the same, and both players will have 6 cards face up. From here, any $n$ from 2-4 will do. If we both choose $n=3$ , then we have a game with 3 cards each, where our only reasonable option next is to ask a question to eliminate either 1 or 2 characters.
14 vs. 14: Now it gets interesting! Our best move is to ask a question to eliminate 4/10 or 6/8 of the characters. Choosing 5/9 or 7/7 actually reduces our win rate by roughly 1%! Therefore, this is one situation that creates variance - multiple paths - immediately after the first move. If we choose $n=6$ , we could find ourselves with either 6 or 8 cards face up before we pass the turn. In both of those cases, the ideal move for the opponent is to eliminate either 6, 7 or 8 characters. Suppose they choose 7. Now we would have a turn with 6 or 8 face up cards ourselves, and 7 face up cards for the opponent. Again, we have to be careful about our next move. We want to guess even numbers only: either 2, 4, or 6 (if possible). Ultimately, our ideal strategy results in an expected win rate of 56.12%.

Methodology

Perhaps my solutions have become a bit too predictable? Friendly Riddler Nation member James Chapman intuited my problem solving process before I had even put pen to paper!

Have a feeling I know how @ashjasont will approach this one! Luckily I've learnt from following his solutions in recent weeks :)
— James Chapman (@chapmajw) March 6, 2020

Undeterred, (and flattered) I proceeded as predicted with my trusted puzzling technique: dynamic programming. In dynamic programming, we evaluate simple sub-problems, often repeatedly, in order to solve more complex problems.

A convention I've found useful in problems like this is to model the world in terms of \"GameStates\". A GameState encapsulates everything we know about the game, which is all we need to decide our best play. This is a valid technique because the game we are modeling is memoryless, meaning that the best action to take now doesn't depend on what happened in the past. Even much more complicated games like chess and go have this property. Regardless of the order of moves to this point, the game can be completely described by the current arrangement of the pieces.

In Guess Who, the GameState can be captured with just two variables: the number of face-up characters remaining for each player. We always list the guessing player's cards first. For example, if the player currently guessing has 10 face-up characters and the other player has 12, then we would write GameState(a=10, b=12).

Now we try to identify simple sub-problems and work our way to more complex problems as a way to solve the puzzle. In this game, the simplest sub-problem is when we have a GameState with a=1. Regardless of the number of face-up characters for player B, player A can win immediately by guessing the only remaining character and winning 100% of the time. So we know any GameState with a=1 should result in an expected value of 100%.

We also know what to do if the opponent has a single character remaining. The opponent is guaranteed to win next turn, so we have the best outcome if we guess a random character and hope for the best: even our unlikely guess is better than a guaranteed loss. Therefore, any GameState with b=1 results in an expected value of 1/a.

If the case is more complex, for example GameState(a=4, b=4), then we want to evaluate all the possible moves player A could make in order to choose the best one. What are those moves?

Ask a question to eliminate either 1 or 3 characters, with probability $\\frac{1}{4}$ or $\\frac{3}{4}$ , respectively.
Ask a question that would leave 2 characters remaining.
Guess a random character, and win the game with probability $\\frac{1}{4}$ .

Several of these moves result in new GameStates, which we evaluate the same way - enumerating each of the possible moves from those states and choosing the best one. When a move creates two GameStates, we calculate the weighted average of the result. A subtle trick here is that we model alternating turns by switching a and b each time, then we calculate the complement of our opponent's win percentage when it's their turn. For example, a 60% win rate for our opponent is the same as a 40% win rate for us.

As we trace through each of these branches, we create a table of expected values for each GameState in order to avoid repeating calculations we've already performed. The final result is a python function that returns the expected value (i.e. win percent) from any given GameState.

>>> GameState(a=4, b=4).expected_value()\n0.5625\n\n>>> GameState(a=24, b=24).expected_value()\n0.5555555555555556\n\n>>> GameState(a=14, b=14).expected_value()\n0.5612244897959183\n

Full Code

The GameState class has methods to return the expected value for any number of characters. It's nearly instant for games with a few hundred cards, but isn't designed to scale well for much larger games.

from collections import namedtuple\n\n\nclass GameState(namedtuple(\"GameState\", \"a b\")):\n    \"\"\"\n    A GameState represents the number of face-up cards for each player\n    at any given point in the game. (It doesn't matter how many cards\n    are face down.) The GameState has two variables, \"a\", and \"b\", to\n    represent the number of face-up cards for each player. We assume\n    player \"a\" is currently guessing, and calling the \"expected_value\"\n    method returns the probability (e.g. 75%) that player \"a\" will win\n    from this position, assuming optimal play from both players.\n\n    Parameters\n    ----------\n    a : int, the number of face-up character cards for player A\n    b : int, the number of face-up character cards for player B\n\n    Examples\n    --------\n    >>> GameState(a=4, b=4).expected_value()\n    0.5625\n\n    >>> GameState(a=24, b=24).expected_value()\n    0.5555555555555556\n\n    >>> GameState(a=14, b=14).expected_value()\n    0.5612244897959183\n    \"\"\"\n\n    cache: dict = {}\n\n    def ask(self, n) -> list:\n        \"\"\"\n        On your turn, you can ask a question that is designed to rule\n        out \"n\" of the remaining face-up cards, where n is in [1, a).\n\n        The answer can be either yes or no, which produces two new\n        GameStates, and it becomes player b's turn. Therefore, we\n        could have a new number of face up cards of (a - n) or (n),\n        with weights (a - n) / a and n / a, respectively, and we flip\n        the position of the a and b cards to account for the fact that\n        player \"b\" gets to go next.\n\n        Parameters\n        ----------\n        n : int, the number of cards you seek to eliminate\n\n        Returns\n        -------\n        states : list[tuples], a list of tuples of (new_state, likelihood)\n\n        Examples\n        --------\n        >>> GameState(a=15, b=15).ask(3)\n        [(GameState(a=15, b=12), 0.8), (GameState(a=15, b=3), 0.2)]\n\n        >>> GameState(a=8, b=10).ask(7)\n        [(GameState(a=10, b=1), 0.125), (GameState(a=10, b=7), 0.875)]\n\n        >>> GameState(a=5, b=7).ask(5)\n        Traceback (most recent call last):\n        ...\n        ValueError: n cannot be greater than 4\n        \"\"\"\n        if n > self.a - 1:\n            raise ValueError(f\"n cannot be greater than {self.a - 1}\")\n        if n < 1:\n            raise ValueError(f\"n must be greater than 0\")\n        return [\n            (GameState(self.b, self.a - n), (self.a - n) / self.a),\n            (GameState(self.b, n), n / self.a)\n        ]\n\n    def expected_value(self) -> float:\n        \"\"\"\n        Returns the probability of player A winning from this GameState,\n        based on optimal play from each player from this position forward.\n\n        Examples\n        --------\n        >>> GameState(a=1, b=5).expected_value()\n        1.0\n\n        >>> GameState(a=10, b=1).expected_value()\n        0.1\n\n        >>> GameState(a=2, b=2).expected_value()\n        0.5\n        \"\"\"\n        try:\n            return self.cache[self]\n        except KeyError:\n            if self.a == 1:\n                # only one card remaining; we can win this turn by guessing\n                self.cache[self] = 1.0\n            else:\n                # we have two options: we could guess a single person, or we\n                # could ask a question to eliminate \"n\" people; we test all\n                # values of \"n\" and the GameStates they produce, then choose\n                # the one that produces the best outcome. Finally, we check\n                # whether we could do even better by guessing a single card\n                asks = (self.ask(n) for n in range(1, self.a))\n                best_ask = 1 - min(\n                    sum(gs.expected_value() * w for gs, w in ask)\n                    for ask in asks\n                )\n                best_guess = 1 / self.a\n                self.cache[self] = max(best_guess, best_ask)\n            return self.cache[self]\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Haircuts","date":"Feb 28, 2020","slug":"riddler-haircuts","excerpt":"This week's Riddler asks us to estimate how long it takes to get a haircut with our favorite barber. Rather than scheduling an appointment, we roll the dice and hope we won't have to wait too long if we drop by unannounced. How long exactly? We'll use probability distributions and monte carlo simulation to estimate our idle time.","tags":[],"status":"published","content":"

Introduction

This week's Riddler asks us to estimate how long it takes to get a haircut with our favorite barber. Rather than scheduling an appointment, we roll the dice and hope we won't have to wait too long if we drop by unannounced. How long exactly? We'll use probability distributions and monte carlo simulation to estimate our idle time.

\nAt your local barbershop, there are always four barbers working simultaneously. Each haircut takes exactly 15 minutes, and there’s almost always one or more customers waiting their turn on a first-come, first-served basis.\n
Being a regular, you prefer to get your hair cut by the owner, Tiffany. If one of the other three chairs opens up, and it’s your turn, you’ll say, “No thanks, I’m waiting for Tiffany.” The person behind you in line will then be offered the open chair, and you’ll remain at the front of the line until Tiffany is available.
\n
Unfortunately, you’re not alone in requesting Tiffany — a quarter of the other customers will hold out for Tiffany, while no one will hold out for any of the other barbers.
\n
One Friday morning, you arrive at the barber shop to see that all four barbers are cutting hair, and there is one customer waiting. You have no idea how far along any of the barbers is in their haircuts, and you don’t know whether or not the customer in line will hold out for Tiffany.
\n
What is the expected wait time for getting a haircut from Tiffany?
\n

Solution

Our average wait time is just a bit longer than 14 minutes.

Methodology

I solved this problem in two ways: first by running a simulation, then by writing the probability density function analytically. Fortunately, my two results converged, and they both resulted in the final value of 14.0625. The simulation code is highly efficient, allowing you to run tens of millions of scenarios nearly instantly.

>>> trials = 10_000_000\n>>> results = model(trials)\n>>> print(results)\n14.06276349572674\n

The analytical work, on the other hand, was much more complicated, and, forgive me, but I'll leave my scrap work out of this week's writeup. Instead, I'll show the three components of the problem in separate charts and how they add up to a legitimate probability density function in the image below. Indeed we can use these density functions to calculate the exact value, and it was fun to see the progression of each of the three cases build up to the whole. Those three cases are:

A - the case in which the customer ahead of us always chooses Tiffany. We must wait until she finishes the current haircut, plus an additional 15 minutes for the next customer. This occurs 25% of the time.
B - the case in which the customer ahead of us doesn't care about the barber, but Tiffany becomes the first available. Our wait time is the same as in A, which is Tiffany's cut time plus an additional 15 minutes. This occurs 18.75% of the time, which is calculated by multiplying 75% (the likelihood that the customer ahead of us does not prefer Tiffany) and 25% (the odds that Tiffany finishes first among her three other colleagues.
C - finally, we tackle the best-case scenario, where the customer ahead of us doesn't prefer Tiffany and is able to be served by a different barber. Therefore, we only have to wait for Tiffany to finish her current cut before we can be seated. The complicating element here is that Tiffany must not finish before any of the other barbers, which makes the probability distribution slightly more complicated to evaluate.

In any case, when we sum each of the possibilities together, we get the chart on the far right, which lets us calculate the probability of being seated within some range of times, such as \"between 10 and 15 minutes\" or \"between 10:00 and 10:01 minutes\".

Full Code

Simulation code is below. It's fast! You can run 10 million scenarios in a snap of the fingers.

import numpy as np\n\n\ndef model(trials: int, barbers: int = 4, haircut_time: int = 15) -> np.ndarray:\n    \"\"\"\n    Simulate a number of haircut scenarios and return an array of results,\n    which are the times it takes for your haircut with tiffany to begin.\n\n    This is a vectorized simulation, so calculating ten million or more\n    scenarios is nearly instantaneous.\n    \"\"\"\n    # simulate the time it would take each barber to finish their haircut\n    # we assume tiffany is listed first in the array, but it's arbitrary\n    haircuts = np.random.uniform(high=haircut_time, size=(trials, barbers))\n\n    # determine whether or not tiffany finishes cutting hair first\n    tiffany_first = haircuts.argmin(axis=1) == 0\n\n    # simulate an array representing whether or not the customer ahead of\n    # us prefers tiffany, which happens 25% of the time\n    prefers_tiffany = np.random.uniform(size=trials) < 0.25\n\n    # create an array to store the results, then go through the cases\n    results = np.zeros(shape=trials)\n\n    # case 1: customer ahead of us doesn't prefer tiffany AND she doesn't\n    # finish first, so we simply wait for her to finish before our turn\n    idx = (~tiffany_first) & (~prefers_tiffany)\n    results[idx] = haircuts[idx, 0]\n\n    # case 2: all other cases require us to wait for tiffany to finish\n    # her existing haircut, then another 15 minutes, either because the\n    # customer ahead prefers her, or because she finished first\n    results[~idx] = haircuts[~idx, 0] + haircut_time\n\n    return results\n\n\nif __name__ == \"__main__\"\n    results = model(10_000_000)\n    print(results.mean())\n

And lastly, the code to generate the probability density functions and plot, which were coded somewhat manually based on my calculations.

from matplotlib import pyplot as plt\nimport numpy as np\n\n\ndef a(x):\n    \"\"\"\n    Customer ahead of us prefers Tiffany, so we wait for her\n    to finish her current cut plus one more before our turn.\n    \"\"\"\n    out = np.full_like(x, 1 / 15)\n    out[x < 15] = 0.0\n    return out\n\ndef b(x):\n    \"\"\"\n    Tiffany finishes first, so we have to wait for her finish\n    time plus the full time for another haircut ahead of us\n    \"\"\"\n    out = 4 / 15 ** 4 * (15 - (x - 15)) ** 3\n    out[x < 15] = 0.0\n    return out\n\ndef c(x):\n    \"\"\"\n    Tiffany doesn't finish first, and the customer ahead of us\n    didn't prefer her, so we can be served as soon as she's done.\n    \"\"\"\n    out = 4 / 45 * (1 - ((15 - x) / 15) ** 3)\n    out[x >= 15] = 0.0\n    return out\n\ndef d(x):\n    \"\"\"Sum the individual components by weight\"\"\"\n    return a(x) * 0.25 + b(x) * 0.1875 + c(x) * 0.5625\n\n\nfig, ax = plt.subplots(ncols=4, sharex=True, sharey=True, figsize=(10, 2))\nplt.tight_layout(pad=-1.5)\nax[0].set_title(\"Case A: 25%\\nCustomer prefers Tiffany\", loc=\"left\")\nax[1].set_title(\"Case B: 18.75%\\nNo pref., Tiffany available\", loc=\"left\")\nax[2].set_title(\"Case B: 56.25%%\\nNo pref., Another available\", loc=\"left\")\nax[3].set_title(\"Total: A + B + C\\n\", loc=\"left\")\n\nx = np.linspace(0, 30, 10001)\nax[0].plot(x, a(x) * 0.25, c='0.2')\nax[1].plot(x, b(x) * 0.1875, c='0.2')\nax[2].plot(x, c(x) * 0.5625, c='0.2')\nax[3].plot(x, d(x), c='0.2')\n\nax[0].fill_between(x, a(x) * 0.25, 0, facecolor=\"0.95\")\nax[1].fill_between(x, b(x) * 0.1875, 0, facecolor=\"0.95\")\nax[2].fill_between(x, c(x) * 0.5625, 0, facecolor=\"0.95\")\nax[3].fill_between(x, d(x), 0, facecolor=\"0.95\")\n\nfor i in range(4):\n    ax[i].set_ylim(0, 0.07)\n    for s in [\"top\", \"right\"]:\n        ax[i].spines[s].set_visible(False)\n\nplt.show()\n

"},{"title":"Riddler Flips","date":"Feb 21, 2020","slug":"riddler-flips","excerpt":"We tackle a solitaire game of coin flipping in this week's Riddler Classic. Using dynamic programming, we build a tree to explore all possible game states and work backwards to identify the ideal move at each state.","tags":[],"status":"published","content":"

Introduction

We tackle a solitaire game of coin flipping in this week's Riddler Classic. Using dynamic programming, we build a tree to explore all possible game states and work backwards to identify the ideal move at each state. Here is the full problem text.

\nYou have two fair coins, labeled A and B. When you flip coin A, you get 1 point if it comes up heads, but you lose 1 point if it comes up tails. Coin B is worth twice as much — when you flip coin B, you get 2 points if it comes up heads, but you lose 2 points if it comes up tails.\n
To play the game, you make a total of 100 flips. For each flip, you can choose either coin, and you know the outcomes of all the previous flips. In order to win, you must finish with a positive total score. In your eyes, finishing with 2 points is just as good as finishing with 200 points — any positive score is a win. (By the same token, finishing with 0 or −2 points is just as bad as finishing with −200 points.)
\n
If you optimize your strategy, what percentage of games will you win? (Remember, one game consists of 100 coin flips.)
\n
Extra credit: What if coin A isn’t fair (but coin B is still fair)? That is, if coin A comes up heads with probability p and you optimize your strategy, what percentage of games will you win?
\n

Solution

We can win this game with roughly 64% probability if we play optimally. It is interesting to note that we could win a game with a single coin just 46% of the time. (Why not 50%? We need a positive score to win, and we lose with a score of zero.) Therefore, the ability to choose between the coins as we play improves our odds of winning by nearly 20%!

Methodology

Here is a snippet that shows the odds of winning a game with a single, fair coin, based on 100,000 simulated games. We only win 46% of the time because we need to have at least 51 winning flips.

>>> import numpy as np\n>>> trials = 100000\n>>> scores = np.random.randint(2, size=(trials, 100)).sum(1)\n>>> wins = (scores > 50).sum()\n>>> wins / trials\n0.46086\n

Now how do we solve the game with two coins? I'll turn to dynamic programming, a technique I've used on several other problems. That is, in order to model the probability of winning from our current position, we model the probability of winning from all the positions we could reach from our position, then choose the action that gives us the best expected result.

For this problem, the state of the game is expressed by the number of flips we've completed so far, which falls between 0 and 100, and the current score of the game, which falls between 0 and 200. Not every flip and score combination is valid - for example we can't have a score of 10 if we have only flipped twice, but these two variables completely express the state of our game. In python, we store the state of the game in an object called GameState. For example, GameState(n_flip=30, score=-10) means we have flipped 30 coins so far and our cumulative score is -10.

Once we know how to express the state of the game, we want to be able to calculate its expected value - that is, the likelihood of winning the game from this position. 100% implies we win the game in every case; 50% means we win half of the games we play, and so on.

In python, we calculate the expected value of a GameState by simulating all future positions we could reach - by flipping coin A and winning, flipping coin A and losing, flipping coin B and winning, or flipping coin B and losing. We take the average of the results from flipping coin A and compare it against the average of the results of flipping coin B and choose the coin that improves our odds the most.

Finally, we solve the problem by calculating the expected value of the game before we have flipped a single coin, which gives us just over 64%.

>>> GameState(n_flip=0, score=0).expected_value()\n0.6403174472759772\n

In addition, we can also plot the various states of the game and their associated winning probabilities using a heatmap. In the figure below, each GameState is plotted as a point: the x-axis is the number of flips we've completed, and the y-axis is our cumulative score. The color of the point represents how likely we are to win from that position, where yellow means almost a sure thing, and purple means we're virtually certain to lose. (I omitted many of the points that have more than 99% or less than 1% chances of winning to simplify the plot.)

The extra credit this week asked how the game changes if we vary the probability that each coin turns up heads. In python we can run any number of scenarios by changing the class attributes p_a and p_b, which set the likelihood of winning and losing each flip for each coin. As expected, when coin A becomes more of a sure thing, our odds of winning the game increase, but I'll leave it as an exercise for the motivated reader to adjust the code and calculate the exact values!

Full Code

Fairly short code for this week. We create a GameState class as a namedtuple, then extend its functionality by adding a method to calculate expected_value recursively. The solution to the puzzle is calculated by calling GameState(0, 0).expected_value().

from collections import namedtuple\n\n\nclass GameState(namedtuple(\"GameState\", (\"n_flip\", \"score\"))):\n    \"\"\"\n    The GameState object represents the state of the game, which is\n    specified by the number of flips we've completed already (from\n    zero to 100), and the current game score, which can be either\n    positive or negative, but has bounds determined by the number of\n    flips we've completed already.\n\n    We add a method to solve for the expected value of the GameState,\n    which is the number of games we would expect to win from this\n    position given optimal play.\n    \"\"\"\n\n    cache: dict = {}  # cache for expected value of GameStates\n    p_a: float = 0.5  # probability that coin A wins (heads)\n    p_b: float = 0.5  # probability that coin B wins (heads)\n    v_a: int = 1      # value of a win from coin A\n    v_b: int = 2      # value of a win from coin B\n\n    def expected_value(self) -> float:\n        \"\"\"\n        Return the expected percent of games won from this state,\n        e.g. 0.85 implies you can win 85% of games from this position\n        by playing optimally. To find the expected value of the game\n        before it starts, call expected_value on the initial GameState\n\n        Examples\n        --------\n        >>> GameState(99, 0).expected_value()\n        0.5\n        >>> GameState(0, 0).expected_value()\n        0.6403174472759772\n        \"\"\"\n        # search the cache to see if we've calculated this result before\n        # otherwise, calculate the result and store it in the cache\n        try:\n            return self.cache[self]\n        except KeyError:\n            if self.n_flip == 100:\n                # the game has ended; positive scores win; negative scores lose\n                if self.score > 0:\n                    self.cache[self] = 1.0\n                else:\n                    self.cache[self] = 0.0\n            else:\n                # we continue flipping coins; calculate the expected value of\n                # flipping coin a and coin b, then choose the best one\n                n, s = self.n_flip + 1, self.score\n                a = (\n                    self.p_a * GameState(n, s+ self.v_a).expected_value()\n                    + (1 - self.p_a) * GameState(n, s - self.v_a).expected_value()\n                )\n                b = (\n                    self.p_b * GameState(n, s + self.v_b).expected_value()\n                    + (1 - self.p_b) * GameState(n, s - self.v_b).expected_value()\n                )\n                self.cache[self] = max(a, b)\n            return self.cache[self]\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Pennies","date":"Jan 24, 2020","slug":"riddler-pennies","excerpt":"This week's Riddler Classic explores ideal strategy in a two-player game. We take turns removing coins from two piles, and the last one to remove a coin wins. I'll use pen and paper to sketch out the logical framework, then code a flexible solution using python and dynamic programming.","tags":[],"status":"published","content":"

Introduction

This week's Riddler Classic explores ideal strategy in a two-player game. We take turns removing coins from two piles, and the last one to remove a coin wins. I'll use pen and paper to sketch out the logical framework, then code a flexible solution using python and dynamic programming.

\nThe game starts with somewhere between 20 and 30 pennies, which I then divide into two piles any way I like. Then we alternate taking turns, with you first, until someone wins the game. For each turn, a player may take any number of pennies he or she likes from either pile, or instead take the same number of pennies from both piles. Each player must also take at least one penny every turn. The winner of the game is the one who takes the last penny.\n
If we both play optimally, what starting numbers of pennies (again, between 20 and 30) guarantee that you can win the game?
\n

Solution

I'll take a small liberty and answer the complementary question: what configurations of pennies guarantee that I lose the game? There are fewer combinations that satisfy this constraint, so it's easier to list them.

With their choice of 20-30 pennies, my opponent could create three configurations that guarantee I lose the game, provided I must play first: (8, 13), (9, 15), and (11, 18). These configurations require 21, 24, and 29 pennies, respectively. If my opponent starts with any other number of pennies between 20-30, there is no configuration they could create that I can't win by playing optimally.

Methodology

I used a combination of pen and paper and computer code to solve this problem. I started by looking for patterns in a highly simplified version of the game, then I generalized those patterns to larger numbers of coins. In computer science this approach is called dynamic programming, where we solve a complex problem by breaking it down into simpler component parts that we can solve individually. Later, we'll reuse the simple component parts to solve the more complex problem, like building a lego structure with little bricks that we solve along the way.

Without loss of generality, I will follow the convention that ( $a$ , $b$ ) represents the state of the game, where $a \\le b$ , so the smaller pile is always listed first. I will assign winning states a value of 1, and losing states a value of -1. The simplest sub-problem we can solve is a game with one coin, where $a=0$ and $b=1$ . In this sub-problem, we can win immediately by taking the only coin available, so the expected value of (0, 1) is 1.

The next sub-problem involves two coins, and we have two states: (0, 2) or (1, 1). With (0, 2) we can win immediately by taking both coins from pile $b$ . With (1, 1), we can win immediately by taking one coin from each pile. The expected values of (0, 2) and (1, 1) are both 1.

With three coins, we also have two states: (0, 3) or (1, 2). (0, 3) has a winning move by taking all three coins from pile $b$ , so its expected value is 1. However, (1, 2) is more complicated. Let's list all available moves from this position:

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Begin State	Move	End State	Expected Value
(1, 2)	(1, 0) - take 1 coin from $a$	(0, 2)	1
(1, 2)	(0, 1) - take 1 coin from $b$	(1, 1)	1
(1, 2)	(0, 2) - take 2 coins from $b$	(0, 1)*	1
(1, 2)	(1, 1) - take 1 coin from both piles	(0, 1)	1
	*recall we always set $a \\le b$

Each of our available moves results in a state with expected value 1... for our opponent! We can't make any move that avoids losing from this position, so the expected value of (1, 2) is -1.

Each state we solve gets added to a dictionary of states and expected values. To solve states with larger numbers of coins, we follow a process like this:

List all the available moves we could make.
Determine the resulting states after we make each possible move.
If we've calculated the value of the new state before, use it. Otherwise, go to step #1 with the new state. At each change of turns, multiply the expected values by -1.
Out of all possible moves, choose the best one - the one that produces an expected value of 1 - if possible. Otherwise, mark the state as losing.

If we continue this process by hand, we can build a small diagram of optimal decisions, shown below. Each state has a color: red states are losing, and green states are winning. To simplify the states, I've used a generic $n$ to represent some positions. (0, $n$ ) represents a state with a zero in one pile and any number of coins in the other. Similarly ( $n$ , $n$ ) represents a state with an equal number of coins in both piles. For example, we showed that no move from (1, 2) can win the game, because (1, 2) only connects to (0, $n$ ) and ( $n$ , $n$ ), which are winning states for our opponent.

Suppose we start at (3, 7) on our turn. Our best move is to remove 2 coins from pile $b$ , putting our opponent in the unwinnable state (3, 5). The opponent may choose to remove one coin from pile $b$ , giving us the state (3, 4). We will remove 2 coins from both piles, giving our opponent the unwinnable (1, 2) state, from which we've shown we will eventually win.

As the diagram shows, this process quickly becomes complicated for larger numbers of coins. At this point I turned to the computer. In python I created a class called GameState that tracks the number of coins in each pile and allows us to simulate potential moves and calculate expected values using the steps listed above. For example, we can verify the expected values we calculated by hand earlier, and test states with much higher values.

>>> GameState(a=1, b=1).expected_value()\n1\n>>> GameState(a=1, b=2).expected_value()\n-1\n>>> GameState(a=75, b=90).expected_value()\n1\n

We can also use the GameState class to identify the best move to make from any state. For example, how should we play if there are 75 coins in pile $a$ and 90 coins in pile $b$ ?

>>> GameState(a=75, b=90).best_move()\n(51, 51)\n

The best move is to remove 51 coins from both piles. (Note, there may be several winning moves from a given position, but the code returns the move that wins the fastest. No need to delay the inevitable...) After our move, the opponent faces a new GameState with $a=24$ and $b=39$ . What is our opponent's best move?

>>> GameState(a=24, b=39).best_move()\n\n---------------------------------------------------------------------------\nValueError: No best move; this is a losing position\n

Good news for us! Looks like no matter what our opponent does, we are guaranteed to win.

Finally, to answer the original question, we want to list all unwinnable states. Because we store all the expected values, we can search the dictionary for all the losing states and return them as a list.

>>> # show the first 20 losing states\n>>> GameState.losing_states()[:20]\n[GameState(a=0, b=0),\n GameState(a=1, b=2),\n GameState(a=3, b=5),\n GameState(a=4, b=7),\n GameState(a=6, b=10),\n GameState(a=8, b=13),\n GameState(a=9, b=15),\n GameState(a=11, b=18),\n GameState(a=12, b=20),\n GameState(a=14, b=23),\n GameState(a=16, b=26),\n GameState(a=17, b=28),\n GameState(a=19, b=31),\n GameState(a=21, b=34),\n GameState(a=22, b=36),\n GameState(a=24, b=39),\n GameState(a=25, b=41),\n GameState(a=27, b=44),\n GameState(a=29, b=47),\n GameState(a=30, b=49)]\n

We use this list to answer the original question. With 20-30 coins, only the states (8, 13), (9, 15), and (11, 18) guarantee us to lose if we play first. Of course we can test larger numbers of coins, but I'll leave that as an exercise for the motivated reader. My full code is available below!

Full Code

The code for this week was fun to write. I created a class called GameState that represents the game, has methods to yield valid moves, calculate expected value, return the best move to make, and more. I feel like I could have kept adding more and more functionality to this class, but I tried to keep it relatively focused for now.

from collections import namedtuple\nfrom itertools import chain\n\n\nclass GameState(namedtuple(\"GameState\", \"a b\")):\n    \"\"\"\n    Each turn of the game we may take any number of pennies from either pile, or\n    an equal number of pennies from both piles. (We must take at least one penny\n    per turn.) The person who takes the last penny (or pennies) wins the game.\n\n    Represent the state of the game as a tuple, (a, b), where a is the number of\n    pennies in the first pile, and b is the number of pennies in the second pile\n\n    If a == b, then the game will end this turn because we will take all pennies\n    from both piles. If either a or b == 0, then we can also end the game this\n    turn by taking the remaining pennies from the non-empty pile. Otherwise, we\n    will determine the optimal action to take by considering all possible moves\n    and choosing the one that gives the best chance of winning on a later turn.\n\n    Examples\n    --------\n    >>> # start a game with 8 pennies in \"A\" and 14 pennies in \"B\"\n    >>> # then determine its expected value and best move\n    >>> game = GameState(8, 14)\n    >>> game.expected_value()\n    1\n    >>> game.best_move()\n    (0, 1)\n    \"\"\"\n\n    _cache: dict = {}\n\n    def __hash__(self):\n        \"\"\"\n        Custom hash function for the GameState, which allows us to assert\n        equality between GameState(a, b) and GameState(b, a)\n\n        >>> GameState(5, 10).__hash__()\n        3713085962056061156\n        >>> GameState(10, 5).__hash__()\n        3713085962056061156\n        \"\"\"\n        return hash((min(self.a, self.b), max(self.a, self.b)))\n\n    def __eq__(self, other):\n        \"\"\"\n        We want GameState(a, b) to be equal to GameState(b, a)\n\n        Examples\n        --------\n        >>> GameState(5, 10) == GameState(10, 5)\n        True\n        \"\"\"\n        return hash(self) == hash(other)\n\n    def __sub__(self, other: tuple):\n        \"\"\"\n        Update the game state by subtracting pennies\n       \n        Examples\n        --------\n        >>> GameState(9, 10) - (5, 5)\n        GameState(a=4, b=5)\n        >>> GameState(10, 5) - (4, 0)\n        GameState(a=6, b=5)\n        \"\"\"\n        if other[0] > self.a or other[1] > self.b:\n            raise ValueError(\"Not enough pennies left to make this move.\")\n        return GameState(self.a - other[0], self.b - other[1])\n\n    def available_moves(self):\n        \"\"\"\n        Yield all possible moves for this GameState\n       \n        Examples\n        --------\n        >>> moves = GameState(1, 2).available_moves()\n        >>> list(moves)\n        [(1, 0), (0, 1), (0, 2), (1, 1)]\n        \"\"\"\n        # create separate generators for all moves taking coins from pile a,\n        # pile b, and equal draws from both piles, then chain them together\n        gen_a = ((x, 0) for x in range(1, self.a + 1))\n        gen_b = ((0, x) for x in range(1, self.b + 1))\n        gen_c = ((x, x) for x in range(1, min(self.a, self.b) + 1))\n        return chain(gen_a, gen_b, gen_c)\n\n    def best_move(self) -> tuple:\n        \"\"\"\n        Return the best possible move to make; if there are multiple best\n        moves, return the one that removes the most pennies from the board\n       \n        Examples\n        --------\n        >>> GameState(9, 10).best_move()\n        (8, 8)\n        >>> GameState(2, 1).best_move()\n        Traceback (most recent call last):\n        ValueError: No best move; this is a losing position\n        \"\"\"\n        winning_moves = (\n            move for move in self.available_moves()\n            if (self - move).expected_value() == -1\n        )\n        try:\n            return max(winning_moves, key=sum)\n        except ValueError as e:\n            raise ValueError(\"No best move; this is a losing position\") from e\n\n    def expected_value(self) -> int:\n        \"\"\"\n        Returns the expected value from this GameState, assuming it is your\n        move. 1 represents a guaranteed win with a single move or series of\n        moves, while -1 represents a guaranteed loss.\n       \n        Examples\n        --------\n        >>> GameState(1, 3).expected_value()  # winning state\n        1\n        >>> GameState(2, 2).expected_value()  # winning state\n        1\n        >>> GameState(1, 2).expected_value()  # losing state\n        -1\n        \"\"\"\n        # check the cache to see if we've already calculated the result\n        # otherwise, calculate the result and store it in the cache\n        try:\n            return self._cache[self]\n        except KeyError:\n            if self.a == self.b == 0:\n                self._cache[self] = -1\n            else:\n                self._cache[self] = max(\n                    -1 * (self - move).expected_value()\n                    for move in self.available_moves()\n                )\n            return self._cache[self]\n\n    @classmethod\n    def losing_states(cls, max_coins: int = 100):\n        \"\"\"\n        Return all losing states from the cache up to a maximum coin count\n\n        Examples\n        --------\n        >>> GameState._cache = {}  # reset the cache before performing this test\n        >>> GameState.losing_states(max_coins=8)\n        [GameState(a=0, b=0), GameState(a=1, b=2), GameState(a=3, b=5), GameState(a=4, b=7)]\n        \"\"\"\n        # run the GameState up to the max value to populate the cache\n        GameState(max_coins, max_coins).expected_value()\n        return [k for k, v in cls._cache.items() if v == -1]\n\n\nif __name__ == \"__main__\":\n    import doctest\n\n    doctest.testmod()\n

"},{"title":"Riddler Delirious Ducks","date":"Jan 17, 2020","slug":"riddler-delirious-ducks","excerpt":"This week's Riddler Classic is a delightful diversion - tracking delirious ducks as they randomly swim from rock to rock in a pond. How long will it take them to end up on the same rock? We'll use markov chains in Python to solve it.","tags":[],"status":"published","content":"

Introduction

This week's Riddler Classic is a delightful diversion - tracking delirious ducks as they randomly swim from rock to rock in a pond. How long will it take them to end up on the same rock? We'll use markov chains in Python to solve it.

\nAfter a long night of frivolous quackery, two delirious ducks are having a difficult time finding each other in their pond. The pond happens to contain a 3×3 grid of rocks.\n
Every minute, each duck randomly swims, independently of the other duck, from one rock to a neighboring rock in the 3×3 grid — up, down, left or right, but not diagonally. So if a duck is at the middle rock, it will next swim to one of the four side rocks with probability 1/4. From a side rock, it will swim to one of the two adjacent corner rocks or back to the middle rock, each with probability 1/3. And from a corner rock, it will swim to one of the two adjacent side rocks with probability 1/2.
\n
If the ducks both start at the middle rock, then on average, how long will it take until they’re at the same rock again? (Of course, there’s a 1/4 chance that they’ll swim in the same direction after the first minute, in which case it would only take one minute for them to be at the same rock again. But it could take much longer, if they happen to keep missing each other.)
\n
Extra credit: What if there are three or more ducks? If they all start in the middle rock, on average, how long will it take until they are all at the same rock again?
\n

Solution

Fortunately, the pond is small enough that our delirious ducks are expected to meet each other less than five minutes after they start swimming: 4.905 minutes, to be exact. Of course, because the process is random, they could end up swimming for quite some time, but this answer reflects the average of all potential random outcomes.

Methodology

We can use Markov Chains to solve this problem - a highly effective tool in our probabilistic arsenal that I've used several times before. In a markov chain, we specify the probability of moving from one state to the next - in this case, from one rock in the pond to the next.

Because there are two ducks, each state will need to encode both ducks' positions. We can exploit the rotational symmetry of the problem and cover all possible positions with just five states, shown below. Each blue box represents the position of one duck (it doesn't matter which duck.)

Note that the ducks will never be in adjacent squares (for example, the top left square and the top middle square) because of the parity of this problem. The ducks can't move diagonally, so they shift between the diamond squares (middle of each edge) and the other squares each time they swim. This vastly simplifies the number of states we need to model. (If the ducks could randomly decide not to swim and to stay on their current rock, then the problem loses this parity and becomes more complex.)

Once we specify the states, we need to calculate the probability of moving from one state to the next, including the probability of arriving at the same rock. When they arrive at the same rock, we call this the absorbing state, and the markov chain stays there forever. Fortunately, we can use some clever math to solve for the expected amount of time it takes to arrive in the absorbing state, and that gives us our answer.

The probabilities of moving from state to state are encoded in a transition matrix, which allows us to calculate the time it takes for our ducks to meet again after starting. We use numpy to create this matrix, where each row is the starting state, and each column is a potential ending state.

import numpy as np\n\nM = np.array([\n    [0.0, 1/4, 0.0, 0.0, 1/2, 0.0, 1/4],  # start\n    [0.0, 0.0, 2/9, 4/9, 0.0, 2/9, 1/9],  # middle across\n    [0.0, 1/4, 0.0, 0.0, 1/2, 0.0, 1/4],  # outer edge across\n    [0.0, 1/4, 0.0, 0.0, 1/2, 0.0, 1/4],  # diagonal including middle\n    [0.0, 0.0, 2/9, 4/9, 0.0, 1/9, 2/9],  # diagonal excluding middle\n    [0.0, 1/2, 0.0, 0.0, 1/2, 0.0, 0.0],  # opposite corners\n    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],  # absorbing state\n])\n

Each row of the matrix sums to 1, because it specifies the probabilities of moving from a given state to all other states. Once we arrive in the absorbing state, the probability of staying there is 100%. With some linear algebra we can solve for the number of steps it takes to move from the starting position to the absorbing state.

>>> np.linalg.inv(np.eye(6) - M[:-1, :-1]).sum(1)\narray([4.90540541, 5.67567568, 4.90540541, 4.90540541, 4.97297297,\n       6.32432432])\n

The output array tells us how many steps it takes to get from each state to the absorbing state. We see it takes 4.905 steps from the start position, 5.676 steps from the \"middle across\" position, and so on. Interestingly, the \"outer across\" and \"diagonal middle\" states have the exact same answer as the starting position, meaning that if the ducks started in those configurations the answer would be unchanged.

In the future I hope to tackle the extra credit portion of this problem, but I'm running short of time this weekend. I think exploiting the parity of the problem will be a key element of solving this without explicitly listing all possible arrangements of $N$ ducks. Stay tuned!

"},{"title":"Riddler Gematria","date":"Jan 10, 2020","slug":"riddler-gematria","excerpt":"Gematria is a numerical system that links Hebrew characters to numbers. This week's Riddler Classic explores the \"score\" of a number, and asks us to identify any patterns that emerge.","tags":[],"status":"published","content":"

Introduction

Gematria is a numerical system that links Hebrew characters to numbers. This week's Riddler Classic explores the \"score\" of a number, and asks us to identify any patterns that emerge.

\nIn Jewish study, “Gematria” is an alphanumeric code where words are assigned numerical values based on their letters. We can do the same in English, assigning 1 to the letter A, 2 to the letter B, and so on, up to 26 for the letter Z. The value of a word is then the sum of the values of its letters. For example, RIDDLER has an alphanumeric value of 70, since R + I + D + D + L + E + R becomes 18 + 9 + 4 + 4 + 12 + 5 + 18 = 70.\n
But what about the values of different numbers themselves, spelled out as words? The number 1 (ONE) has an alphanumeric value of 15 + 14 + 5 = 34, and 2 (TWO) has an alphanumeric value of 20 + 23 + 15 = 58. Both of these values are bigger than the numbers themselves.
\n
Meanwhile, if we look at larger numbers, 1,417 (ONE THOUSAND FOUR HUNDRED SEVENTEEN) has an alphanumeric value of 379, while 3,140,275 (THREE MILLION ONE HUNDRED FORTY THOUSAND TWO HUNDRED SEVENTY FIVE) has an alphanumeric value of 718. These values are much smaller than the numbers themselves.
\n
If we consider all the whole numbers that are less than their alphanumeric value, what is the largest of these numbers?
\n

Solution

The lucky number for this weeks solution is 279. With a score of 284, it is the largest integer that doesn't exceed its score.

If we test the first million numbers we see clear patterns emerge (well, maybe not crystal clear because rendering a million points doesn't make for the sharpest image.) The cyclical shape tends to range between values of 500-700 for most of the numbers up to one million.

Full Code

Lots of static dictionaries and testing in this code, which make it appear longer than it really is. In reality, the two short class methods, Number.spell and Number.score are the heavy-lifters, and they run very quickly! It takes just less than one second to run the first hundred thousand numbers.

import doctest\n\n\nclass Number(int):\n\n    letter_score = \" abcdefghijklmnopqrstuvwxyz\"\n    letter_score = {k: v for v, k in enumerate(letter_score)}\n    spelling = {\n        0: \"\",\n        1: \"one\",\n        2: \"two\",\n        3: \"three\",\n        4: \"four\",\n        5: \"five\",\n        6: \"six\",\n        7: \"seven\",\n        8: \"eight\",\n        9: \"nine\",\n        10: \"ten\",\n        11: \"eleven\",\n        12: \"twelve\",\n        13: \"thirteen\",\n        14: \"fourteen\",\n        15: \"fifteen\",\n        16: \"sixteen\",\n        17: \"seventeen\",\n        18: \"eighteen\",\n        19: \"nineteen\",\n        20: \"twenty\",\n        30: \"thirty\",\n        40: \"forty\",\n        50: \"fifty\",\n        60: \"sixty\",\n        70: \"seventy\",\n        80: \"eighty\",\n        90: \"ninety\",\n    }\n\n    @classmethod\n    def spell(cls, n: int) -> str:\n        \"\"\"\n        Convert an integer into a spelled word, e.g. 42 -> forty two\n\n        Examples\n        --------\n        >>> spell = Number.spell\n        >>> spell(18)\n        'eighteen'\n        >>> spell(61)\n        'sixty one'\n        >>> spell(100)\n        'one hundred'\n        >>> spell(118)\n        'one hundred eighteen'\n        >>> spell(178)\n        'one hundred seventy eight'\n        >>> spell(999)\n        'nine hundred ninety nine'\n        >>> spell(10018)\n        'ten thousand eighteen'\n        >>> spell(78123)\n        'seventy eight thousand one hundred twenty three'\n        >>> spell(987654)\n        'nine hundred eighty seven thousand six hundred fifty four'\n        >>> spell(118406714)\n        'one hundred eighteen million four hundred six thousand seven hundred fourteen'\n        >>> spell(12000000012)\n        'twelve billion twelve'\n        >>> spell(1000000000000)\n        Traceback (most recent call last):\n        ValueError: Unable to convert numbers larger than 999,999,999,999\n        \"\"\"\n        try:\n            return cls.spelling[n]\n        except KeyError:\n            if n < 100:\n                return f\"{cls.spell((n // 10) * 10)} {cls.spell(n % 10)}\"\n            if n < 1e3:\n                return f\"{cls.spell(n // 100)} hundred {cls.spell(n % 100)}\".strip()\n            if n < 1e6:\n                return f\"{cls.spell(n // 1e3)} thousand {cls.spell(n % 1e3)}\".strip()\n            if n < 1e9:\n                return f\"{cls.spell(n // 1e6)} million {cls.spell(n % 1e6)}\".strip()\n            if n < 1e12:\n                return f\"{cls.spell(n // 1e9)} billion {cls.spell(n % 1e9)}\".strip()\n            raise ValueError(\"Unable to convert numbers larger than 999,999,999,999\")\n\n    @classmethod\n    def score(cls, n: int) -> int:\n        \"\"\"\n        Returns the 'score' of an integer, where score is calculated by spelling\n        the word (e.g. 42 becomes 'forty two'), then assigning a value to each\n        of the characters (a=1, b=2, c=3, ..., z=26) and adding them up.\n\n        Examples\n        --------\n        >>> score = Number.score\n        >>> score(2)\n        58\n        >>> score(42)\n        142\n        >>> score(1417)\n        379\n        >>> score(3140275)\n        718\n        \"\"\"\n        return sum(cls.letter_score[letter] for letter in cls.spell(n))\n\n\nif __name__ == \"__main__\":\n    doctest.testmod()\n\n    # sample generator for the scores of the first 100,000 integers\n    scores = (Number.score(x) for x in range(100000))\n

"},{"title":"Riddler Spelling Hexagons","date":"Jan 3, 2020","slug":"riddler-spelling-hexagons","excerpt":"This week's Riddler Classic was a fun way to welcome the new year. We're asked to find seven letters that maximize the score from the New York Times Spelling Bee puzzle. I use pure Python (lists, sets, and dictionaries only) to find the optimum pool of seven words.","tags":[],"status":"published","content":"

Introduction

This week's Riddler Classic was a fun way to welcome the new year. We're asked to find seven letters that maximize the score from the New York Times Spelling Bee puzzle. I use pure Python (lists, sets, and dictionaries only) to find the optimum pool of seven words.

\nThe New York Times recently launched some new word puzzles, one of which is Spelling Bee. In this game, seven letters are arranged in a honeycomb lattice, with one letter in the center.\n
The goal is to identify as many words that meet the following criteria:
\n
\n
The word must be at least four letters long.
\n
The word must include the central letter.
\n
The word cannot include any letter beyond the seven given letters.
\n
\n
Which seven-letter honeycomb results in the highest possible game score? To be a valid choice of seven letters, no letter can be repeated, it must not contain the letter S (that would be too easy) and there must be at least one pangram.
\n

Solution

Using a brute-force approach in Python, I found the seven letters A, E, G, I, N, R, T, with a center letter of R, which has the highest potential score of 3898. Even enterprising wordsmiths among us will have a hard time finding all 537 valid words. The choice of R as the center letter matters quite a bit: if we changed the center letter to G, the maximum potential score would drop to 3095.

Methodology

There are at least two ways of approaching this problem, which I'll call the \"bottoms-up\" approach and the \"top-down\" approach.

Bottoms-up approach: we assemble every valid seven-letter pool, then build word lists from them, summing the total score as we go. We aren't allowed to use the letter \"s\" for this Riddler, so we can choose $25\\choose6$ combinations, which is 3,364,900 possibilities. This isn't impossible, but it's a daunting task.
Top-down approach: we can narrow the field of valid seven-letter pools because we have the master word list. The rules state that we must be able to create at least one pangram, so we know the winning seven-letter pool must be found within at least one word on the list. It turns out there are 7,986 unique seven-letter pools represented by words in the list, which is a manageable list to check compared to the bottoms-up approach.

On my computer, in pure python, it takes roughly 4 seconds to check each seven-letter group, as well as to check all possible center letters for each group. The code below returns the top 10 groups of letters. Good luck to New York Times readers if any of these puzzles show up in the paper!

Full Code

This week's post is shorter on text and longer on code. It was so fun to write, I hope it speaks for itself!

from collections import namedtuple\nfrom itertools import combinations\nfrom typing import Sequence\nfrom urllib.request import urlopen\n\n\ndef get_words() -> Sequence[str]:\n    \"\"\"Download and yield a sequence of valid words\"\"\"\n    source = urlopen(\"https://norvig.com/ngrams/enable1.txt\")\n    for word in source:\n        word = word.strip().decode(\"utf-8\").lower()\n        if \"s\" in word: continue\n        if len(word) < 4: continue\n        if len(set(word)) > 7: continue\n        yield word\n\n\ndef word_score(word: str) -> int:\n    \"\"\"Return the score of a word\"\"\"\n    if len(word) == 4:\n        return 1\n    return len(word) + 7 * (len(set(word)) == 7)\n\n\ndef get_letterset() -> dict:\n    \"\"\"Returns a dictionary of the sets of letters and their scores\"\"\"\n    letterset = {}\n    for word in get_words():\n        key, score = frozenset(word), word_score(word)\n        letterset[key] = letterset.get(key, 0) + score\n    return letterset\n\n\nclass Puzzle(namedtuple('Puzzle', ('letters', 'center'))):\n\n    letterset = get_letterset()\n    pangrams = {x for x in letterset if len(x) == 7}\n\n    @classmethod\n    def max_scores(cls) -> dict:\n        \"\"\"Return all possible Puzzles and their maximum scores\"\"\"\n        scores = {\n            (pangram, center): Puzzle(pangram, center).score()\n            for pangram in cls.pangrams for center in pangram\n        }\n        return sorted(scores.items(), key=lambda x: -x[1])\n\n    def subsets(self) -> list:\n        \"\"\"Return a list of all sub-puzzles\"\"\"\n        letters = frozenset(self.letters)\n        for n in range(len(letters) + 1):\n            for c in combinations(letters, n):\n                if self.center in c:\n                    yield frozenset(c)\n\n    def score(self) -> int:\n        \"\"\"Returns the maximum possible score for this Puzzle\"\"\"\n        return sum(\n            self.letterset.get(subset, 0)\n            for subset in self.subsets()\n        )\n\n\nif __name__ == \"__main__\":\n\n    # print the top 10 highest-scoring puzzles\n    results = Puzzle.max_scores()\n    for result in results[:10]:\n        print(result)\n

"},{"title":"Riddler Rolling","date":"Nov 15, 2019","slug":"riddler-rolling","excerpt":"This week's Riddler tested our ability to think recursively, but surprisingly not of the coding variety. Instead, we'll use a series of equations to solve the problem analytically. Brings back memories of high school proofs... which I may or may not remember with complete fidelity.","tags":[],"status":"published","content":"

Introduction

This week's Riddler tested our ability to think recursively, but surprisingly not of the coding variety. Instead, we'll use a series of equations to solve the problem analytically. Brings back memories of high school proofs... which I may or may not remember with complete fidelity.

\nTo start the game, you roll the die. Your current “score” is the number shown, divided by 10. For example, if you were to roll a 7, then your score would be 0.7. Then, you keep rolling the die over and over again. Each time you roll, if the digit shown by the die is less than or equal to the last digit of your score, then that roll becomes the new last digit of your score. Otherwise you just go ahead and roll again. The game ends when you roll a zero.\n
For example, suppose you roll the following: 6, 2, 5, 1, 8, 1, 0. After your first roll, your score would be 0.6, After the second, it’s 0.62. You ignore the third roll, since 5 is greater than the current last digit, 2. After the fourth roll, your score is 0.621. You ignore the fifth roll, since 8 is greater than the current last digit, 1. After the sixth roll, your score is 0.6211. And after the seventh roll, the game is over — 0.6211 is your final score.
\n
What will be your average final score in this game?
\n

Solution

The expected value of this game is 9/19, roughly 0.473684.

At first, the problem seems like a deeply nested recursive brain-melter. While that might be true, there is a pattern we can exploit in order to find a clean solution. We'll solve the problem by proving a simple base case, then build upon the base case to solve for the final answer.

The simplest base case we can start with is a game with a one-sided dice. (Indulge me, and suspend your rational faculties for a moment.) In this \"game\", we will always have a score of zero. Formally, we can say that $E(0)=0$ , meaning the expected value of this game is equal to zero.

Now, let's build on the base case. Suppose we increase the complexity and have a two-sided dice with the numbers zero and one. (One might even say it resembles a coin...) What can happen in this game? We can roll a zero immediately and end with a score of zero, or we can roll a one and continue. If we roll a one, we increment our score in the appropriate decimal place, after which we will find ourselves in a familiar position: we can either flip a zero or a one again.

We can now write an expression for $E(1)$ that takes both of these outcomes into account.

E(1) = \\frac{1}{2}\\times{E(0)} + \\frac{1}{2}\\times{(\\frac{1}{10} + \\frac{E(1)}{10})}

With 50% probability, we will receive the expected value of 0 and the game will end. With the other 50% probability we will roll a one and add $\\frac{1}{10}$ to our total, then move to the next decimal place, where we will expect to add $\\frac{E(1)}{10}$ to our score again. We divide $E(1)$ by ten to account for the fact that we move to the next decimal place each time we roll again.

Now, after plugging in $E(0)=0$ , we can solve the equation for $E(1)$ . We get $E(1)=\\frac{1}{19}$ .

E(1) = \\frac{1}{20}\\times{(1 + E(1))}

20E(1) = 1 + E(1)

E(1) = \\frac{1}{19}

What about the next case, $E(2)$ ? With 33% probability we can roll a zero and end the game; with 33% probability we can roll a one, and we'll find ourselves in the $E(1)$ universe again; with 33% probability we can roll a two and stay in the $E(2)$ universe.

E(2) = \\frac{1}{3}\\times{E(0)} + \\frac{1}{3}\\times{(\\frac{1}{10} + \\frac{E(1)}{10})} + \\frac{1}{3}\\times{(\\frac{2}{10} + \\frac{E(2)}{10})}

With some algebra, we can solve this equation for $E(2)$ , which gives $\\frac{2}{19}$ . See a pattern? It looks like $E(N)=\\frac{N}{19}$ . Let's attempt to confirm by expanding the equation for $E(N)$ . For a dice with $N$ sides we can expand the formula as follows. For simplicity we'll omit the $E(0)$ term because we know it evaluates to zero.

E(N) = \\frac{1}{N+1}\\times{(\\frac{1}{10} + \\frac{E(1)}{10})} + \\frac{1}{N+1}\\times{(\\frac{2}{10} + \\frac{E(2)}{10})} + ... + \\frac{1}{N+1}\\times{(\\frac{N}{10} + \\frac{E(N)}{10})}

We can factor the $N$ 's and 10's from the denominator for a simpler expression:

E(N) = \\frac{\\sum_{i=1}^N (i+E(i))}{10(N+1)}

We will attempt to prove $E(N)=\\frac{N}{19}$ using induction. We've already verified that $E(1)=\\frac{1}{19}$ . Now we must verify that $E(N+1)=\\frac{N+1}{19}$ . We will use the fact that $\\sum_{i=1}^N i = \\frac{N(N+1)}{2}$ to remove the summations from the numerator.

\\frac{N+1}{19}=\\frac{\\frac{(N+1)(N+2)}{2} + \\frac{(N+1)(N+2)}{38}}{10(N+2)}

Next, we multiply both sides by $10(N+2)$ :

\\frac{10(N+1)(N+2)}{19}=\\frac{(N+1)(N+2)}{2} + \\frac{(N+1)(N+2)}{38}

Now, remove the common $(N+1)(N+2)$ terms, and verify both sides are equal.

\\frac{10}{19}=\\frac{1}{2} + \\frac{1}{38}

Therefore we have proven by mathematical induction that $E(N)=\\frac{N}{19}$ . Our original problem was for $N=9$ , so we confirm our answer of $E(9)=\\frac{9}{19}$ .

Proof

Because LaTeX is not my specialty, I also wrote an old-fashioned proof as well. Enjoy!

"},{"title":"Riddler Dowries","date":"Nov 1, 2019","slug":"riddler-dowries","excerpt":"A small twist on a classic problem is this week's challenge from the Riddler. We're going to tackle an extension of the secretary problem - also known as the Sultan's Dowry problem. This classic puzzle has led to fascinating research in optimal stopping theory, which we will use to help our Sultan choose the best possible suitor. Let's dive in!","tags":[],"status":"published","content":"

Introduction

A small twist on a classic problem is this week's challenge from the Riddler. We're going to tackle an extension of the secretary problem - also known as the Sultan's Dowry problem. This classic puzzle has led to fascinating research in optimal stopping theory, which we will use to determine how effective our Sultan is at choosing a suitor. Let's dive in!

\nThe sultan has asked her vizier to present her with 10 candidates for marriage. The vizier has searched the kingdom for the 10 most desirable partners, but he does not know whom the sultan will prefer. If she saw them all at the same time, she would easily be able to rank them from 1 (the best partner) to 10 (the worst partner). But the vizier can only present the candidates one at a time — very hard to sync everybody’s calendars, even back then — and in a random order. Upon seeing each candidate, the sultan must reject or accept him. If a candidate is rejected, the sultan cannot pick him again. But on seeing each new candidate, she knows exactly where he’d stack up relative to the candidates she has rejected. **If she strategizes, what’s the highest rank she can expect her chosen candidate to have on average?**\n
For example, if she simply accepted the first candidate presented to her, his rank could be anywhere from 1 to 10 with equal probability, averaging to 5.5. Surely she can do better...
\n

As an aside, I recently read Algorithms to Live By, which covered how puzzles like these might be applied to real-life situations as well. It was a fun read discussing how computer science algorithms can help us make better decisions, from folding socks as efficiently as possible to deciding whether to return to our favorite restaurant or try a new one. Highly recommended!

Solution

Thanks to some helpful suggestions, I revised my original answer, in which I used the proven strategy for the original problem, rather than devising a new strategy for the specific problem we are trying to solve this week. In short, if we apply the strategy from the original problem - where we try to choose the single best suitor - the expected result is 3.025. On the other hand, if we devise a new strategy, we can improve the results by roughly half a rank. The following is what I believe to be the ideal strategy and answer. Thanks again for the helpful nudge in the right direction, Riddler Nation twitter!

If the Sultan chooses optimally, her suitor will have an average rank of roughly 2.56.

Methodology

We'll solve this problem using Dynamic Programming. I'll create a data structure called \"State\" that keeps track of everything we know about the world at each point in time. \"State\" is comprised of three variables.

m - the rank of the current suitor, relative to all suitors we've seen so far. For example, m=2 means we're looking at the second-best suitor we've seen so far.
seen - the number of suitors we've seen in total, including the one we're currently considering.
N - the total number of suitors available to consider, in our case, the default is 10.

Together, these three variables tell us everything we need to know to make the right decision. To solve the problem, we work backwards, from the last step to the first. We know that we must pick the 10th suitor if we get to that point. We also know the actual rank of the suitor, because we've seen everyone. Therefore, if we have State(m=4, seen=10, N=10), we know the rank we end up with is 4.

If we are viewing the 9th suitor, then we have two options: choose the one we have in front of us, or pass, and gamble that the randomly drawn 10th suitor will be better. Intuitively, we might think that if we're looking at the best suitor we've seen so far: State(m=1, seen=9, N=10), then it makes sense to stop. There's only a 10% chance we would find someone better. But if we're looking at the worst suitor we've seen so far: State(m=9, seen=9, N=10), then it makes sense to pass and take our chances with the next one. When we formalize this process, we calculate the expected value of stopping and the expected value of continuing. At each point in the process, we choose the option that gives us the better (minimum) expected outcome. When we work backwards all the way to the very first suitor we see, we will have the answer we're looking for.

The following code creates the State class by subclassing namedtuple, then adds methods to calculate the stop_value and expected_value of each State. We're interested in the expected value when we start the process, which is State(m=1, seen=1, N=10). Then we call expected_value() to get our answer. It turns out that designing a new strategy from first principles allows us to improve the answer from above, and we get an average expected rank of 2.56.

Furthermore, now that we have a framework with flexible inputs, we can also solve for different values of N - if the Sultan had a pool of 50 applicants, for example. We can plot the expected rank as the value of N changes, and we see a curve that quickly approaches ~3.7, though there has been interesting discussions about the actual limiting behavior of this process.

Full Code

This code is used for the ideal strategy I outline above.

from collections import namedtuple\nfrom functools import lru_cache\nimport doctest\n\n\nclass State(namedtuple(\"State\", (\"m\", \"seen\", \"N\"))):\n    \"\"\"\n    Represents the current state of the game. \"m\" is the rank of\n    the suitor we are currently considering, relative to the ones\n    we have seen already. \"seen\" is the number of candidates we have\n    already seen, including the one we are currently considering.\n    \"N\" is the total number of candidates available.\n\n    Parameters\n    ----------\n    m : int, the relative rank of the current suitor, compared\n        against the suitors we've seen already. For example,\n        m=2 means we're viewing the second-best suitor we've seen\n        up to this point. m <= seen\n    seen : int, the number of suitors we've seen so far, including\n        the one we are currently viewing.\n    N : int, the total number of suitors available\n    \"\"\"\n\n    @lru_cache(maxsize=None)\n    def stop_value(self):\n        \"\"\"\n        Returns the expected value if we were to choose suitor m\n\n        Examples\n        --------\n        >>> State(m=3, seen=10, N=10).stop_value()\n        3.0\n\n        >>> State(m=1, seen=9, N=10).stop_value()\n        1.1\n\n        >>> State(m=1, seen=8, N=10).stop_value()\n        1.2222222222222223\n\n        >>> State(m=1, seen=7, N=10).stop_value()\n        1.3750000000000002\n\n        >>> State(m=1, seen=1, N=10).stop_value()\n        5.500000000000001\n        \"\"\"\n        if self.seen == self.N:\n            # if we're viewing the last suitor, stop value is m\n            return float(self.m)\n        else:\n            # otherwise, stop value is the weighted average of seeing\n            # someone better than m and seeing someone worse than m\n            better = State(m=self.m+1, seen=self.seen+1, N=self.N).stop_value()\n            worse = State(m=self.m, seen=self.seen+1, N=self.N).stop_value()\n            return (\n                better * self.m + worse * (self.seen - self.m + 1)\n            ) / (self.seen +1)\n\n    @lru_cache(maxsize=None)\n    def expected_value(self):\n        \"\"\"\n        Returns the expected value of this State, where expected value is\n        defined as the expected rank of suitor we will end up with if we\n        make perfect decisions from this point forward.\n\n        Examples\n        --------\n        >>> State(m=1, seen=9, N=10).expected_value()\n        1.1\n\n        >>> State(m=9, seen=9, N=10).expected_value()\n        5.5\n\n        >>> State(m=1, seen=1, N=10).expected_value()\n        2.5579365079365086\n        \"\"\"\n        if self.seen == self.N:\n            # we must select the last suitor if we get to that point\n            return float(self.m)\n        else:\n            # otherwise, we find ourselves in a future state where seen\n            # is incremented by one, and we could view any new rank, m\n            # we then choose the optimal path in those future states\n            ev = [\n                State(m=x, seen=self.seen+1, N=self.N).expected_value()\n                for x in range(1, self.seen+2)\n            ]\n            ev = sum(ev) / len(ev)\n            return min(ev, self.stop_value())\n\n\nif __name__ == '__main__':\n    doctest.testmod()\n

"},{"title":"Introducing pyesg!","date":"Oct 31, 2019","slug":"introducing-pyesg","excerpt":"I've started a new project called pyesg - Python Economic Scenario Generator. Economic Scenario Generators, or ESGs, are used to simulate possible future markets, like stock prices, interest rates, or volatility. Actuaries use ESGs to determine the potential values of insurance portfolios in the future. This helps them ensure that their companies will have enough money to pay claims even under the worst scenarios. Other professionals might use ESGs to understand how business decisions today could affect company value in the future. The Python ecosystem has amazing libraries for data analysis, machine learning, and many other fields, but not for generating economic scenarios. I hope that an ESG library for Python will make this type of analysis easier and more widely adopted.","tags":[],"status":"published","content":"

Introduction

I've started a new project, called pyesg - Python Economic Scenario Generator. Economic Scenario Generators, or ESGs, are used to simulate possible future markets, like stock prices, interest rates, or volatility. Actuaries use ESGs to determine the potential values of insurance portfolios in the future. This helps them ensure that their companies will have enough money to pay claims even under the worst scenarios. Other professionals might use ESGs to understand how business decisions today could affect company value in the future. The Python ecosystem has amazing libraries for data analysis, machine learning, and many other fields, but not for generating economic scenarios. I hope that an ESG library for Python will make this type of analysis easier and more widely adopted.

Today, one of the most widely used economic scenario generators among actuaries is provided for free by the Society of Actuaries and the American Academy of Actuaries. It is an Excel file that is available here. This is a fantastic resource provided by these organizations, but suffers from the classic drawbacks of Excel, including lack of unit-testing, compatibility issues (it is a .xls file, not the more ubiquitous .xlsx or .xlsm files today), and speed issues (it takes roughly 7-8 minutes to generate a full set of scenarios.) One of the goals of pyesg is to provide the same functionality as the Academy generator in a well-tested and fast python package.

Objectives

I'm not aware of any comprehensive ESG library available for Python today. I think such a library should have the following components:

A suite of stochastic models - inspired by the \"fit\"/\"predict\" scikit-learn API\n
- that are easy to calibrate (\"fit\") using historical data, or to manually provide parameters.
- that can simulate future economic paths (\"predict\")
\n
A suite of model and scenario evaluation tools to\n
- evaluate the goodness of fit of models
- calculate significance measures of generated scenarios (to select subsets of scenarios if desired)
\n
Replicate the existing SOA and AAA Excel generator so actuarial teams can migrate to Python.
Minimal dependencies - relying on the standard scientific python stack: numpy, pandas, and scipy, with optional plotting from matplotlib.

I expect that these objectives may shift or expand as I continue working on the library. Please let me know if you think anything is missing!

Example - Vasicek Interest Rate Model

The project is in its early stages, but I've recently implemented the Vasicek interest rate model. At the moment, the API looks like this.

import pyesg\n\n# load a dataset of US Treasury rates, contained in pyesg.datasets, which is a\n# pandas dataframe of rates for various maturities, indexed by year and month\nust = pyesg.datasets.load_ust_historical()\n\n# for this example, we'll train on the following data:\n# y - the 3-month US treasury rate\n# X - the time of each observation, starting at zero, in monthly steps\ny = ust.loc['3-month'].values\nX = np.full(len(y), 1/12).cumsum()\n\n# create a vasicek model object, just like an estimator model from sklearn\nvasicek = pyesg.Vasicek()\n\n# fit the model by passing the X and y vectors; the model is now trained\nvasicek.fit(X, y)\n\n# sample future paths from the model\n# specify the number of scenarios (e.g. 1000)\n# length of projection (e.g. 30 years)\n# and time step (e.g. weekly, or 52 time-steps per year)\nscenarios = vasicek.sample(size=(1000, 30, 52))\n

Example - Nelson-Siegel and Nelson-Siegel-Svensson Curve Interpolators

We can almost always observe interest rates at key maturities, for example, bonds trading with maturities of 1, 2, 3, 5, 7, or 10 years. If we want to estimate the interest rate for an 8-year bond, we need to interpolate between the observed values. Simple techniques like linear interpolation are possible, but have certain obvious disadvantages - namely that the interest rate curve is non-linear. Instead, better techniques like the Nelson-Siegel and Nelson-Siegel-Svensson interpolators might give better results. Both interpolators are available in pyesg.

import pyesg\nimport matplotlib.pyplot as plt\n\n\n# load a dataset of historical US Treasury rates, contained in pyesg.datasets\n# ust is a pandas dataframe of rates for various maturities, indexed by year and month\nust = pyesg.datasets.load_ust_historical()\n\n# we will be interpolating rates from the file:\n# y - the observed US Treasury rate for the given maturity for a select observation date\n# X - the maturity of the bond measured in years\ny = data.iloc[-10].values\nX = np.array([0.25, 0.5, 1, 2, 3, 5, 7, 10, 20, 30])\n\n# create Nelson-Siegel and Nelson-Siegel-Svensson interpolator objects\n# then fit both models using the historical data\nns = pyesg.NelsonSiegel()\nnss = pyesg.NelsonSiegelSvensson()\nns.fit(X, y)\nnss.fit(X, y)\n\n# finally, we can plot the results\nfig, ax = plt.subplots(figsize=(10,7))\n\nx = np.arange(1, 121) / 4\nax.plot(x, ns.predict(x), color='C1', label='Nelson-Siegel')\nax.plot(x, nss.predict(x), color='C2', label='Nelson-Siegel-Svensson')\nax.scatter(X, y)\n\nax.legend(frameon=False, fontsize=12)\nfor s in ['top', 'right', 'left']:\n    ax.spines[s].set_visible(False)\nplt.show()\n

Progress

The pyesg package is available on pypi, and can be installed quickly using:

pip install pyesg\n

The source code is available on github, and is open-source licensed under MIT.

If this project sounds interesting to you, I would love to hear your thoughts! I would also welcome contributions. You can reach me at jason@ashanalytics.com.

"},{"title":"Riddler Cornfield Maze","date":"Oct 18, 2019","slug":"riddler-cornfield-maze","excerpt":"I'm a sucker for a good maze problem from the Riddler Express. Let's over-engineer it using networkx and python to extend the problem and see what we can learn!","tags":[],"status":"published","content":"

Introduction

I'm a sucker for a good maze problem from the Riddler Express. Let's over-engineer it using networkx and python to extend the problem and see what we can learn!

\nThe number in each box tells you how many spaces up, down, left or right you must move. (No diagonal moves, people.) Starting at the yellow six in the bottom left corner, can you make your way to the asterisk?\n

Solution

The shortest path from the highlighted 6 to the target square consists of 8 steps.

What else can we learn about this maze? I think it would be interesting to see which square has the longest path to the target. Or for that matter, the path length from every square in the maze to the target. By treating the entire maze like a network, we can find the links between each and every square, then use the network to answer these questions. For example, each square is \"linked\" to up to four other squares moving up, down, left, or right. Using python and the fabulous networkx library, which I've used several times before, we can start to answer some of these other questions. My full code is available below, but I'll show interesting snippets as we go along.

The following shows us the number of steps from each square to the target. (-1 means no path exists.) The longest number of steps is 10, and actually comes from a box bordering the target! We can also quantify the average number of steps to the target from any square, which is 6.64 (among squares where a path exists at all, and excluding the target itself.)

>>> out = steps(maze, target=(6,2))\n>>> out\narray([[ 2,  4,  4,  3,  8,  8,  8,  3,  6,  8],\n       [ 9,  6,  9,  6,  7,  7,  8,  8,  7,  7],\n       [ 9,  8,  5,  4,  7,  8,  7,  8,  6,  7],\n       [ 8,  5,  5,  6,  6,  7, -1,  4,  6,  7],\n       [ 6,  5,  6,  4,  5,  6,  5,  7,  5,  6],\n       [ 8,  7, 10,  9, -1,  7,  6,  9,  9,  8],\n       [ 1,  9,  0,  5,  7,  9,  9,  7,  7,  6],\n       [ 7,  6,  5,  7,  6,  6,  7,  6,  7,  6],\n       [ 7,  7,  9,  5,  6,  8,  6,  8,  7,  8],\n       [ 8,  8,  7,  5,  7,  6,  7,  8,  7,  8]])\n>>> out[out > 0].mean()\n6.639175257731959\n

What about the \"best\" or \"worst\" target square? Which target square is the easiest or hardest to hit? Suppose we cycle through each possible square and declare it the target, then calculate the average number of steps required to hit it. (Key caveat here is that we'll exclude cells with no path to our new targets. We'll also assume the original target cell has a value of zero, so it can't connect outward at all.)

The easiest target square is in the fifth row, fourth column: cell (4,3) when we count using zero-indexing. This cell has the value of 4. The hardest cell to reach is in the top row, eighth column, with a value of 7. The average number of steps to reach this target is a whopping 18.21! However, we could also argue that the most difficult target square is our yellow-highlighted six. It's unreachable from any other square in the maze!

import pandas as pd\n\n>>> out = {target: steps(maze, target=target) for target in graph(maze).nodes}\n>>> out = {target: value[value > 0].mean() for target, value in out.items()}\n>>> pd.Series(out).sort_values()\n4  3     3.500000\n2  1     3.572917\n8  2     3.677083\n0  6     3.677083\n3  5     3.687500\n          ...\n2  2    15.791667\n3  2    16.614583\n   7    17.437500\n0  7    18.208333\n9  0          NaN\nLength: 100, dtype: float64\n

Full Code

Feel free to expand or use this code below to draw your own conclusions about this week's maze.

import doctest\nimport numpy as np\nimport networkx as nx\n\n\nmaze = np.array([\n    [6, 2, 1, 3, 6, 1, 7, 7, 4, 3],\n    [2, 3, 4, 5, 7, 8, 1, 5, 2, 3],\n    [1, 6, 1, 2, 5, 1, 6, 3, 6, 2],\n    [5, 3, 5, 5, 1, 6, 7, 3, 7, 3],\n    [1, 2, 6, 4, 1, 3, 3, 5, 5, 5],\n    [2, 4, 6, 6, 6, 2, 1, 3, 8, 8],\n    [2, 4, 0, 2, 3, 6, 5, 2, 4, 6],\n    [3, 1, 7, 6, 2, 3, 1, 5, 7, 7],\n    [6, 1, 3, 6, 4, 5, 4, 2, 2, 7],\n    [6, 7, 5, 7, 6, 2, 4, 1, 9, 1],\n])\n\n\ndef connections(loc, value, size=(10, 10)):\n    \"\"\"\n    Returns the valid connections from a given point\n\n    Parameters\n    ----------\n    loc : tuple(int, int), the location of the point, e.g. (3, 6)\n    value : int, the value of the point, e.g. 6\n    max_size : tuple(int, int), the size of the maze\n\n    Returns\n    -------\n    locs : list of tuple(int, int) for valid connection points\n\n    Examples\n    --------\n    >>> connections(loc=(5, 5), value=3)\n    [(2, 5), (8, 5), (5, 2), (5, 8)]\n\n    >>> connections(loc=(3, 3), value=6)\n    [(9, 3), (3, 9)]\n\n    >>> connections(loc=(0,0), value=5)\n    [(5, 0), (0, 5)]\n    \"\"\"\n    x_idx = [-value, value, 0, 0]\n    y_idx = [0, 0, -value, value]\n    locs = [(loc[0] + x, loc[1] + y) for x, y in zip(x_idx, y_idx)]\n    return [loc for loc in locs if max(loc) < max(size) and min(loc) >= 0]\n\ndef graph(maze):\n    \"\"\"Create a graph from a maze\"\"\"\n    G = nx.DiGraph()\n    edges =  {\n        loc: connections(loc, value, size=maze.shape)\n        for loc, value in np.ndenumerate(maze)\n    }\n    for loc, values in edges.items():\n        for v in values:\n            G.add_edge(loc, v)\n    return G\n\ndef paths(maze, target):\n    \"\"\"\n    Returns a dictionary of path length from every\n    node in the graph to a given target in the graph\n    \"\"\"\n    G = graph(maze)\n    out = {}\n    for node in G.nodes:\n        try:\n            path = len(nx.shortest_path(G, source=node, target=target)) - 1\n        except nx.NetworkXNoPath:\n            path = -1\n        out[node] = path\n    return out\n\ndef steps(maze, target):\n    \"\"\"\n    Returns an array the same shape as the maze where the values in the\n    array represent the number of steps from the given node to the target\n    \"\"\"\n    out = np.zeros_like(maze)\n    for loc, value in paths(maze, target).items():\n        out[loc] = value\n    return out\n\nif __name__ == '__main__':\n    doctest.testmod()\n

"},{"title":"Riddler Currency Conversion","date":"Oct 18, 2019","slug":"riddler-currency","excerpt":"This was a clever version of a classic problem for this week's Riddler Classic. With just two denominations of currency, what is the largest amount we can't create from a combination of bills?","tags":[],"status":"published","content":"

Introduction

This was a clever version of a classic problem for this week's Riddler Classic. With just two denominations of currency, what is the largest amount we would be unable to create from a combination of bills?

\nRiddler Nation has two coins: the Dio, worth 538, and the Phantus, worth 19. When visiting on vacation, Riddler National Bank will gladly convert your dollars into Dios and Phanti. For example, if you were to give a bank teller 614, they’d return to you one Dio and four Phanti, since 614 = 1 × 538 + 4 × 19. But if you tried to exchange one dollar more (i.e., 615), then alas, there is no combination of Dios and Phanti the teller could give you, and you won’t get your money’s worth in local currency.\n
To make the bank teller’s job (and your vacation) as miserable as possible, you decide to bring the largest dollar amount that cannot be converted into Riddler currency. How much money are we talking here? That is, what’s the largest whole number that cannot be expressed as a sum of 19s and 538s?
\n
Extra Credit: Word is that Riddler Nation is considering minting a third currency, worth 101. If they do, then what would be the largest dollar amount that cannot be converted into Riddler currency?
\n

Solution

The largest amount we could fail to create is $9665.

It turns out this is a fivethirtyeight twist on a classic: the coin problem. It is also known as the Diophantine Frobenius Problem - hence the clever names for our two currencies, the \"Dio\" and \"Phantus\".

For any two relatively prime numbers - numbers that share no common divisors except 1 - there is a formula to solve our problem: $ab-a-b$ . With $a=538$ and $b=19$ , we get $538*19-538-19=9665$ . Intuitively, the way I thought about this problem is that we eventually will find a string of numbers 19-long that we can create (for example, by looping through each starting point of 538, then 1076, etc.) From there, we could always add multiples of 19 to achieve any higher number. I think of it as \"cycling through\" the 19's until we have all remainders of zero.

For fun, to verify with python, I used the following function. The idea is to select a substantially large value for $n$ , then identify the largest number that couldn't be created from the 19 and 538.

import numpy as np\n\ndef model(n, a=538, b=19):\n    \"\"\"\n    Returns the highest integer less than n which cannot be created\n    by a positive number of\n    \"\"\"\n    a, b = max(a, b), min(a, b)\n    mask = np.ones(shape=n, dtype=bool)\n    for idx in range(n//a+1):\n        mask[idx*a::b] = False\n    return np.arange(n)[mask].max()\n\n>>> model(100000)\n9665\n

Now, what about three numbers? This gets reasonably harder. There is no simple formula (that we've discovered yet). Instead I used another programmatic approach to solve the extra credit. Even though we add a third currency worth 101, we we can only cycle through our smallest currency a maximum of 19 times before we will find repeat values. Therefore, our maximum number should be less than $19\\times101=1919$ . We pick some arbitrarily high number, in this case 100,000 just to confirm our intuition, and check the largest number we were able to find that couldn't be created from the three values.

def model(n, a=538, b=19, c=101):\n    \"\"\"\n    Returns the highest integer less than n which cannot be created\n    by a positive number of\n    \"\"\"\n    a, b, c = sorted([a, b, c])\n    mask = np.ones(shape=n, dtype=bool)\n    for idx in range(n//b+1):\n        mask[idx*b::a] = False\n        mask[idx*c::a] = False\n    return np.arange(n)[mask].max()\n\n>>> model(100000)\n1799\n

Usually there's some fancy tagline here about \"and this is why it pays to know math\", but I struggle to find a meaningful takeaway from solving for the worst currency conversion outcome (losing our money in the process). I suppose we should let this serve as a warning for you travelers instead!

"},{"title":"Who Wants to Bayes a Millionaire","date":"Oct 4, 2019","slug":"riddler-bayes-millionaire","excerpt":"Forgive the pun - this was a fantastic Riddler Express challenging you to calculate your odds of winning a million dollars!","tags":[],"status":"published","content":"

Introduction

Forgive the pun - this was a fantastic Riddler Express challenging you to calculate your odds of winning a million dollars!

\nYou’ve made it to the $1 million question, but it’s a tough one. Out of the four choices, A, B, C and D, you’re 70 percent sure the answer is B, and none of the remaining choices looks more plausible than another. You decide to use your final lifeline, the 50:50, which leaves you with two possible answers, one of them correct. Lo and behold, B remains an option! How confident are you now that B is the correct answer?\n

Solution

After the 50-50, we should be 87.5% confident that the correct answer is B.

We started the problem by estimating our confidence in the answer, B. But when new information is revealed to us, we should revise our estimate. In general, when we receive new information about a situation, we should try to update our beliefs about the expected outcomes. The primary tool to do this is Bayes's Theorem.

P(A|B) = \\frac{P(B|A) \\times P(A)}{P(B)}

In the formula, $A$ and $B$ represent events, such as \"B is the correct answer\". $P(A|B)$ , called a conditional probability, is the likelihood that event $A$ occurs, given $B$ has also occurred. Typically it is easy for us to solve for one of the conditional probabilities, for example $P(B|A)$ , but hard for us to solve for the other, $P(A|B)$ . Bayes's theorem gives us a way to translate one into the other.

The problem asks us to estimate the probability that B is correct, given that it remains after the 50-50 elimination. In math terms, we want to solve for the conditional probability $P(\\text{B is correct}|\\text{B remains})$ . Now that we have defined the conditional probability, we can write our version of the formula as follows:

P(\\text{B is correct}|\\text{B remains}) = \\frac{P(\\text{B remains}|\\text{B is correct}) \\times P(\\text{B is correct})}{P(\\text{B remains})}

Remember how I said that one of the conditional probabilities tends to be easy to solve? In our case, the conditional probability $P(\\text{B remains}|\\text{B is correct})$ , is the easy one. We know if B is the correct answer, it can never be eliminated by the 50-50, so this probability is 100%. We also assumed B was the correct answer with 70% confidence, so $P(\\text{B is correct})=0.7$ . Therefore, our formula becomes:

P(\\text{B is correct}|\\text{B remains}) = \\frac{1.0 \\times 0.7}{P(\\text{B remains})}

Once we calculate $P(\\text{B remains})$ , we will be able to solve the problem. How do we calculate the probability that B remains on the board after the 50-50? Let's use an example.

Suppose the true answer to the question is D. It would be impossible to eliminate the true answer for the 50-50, so the remaining options are to eliminate one of the three pairs, AB, AC, or BC. We will assume each of the pairs is eliminated with equal probability. Therefore B remains on the board one third of the time. The same holds if we assume the true answer is A, or if the true answer is C. If the true answer is B, then we know B can't be eliminated. When we combine each of these possibilities, we get this weighted sum:

P(\\text{B remains}) = 3\\times 0.1 \\times \\frac{1}{3} + 0.7\\times1=0.8

Finally, we can solve for our desired quantity:

P(\\text{B is correct}|\\text{B remains}) = \\frac{1.0 \\times 0.7}{0.8}=\\frac{7}{8}=87.5\\%

It certainly pays to know Bayes's Theorem!

"},{"title":"Riddler Birthdays","date":"Oct 4, 2019","slug":"riddler-birthdays","excerpt":"This week's Riddler is a twist on the classic birthday problem. The birthday problem tells us that among a group of just 23 people, we are 50% likely to find at least one pair of matching birthdays. But what if we want to find three matching birthdays instead?","tags":[],"status":"published","content":"

Introduction

This week's Riddler is a twist on the classic birthday problem. The birthday problem tells us that among a group of just 23 people, we are 50% likely to find at least one pair of matching birthdays. But what if we want to find three matching birthdays instead?

\nIn the U.S. Senate, three senators happen to share the same birthday of October 20: Kamala Harris, Brian Schatz and Sheldon Whitehouse.\n
How many people do you need to have better-than-even odds that at least three of them have the same birthday? (Again, ignore leap years.)
\n

Solution

The US Senate comprises a group of 100 individuals. It turns out that for a group of that size, we expect three shared birthdays roughly 64% of the time. For 50% odds, we need a group of 88 people.

Methodology

The classic birthday problem can be solved with pen, paper, and probability. We consider two possibilities: no shared birthdays, or at least one shared birthday. Because these are the only two possibilities, their odds must sum to 100%. It's often easier to solve for the likelihood of all unique birthdays, then subtract that answer from 100% to solve the problem.

However, with three birthdays the math becomes much more involved. For a group of size $n$ , we would have to partition the world into categories like this:

$n$ distinct birthdays
1 pair of birthdays & $n-1$ distinct birthdays
2 pairs of birthdays & $n-2$ distinct birthdays
3 pairs of birthdays & $n-3$ distinct birthdays\n...

At the extreme, we would have $\\frac{n}{2}$ pairs of birthdays (everyone in the group has a birthday buddy). The final option would be that at least three people share the same birthday. We sum the likelihoods of everything except the probability we're interested in, subtract from 100%, and arrive at our answer.

Instead, I opted to solve this problem using simulated trials. By simulating enough groups and measuring how many people are needed to find three matching birthdays, we can estimate the answer. If we simulate one million groups, we can measure the median group size of our samples to find the point at which we cross 50% likelihood.

Python does the heavy lifting this week. The function itself is short, but we rely on a million sampled groups to converge on the correct answer.

import random\n\ndef model(n=3, days=365):\n    size = 0\n    seen = [set() for _ in range(n)]\n    while len(seen[-1]) == 0:\n        i = random.randint(a=0, b=days)\n        for s in seen:\n            if i not in s:\n                s.add(i)\n                break\n        size += 1\n    return size\n

Each time we run model(), it returns a random sample of the number of people required to find three matching birthdays. The function is also general enough to search for any number of desired birthdays - for example, the number of people we need for four matching birthdays - though the speed decreases as we search for larger numbers.

The function tracks the number of occurrences of each birthday in the group. In the default case, looking for three matching birthdays, it tracks the number of birthdays we've seen only once, and the number of birthdays we've seen twice. For each new random number we draw, we determine how many times we've seen it before. If it's brand new, we add it to the first set. If we've seen it once before, we add it to the second set. And if we've seen it twice before, we know we've found the third instance, so the function halts and returns the number of birthdays we needed to see in total.

The chart below shows the cumulative curves for two, three, and four matching birthdays. As we know from the classic problem, we reach 50% cumulative likelihood with a group of 23. For three birthdays, we need 88, and for four birthdays we need 188! Therefore the House of Representatives is more likely than not to have at least four matching birthdays.

"},{"title":"Riddler League Baseball","date":"Sep 27, 2019","slug":"riddler-league-baseball","excerpt":"What happens when you create a baseball league from three teams with peculiar specialties? That's the objective of this week's Riddler. We're asked to determine whether it's better to specialize in home runs, doubles, or walks as a strategy to tally the most wins from a season of baseball in the Riddler League.","tags":[],"status":"published","content":"

Introduction

What happens when you create a baseball league from three teams with peculiar specialties? That's the objective of this week's Riddler. We're asked to determine whether it's better to specialize in home runs, doubles, or walks as a strategy to tally the most wins from a season of baseball in the Riddler League.

We've seen similar problems from the Riddler about baseball simulations, but this one has a competitive twist - simulating an entire season of games among a full League of teams. Here's the full problem text.

\nRiddler League Baseball, also known as the RLB, consists of three teams: the Mississippi Moonwalkers, the Delaware Doubloons and the Tennessee Taters.\n
Each time a batter for the Moonwalkers comes to the plate, they have a 40 percent chance of getting a walk and a 60 percent chance of striking out. Each batter for the Doubloons, meanwhile, hits a double 20 percent percent of the time, driving in any teammates who are on base, and strikes out the remaining 80 percent of the time. Finally, each batter for the Taters has a 10 percent chance of hitting a home run and a 90 percent chance of striking out.
\n
During the RLB season, each team plays an equal number of games against each opponent. Games are nine innings long and can go into extra innings just like in other baseball leagues. Which of the three teams is most likely to have the best record at the end of the season?
\n

Solution

It turns out that swinging for the fences is a viable strategy in Riddler League Baseball. The Taters, who hit home runs with 10% of their batting attempts, are able to win a decisive victory against their opponents. The table below shows the win rates for each potential matchup in the League, based on simulating 10 million games between each pair of teams. (Note there is no actual home field advantage, but assigning teams to \"home\" and \"away\" helps clarify which team has the better odds of winning.)

The Taters have a clear advantage over the Doubloons, winning over 62% of their games against that team. The closest matchup is between the Taters and the Moonwalkers - teams with seemingly polar opposite game plans.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Home Team	Away Team	Home team win %
Taters	Doubloons	62.73%
Moonwalkers	Doubloons	58.49%
Taters	Moonwalkers	51.62%

If we simulate a season of 162 games using the win rates from the table above, we get the following records for each team. For example, the Taters are expected to play the Doubloons 81 times and the Moonwalkers 81 times. They win 62.73% of their 81 games against the Doubloons and 51.62% of their 81 games against the Moonwalkers for a total of $81\\times62.73\\% + 81\\times51.62\\%=92.6$ wins for the season. We calculate wins and losses similarly for each other team.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Team	Expected Wins	Expected Losses
Taters	92.6	69.4
Moonwalkers	86.6	75.4
Doubloons	63.8	98.2

Methodology

How did we calculate the win percentages? We want to tally the number of runs scored by each team during a game, which is the sum of the runs scored during each of nine innings. How many runs might each of our teams score in a single inning?

Taters: Each batter has a 10% chance of scoring a single run. We want to count the number of runs scored before the third out is recorded.
Doubloons: The inning starts with bases empty. Once the first player hits a double, the next batter drives in a run if he also hits a double. Furthermore, every subsequent batter also drives in a run with a double, because strikeouts don't affect baserunners. Therefore, if the Doubloons have three doubles in an inning, we know they have scored two runs.
Moonwalkers: Similar to the Doubloons, the Moonwalkers score runs for each walk after the first three walks. If they have seven walks in an inning, we know they scored four runs.

Suppose we want to calculate the likelihood that the Doubloons score three runs in a single inning. We know they need four hits before the third out. They get a single hit with 20% odds, so four hits occurs with probability $0.2^4$ . We also need three outs, which occurs with probability $0.8^3$ . The order of hits and outs doesn't matter (as long as all four hits occur before the third out), so we can account for each valid ordering by adding a combinatorial term, ${{hits + outs - 1}\\choose {hits}} = {6 \\choose 4}$ . We multiply all three components together for the overall probability of three runs: ${6 \\choose 4}\\times0.2^4\\times0.8^3=1.2288\\%$

This process of counting a number of occurrences before a terminal event (e.g. \"3 outs\") is modeled by a Negative Binomial distribution. In this case, we'll use the distribution to count the number of hits (or walks). However, we need to translate hits into runs for each team, so we'll make a slight modification: for the Doubloons we'll subtract one; for the Moonwalkers, we'll subtract three.

We can build Negative Binomial distributions in Python using the scipy.stats library. Our trick will be to shift each distribution by the number of hits (or walks) required to prime the bases for future runs, using the loc attribute of each distribution. For the Doubloons, we shift the distribution left by one position; for the Moonwalkers, we shift left by three positions. Then, if the distribution ever returns a negative number, it means we didn't have enough hits to score any runs, so we return a zero for the inning.

from scipy.stats import nbinom\n\n# mississippi moonwalkers: walks 40% of the time\n# delaware doubloons: doubles 20% of the time\n# tennessee taters: home runs 10% of the time\nMOONWALKERS = nbinom(n=3, p=0.6, loc=-3)\nDOUBLOONS = nbinom(n=3, p=0.8, loc=-1)\nTATERS = nbinom(n=3, p=0.9, loc=0)\n

The number of runs scored during a full game is the sum of runs scored during nine innings. We draw random samples from the distributions using the .rvs() method attached to the nbinom distributions for runs scored in each inning, then sum across all innings for the final tally. Below, I've shown smoothed distributions of the number of runs scored by each team during a full 9-inning game (not including extra innings.)

The distribution shows us that the Taters consistently score between one to five runs per game, enough to beat the average performance from the Doubloons and Moonwalkers. However, the Moonwalkers have the potential for high-scoring ~~slugfests~~, er, walkfests. They might not be the most exciting team, but they are actually competitive against the Taters, winning roughly 49% of their games.

def game_score(team, innings=9, games=1000000):\n    \"\"\"\n    Returns random samples of the number of runs scored during a\n    single game, for the number of trials, default 1 million.\n\n    Parameters\n    ----------\n    team : a \"team\" is represented by a negative binomial distribution\n        object from scipy.stats. It describes the likelihood of scoring\n        various numbers of runs during an inning\n    \"\"\"\n    return np.maximum(0, team.rvs((games, innings))).sum(1)\n

Now that we can sample from the distribution of runs scored per game, we can pit the teams against one another. Adding a bit of extra logic to handle ties, we are able to calculate the win percentages we showed above. I was also interested in testing how well the teams performed in sudden death. Was any team able to sneak wins from a better opponent if they had just one inning? The percentages suggest not - each team performs roughly the same whether it's a full 9-inning game or a sudden death tiebreaker.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Home Team	Away Team	Home team win %	Sudden Death win %
Taters	Doubloons	62.73%	61.17%
Moonwalkers	Doubloons	58.49%	59.59%
Taters	Moonwalkers	51.62%	51.09%

Full Code

import numpy as np\nfrom scipy.stats import nbinom\n\n\n# mississippi moonwalkers: walks 40% of the time\n# delaware doubloons: doubles 20% of the time\n# tennessee taters: home runs 10% of the time\nMOONWALKERS = nbinom(n=3, p=0.6, loc=-3)\nDOUBLOONS = nbinom(n=3, p=0.8, loc=-1)\nTATERS = nbinom(n=3, p=0.9, loc=0)\n\n\ndef game_score(team, innings=9, games=1000000):\n    \"\"\"\n    Returns random samples of the number of runs scored during a\n    single game, for the number of trials, default 1 million.\n\n    Parameters\n    ----------\n    team : a \"team\" is represented by a negative binomial distribution\n        object from scipy.stats. It describes the likelihood of scoring\n        various numbers of runs during an inning\n    \"\"\"\n    return np.maximum(0, team.rvs((games, innings))).sum(1)\n\ndef win_rate(team, other, innings=9, games=1000000, random_state=None):\n    \"\"\"\n    Returns random samples of the number of runs scored during a\n    single game, for the number of trials, default 1 million.\n\n    Parameters\n    ----------\n    team : a \"team\" is represented by a negative binomial distribution\n        object from scipy.stats. It describes the likelihood of scoring\n        various numbers of runs during an inning\n    other : the opponent, another \"team\", distribution object\n    \"\"\"\n    np.random.seed(random_state)\n\n    # play all nine innings, then count number of wins\n    team_score = game_score(team, innings=innings, games=games)\n    other_score = game_score(other, innings=innings, games=games)\n    team_wins = (team_score > other_score).sum()\n    other_wins = (other_score > team_score).sum()\n\n    # play extra innings for any ties, continue until no more ties\n    while team_wins + other_wins < games:\n        team_score = game_score(team, innings=1, games=games - team_wins - other_wins)\n        other_score = game_score(other, innings=1, games=games - team_wins - other_wins)\n        team_wins += (team_score > other_score).sum()\n        other_wins += (other_score > team_score).sum()\n\n    return team_wins / games\n\ndef summary(games=1000000, random_state=None):\n    np.random.seed(random_state)\n    taters_doubloons = win_rate(TATERS, DOUBLOONS, games=games)\n    moonwalkers_doubloons = win_rate(MOONWALKERS, DOUBLOONS, games=games)\n    taters_moonwalkers = win_rate(TATERS, MOONWALKERS, games=games)\n    table = (\n        f'| Home Team   | Away Team   | Home team win % |\\n'\n        f'|:------------|:------------|:----------------|\\n'\n        f'| Taters      | Doubloons   | {taters_doubloons:.2%} |\\n'\n        f'| Moonwalkers | Doubloons   | {moonwalkers_doubloons:.2%} |\\n'\n        f'| Taters      | Moonwalkers | {taters_moonwalkers:.2%} |\\n'\n    )\n    return table\n\nprint(summary(games=10000000, random_state=42))\n

"},{"title":"Riddler Cycling","date":"Sep 20, 2019","slug":"riddler-cycling","excerpt":"This week's riddler was an entertaining blend of probability and one of my favorite sports, cycling. We're asked to choose the ideal pace for a team time trial - trying to balance the rewards of a competitive time with the risks of pushing our riders too hard and having them crack due to the effort. Plus, there's a bonus extra credit problem!","tags":[],"status":"published","content":"

Introduction

This week's riddler was an entertaining blend of probability and one of my favorite sports, cycling. We're asked to choose the ideal pace for a team time trial - trying to balance the rewards of a competitive time with the risks of pushing our riders too hard and having them crack due to the effort.

\nYou are the coach for Team Riddler at the Tour de FiveThirtyEight, where there are 20 teams (including yours). Your objective is to win the Team Time Trial race, which has the following rules:\n
\n
Each team rides as a group throughout the course at some fixed pace, specified by that team’s coach. Teams that can’t maintain their pace are said to have “cracked,” and don’t finish the course.
\n
The team that finishes the course with the fastest pace is declared the winner.
\n
Teams ride the course one at a time. After each team completes its attempt, the next team quickly consults with its coach (who assigns a pace) and then begins its ride. Coaches are aware of the results of all previous teams when choosing their own team’s pace.
\n
\n
Assume that all teams are of equal ability: At any given pace, they have the exact same probability of cracking, and the faster the pace, the greater the probability of cracking. Teams’ chances of cracking are independent, and each team’s coach knows exactly what a team’s chances of cracking are for each pace.
\n
Team Riddler is the first team to attempt the course. To maximize your chances of winning, what’s the probability that your team will finish the course? What’s the probability you’ll ultimately win?
\n
Extra Credit: If Team Riddler is the last team to attempt the course (rather than the first), what are its chances of victory?
\n

Solution

At first, it seems like the problem doesn't give us enough information about the relationship between the pace and the probability of cracking. Wouldn't it be useful to know exactly what pace is associated with the probability of cracking? Is it a linear relationship? Quadratic? Fortunately, we can solve the problem without knowing this - of course the Riddler wouldn't let us down! Let's figure out how.

Let's call the probability of cracking $p$ . This value will be a number between 0% and 100%. At 0%, we've selected a pace such that we're guaranteed to finish the course: it might be slow, but we will be sure to complete the race. At 100%, we're guaranteed not to finish the race, so it's impossible for us to win. Some point in between lies the best chance for us to win.

Suppose we pick a value of $p=50\\%$ . If we complete the race, our competitors will choose a probability of cracking that is slightly higher, resulting in a pace that is slightly faster. If they also complete the race, they will move ahead of us in the rankings. This will continue for each subsequent team. On the other hand, if we fail to complete the race, then our competitors could choose any new value of $p$ they want, but it won't matter for us, because we would already have been eliminated.

\n\n

Therefore, we win the time trial if and only if two things happen:

We complete the race successfully at our desired pace.
Each of the 19 subsequent teams fails to complete the race with at least the same pace we set.

If we express this mathematically, our odds of winning, $f(p)$ , look like this.

f(p) > p^{19} \\times (1 - p)

This equation has the two components we want: our probability of finishing the race, given by $(1-p)$ , and the probability of each competitor failing to complete the race, given by $p^{19}$ . To find the value of $p$ that maximizes this function, we use calculus: take the derivative, set it to zero, then solve for $p$ . This tells us the point at which the function stops rising or falling, which means it is either a minimum or a maximum.

We use the chain rule to differentiate $f(p)$ , which gives us the following:

\\frac{\\partial f}{\\partial p} = -p^{19} + 19p^{18}(1-p)

When we set $\\frac{\\partial f}{\\partial p}$ to zero and simplify the terms on the right, we get:

0 = -20p^{19} + 19p^{18}

which evaluates to:

20p^{19}=19p^{18}

and finally:

p=\\frac{19}{20}

Therefore, the value of $p$ that maximizes our odds of winning is $\\frac{19}{20}=95\\%$ . When we choose 95% for $p$ , our overall chances of winning the event are $f(0.95)>(1-0.95)\\times 0.95^{19}=1.89\\%$ . In other words, we should pick an extremely risky strategy with a low probability of success in order to have the best odds of winning the entire event. Our odds of completing the time trial are low, but so are everyone else's! As we can see in the chart below, the function hits a maximum value at 95%.

Extra Credit

There's a nice feature of our answer above. The value of $p=\\frac{19}{20}$ corresponds exactly with the number of teams in the competition. In fact, for a race with $n$ teams, the team going first should always race with $p=\\frac{n-1}{n}$ . (For example, the first team in a 10-team field should select $\\frac{9}{10}=90\\%$ as their value of $p$ .) Subsequent teams will race with values of $p$ that depend on what has happened before. They will either race at the highest successful attempt so far, or the value of $p$ they would select as if they were racing first in a brand new event.

In our race, with 20 teams, the table below shows the values of $p$ that each team would select, as long as no prior team has completed the race. For example, the fifth team would select a value of $p=93.75\\%$ if no prior team had finished. If a prior team had finished, the fifth team would select the value of $p$ set by that prior team. The final team, with the advantage of seeing everyone's scores before competing, could potentially select a value of $p=0\\%$ if nobody had successfully finished the race - guaranteeing a finish and a win. Otherwise, they would select the value of $p$ from the last team that finished.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Team (n/20)	Ideal $p$	Team (n/20)	Ideal $p$
1	95.00%	11	90.00%
2	94.74%	12	88.89%
3	94.44%	13	87.50%
4	94.12%	14	85.71%
5	93.75%	15	83.33%
6	93.33%	16	80.00%
7	92.86%	17	75.00%
8	92.31%	18	66.67%
9	91.67%	19	50.00%
10	90.91%	20	00.00%

Now we have the tools we need to answer the extra credit problem. Suppose team 1 completes the race, which happens 5% of the time. Every subsequent team would be forced to attempt (almost exactly) the same pace, and team 20 would win the overall competition only if they are able to complete the course as well with the same value of $p$ , which occurs (almost exactly) 5% of the time. The total odds of this happening are $(\\frac{1}{20})^2$ . If team 1 fails their attempt, then we would move to team 2, which would choose a value of $p=94.74\\%$ . If they succeed, every subsequent team would attempt the same pace, all the way until team 20. This pattern continues for all teams.

To calculate the odds of team 20 winning the competition, we must account for each of these branching paths, summing the probabilities along the way. We will use the $<$ operator to show the maximum probability that team 20 wins, by assuming they attempt exactly the same $p$ as prior successful teams.

P(\\text{Team 20 wins})<\\frac{1}{20^2} + \\frac{19}{20} \\times(\\frac{1}{19^2} + \\frac{18}{19} \\times (\\frac{1}{18^2} + \\frac{17}{18} \\times ...

A formula like this lends itself to a recursive implementation using code. With 20 teams, the team going last has at most a 17.99% chance of winning overall.

def model(teams=20):\n    \"\"\"\n    Solves the extra credit portion of\n    the Riddler Classic from 9/20/19\n    \"\"\"\n    if teams == 1:\n        # if there is only one team,\n        # they win 100% of the time!\n        return 1.0\n    else:\n        # multiple teams; calculate the\n        # odds of the last team winning\n        return (1/teams)**2 + (teams-1)/teams*model(teams-1)\n\n>>> model(20)\n0.17988698285718413\n

Finally, we can plot the win percentages for the team going last among a competition with $n$ competitors. It's a remarkable advantage to go last!

"},{"title":"Riddler State Superstrings","date":"Sep 13, 2019","slug":"riddler-state-superstrings","excerpt":"The fivethirtyeight riddler this week asks us to make connections between states. Specifically, we want to map the connections between state abbreviations (e.g. CA for California). We've been tasked with finding the longest string of connections where the last letter from one state is the first letter from another, without repeating any states. With 59 state abbreviations to choose from, what is the longest string we can create?","tags":[],"status":"published","content":"

Introduction

The fivethirtyeight riddler this week asks us to make connections between states. Specifically, we want to map the connections between state abbreviations (e.g. CA for California). We've been tasked with finding the longest string of connections where the last letter from one state is the first letter from another, without repeating any states. With 59 state abbreviations to choose from, what is the longest string we can create?

\nThe challenge is to find the longest string of letters in which (1) every pair of consecutive letters is a two-letter state or territory abbreviation, and (2) no state abbreviation occurs more than once. For example, Guam, Utah and Texas can be combined into the valid four-letter string GUTX. Another valid string is ALAK (Alabama, Louisiana and Alaska), while ALAL (Alabama, Louisiana and Alabama) is invalid because it includes the same state, Alabama, twice.\n

Solution

FMNVIDCALAKSCOHINCTNMPWVARIASDE

This string of nonsense represents the longest possible path between state abbreviations, with 30 connections starting from the Federated States of Micronesia (FM) and ending in Delaware (DE), without any repeats. (As a side note, the longest path between any pair of states starts with FM and ends with DE, but there are 9,984 paths from FM to DE with length 30. I chose this one arbitrarily.) Here's how I calculated it.

In the spirit of several prior problems, I elected to tackle this problem with a graph. The graph formalizes links between states. For example, California (CA) is linked to Alabama (AL), Alaska (AK), American Samoa (AS), Arizona (AZ), and Arkansas (AR) by the letter \"A\". On the other hand, certain states like Kentucky (KY) are lonelier. No state code begins with the letter Y, so Kentucky doesn't connect outward to any other state. (Don't worry, Alaska (AK) and Oklahoma (OK) connect inwards to Kentucky, so it's not totally alone.)

Between the 59 states there are 168 connections, which we represent in a graph that looks something like this.

As it turns out, computing the longest path from any starting node to any other node is not an easy problem. It is especially difficult because this graph is cyclical, meaning that you can find yourself in loops of repeating patterns if you're not careful. For example, a loop occurs between CA -> AS -> SC -> CA. Obviously we don't want loops in our result because we're not allowed to repeat states. Therefore, we want simple paths through the graph: paths that visit a node at most one time.

Fortunately, algorithms exist to calculate simple paths through cyclical graphs, but they can be very slow. Despite this, with a bit of patience (82 minutes of patience, to be specific in this case), we can calculate every path between every starting and ending state in the graph. There are $59\\times 58=3422$ total pairs of states, and we measure the longest path between each pair. Then we just need to select the longest one from all the pairs.

As it turns out, most paths tend to include at least 20 states, as shown by the chart below. On the other hand, several starting-ending state pairs have no connections, such as Kentucky, that can't connect outward to any other state. The chart below shows a histogram of all the longest paths between each pair of states.

Full Code

The full code this week is fairly straightforward to read, but takes quite a while to calculate. The model function took well over an hour to run on my computer. Fortunately, I saved the full results if you want to skip the calculation and look at the raw output. Each state pair is represented here, with one example of the longest simple path you could take between the two.

import json\nimport networkx as nx\n\nfrom itertools import permutations\nfrom tqdm import tqdm\n\n\nSTATES = {\n    'Alabama': 'AL',\n    'Alaska': 'AK',\n    'American Samoa': 'AS',\n    'Arizona': 'AZ',\n    'Arkansas': 'AR',\n    'California': 'CA',\n    'Colorado': 'CO',\n    'Connecticut': 'CT',\n    'Delaware': 'DE',\n    'District of Columbia': 'DC',\n    'Federated States of Micronesia': 'FM',\n    'Florida': 'FL',\n    'Georgia': 'GA',\n    'Guam': 'GU',\n    'Hawaii': 'HI',\n    'Idaho': 'ID',\n    'Illinois': 'IL',\n    'Indiana': 'IN',\n    'Iowa': 'IA',\n    'Kansas': 'KS',\n    'Kentucky': 'KY',\n    'Louisiana': 'LA',\n    'Maine': 'ME',\n    'Marshall Islands': 'MH',\n    'Maryland': 'MD',\n    'Massachusetts': 'MA',\n    'Michigan': 'MI',\n    'Minnesota': 'MN',\n    'Mississippi': 'MS',\n    'Missouri': 'MO',\n    'Montana': 'MT',\n    'Nebraska': 'NE',\n    'Nevada': 'NV',\n    'New Hampshire': 'NH',\n    'New Jersey': 'NJ',\n    'New Mexico': 'NM',\n    'New York': 'NY',\n    'North Carolina': 'NC',\n    'North Dakota': 'ND',\n    'Northern Mariana Islands': 'MP',\n    'Ohio': 'OH',\n    'Oklahoma': 'OK',\n    'Oregon': 'OR',\n    'Palau': 'PW',\n    'Pennsylvania': 'PA',\n    'Puerto Rico': 'PR',\n    'Rhode Island': 'RI',\n    'South Carolina': 'SC',\n    'South Dakota': 'SD',\n    'Tennessee': 'TN',\n    'Texas': 'TX',\n    'Utah': 'UT',\n    'Vermont': 'VT',\n    'Virgin Islands': 'VI',\n    'Virginia': 'VA',\n    'Washington': 'WA',\n    'West Virginia': 'WV',\n    'Wisconsin': 'WI',\n    'Wyoming': 'WY',\n}\n\n\ndef paths(state_codes):\n    \"\"\"\n    Returns a list of tuples of state codes, where the\n    last letter of the first state code matches the\n    first letter of the last state code, e.g.\n        ('WA', 'AL'), or ('DC, 'CA')\n\n    Parameters\n    ----------\n    state_codes : iterable of codes, e.g. ['AL', 'AK', 'AS', ...]\n\n    Returns\n    -------\n    paths : list of tuples, e.g. [('WA', 'AL'), ('DC, 'CA'), ...]\n    \"\"\"\n    return [\n        x for x in permutations(state_codes, 2)\n        if x[0][1] == x[1][0]\n    ]\n\ndef graph(state_codes):\n    \"\"\"\n    Returns the directed graph of linked state codes\n    Preserves the order of state_code when building the graph\n    \"\"\"\n    G = nx.DiGraph()\n    G.add_nodes_from(state_codes)\n    G.add_edges_from(paths(state_codes))\n    return G\n\ndef longest_simple_path(graph, source, target, **kwargs):\n    \"\"\"Finds the longest simple path between two nodes in a graph\"\"\"\n    paths = nx.all_simple_paths(G=graph, source=source, target=target, **kwargs)\n    try:\n        return max(paths, key=len)\n    except ValueError:\n        # paths is an empty sequence\n        return []\n\ndef model(state_codes):\n    \"\"\"\n    Returns a dictionary with tuple keys and list values, e.g.\n        [('FM', 'DE')] = ['FM', 'MN', 'NV', 'VI', 'ID', ... , 'DE']\n\n    This is an exhaustive search of the longest simple paths between\n    all possible states in the state_codes list, so is guaranteed to\n    find the longest possible path between any two codes.\n\n    WARNING : this function took 82 minutes to run on my computer\n        for all 3422 paths. Uses tqdm to display a progress bar\n    \"\"\"\n    out = {}\n    G = graph(state_codes)\n    for s, t in tqdm(list(permutations(state_codes, 2))):\n        out[(s, t)] = longest_simple_path(G, source=s, target=t)\n    return out\n\ndef write_json(state_codes, file_name):\n    \"\"\"Outputs the results of the model to a json file\"\"\"\n    # replace tuple keys ('X', 'Y') with \"X-Y\" as a string\n    results = {f'{k[0]}-{k[1]}': v for k, v in model(state_codes).items()}\n    with open(file_name, 'w') as file:\n        file.write(json.dumps(results), indent=4)\n    return None\n

"},{"title":"Riddler Counterfeits","date":"Aug 23, 2019","slug":"riddler-counterfeits","excerpt":"This week's fivethirtyeight riddler was created by yours truly! It was the first puzzle I've submitted to the riddler, and I hope you enjoyed it. This week we attempt to fool a bank with counterfeit hundred dollar bills.","tags":[],"status":"published","content":"

Introduction

This week's fivethirtyeight riddler was created by yours truly! It was the first puzzle I've submitted to the riddler, and I hope you enjoyed it. This week we attempt to fool a bank with counterfeit hundred dollar bills. Here is the full text.

\nYou are an expert counterfeiter, and you specialize in forging one of the most ubiquitous notes in global circulation, the U.S. $100 bill. You’ve been able to fool the authorities with your carefully crafted C-notes for some time, but you’ve learned that new security features will make it impossible for you to continue to avoid detection. As a result, you decide to deposit as many fake notes as you dare before the security features are implemented and then retire from your life of crime.\n
You know from experience that the bank can only spot your fakes 25 percent of the time, and trying to deposit only counterfeit bills would be a ticket to jail. However, if you combine fake and real notes, there’s a chance the bank will accept your money. You have $2,500 in bona fide hundreds, plus a virtually unlimited supply of counterfeits. The bank scrutinizes cash deposits carefully: They randomly select 5 percent of the notes they receive, rounded up to the nearest whole number, for close examination. If they identify any note in a deposit as fake, they will confiscate the entire sum, leaving you only enough time to flee.
\n
How many fake notes should you add to the $2,500 in order to maximize the expected value of your bank account? How much free money are you likely to make from your strategy?
\n

Solution

The counterfeiter wants to strike the optimum balance between profitability and risk. The ideal strategy will include as many fake notes as possible to maximize the size of the deposit, but not so many that the bank becomes aware of the fraud and seizes everything.

The ideal strategy is to add 55 fake notes to the 25 real notes for a total deposit of $8000. The expected gain from this strategy is $1256†, which is the weighted average of expected profit from successful deposits and expected losses from bank seizures. With 55 fake notes, there is a 47% chance we avoid detection and collect a profit of $5500 - the value of the fake notes we were able to sneak into circulation. (Remember we started with $2500, so only the fake notes count as profit.) There is a 53% chance we are caught by the bank and lose the $2500 in real dollars we used as decoys.

† A note on interpreting the results: I intended the problem to include the risk of losing $2500 if we are caught, and gaining the value of the fake notes if we are not. Therefore, the expected value would be $47\\%\\times5500-53\\%\\times2500=1256$ . However, potentially to avoid some ambiguity, the problem was rewritten to ask \"how much free money are you likely to make from your strategy?\" I believe with that criteria, the answer should be $47\\%\\times5500=2582$ , which includes only the value of the fake notes, and doesn't penalize losing the real ones. Another interpretation could count the original $2500 as free money as well (perhaps because it may have been the product of fraud at one point or another too!), for an answer of $47\\%\\times8000=3756$ . I think all three are reasonable interpretations of the problem, but the first method is my favorite, so I'll continue that way.

How can we be sure no other strategy produces a higher profit? For example, suppose we combine 30 fake notes with 25 real notes instead. The bank will select three notes for its audit, which is 5% of 55, rounded up to the nearest whole number. Depending on our luck, the bank could choose all three fake notes, all three real notes, or some combination in between.

Let’s assume the bank randomly chooses two fake notes and one real note for its audit. This occurs with roughly 41.5% probability, given by the formula ${{3}\\choose{2}}\\times\\frac{30}{55}\\times\\frac{29}{54}\\times\\frac{25}{53}$ . Each fake note is detected 25% of the time, which means at least one fake note from the pool of two is detected $1-0.75^2=43.75\\%$ of the time. We use similar logic to solve for the likelihood and detection rate of the audits with three fakes, one fake, and zero fake notes. The overall detection rate is equal to the weighted average across each potential audit.

For the 30 fake, 25 real strategy, the probability of success is 64.3%, and the probability of detection is 35.7%. Therefore, the expected profit is $64.3\\%\\times3000-35.7\\%\\times2500=1038$ . That’s a decent payday, but we can do better. The chart below shows the profit for strategies with up to 200 fake notes, and it confirms the maximum is achieved when we use 55.

We can see two patterns above. First, as we move to the right, we enter the “greedy danger zone,” where the bank becomes more likely to discover our fraud and seize the starting capital, resulting in larger and larger expected losses. Second, we see a sawtooth behavior caused by the bank’s practice of auditing 5% of deposited notes. The effect is significant: 55 is the ideal answer because we deposit 80 total notes, resulting in the bank auditing four. If we use 56 fake notes for a total of 81, then the bank audits five instead, which cuts the expected gain in half! A life of crime only pays if you’re good with numbers.

Full Code

The code this week is comprised of a single function that returns the expected value of a strategy with $n$ fake notes and $m$ real notes. There are optional parameters for the number of notes selected in an examination, the accuracy of the bank in detecting fake notes, and the denomination of bill used, with defaults set per the question. To generate a chart, run this model for the desired range of fake notes, e.g. 1 through 200, and plot the results.

import numpy as np\n\nfrom math import ceil\nfrom scipy.special import comb\n\ndef model(n_fake, n_real, selected=0.05, accuracy=0.25, denomination=100):\n    \"\"\"\n    Calculate the expected value of a strategy with n fake bills and m real bills.\n\n    Final expected value is defined as\n        * the value of the fake notes times the probability of not being caught\n        * minus the value of the real notes times the probability of being caught.\n\n    Parameters\n    ----------\n    n_fake : int > 0, the number of fake bills used\n    n_real : int > 0, the number of real bills used\n    selected : float, between 0 and 1, the percent of bills examined by the bank,\n        which will be applied to (n_fake + n_real), then rounded up to the nearest\n        whole number\n    accuracy : float, between 0 and 1, the likelihood of a bank detecting a fake\n        note, given that it is examining that note\n    denomination : int, the bill in question, e.g. $100, to multiply the result\n\n    Returns\n    -------\n    expected_value : float, the expected value of the given strategy\n\n    Examples\n    --------\n    >>> model(n_fake=55, n_real=25, selected=0.05, accuracy=0.25, denomination=100)\n    1256.8909531923773\n    \"\"\"\n    # number of notes randomly selected for inspection (rounded up to nearest whole)\n    k = ceil((n_fake+n_real)*selected)\n\n    # probabilities of choosing 0 through x fake notes in an examination\n    # calculated by solving for the denominator and numerator separately,\n    # then the (n choose k) component of each examination, and finally by\n    # multiplying all three together for an overall likelihood factor.\n    denominator = np.array([n_real+n_fake-x for x in range(k)])\n    numerator = np.array([\n        [n_fake - a for a in range(k-x)] + [n_real - b for b in range(x)]\n        for x in range(k+1)\n    ])\n    combinations = np.array([comb(k, x) for x in range(k+1)])\n    factor = combinations * (numerator / denominator).prod(1)\n\n    # final likelihood of detection and corresponding expected value of payoffs\n    likelihood = np.array([(1-accuracy)**(k-x) for x in range(k+1)])\n    payoff = n_fake*likelihood - n_real*(1-likelihood)\n    return (factor * payoff * denomination).sum()\n

"},{"title":"Riddler Tanks","date":"Jun 7, 2019","slug":"riddler-tanks","excerpt":"Based on an actual statistical analysis problem from World War II, this week's Riddler asks us to estimate the population of German tanks given uncertain information about the tanks we've observed. Fortunately, despite the uncertainty in our observations, we can still provide reasonably accurate estimates for the total German tank population. We'll rely heavily on Bayesian analysis to solve this problem.","tags":[],"status":"published","content":"

Introduction

Based on actual statistics from World War II, this week's Riddler asks us to estimate the number of German tanks given uncertain information about the tanks we've observed. Fortunately, despite the uncertainty in our observations, we can still provide reasonably accurate estimates for the total German tank population. We'll rely heavily on Bayesian analysis to solve this problem. Let's continue with the full problem.

\nMathematician Dr. Lana Gurtin has a problem to solve. She was hired by British intelligence for a top-secret assignment, but things have not gone according to plan. The year is 1942 and the Germans are rolling out a new and powerful tank, the Uberpanzer. Prominently displayed on the back of each Uberpanzer is its serial number, which is simply the number of tanks that had been built when it rolled off the line. So the first tank built has the serial number 1, the second one built has a 2, and so on.\n
Recently, a number of these new tanks were spotted by British scouts who recorded the serial numbers that they saw. They immediately sent this information to British intelligence, hoping that the serial number data could be used to estimate the total number of Uberpanzers the Germans have built. This is when Dr. Gurtin was brought on to head the project.
\n
But then the unexpected happened. A German spy intercepted the dossier with the data before it could reach MI6. By the time British agents caught up with the spy, most of the data had been destroyed. However, two pieces of information were recovered from the debris. One: The lowest serial number recorded was 22. Two: The highest serial number recorded was 114.
\n
Luckily, Dr. Gurtin knows exactly what to do. Assuming that the original data set was a random sample of serial numbers, what is Dr. Gurtin’s best estimate of the total number of Uberpanzers the Germans have built?
\n

The German Tank Problem

Because of this problem's fame, it is commonly referred to as the German Tank Problem. It also shares elements with capture-recapture problems. In both problems, we attempt to estimate a total population size, given some knowledge about samples from the population.

Problems like these are perfect for Bayesian techniques, because these techniques allow us to express uncertainty and confidence levels around the variable we are trying to measure. Specifically, a Bayesian analysis lets us calculate the probability distribution of population size. Before we solve this week's Riddler, let's review the Bayesian solution to the classic German Tank Problem.

Bayesian Solution

Suppose we have observed the following six serial numbers from a population of tanks of unknown size: 14, 36, 108, 65, 18, 97. Immediately we conclude the total population size must be at least as high as the largest number we've seen: 108. We've seen six numbers all with reasonably low values, so we might suspect the total population size is small, but we can't explicitly rule out the possibility that the total population is some larger number, like 500. However, we can determine the likelihood that the population size is 500, along with any other value we want to test.

In other words, we want to develop a formula for the probability that the total population is equal to some number, $N$ , given the information we have about the serial numbers we've observed. Interestingly, we don't care about most of the actual serial numbers we've observed, but rather the number of serial numbers we've observed. We'll call the total number of tanks we've seen $K$ . The only actual serial number we care about is the maximum value, which we'll call $M$ . Given these inputs, we have the following formula.

P(N=n|K=k, M=m) = \\frac{k-1}{k}\\frac{{m-1}\\choose{k-1}}{{n}\\choose{k}}

Plugging in our values, we have $m=108$ and $k=6$ . Suppose we want to know the probability that total population is $n=108$ . We solve $P(N=108|K=6, M=108) = \\frac{6-1}{6}\\frac{{108-1}\\choose{6-1}}{{108}\\choose{6}} = 4.6\\%$ . We could also test $n=500$ , where we calculate $~0.0004\\%$ . Very small, but still possible. The key takeaway is that we can't solve the problem with certainty, but we can develop an understanding of the ranges of values we might expect.

Riddler Solution

This week's Riddler has several similarities with the German Tank Problem, except that we can't be certain what our value of $K$ is. We know for a fact that we observed at least 2 serial numbers, 22 and 114. And, critically, we know our value of $M$ should be 114 - the highest value we've seen. But we could have observed many more serial numbers, perhaps as many as 93 in total, if we had somehow seen every single number between 22 and 114. According to the problem text, the original data set was a random sample of serial numbers, which I'll interpret to mean our value of $K$ should be uniformly distributed between 2 and 93, meaning each value was equally likely.

Before, we had a one-dimensional problem where we solved for many values of $N$ . Now, we have a two-dimensional problem, where we want to solve for many values of $N$ across many values of $K$ . Because the values of $K$ are uniformly distributed, we should average our values with respect to $K$ in order to solve for the values of $N$ .

For example, if $K=2$ , then the likelihood that $N=114$ is $0.88\\%$ , because having seen just two serial numbers, we can't conclude much about the true population size. However, if $K=93$ , then the likelihood that $N=114$ is $80.7\\%$ , because we've seen over 90 tanks with no value higher than 114. When we average across all $K$ from 2 to 93, we find the probability that total tank population is 114 is roughly $40.8\\%$ . Of course, we need to consider all other values of $N$ as well, which we do in the following chart. We see that the single best estimate for total population size is 114, and while we can't be certain of the exact tank population, we can be 95% sure that the total German tank population is less than 138.

Therefore, despite the best efforts of the courageous German spy, it seems that probability theory is still enough to give the Allies an advantage.

Full Code

The code this week is quite simple, leveraging the Bayesian formula for population estimates. The only tricky part is to test across multiple values of $k$ and $n$ , then average the results for the correct answer. As always, please let me know if you have any questions or comments!

import numpy as np\nfrom scipy.special import comb\n\ndef model(n, k=2, m=114):\n    \"\"\"\n    Calculates the probability that \"n\" total tanks exist, given that we\n    have observed \"k\" tanks and have seen a highest serial number, \"m\".\n\n    Parameters\n    ----------\n    n : int, the number of tanks we posit as existing.\n        n >= m\n    k : int, the number of tanks whose serial numbers we have observed\n        1 < k <= m\n    m : int, the highest serial number we observed from the \"k\" tanks\n\n    Returns\n    -------\n    P(N=n) : float, the probability of \"n\" tanks existing\n    \"\"\"\n    return (k-1)/k * comb(m-1, k-1) / comb(n, k)\n\n\nif __name__ == '__main__':\n\n    # create arrays to represent possible values of n and k\n    n = np.arange(114, 501)\n    k = np.arange(2, 94).reshape(-1, 1)\n\n    # calculate probabilities under each pair of variables\n    results = model(n=n, k=k, m=114)\n\n    # reduce dimension by averaging across all values of k\n    results = results.mean(0)\n\n    # print results\n    for n, p in zip(n, results):\n        if n < 150: print(f'P(N={n}) = {p:.2%}')\n

"},{"title":"Riddler Countdown","date":"May 31, 2019","slug":"riddler-countdown","excerpt":"Computers continue to fascinate me. The Riddler this week deals with an explosion of combinations and math that is nearly impossible to grasp without the help of a computer. Specifically, we're interested in crafting an ideal strategy for the \"numbers game\" from the UK television show Countdown. The numbers game asks contestants to use four mathematical operations (addition, subtraction, multiplication, and division) with six numbers as inputs to solve for a single, three digit target. Most of the time, this can be quite difficult, especially with a 30-second time limit. However, with the help of a computer, we can solve for every possible combination of input and output to identify the strategy that gives the humans the best chance to win!","tags":[],"status":"published","content":"

Introduction

Computers continue to fascinate me. The Riddler this week deals with an explosion of combinations and math that is nearly impossible to grasp without the help of a computer. Specifically, we're interested in crafting an ideal strategy for the \"numbers game\" from the UK television show Countdown. The numbers game asks contestants to use four mathematical operations (addition, subtraction, multiplication, and division) with six numbers as inputs to solve for a single, three digit target. Most of the time, this can be quite difficult, especially with a 30-second time limit. However, with the help of a computer, we can solve for every possible combination of input and output to identify the strategy that gives the humans the best chance to win!

Here is the complete problem text.

\nMy favorite game show is “Countdown” on Channel 4 in the UK. I particularly enjoy its Numbers Game. Here is the premise: There are 20 “small” cards, two of each numbered 1 through 10. There are also four “large” cards numbered 25, 50, 75 and 100. The player asks for six cards in total: zero, one, two, three or four “large” numbers, and the rest in “small” numbers. The hostess selects that chosen number of “large” and “small” at random from the deck. A random-number generator then selects a three-digit number, and the players have 30 seconds to use addition, subtraction, multiplication and division to combine the six numbers on their cards into a total as close to the selected three-digit number as they can.\n
There are four basic rules: You can only use a number as many times as it comes up in the six-number set. You can only use the mathematical operations given. At no point in your calculations can you end on something that isn’t a counting number. And you don’t have to use all of the numbers.
\n
For example, say you ask for one large and five smalls, and you get 2, 3, 7, 8, 9 and 75. Your target is 657. One way to solve this would be to say 7×8×9 = 504, 75×2 = 150, 504+150 = 654 and 654+3 = 657. You could also say 75+7 = 82, 82×8 = 656, 3-2 = 1 and 656+1 = 657.
\n
This riddle is twofold. One: What number of “large” cards is most likely to produce a solvable game and what number of “large” cards is least likely to be solvable? Two: What three-digit numbers are most or least likely to be solvable?
\n

Thanks to Laurent Lessard who pointed out a bug in an earlier version of my code. It's since been updated.

Solution

This Riddler was quite complicated, but it was also one of my favorites because it combined healthy doses of math, probability, combinatorics, and computer programming. I'll start by showing the results, then continue by walking through my solution for readers interested in the details. (Or you can skip to the full code at the bottom of the article!)

The first part of the question asked us to identify the number of 'large' cards that would be expected to produce the most or least solvable puzzles. Recall that we start the game by selecting either 0, 1, 2, 3, or all 4 large numbers, so let's examine our odds of solving the puzzle given those starting conditions. The table below shows our inputs: the number of large and small numbers, the total number of combinations we could receive, the total number of solvable puzzles that could be created from those inputs, and the percent of solvable puzzles, which is the column we're interested in.

We should select two large numbers and four small numbers in order to have the best odds of creating a solvable puzzle. If we do so, we create a solvable puzzle roughly 98% of the time. On the other hand, if we wanted to make things difficult for ourselves, we could choose zero large numbers, leaving us with roughly 84% odds of any valid solution existing.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Large #	Small #	Combinations Large	Combinations Small	Combinations Total	Sum of Solvable Targets	% of Solvable Targets
0	6	1	38,760	38,760	29,261,974	83.88%
1	5	4	15,504	62,016	54,558,826	97.75%
2	4	6	4845	29,070	25,690,882	98.20%
3	3	4	1140	4560	3,887,884	94.73%
4	2	1	190	190	154,693	90.46%
			$average$	134,596	113,554,259	93.74%

The second part of the question asked us to identify which three-digit numbers would be more or less likely to be valid solutions. Obviously this depends on our choice of large numbers, so I'll show the likelihood of each number being a valid solution given each of the five initial conditions. In fact, the chart below helps us visualize several key trends.

We confirm that choosing two large cards gives us the highest average probability of finding a solution. The chart on the bottom left has higher values across all target numbers than any other chart.
Higher target numbers are harder to solve for. In fact, several values, like 967 and 863 are more difficult to solve, regardless of the number of large cards we choose.
\"Round\" numbers, like 200, 250, 300, etc. are much easier to solve consistently when we choose more large cards. This makes sense, given that we're more likely to find the 50 or 100 card when we select more from that pool, but isn't enough of an incentive to sacrifice the valuable \"small\" numbers that help us fill in the gaps.

Here is a table of the most difficult numbers to solve, given a starting number of large cards. For example, if we choose 1 large card and 5 small cards, and our target number is 941, then across all the different combinations of numbers we could be given, we will be able to solve the puzzle just 84% of the time.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Pick 0 Large	Pick 1 Large	Pick 2 Large	Pick 3 Large	Pick 4 Large
997, 36.9%	941, 84.1%	967, 89.2%	863, 75.2%	839, 41.6%
947, 38.5%	937, 84.4%	983, 90.1%	967, 76.9%	961, 43.7%
983, 39.2%	933, 85.2%	977, 90.6%	961, 77.2%	955, 47.9%
941, 40.4%	947, 85.4%	961, 90.9%	862, 77.3%	967, 48.9%
929, 41.3%	863, 86.5%	863, 91.3%	964, 79.4%	965, 51.6%

And here is the list of easiest values to solve. If we choose at least 1 large card, there are some target values that can be solved with every possible configuration of starting numbers! For example, numbers like 100, 150, 200, and other round numbers become completely solvable once we have enough \"large\" numbers to work with.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Pick 0 Large	Pick 1 Large	Pick 2 Large	Pick 3 Large	Pick 4 Large
108, 99.997%	25 @ 100%	36 @ 100%	57 @ 100%	203 @ 100%
120, 99.99%
105, 99.98%
104, 99.98%
112, 99.98%

Methodology

Even though we ultimately want to solve this problem for a pool of six numbers, let's start by considering just two. We want to build a function that takes two numbers as inputs and returns all valid numbers they can produce using addition, subtraction, multiplication, and division. We also want the function to return each of the numbers themselves, because we aren't required to use all the numbers available to us.

Here's an example using the numbers $4$ and $5$ . Our function should return:

$4$
$5$
$4+5=9$
$5-4=1$
$4-5=-1$
$4*5=20$
$\\frac{4}{5},\\text{excluded because not a whole number}$
$\\frac{5}{4},\\text{excluded because not a whole number}$

We also need a way to store each of these values. For this problem, I used one of python's default data structures: sets. Sets are similar to arrays, except they are unordered collections of unique elements, such as {1,3,5,7}. If we attempt to add another 5 to this set, it will remain unchanged. This becomes very useful for our purposes here. For example, we can reproduce the logic above using this python function. (Note, I called the function two because it takes two numbers as inputs; later we'll have functions for three, four, five, and six. The naming conventions leave something to be desired, and probably deserve to be refactored later...)

The function is relatively straightforward. We always include a, b, addition, subtraction, and multiplication. We only include $\\frac{a}{b}$ or $\\frac{b}{a}$ if it is a whole number.

def two(a, b):\n    \"\"\"\n    Returns a set of all valid combinations of a and b:\n    identity of a, identity of b, addition, subtraction,\n    multiplication, and division\n    \"\"\"\n    out = {a, b, a+b, a-b, b-a, a*b}\n    try:\n        if a/b == int(a/b): out.add(int(a/b))\n    except ZeroDivisionError:\n        pass\n    try:\n        if b/a == int(b/a): out.add(int(b/a))\n    except ZeroDivisionError:\n        pass\n    return out\n\n# examples\n>>> two(4, 5)\n{-1, 1, 4, 5, 9, 20}\n\n>>> two(2, 4)\n{-2, 2, 4, 6, 8}\n

Now we have created the universe of valid targets for any two numbers. How could we handle three numbers, such as $a$ , $b$ , and $c$ ? We could add $a$ and $b$ , then multiply by $c$ , or subtract $c$ from $a$ then divide by $b$ , we might want to ignore $c$ completely, or consider many other possibilities. Fortunately, we can use recursion to delegate this explosion of possibilities to the computer.

First, we create the list of valid numbers that we can derive from $a$ and $b$ . Then, for each possible output, we combine it with $c$ . For example, we found above that $4$ and $5$ combine to give us a set of $(-1, 1, 4, 5, 9, 20)$ . If our third value were $3$ , then we would also want to find all numbers we could create from pairs of $(3,-1), (3,1), (3,4), (3,5), (3,9), \\text{and }(3,20)$ .

However, we could also start by pairing $3$ and $5$ , then pairing those outputs with $4$ . The answers we get depend on the order of operations! For this, we want to combine $3$ and $5$ first, giving us a set of $(-2, 2, 3, 5, 8, 15)$ . Then we would pair each of those values with $4$ . Finally, we would generate all values from $3$ and $4$ and pair each of them with our last number, $5$ . All told, we need to perform three \"combinations of combinations\".

Each time we generate new possible derived values, we want to add them to a master set of all values we were able to create. Sets in python have the mathematical operations we expect, such as the \"union\". When we take the union of two or more subsets, we return every number that occurs in at least one of the subsets. The final union of our three combinations tells us every possible number we can create starting from the original three.

Here is how I implemented this in python. The * notation is python's list unpacking, which helps us collect each unique value we generate through the mathematical operations and store them in a single, larger set. We see that every possible number we can generate starting with $3$ , $4$ , and $5$ is 30 numbers ranging from $-17$ to $60$ . You can verify this, though it takes some time, using pen and paper!

def three(a, b, c):\n    return set().union(*[\n        *[two(x, a) for x in two(b, c)],\n        *[two(x, b) for x in two(c, a)],\n        *[two(x, c) for x in two(a, b)],\n    ])\n\n# examples\n>>> three(3, 4, 5)\n{-17, -11, -8, -7, -6, -5, -4, -3, -2, -1,\n 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15,\n 17, 19, 20, 23, 27, 32, 35, 60}\n

Now we've established a method to find solutions for larger and larger pools of numbers. Each time we increase the numbers available to us, we call the prior function several times on each new combination of numbers, then take the union of all the sets we create. Eventually, we create a function that takes six numbers as arguments and returns a set of all valid combinations of those numbers. These sets can get quite large. For example, we can create 3,918 values using the numbers $3$ , $4$ , $5$ , $6$ , $7$ , and $8$ .

Ultimately, we want to filter those sets for the target range we care about, which is three-digit numbers. This time, we use another operation on sets: the intersection. We're only interested in the combinations of our six numbers that fall between 100 and 999. In python, I wrote the countdown function to do this, shown below. It returns a set of up to 900 numbers (the most available in our desired range), for any six numbers.

def countdown(a, b, c, d, e, f, low=100, high=999):\n    \"\"\"\n    Returns the valid mathematical combinations of the six inputs\n    that fall between a range of \"low\" and \"high\"\n    \"\"\"\n    return six(a, b, c, d, e, f).intersection(range(low, high+1))\n

However, we're not done yet. We've built a general purpose solution-checker for any six numbers, but we need to consider which six numbers we're likely to receive on the show. To do this, we create two lists of all possible cards, separated into large and small numbers. Then we use these lists to generate all possible number pools, given our choice of large cards to start with.

# four large numbers: 25, 50, 75, and 100, and 20 small numbers from 1-10\nLARGE = [25, 50, 75, 100]\nSMALL = 2*[*range(1, 11)]\n\ndef number_pool(n_large, total=6):\n    \"\"\"\n    Returns a list of randomly selected numbers where the\n    returned list has \"n_large\" numbers selected from the\n    LARGE list, and \"total - n_large\" numbers selected\n    from the SMALL list.\n    \"\"\"\n    # ensure we don't try to pick more numbers than available\n    n_large = min(len(LARGE), n_large)\n\n    # generate the list of numbers, then sort it before returning\n    out = (\n        list(L) + list(S)\n        for L in combinations(LARGE, n_large)\n        for S in combinations(SMALL, total - n_large)\n    )\n    return [sorted(x) for x in out]\n

For example, the number pool with n_large=1 is a list of all 62,016 different six-number pools we could possibly see on the show, such as $(25, 1, 3, 5, 7, 9)$ , or $(75, 5, 5, 1, 1, 3)$ . Each of those 62,016 number pools has its own solution space: the numbers we could create between 100 and 999 using them. We can create all 900 unique target numbers using $(25, 1, 3, 5, 7, 9)$ , and just 736 from $(75, 5, 5, 1, 1, 3)$ . If it were just those two possibilities, we would say our average probability of success is $\\frac{900+736}{2\\times{900}} = 90.9\\%$ . Using our code, we can calculate the probability of solving for all target values starting with all number pools.

def solvable_percent(n_large, total=6, low=100, high=999):\n    \"\"\"\n    Returns the percent of random targets that can be solved\n    given a list of six numbers comprised of \"n_large\" LARGE\n    numbers and \"total - n_large\" SMALL numbers.\n    \"\"\"\n    # create number list given a number of LARGE numbers\n    numbers = number_pool(n_large=n_large, total=total)\n\n    # run each group of numbers to count the total number of solvable targets\n    numerator = sum([solvable_count(*n, low=low, high=high) for n in numbers])\n    denominator = len(numbers) * len(mask)\n    return numerator / denominator\n\n>>> solvable_percent(n_large=2)\n0.9819547452509269\n

And this function, built slowly from its humble roots of comparing two numbers, allows us to solve the problem! We simply call this function with a given number of large cards, and it returns the likelihood that we would see a solvable puzzle from all possible number pools and random targets. Importantly, this is an exact solution - no simulation required!

The second part of the question asked us to identify the target values that were most likely to be solvable. Up to this point, we didn't particularly care \"how solvable\" a target value was; we only cared that there was a way to solve it. But using our functions from above, we can tally the number of target values that are most and least likely to occur given our starting number pools, and our work here is done. The full code is available below.

Full Code

This was an extremely fun problem to work on, and finding a way to explore the hundreds of millions of combinations simply and quickly was a challenge. There are certainly further optimizations to explore, such as simplifying the code for the four, five and six functions, now that I know how everything should work. But the process of building this was extremely enjoyable. Let me know if you find ways to improve this!

# -*- coding: utf-8 -*-\n\"\"\"\nSolves the Riddler Classic from May 31, 2019\n\nIn the 'numbers game' from the television show 'Countdown',\nwhat number of large numbers (from zero to four) gives the\nhighest likelihood of being able to match a random number\nbetween 100 and 999?\n\"\"\"\nimport numpy as np\nimport pandas as pd\n\nfrom functools import lru_cache\nfrom itertools import combinations\n\n# four large numbers: 25, 50, 75, and 100, and 20 small numbers from 1-10\nLARGE = [25, 50, 75, 100]\nSMALL = 2*[*range(1, 11)]\n\n@lru_cache(maxsize=None)\ndef two(a, b):\n    \"\"\"\n    Returns a set of all valid combinations of a and b:\n    identity of a, identity of b, addition, subtraction,\n    multiplication, and division\n    \"\"\"\n    out = {a, b, a+b, a-b, b-a, a*b}\n    try:\n        if a/b == int(a/b): out.add(int(a/b))\n    except ZeroDivisionError:\n        pass\n    try:\n        if b/a == int(b/a): out.add(int(b/a))\n    except ZeroDivisionError:\n        pass\n    return out\n\n@lru_cache(maxsize=None)\ndef three(a, b, c):\n    return set().union(*[\n        *[two(x, a) for x in two(b, c)],\n        *[two(x, b) for x in two(c, a)],\n        *[two(x, c) for x in two(a, b)],\n    ])\n\n@lru_cache(maxsize=None)\ndef four(a, b, c, d):\n    return set().union(*[\n        *[two(x, a) for x in three(b, c, d)],\n        *[two(x, b) for x in three(c, d, a)],\n        *[two(x, c) for x in three(d, a, b)],\n        *[two(x, d) for x in three(a, b, c)],\n\n        *[two(x, y) for x in two(a, b) for y in two(c, d)],\n        *[two(x, y) for x in two(a, c) for y in two(b, d)],\n        *[two(x, y) for x in two(a, d) for y in two(b, c)],\n    ])\n\n@lru_cache(maxsize=None)\ndef five(a, b, c, d, e):\n    return set().union(*[\n        *[two(x, a) for x in four(b, c, d, e)],\n        *[two(x, b) for x in four(c, d, e, a)],\n        *[two(x, c) for x in four(d, e, a, b)],\n        *[two(x, d) for x in four(e, a, b, c)],\n        *[two(x, e) for x in four(a, b, c, d)],\n\n        *[two(x, y) for x in two(a, b) for y in three(c, d, e)],\n        *[two(x, y) for x in two(a, c) for y in three(b, d, e)],\n        *[two(x, y) for x in two(a, d) for y in three(b, c, e)],\n        *[two(x, y) for x in two(a, e) for y in three(b, c, d)],\n        *[two(x, y) for x in two(b, c) for y in three(a, d, e)],\n        *[two(x, y) for x in two(b, d) for y in three(a, c, e)],\n        *[two(x, y) for x in two(b, e) for y in three(a, c, d)],\n        *[two(x, y) for x in two(c, d) for y in three(a, b, e)],\n        *[two(x, y) for x in two(c, e) for y in three(a, b, d)],\n        *[two(x, y) for x in two(d, e) for y in three(a, b, c)],\n    ])\n\n@lru_cache(maxsize=None)\ndef six(a, b, c, d, e, f):\n    return set().union(*[\n        *[two(x, a) for x in five(b, c, d, e, f)],\n        *[two(x, b) for x in five(c, d, e, f, a)],\n        *[two(x, c) for x in five(d, e, f, a, b)],\n        *[two(x, d) for x in five(e, f, a, b, c)],\n        *[two(x, e) for x in five(f, a, b, c, d)],\n        *[two(x, f) for x in five(a, b, c, d, e)],\n\n        *[two(x, y) for x in two(a, b) for y in four(c, d, e, f)],\n        *[two(x, y) for x in two(a, c) for y in four(b, d, e, f)],\n        *[two(x, y) for x in two(a, d) for y in four(b, c, e, f)],\n        *[two(x, y) for x in two(a, e) for y in four(b, c, d, f)],\n        *[two(x, y) for x in two(a, f) for y in four(b, c, d, e)],\n        *[two(x, y) for x in two(b, c) for y in four(a, d, e, f)],\n        *[two(x, y) for x in two(b, d) for y in four(a, c, e, f)],\n        *[two(x, y) for x in two(b, e) for y in four(a, c, d, f)],\n        *[two(x, y) for x in two(b, f) for y in four(a, c, d, e)],\n        *[two(x, y) for x in two(c, d) for y in four(a, b, e, f)],\n        *[two(x, y) for x in two(c, e) for y in four(a, b, d, f)],\n        *[two(x, y) for x in two(c, f) for y in four(a, b, d, e)],\n        *[two(x, y) for x in two(d, e) for y in four(a, b, c, f)],\n        *[two(x, y) for x in two(d, f) for y in four(a, b, c, e)],\n        *[two(x, y) for x in two(e, f) for y in four(a, b, c, d)],\n\n        *[two(x, y) for x in three(a, b, c) for y in three(d, e, f)],\n        *[two(x, y) for x in three(a, b, d) for y in three(c, e, f)],\n        *[two(x, y) for x in three(a, b, e) for y in three(c, d, f)],\n        *[two(x, y) for x in three(a, b, f) for y in three(c, d, e)],\n        *[two(x, y) for x in three(a, c, d) for y in three(b, e, f)],\n        *[two(x, y) for x in three(a, c, e) for y in three(b, d, f)],\n        *[two(x, y) for x in three(a, c, f) for y in three(b, d, e)],\n        *[two(x, y) for x in three(a, d, e) for y in three(b, c, f)],\n        *[two(x, y) for x in three(a, d, f) for y in three(b, c, e)],\n        *[two(x, y) for x in three(a, e, f) for y in three(b, c, d)],\n    ])\n\n@lru_cache(maxsize=None)\ndef countdown(a, b, c, d, e, f, low=100, high=999):\n    \"\"\"\n    Returns the valid mathematical combinations of the six inputs\n    that fall between a range of \"low\" and \"high\"\n    \"\"\"\n    return six(a, b, c, d, e, f).intersection(range(low, high+1))\n\n@lru_cache(maxsize=None)\ndef solvable_count(a, b, c, d, e, f, low=100, high=999):\n    \"\"\"\n    Returns the number of solvable targets from the mask range\n    \"\"\"\n    return len(countdown(a, b, c, d, e, f, low=low, high=high))\n\n@lru_cache()\ndef number_pool(n_large, total=6):\n    \"\"\"\n    Returns a list of randomly selected numbers where the\n    returned list has \"n_large\" numbers selected from the\n    LARGE list, and \"total - n_large\" numbers selected\n    from the SMALL list.\n    \"\"\"\n    # ensure we don't try to pick more numbers than available\n    n_large = min(len(LARGE), n_large)\n\n    # generate the list of numbers, then sort it before returning\n    out = (\n        list(L) + list(S)\n        for L in combinations(LARGE, n_large)\n        for S in combinations(SMALL, total - n_large)\n    )\n    return [sorted(x) for x in out]\n\ndef solvable_percent(n_large, total=6, low=100, high=999):\n    \"\"\"\n    Returns the percent of random targets that can be solved\n    given a list of six numbers comprised of \"n_large\" LARGE\n    numbers and \"total - n_large\" SMALL numbers.\n    \"\"\"\n    # create number list given a number of LARGE numbers\n    numbers = number_pool(n_large=n_large, total=total)\n\n    # run each group of numbers to count the total number of solvable targets\n    numerator = sum([solvable_count(*n, low=low, high=high) for n in numbers])\n    denominator = len(numbers) * len(mask)\n    return numerator / denominator\n\n@lru_cache()\ndef target_percent(n_large, total=6, low=100, high=999):\n    \"\"\"\n    Returns a pandas Series indexed by targets, with values\n    equal to the likelihood of being able to successfully hit\n    the target given a random set of input numbers.\n    \"\"\"\n    numbers = number_pool(n_large=n_large, total=total)\n    targets = [countdown(*n) for n in numbers]\n    targets = [elem for subset in targets for elem in subset]\n    targets = np.histogram(targets, bins=range(low, high+2))\n    targets = pd.Series(index=targets[1][:-1], data=targets[0])\n    return targets.div(len(numbers))\n\ndef plot_target_percent(n_large, total=6, low=100, high=999):\n    \"\"\"\n    Returns a bar graph of the target numbers and their likelihood\n    of being solvable, given a number of LARGE numbers in the pool.\n    \"\"\"\n    targets = target_percent(n_large=n_large, total=total, low=low, high=high)\n\n    fig, ax = plt.subplots(figsize=(10,7))\n\n    targets.plot(drawstyle='steps')\n    ax.set_xticks(range(low, high+2, 50))\n    ax.set_xlim(low, high+1)\n    for s in ['top', 'right']:\n        ax.spines[s].set_visible(False)\n\n    return ax\n

"},{"title":"Riddler Colorful Maze","date":"May 17, 2019","slug":"riddler-colorful-maze","excerpt":"This was a colorful Riddler Express. We start with a maze comprised of edges of different colors. Our task is to identify the shortest path from start to finish using only edges of certain colors. This was a great opportunity to take python's networkx library for a spin! We can build the maze as a network, where each edge has a \"color\" attribute, and use powerful solvers to do the path-finding for us!","tags":[],"status":"published","content":"

Introduction

This was a colorful Riddler Express. We start with a maze comprised of edges of different colors. Our task is to identify the shortest path from start to finish using only edges of certain colors. This was a great opportunity to take python's networkx library for a spin! We can build the maze as a network, where each edge has a \"color\" attribute, and use powerful solvers to do the path-finding for us! Here's the full problem text, and the visual to go along with it.

\nIn grade school, you may have learned about the three primary colors — blue, yellow and red — and the three secondary colors — green (blue + yellow), purple (red + blue) and orange (yellow + red).\n
And now it’s time to put that knowledge to use. Try to get through the maze below, a nine-by-nine grid of lines, three times: once as blue, once as yellow, and once as red. If you are blue, you may only travel on lines that include the color blue. So you may travel on lines that are blue, green, purple or white (which contains all colors). You may not travel on orange, yellow, red or black (which contains no colors). The analogous rules hold for your trips as yellow and red.
\n\n

Coding the maze

I used the fantastic python library networkx to code the maze. In this case, the nodes are fairly unimportant, and we're really interested in the edges; specifically, we're interested in assigning a \"color\" attribute to each edge. Later, we can use the color attribute to filter the edges for valid pathways, and use networkx's built in solvers to identify the shortest path from start to finish.

The full reference code can be found at the bottom of this article, but the basic approach to codifying the maze is to create an edge between two nodes and assign it a color. For example, this snippet creates the graph and assigns the first eight edges.

import networkx as nx\n\nG = nx.Graph()\nG.add_edge((0,0), (0,1), color='o')\nG.add_edge((0,1), (0,2), color='w')\nG.add_edge((0,2), (0,3), color='g')\nG.add_edge((0,3), (0,4), color='w')\nG.add_edge((0,4), (0,5), color='y')\nG.add_edge((0,5), (0,6), color='w')\nG.add_edge((0,6), (0,7), color='y')\nG.add_edge((0,7), (0,8), color='w')\n

Building the graph is the most time-consuming part of the problem. We have to manually assign colors to each of the 144 edges between the nodes to recreate the graph. But once this part is finished the rest of the process is fully automated by the code!

After all that work, we can verify everything is correct by visualizing the graph. The helper function plot_maze takes care of this for us, and produces the image below. It bears a striking resemblance to the original!

Solving the problem

Building the graph took time, but the initial work provides a significant advantage when it comes to solving the problem. In exchange for coding the network, we can use automated methods to solve for the shortest paths from start to finish.

Because we're only allowed to use certain colors to pass through the maze, we need a way to filter the valid and invalid paths. We will do this by creating subgraphs that contain only edges with the colors we want. Here's an example of filtering our graph for valid \"blue\" pathways, which can include edges that are blue, green, purple, or white.

G = create_graph()\nsubgraph = nx.Graph()\n    subgraph.add_edges_from([\n        (u, v) for u, v, d in G.edges(data=True) if d['color'] in COLORS['blue']\n    ])\n

All we need to do now is call nx.shortest_path on our subgraph and we have our answer! Along with our plotting function from before, we can illustrate the paths to check our work. Here they are!

Full Code

The code below contains functions to build and visualize the maze, create subgraphs, and solve for the shortest path along a given color pathway.

# -*- coding: utf-8 -*-\n\"\"\"\nSolves the Riddler Express from 5-17-2019 using a networkx graph to specify\nedge colors and solve for the shortest path along valid routes.\n\"\"\"\nimport networkx as nx\nimport matplotlib.pyplot as plt\n\n\nCOLORS = {\n    'b': ['b', 'g', 'p', 'w'],\n    'y': ['y', 'g', 'o', 'w'],\n    'r': ['r', 'o', 'p', 'w'],\n}\nCOLOR_MAP = {\n    'b': '#1976D2',\n    'o': '#FF9800',\n    'g': '#4CAF50',\n    'r': '#D32F2F',\n    'p': '#9C27B0',\n    'y': '#FFEB3B',\n    'w': '#FFFFFF',\n    'k': '#212121'\n}\n\ndef color_pathway(graph, source=(0,1), target=(8,7), color='b'):\n    \"\"\"\n    Return the shortest path through a graph, given a \"color pathway\",\n    which can be \"b\" (blue), \"y\" (yellow), or \"r\" (red) from a source\n    node to a target node. The color pathway establishes a subgraph of\n    nodes and edges that contain related colors. The function returns\n    one pathway linking the source and target if it exists.\n    \"\"\"\n    subgraph = nx.Graph()\n    subgraph.add_edges_from([\n        (u, v) for u, v, d in graph.edges(data=True) if d['color'] in COLORS[color]\n    ])\n    return nx.shortest_path(subgraph, source=source, target=target)\n\ndef plot_maze(graph, color=None):\n    \"\"\"\n    Plot the maze and optionally highlight the path along a specific color,\n    such as 'b', 'y', or 'r'. If color_pathway is None, no path will be\n    highlighted.\n    \"\"\"\n    fig, ax = plt.subplots(figsize=(8,7))\n    ax.set_facecolor('0.9')\n    ax.set_title('Riddler Maze')\n\n    # data for plotting\n    pos = {n: n for n in graph.nodes}\n    edge_color = [COLOR_MAP[d['color']] for u, v, d in graph.edges(data=True)]\n\n    # highlight the path for a given color if requested\n    if color is not None:\n        solution = color_pathway(graph, color=color)\n        nx.draw_networkx_edges(\n            graph, pos, edgelist=list(zip(solution, solution[1:])),\n            edge_color='k', width=19, ax=ax\n        )\n        nx.draw_networkx_edges(\n            graph, pos, edgelist=list(zip(solution, solution[1:])),\n            edge_color='0.5', width=13, ax=ax\n        )\n\n    # draw the original maze\n    nx.draw_networkx(\n        graph, pos, node_color='0.85', node_size=100, with_labels=False,\n        edge_color=edge_color, width=7, ax=ax\n    )\n\n    # annotation\n    ax.annotate('Start', (-0.2, 1), ha='right', va='center', fontsize=12, fontweight='bold')\n    ax.annotate('End', (8.2, 7), ha='left', va='center', fontsize=12, fontweight='bold')\n\n    # style\n    ax.xaxis.set_visible(False)\n    ax.yaxis.set_visible(False)\n    for s in ['top','right','left','bottom']:\n        ax.spines[s].set_visible(False)\n    ax.set_ylim(-0.5, 8.5)\n    ax.set_xlim(-1, 9)\n\n    return ax\n\ndef create_graph():\n    \"\"\"\n    Create the graph of the riddler express using coordinates as nodes\n    and identifying colors of edges using single letter codes. Lower\n    left corner is (0,0), and upper right corner is (8,8).\n    \"\"\"\n    G = nx.Graph()\n\n    # first column\n    G.add_edge((0,0), (0,1), color='o')\n    G.add_edge((0,1), (0,2), color='w')\n    G.add_edge((0,2), (0,3), color='g')\n    G.add_edge((0,3), (0,4), color='w')\n    G.add_edge((0,4), (0,5), color='y')\n    G.add_edge((0,5), (0,6), color='w')\n    G.add_edge((0,6), (0,7), color='y')\n    G.add_edge((0,7), (0,8), color='w')\n\n    # second column\n    G.add_edge((1,0), (1,1), color='g')\n    G.add_edge((1,1), (1,2), color='k')\n    G.add_edge((1,2), (1,3), color='r')\n    G.add_edge((1,3), (1,4), color='p')\n    G.add_edge((1,4), (1,5), color='g')\n    G.add_edge((1,5), (1,6), color='k')\n    G.add_edge((1,6), (1,7), color='w')\n    G.add_edge((1,7), (1,8), color='r')\n\n    # third column\n    G.add_edge((2,0), (2,1), color='o')\n    G.add_edge((2,1), (2,2), color='w')\n    G.add_edge((2,2), (2,3), color='p')\n    G.add_edge((2,3), (2,4), color='k')\n    G.add_edge((2,4), (2,5), color='p')\n    G.add_edge((2,5), (2,6), color='o')\n    G.add_edge((2,6), (2,7), color='g')\n    G.add_edge((2,7), (2,8), color='w')\n\n    # fourth column\n    G.add_edge((3,0), (3,1), color='b')\n    G.add_edge((3,1), (3,2), color='o')\n    G.add_edge((3,2), (3,3), color='o')\n    G.add_edge((3,3), (3,4), color='o')\n    G.add_edge((3,4), (3,5), color='g')\n    G.add_edge((3,5), (3,6), color='w')\n    G.add_edge((3,6), (3,7), color='p')\n    G.add_edge((3,7), (3,8), color='y')\n\n    # fifth column\n    G.add_edge((4,0), (4,1), color='o')\n    G.add_edge((4,1), (4,2), color='p')\n    G.add_edge((4,2), (4,3), color='y')\n    G.add_edge((4,3), (4,4), color='r')\n    G.add_edge((4,4), (4,5), color='o')\n    G.add_edge((4,5), (4,6), color='k')\n    G.add_edge((4,6), (4,7), color='w')\n    G.add_edge((4,7), (4,8), color='p')\n\n    # sixth column\n    G.add_edge((5,0), (5,1), color='k')\n    G.add_edge((5,1), (5,2), color='r')\n    G.add_edge((5,2), (5,3), color='b')\n    G.add_edge((5,3), (5,4), color='p')\n    G.add_edge((5,4), (5,5), color='b')\n    G.add_edge((5,5), (5,6), color='p')\n    G.add_edge((5,6), (5,7), color='y')\n    G.add_edge((5,7), (5,8), color='g')\n\n    # seventh column\n    G.add_edge((6,0), (6,1), color='w')\n    G.add_edge((6,1), (6,2), color='w')\n    G.add_edge((6,2), (6,3), color='k')\n    G.add_edge((6,3), (6,4), color='o')\n    G.add_edge((6,4), (6,5), color='o')\n    G.add_edge((6,5), (6,6), color='y')\n    G.add_edge((6,6), (6,7), color='g')\n    G.add_edge((6,7), (6,8), color='r')\n\n    # eighth column\n    G.add_edge((7,0), (7,1), color='b')\n    G.add_edge((7,1), (7,2), color='r')\n    G.add_edge((7,2), (7,3), color='o')\n    G.add_edge((7,3), (7,4), color='b')\n    G.add_edge((7,4), (7,5), color='p')\n    G.add_edge((7,5), (7,6), color='k')\n    G.add_edge((7,6), (7,7), color='k')\n    G.add_edge((7,7), (7,8), color='b')\n\n    # ninth column\n    G.add_edge((8,0), (8,1), color='o')\n    G.add_edge((8,1), (8,2), color='o')\n    G.add_edge((8,2), (8,3), color='y')\n    G.add_edge((8,3), (8,4), color='p')\n    G.add_edge((8,4), (8,5), color='o')\n    G.add_edge((8,5), (8,6), color='r')\n    G.add_edge((8,6), (8,7), color='w')\n    G.add_edge((8,7), (8,8), color='o')\n\n    # first row\n    G.add_edge((0,0), (1,0), color='o')\n    G.add_edge((1,0), (2,0), color='p')\n    G.add_edge((2,0), (3,0), color='w')\n    G.add_edge((3,0), (4,0), color='w')\n    G.add_edge((4,0), (5,0), color='w')\n    G.add_edge((5,0), (6,0), color='r')\n    G.add_edge((6,0), (7,0), color='o')\n    G.add_edge((7,0), (8,0), color='g')\n\n    # second row\n    G.add_edge((0,1), (1,1), color='p')\n    G.add_edge((1,1), (2,1), color='k')\n    G.add_edge((2,1), (3,1), color='r')\n    G.add_edge((3,1), (4,1), color='b')\n    G.add_edge((4,1), (5,1), color='g')\n    G.add_edge((5,1), (6,1), color='w')\n    G.add_edge((6,1), (7,1), color='y')\n    G.add_edge((7,1), (8,1), color='p')\n\n    # third row\n    G.add_edge((0,2), (1,2), color='y')\n    G.add_edge((1,2), (2,2), color='p')\n    G.add_edge((2,2), (3,2), color='g')\n    G.add_edge((3,2), (4,2), color='k')\n    G.add_edge((4,2), (5,2), color='o')\n    G.add_edge((5,2), (6,2), color='b')\n    G.add_edge((6,2), (7,2), color='b')\n    G.add_edge((7,2), (8,2), color='g')\n\n    # fourth row\n    G.add_edge((0,3), (1,3), color='w')\n    G.add_edge((1,3), (2,3), color='g')\n    G.add_edge((2,3), (3,3), color='b')\n    G.add_edge((3,3), (4,3), color='g')\n    G.add_edge((4,3), (5,3), color='o')\n    G.add_edge((5,3), (6,3), color='b')\n    G.add_edge((6,3), (7,3), color='o')\n    G.add_edge((7,3), (8,3), color='p')\n\n    # fifth row\n    G.add_edge((0,4), (1,4), color='k')\n    G.add_edge((1,4), (2,4), color='o')\n    G.add_edge((2,4), (3,4), color='b')\n    G.add_edge((3,4), (4,4), color='p')\n    G.add_edge((4,4), (5,4), color='k')\n    G.add_edge((5,4), (6,4), color='g')\n    G.add_edge((6,4), (7,4), color='p')\n    G.add_edge((7,4), (8,4), color='k')\n\n    # sixth row\n    G.add_edge((0,5), (1,5), color='w')\n    G.add_edge((1,5), (2,5), color='o')\n    G.add_edge((2,5), (3,5), color='o')\n    G.add_edge((3,5), (4,5), color='g')\n    G.add_edge((4,5), (5,5), color='g')\n    G.add_edge((5,5), (6,5), color='p')\n    G.add_edge((6,5), (7,5), color='y')\n    G.add_edge((7,5), (8,5), color='g')\n\n    # seventh row\n    G.add_edge((0,6), (1,6), color='y')\n    G.add_edge((1,6), (2,6), color='r')\n    G.add_edge((2,6), (3,6), color='b')\n    G.add_edge((3,6), (4,6), color='r')\n    G.add_edge((4,6), (5,6), color='o')\n    G.add_edge((5,6), (6,6), color='w')\n    G.add_edge((6,6), (7,6), color='g')\n    G.add_edge((7,6), (8,6), color='r')\n\n    # eighth row\n    G.add_edge((0,7), (1,7), color='r')\n    G.add_edge((1,7), (2,7), color='b')\n    G.add_edge((2,7), (3,7), color='y')\n    G.add_edge((3,7), (4,7), color='k')\n    G.add_edge((4,7), (5,7), color='r')\n    G.add_edge((5,7), (6,7), color='k')\n    G.add_edge((6,7), (7,7), color='o')\n    G.add_edge((7,7), (8,7), color='b')\n\n    # ninth row\n    G.add_edge((0,8), (1,8), color='g')\n    G.add_edge((1,8), (2,8), color='p')\n    G.add_edge((2,8), (3,8), color='p')\n    G.add_edge((3,8), (4,8), color='w')\n    G.add_edge((4,8), (5,8), color='p')\n    G.add_edge((5,8), (6,8), color='w')\n    G.add_edge((6,8), (7,8), color='w')\n    G.add_edge((7,8), (8,8), color='g')\n\n    return G\n\nif __name__ == '__main__':\n\n    G = create_graph()\n\n    blue = color_pathway(G, color='b')\n    yellow = color_pathway(G, color='y')\n    red = color_pathway(G, color='r')\n\n    plot_maze(G)\n    plot_maze(G, color='b')\n    plot_maze(G, color='r')\n    plot_maze(G, color='y')\n

"},{"title":"Riddler Thrones","date":"May 17, 2019","slug":"riddler-thrones","excerpt":"This week's Riddler pits the army of the dead vs. the army of the living. As the two armies battle, any fallen soldiers from the living army rise to fight with the dead. How many soldiers would each side need to make it a fair fight?","tags":[],"status":"published","content":"

Introduction

This week's Riddler pits the army of the dead vs. the army of the living. As the two armies battle, any fallen soldiers from the living army rise to fight with the dead. How many soldiers would each side need to make it a fair fight? Here's the full problem text:

\nAt a pivotal moment in an epic battle between the living and the dead, the Night King, head of the army of the dead, raises all the fallen (formerly) living soldiers to join his ranks. This ability obviously presents a huge military advantage, but how big an advantage exactly?\n
Forget the Battle of Winterfell and model our battle as follows. Each army lines up single file, facing the other army. One soldier steps forward from each line and the pair duels — half the time the living soldier wins, half the time the dead soldier wins. If the living soldier wins, he goes to the back of his army’s line, and the dead soldier is out (the living army uses dragonglass weapons, so the dead soldier is dead forever this time). If the dead soldier wins, he goes to the back of their army’s line, but this time the (formerly) living soldier joins him there. (Reanimation is instantaneous for this Night King.) The battle continues until one army is entirely eliminated.
\n
What starting sizes of the armies, living and dead, give each army a 50-50 chance of winning?
\n

Setup

As with most Riddlers, I'll use Python to do much of the computation. However, it is still up to us to translate the problem into something our computers can understand.

First, let's deal with the inputs. We want the first input, $x$ , to be the number of soldiers in the living army. The next input, $y$ , will be the number of soldiers in the dead army. We also need a function that takes both $x$ and $y$ as inputs and returns a probability, which I'll define as the likelihood that the living army prevails in the battle. This will be a number between 0 and 1. For example, if the living army has 100 soldiers and the dead army has 50 soldiers, what is the likelihood the living army will win the battle?

Then, to solve the problem as stated above, we'll need another function that accepts either $x$ or $y$ , but not both, and returns the other variable such that the odds of winning are 50% for both sides. For example, we might want to know how many soldiers the living army needs to have fair odds against a dead army with 50 soldiers. Or we might want to know how many soldiers the dead army would need to battle against a living army of 500.

We know that soldiers in the army fight one at a time until one of the armies is depleted. Therefore, we know the terminating case of our program could be either $x=0$ or $y=0$ . We also define a \"reward\" in each terminating state, which will help us calculate the probabilities of each army winning. Define the reward when $y=0$ as 1. This means that if the living army wins the battle with any number of soldiers remaining, then the reward is 1. On the other hand, if the dead army wins the battle, we terminate with $x=0$ , and we set the reward to 0.

Lastly, we know how to move from different values of $x$ and $y$ to other values. For example, we know that if both armies start with 10 soldiers each, one of two things could happen.

The living soldier wins. Then the living army remains at 10 soldiers, and the dead army goes from 10 soldiers to 9.
The dead soldier wins. Then the living army goes from 10 to 9 soldiers, and the dead army goes from 10 to 11 soldiers. This is the advantage of night king!

Therefore, we move from a state of ( $x$ , $y$ ) to a state of ( $x$ , $y-1$ ) with 50% probability and to a state of ( $x-1$ , $y+1$ ) with the other 50% probability. This is everything we need to write a recursive function that fully describes the battle!

The Code

The function below calculates the likelihood that the living army wins the battle, given a starting number of soldiers for each side. Importantly, the function is memoized, which means that answers it's already calculated are saved and stored so we don't repeat any steps we've already done.

What is interesting to me is that the problem clearly has elements of randomness: each duel has 50% likelihood of ending in either army's favor. But the function below doesn't need to simulate that randomness. Instead, it uses expected values and calculates exact probabilities.

from functools import lru_cache\n\n@lru_cache(maxsize=None)\ndef model(living, dead, win_rate=0.5):\n    \"\"\"\n    Calculate the likelihood of the living army winning the battle,\n    given a starting army size for both living and dead.\n\n    Parameters\n    ----------\n    living : int, the starting number of living soldiers\n    dead : int, the starting number of dead soldiers\n    win_rate : float, between 0 and 1, the likelihood of a living\n        soldier winning a single duel\n\n    Returns\n    -------\n    outcome : float, between 0 and 1, the likelihood of the living\n        army winning the entire battle\n    \"\"\"\n    if dead < 1:\n        # living army wins\n        return 1.0\n    elif living < 1:\n        # dead army wins\n        return 0.0\n    else:\n        # return the weighted average of both potential branches\n        return (\n            win_rate * model(living, dead - 1, win_rate)\n            + (1 - win_rate) * model(living - 1, dead + 1, win_rate)\n        )\n\n>>> model(1, 1)\n0.5\n\n>>> model(10, 5)\n0.30745625495910645\n

Everything we described above shows up in this code. If we enter into a terminating condition with either $x=0$ or $y=0$ , we end the calculation and return the 1 or 0. Otherwise, we branch into the two possible worlds where the living soldier and the dead soldier each win their battle. The end result of this recursion is a final probability that takes all of the branching possibilities into account.

We can also validate our results by looking at the base case of $x=y=1$ . In this simple case, our final answer should be exactly equal to the soldiers' individual probability of winning a duel, because only one duel will occur before the battle is over. This makes sense, because we know the winner of the single duel determines the overall winner of the battle, and each duel is won by the living soldier 50% of the time. This is confirmed when we see that model(1, 1) returns 50%.

We now have a function that solves for the probability of the living army winning a battle with any combination of starting army sizes. However, that's not quite enough to solve the problem on its own. We know how to find probability based on army sizes, but we also need to be able to find army sizes from a probability. We'll tackle that next.

Graphing the Results

As usual, graphing the results can help to understand the dynamics of this problem. We know the dead army has a significant advantage, but exactly how much? We can use the function from the prior section to map all combinations of army sizes to try to understand the probability surface.

As we can see, the dead army's advantage compounds as it grows. In other words, each additional dead army soldier requires an increasing number of additional living army soldiers to fight. When the dead army has 10 soldiers, it requires 106 living soldiers just to keep the odds fair and square. I've also plotted the soldiers required for different battle probabilities. For example, if the living army wants to win with 60% certainty instead of 50%, it needs even more soldiers.

The relationship here is very close to a square root. For example, if we want to solve for the number of dead soldiers required for 50% odds, given a fixed number of living soldiers, we should take the square root. For example, if the dead army fights a living army with 400 soldiers, it should send roughly 20 of its own for a fair fight. Conversely, if the living army knows how many soldiers it will be facing, it should plan to amass that number squared! Even though the purpose of this Riddler was to solve for even odds, it's hard to imagine how the odds are not stacked in the night king's favor.

"},{"title":"Riddler Circles","date":"Apr 19, 2019","slug":"riddler-circles","excerpt":"The Riddler this week asks us about random points on the edge of a circle. Specifically, if we generate $n$ random points around the circumference of a circle, how likely are those points to fall on only one side?","tags":[],"status":"published","content":"

Introduction

The Riddler this week asks us about random points on the edge of a circle. Specifically, if we generate $n$ random points around the circumference of a circle, how likely are those points to fall on only one side? Our answer should be a function of $n$ . Here is the full text.

\nIf N points are generated at random places on the perimeter of a circle, what is the probability that you can pick a diameter such that all of those points are on only one side of the newly halved circle?\n

Starting with intuition

It's possible to build an intuitive sense of our answer by examining a few values of $n$ . For example, by definition, a single point, $n=1$ , must always be true: a single point is always on its own side. Therefore the odds are 100%.

For $n=2$ , let's take the case that the points are on exact opposite ends of the circle - for example at the \"9 o'clock\" and \"3 o'clock\" positions, respectively. Those points will lie on the same bisecting line of the circle, and I think it's fair to say they should both be considered to be on the same side of the circle. In any other case of randomly generated points, they will be even closer, so it's trivial to show that they will lie on the same side of the circle. Again, our odds are 100%.

When $n=3$ it becomes more complicated. Because we're dealing with randomly generated points, we can always \"spin\" our circle around to fix one point in any position we like. For example, we can assume we will always have a point at the \"3 o'clock\" position. Our next point can be anywhere on the circle, but by similar logic we can maneuver our circle so this next point is on the top half. Given these two points, we can define the valid region of the circle's circumference that satisfies our problem. For example, if the second point is at the \"12 o'clock\" position, then our third point must be located anywhere except between \"3 o'clock\" and \"6 o'clock\" to satisfy our criteria. This will happen 75% of the time.

If the second point is located directly on top of our first point, then we have virtually 100% likelihood of satisfying our criteria. If the second point is located directly across from our first point, then we have 50% likelihood. Therefore, we can take the average of these two values to show that for $n=3$ , the overall likelihood is 75%.

From here, the cases get far more complicated, so I opted to let my computer do the hard work for me! Our single sanity check is that we would expect probabilities to decrease as $n$ increases. As we generate more points, we expect them to cover more of the circle's circumference, making it less likely that they would be clustered on a single side.

Coding a simulation

In order to solve this problem through simulation, we need to define our program instructions. We need a way to generate random points on a circle, and a way to check whether our points lie on the same side or not.

Generating random points - any point on the circle can be uniquely identified by its angle, which is a number between 0 and 360 (for degrees), or between 0 and $2\\pi$ (for radians). We can also simplify this even further and say a point is uniquely identified by a number between 0 and 1, which can be translated into an angle by multiplying by either 360 or by $2\\pi$ .

Calculating the criteria - we can imagine each point of the circle defining two different halves for us to check. If we find that every other point is contained in one of those halves, then we know our criteria is satisfied. To simplify this, we can imagine \"cutting\" our circle at the \"3 o'clock\" position and stretching it out into a number line.

You can see that the points we generated around the edge are simply transposed onto the number line. Next, we generate both sides of each point, shown in grey, keeping in mind that we can wrap around each side of the number line, just like we would on the circle. Thankfully, we can use modular arithmetic to do this \"wrapping\" automatically. The next several images show the two halves we generate from two of our random points. We see that in at least one case, we found a single region that contained each of the three points, so we consider this simulation a success.

Because this is a simulation, we want to generate many trials and count the number of successes. If we divide the number of successes by the total number of trials, we get an approximation of the true rate of success. Here is the Python function that implements our simulation.

What is neat about this code is that we can run all of our simulations simultaneously. This is an example of vectorized code. Vectorized code is often significantly faster than similar code implemented using loops. This code runs one million trials nearly instantly.

def model(n, trials=1000000):\n    \"\"\"\n    Solves the Riddler Classic from April 19, 2019\n\n    First generates a random number array of shape (trials, n). Then\n    calculates the distance between each point in the array from each\n    other point, wrapping around one or zero, just like a circle.\n\n    Using these distances, we calculate the minimum distance that\n    encompasses all points in the array. If the minimum distance is\n    less than 0.5, we return True, otherwise False. The function then\n    returns the sum of all True values divided by the number of trials\n    to estimate the probability for a given value of n.\n    \"\"\"\n    r = np.random.rand(trials, n)\n    r = (r[:, None] - r[:, :, None]) % 1.0\n    r = r.max(2).min(1) < 0.5\n    return r.sum() / trials\n

Results

Using this function, we can test success rates for several values of $n$ .

results = {n: model(n) for n in range(1, 21)}\n\nprint(results)\n{1: 1.0,\n 2: 1.0,\n 3: 0.749476,\n 4: 0.500362,\n 5: 0.312846,\n 6: 0.188008,\n 7: 0.109496,\n 8: 0.062215,\n 9: 0.0348,\n 10: 0.01946,\n 11: 0.010781,\n 12: 0.005754,\n 13: 0.003154,\n 14: 0.001721,\n 15: 0.000897,\n 16: 0.000491,\n 17: 0.000237,\n 18: 0.00013,\n 19: 7.1e-05,\n 20: 4.4e-05}\n

As usual, we can also visualize these probabilities in a histogram, shown below. We see that probabilities decrease significantly, to roughly less than 1% once we reach 10 or more points. When we generate 20 points, it's virtually impossible for them all to be on a single side of the circle. This confirms our intuition from above.

This was another interesting, and deceptively complex problem. It's one that I'd like to come back to and attempt to find an analytical solution later.

"},{"title":"Riddler Gift Cards","date":"Apr 5, 2019","slug":"riddler-gift-cards","excerpt":"Another weekly Riddler, this time with both an analytical and simulated solution!","tags":[],"status":"published","content":"

Introduction

This week's Riddler falls into one of my favorite categories: a problem that can be solved analytically and via simulation. It's great to be able to solve the same problem in two different ways! Here's the full problem text.

\nLucky you! You’ve won two gift cards, each loaded with 50 free drinks from your favorite coffee shop, Riddler Caffei-Nation. The cards look identical, and because you’re not one for record-keeping, you randomly pick one of the cards to pay with each time you get a drink. One day, the clerk tells you that he can’t accept the card you presented to him because it doesn’t have any drink credits left on it.\n
What is the probability that the other card still has free drinks on it? How many free drinks can you expect are still available?
\n

Analytical Solution

Let's define some terms first. Both cards start with $n$ drinks. The question specifically asks about $n=50$ but we can generalize to any $n$ . We are interested in the number $k$ drinks remaining on either card when we try (and fail) to buy a drink with one of our cards. Note that $k$ can be zero, as in the case where we draw down each card equally after buying 100 drinks total. When we frame the question like this, it lets us define the only two possible outcomes, which are:

Card A runs out of drinks first; card B has $k$ drinks remaining.
Card B runs out of drinks first; card A has $k$ drinks remaining.

These two terminating conditions are symmetric - outcome 1 is just as likely as outcome 2. Therefore, we can solve for the probability of outcome 1 and double it for our final answer.

If we run out of drinks on card A, we will have $k$ drinks remaining on card B, where $k$ is any number between 0 and our starting number, $n$ . We know that for this to happen, we must have purchased $n$ drinks on the first card, $n-k$ drinks on the second card, and attempted $1$ more purchase on the first card, for a total of $2n - k + 1$ . Of those purchases, $n$ must have occurred on a single card, which gives us an \"n choose k\" binomial formula. Here's the probability of our event 1 occurring:

P(n, k) = \\binom{2n-k}{n}\\left(\\frac{1}{2}\\right)^{2n-k+1}

Now we account for the fact that either card can run out of drinks, so we multiply this expression by 2 for our final answer. It has the effect of cancelling out the $+1$ in our exponent.

2\\times P(n, k) = 2\\times \\binom{2n-k}{n}\\left(\\frac{1}{2}\\right)^{2n-k+1} = \\binom{2n-k}{n}\\left(\\frac{1}{2}\\right)^{2n-k}

Validation

Let's take our formula for a test drive, where we assume we start with 1 drink on each card. There are six possible outcomes, listed with their probabilities. For example, we can buy two drinks on card \"A\" in a row. If this happens, there will be one drink left on card B, and we know this occurs with 25% probability. Here's the full list.

A, A -> 1 drink remains on B, probability = 0.25
B, B -> 1 drink remains on A, probability = 0.25
A, B, A -> 0 drinks remain on B, probability = 0.125
A, B, B -> 0 drinks remain on A, probability = 0.125
B, A, A -> 0 drinks remain on B, probability = 0.125
B, A, B -> 0 drinks remain on A, probability = 0.125

Adding these up, we see that there is a 50% chance of ending with 1 drink, and a 50% chance of ending with 0 drinks. We can verify with our formula from above that there is a 50% chance of each outcome, so it seems like we've arrived at the right answer.

P(1, 1) = \\binom{1}{1}\\left(\\frac{1}{2}\\right)^{1} = 0.5

P(1, 0) = \\binom{2}{1}\\left(\\frac{1}{2}\\right)^{2} = 0.5

Expected Value

The question asked us about the expected number of drinks remaining. Using our formula, we can calculate the probability for any combination of $n$ and $k$ . Then, for every possible $k$ , we multiply by $k$ and sum the results to arrive at the expected value. It looks like this:

\\text{Expected Value} = \\sum_{k=0}^n k\\times{\\binom{2n-k}{n}\\left(\\frac{1}{2}\\right)^{2n-k}}

Using a bit of mathematical horsepower from WolframAlpha, we can simplify this expression to:

4^{-n}(2n + 1)\\binom{2n}{n}-1

When we substitute $n=50$ , we calculate an expected value of $\\approx7.0385$ . This means that when either card runs out, we expect roughly 7 drinks to be available on the other card.

We were also asked about the probability that there were any drinks available on the other card when the first card expires. We can answer this by taking the complement of the probability that both cards end with zero drinks. For this, we use values of $n=50$ and $k=0$ , and subtract the value from 1, which gives us roughly 92% odds.

Simulated Solution

We can also solve the problem by writing a short Python script. We start with both cards loaded with 50 drinks each. Next, we randomly choose one card and subtract a drink from it. We repeat this process until one of the cards reaches -1, because it means we tried to buy a drink using an empty card. When this happens, we record the number of drinks left on the other card. If we simulate this process a large number of times, then the distribution of results should converge to our analytical solution above. Here's the function we'll use.

from random import randint\n\ndef model(trials, n_drinks=50):\n    \"\"\"Simulate the Riddler Classic\"\"\"\n    for _ in range(trials):\n        cards = [n_drinks, n_drinks]\n        while min(cards) > -1:\n            cards[randint(0,1)] -= 1\n        yield max(cards)\n\ntrials = 1000000\nresults = np.array(list(model(trials, n_drinks=50)))\n\n# expected value\nprint(results.mean())\n# 7.038671\n\n# probability of any drinks remaining\nprint((results > 0).sum() / trials)\n# 0.920398\n

Our result based on one million trials is 7.038671, which is remarkably close to our analytical solution above! Looks like everything worked out the way it should. In addition to the expected value, we can also plot the full distribution of results, shown below.

Overall I was surprised the expected value is so low. There's a nearly a 50% chance that you end up with no more than 5 drinks on one of the cards using this approach! It looks like organizing and tracking gift cards may not be quite as important as one might think. Could this be a new life-hack? I doubt it, but it was a fun problem regardless.

"},{"title":"Riddler Spelling Bee","date":"Mar 29, 2019","slug":"riddler-spelling-bee","excerpt":"I have a distinct memory of participating in my elementary school's spelling bee when I was in second grade. I was the unlikely runner-up, even though I was competing against children in third and fourth grade. What was the secret to my over-performance? Not my natural spelling ability, but rather the rules of the game - a participant is eliminated from the spelling bee after failing to spell a word correctly, which means that going last is an advantage. I was lucky enough to be the near the tail-end of the participants in my spelling bee, which surely improved my final ranking. This week's Riddler asks us to quantify that advantage.","tags":[],"status":"published","content":"

Introduction

I have a distinct memory of participating in my elementary school's spelling bee when I was in second grade. I was the unlikely runner-up, even though I was competing against children in third and fourth grade. (For what it's worth, I will never forget how to spell the word that ultimately bested me, \"gingham\".) What was the secret to my over-performance? Not my natural spelling ability, but rather the rules of the game: a participant is eliminated from the spelling bee after failing to spell a word correctly, which means that going last is an advantage. I was lucky enough to be the near the tail-end of the participants in my spelling bee, which surely improved my final ranking.

This week's riddler asks us to quantify the \"going last\" advantage. Fortunately we can solve it with python, which is perhaps easier than competing in a spelling bee itself. Here's the full question text:

\nYou are competing in a spelling bee alongside nine other contestants. You can each spell words perfectly from a certain portion of the dictionary but will misspell any word not in that portion of the book. Specifically, you have 99 percent of the dictionary down cold, and your opponents have 98 percent, 97 percent, 96 percent, and so on down to 90 percent memorized. The bee’s rules are simple: The contestants take turns spelling in some fixed order, which then restarts with the first surviving speller at the end of a round. Miss a word and you’re out, and the last speller standing wins. The bee words are chosen randomly from the dictionary.\n
First, say the contestants go in decreasing order of their knowledge, so that you go first. What are your chances of winning the spelling bee? Second, say the contestants go in increasing order of knowledge, so that you go last. What are your chances of winning now?
\n

Problem Setup

As the problem states, we can identify participants by their probabilities of spelling words correctly. For example, we have a \"99%\" speller all the way through a \"90%\" speller. We'll organize the participants into numpy arrays, where we can sort from best to worst or worst to best.

# best to worst\nspellers = np.arange(99, 89, -1) / 100\n# array([0.99, 0.98, 0.97, 0.96, 0.95, 0.94, 0.93, 0.92, 0.91, 0.9 ])\n\n# worst to best\nspellers = np.arange(90, 100) / 100\n# array([0.9 , 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, 0.99])\n

Spelling Bee Simulation

Next, we need a way to simulate one round of the spelling bee. A 99% speller only misses 1% of the words she attempts. We can simulate this by drawing random numbers from 0 to 1. If the number is greater than 0.99, which occurs 1% of the time, then the participant is eliminated. Otherwise, she moves to the next round. We generate random numbers for each participant, keep the ones who spell correctly, and remove the others. Importantly, if every participant is eliminated during the round, we know that the final participant would have won, so we return this person instead of an empty array. Here's the function that implements this logic.

def single_round(spellers):\n    \"\"\"\n    Play a single round of the spelling bee; draw a random number for each speller,\n    then compare the number vs. their rate. Each speller that answers correctly\n    is retained in the array, while incorrect spellers are removed. Returns a new\n    array of the spellers that advance to the next round.\n\n    NOTE : if the function would return an empty array, (in the case that every speller\n    failed to spell the word correctly) it instead returns the speller listed last in\n    the original array, who would have won without having to spell a word.\n    \"\"\"\n    r = np.random.rand(len(spellers))\n    out = spellers[r < spellers]\n    if len(out) > 0:\n        return out\n    else:\n        return spellers[-1:]\n

To simulate the entire spelling bee, we'll run as many rounds as it takes to eliminate all but one participant.

def bee(spellers):\n    \"\"\"\n    Run a spelling bee with as many rounds as it takes to eliminate all but one\n    speller.\n    \"\"\"\n    while len(spellers) > 1:\n        spellers = single_round(spellers)\n    return spellers[0]\n

Results

Now that we have the tools to simulate a single spelling bee, we're interested in the distribution of results for a large number of them. This will help us understand how much of an advantage it is to go last. Therefore, we run 1 million spelling bees in which participants are ordered from best to worst, and 1 million in which they are ordered from worst to best. We calculate the number of bees won by each participant under each ordering, and show the results below in a table. The numbers represent a participant's chance of winning a spelling bee under both sets of orderings.

The question asked us (as the fantastic 99% speller that we are) how our chances of winning change based on whether we go first or last. Unsurprisingly, we have a significant edge over our opponents, winning more than half of all simulated bees regardless of ordering. But if we want that extra edge, going last will increase our chances of winning from 51.9% to 52.5%.

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Speller	Best to Worst	Worst to Best	Change
0.90	0.004534	0.004140	0.000394
0.91	0.006646	0.006159	0.000487
0.92	0.009734	0.008977	0.000757
0.93	0.014766	0.013655	0.001111
0.94	0.022588	0.021717	0.000871
0.95	0.036309	0.035115	0.001194
0.96	0.060632	0.060064	0.000568
0.97	0.109423	0.108333	0.001090
0.98	0.215985	0.216553	-0.000568
0.99	0.519383	0.525287	-0.005904

Reference: Full Python Code

# -*- coding: utf-8 -*-\n\"\"\"\nSolves the fivethirtyeight Riddler Classic problem from March 29, 2019\n\nEach speller is identified by their probability of spelling a word correctly,\nsuch as \"0.99\" to represent a 99% correct speller. The program simulates a\nlarge number of spelling bees and returns the winner of each bee.\n\"\"\"\nimport numpy as np\n\n\ndef single_round(spellers):\n    \"\"\"\n    Play a single round of the spelling bee; draw a random number for each speller,\n    then compare the number vs. their rate. Each speller that answers correctly\n    is retained in the array, while incorrect spellers are removed. Returns a new\n    array of the spellers that advance to the next round.\n\n    NOTE : if the function would return an empty array, (in the case that every speller\n    failed to spell the word correctly) it instead returns the speller listed last in\n    the original array, who would have won without having to spell a word.\n    \"\"\"\n    r = np.random.rand(len(spellers))\n    out = spellers[r < spellers]\n    if len(out) > 0:\n        return out\n    else:\n        return spellers[-1:]\n\ndef bee(spellers):\n    \"\"\"\n    Run a spelling bee with as many rounds as it takes to eliminate all but one\n    speller.\n    \"\"\"\n    while len(spellers) > 1:\n        spellers = single_round(spellers)\n    return spellers[0]\n\ndef model(spellers, trials):\n    \"\"\"\n    Run any number of spelling bees and return the winner for each one.\n    Results returned as a numpy array.\n    \"\"\"\n    return np.array([bee(spellers) for _ in range(trials)])\n\ndef summary(spellers, trials):\n    \"\"\"\n    Return a dictionary with key=speller, value=wins from the simulated results\n\n    NOTE : the order of \"p\" matters, because the last speller has an advantage\n    each round. However, the results are shown after sorting the array from\n    lowest to highest so that different orders of \"p\" can be compared easily.\n    \"\"\"\n    results = model(spellers, trials)\n    return {x: sum(results == x) / trials for x in np.sort(spellers)}\n\nif __name__ == '__main__':\n\n    # spellers arranged from best to worst\n    spellers = np.arange(99, 89, -1) / 100\n    print(summary(spellers, trials=1000000))\n\n    # spellers arranged from worst to best\n    spellers = np.arange(90, 100) / 100\n    print(summary(spellers, trials=1000000))\n

"},{"title":"Riddler Baseball","date":"Mar 22, 2019","slug":"riddler-baseball","excerpt":"This week's riddler asks us to simulate a game of baseball using rolls of a dice. To solve this problem, we're going to treat the game of Baseball like a markov chain. Under the simplified dice framework, we identify various states of the game, a set of transition probabilities to subsequent states, and associated payoffs (runs scored) when certain states are reached as a result of game events. Using this paradigm, we can simulate innings probabilistically, count the runs scored by each team, and determine the winner.","tags":[],"status":"published","content":"

Introduction

This week's riddler asks us to simulate a game of baseball using rolls of a dice. To solve this problem, we're going to treat the game of Baseball like a markov chain. To borrow an analogy from one of my favorite professors (Hi, Dr. Popescu!), a markov chain is like a frog hopping among lily pads. The frog has what's called a \"current state\" - that is, the lily pad it is currently occupying. The frog also has a random probability of hopping to any of the lily pads around it, including some probability of staying where it is. Once the frog hops to a new lily pad, it might have different probabilities of hopping to other lily pads, and this process continues for as long as we like. However, a key property of this system is that we only need to know the current state of the frog in order to estimate where it will go next. It doesn't matter how the frog got to its current state. It may have taken hundreds of hops or just a single hop to arrive in its current state, but that doesn't affect the frog's likelihood of moving to other lily pads. This simplifies the modeling process because we don't need to keep track of the history of events over time - we just need to know where we are and the probabilities of moving to new states.

Here's the problem we're given. Next, we'll outline the steps to solve it.

\nOver the years, people have invented many games that simulate baseball using two standard dice. In these games, each dice roll corresponds with a baseball event. Two players take turns rolling dice and tracking what happens on the field. Suppose you happen to be an ardent devotee of one of these simulated games from the late 19th century, called Our National Ball Game, which assigns rolls to baseball outcomes like so:\n
\n
1, 1: double
\n
1, 2: single
\n
1, 3: single
\n
... other rolls... we'll examine the full list later
\n
5, 6: triple
\n
6, 6: home run
\n
\n
Given those rules, what’s the average number of runs that would be scored in nine innings of this dice game? What’s the distribution of the number of runs scored? (Histograms welcome.) You can assume some standard baseball things, like runners scoring from second on singles and runners scoring from third on fly outs.
\n

Markov Chain Baseball

Under the simplified dice framework, we can treat the game of baseball like a markov chain that has a current state, a set of transition probabilities to subsequent states, and associated payoffs (runs scored) when certain states are reached. Using this paradigm, we can simulate innings probabilistically, count the runs scored by each team, and determine the winner. Let's walk through exactly how we turn the game of baseball into a markov chain by describing the different components we'll need.

Current state - describes the strike count for the current batter, the number of outs, and the position of any runners on base. A small quirk of this game: we can only roll for strikes (not balls), so we only need to keep track of the current strikes for our batter. For example, each of these is a valid state of the game.\n
- 0 strikes, 0 outs, bases empty (starting state each inning)
- 1 strike, 1 out, runner on first
- 2 strikes, 2 outs, bases loaded ... (bottom of the ninth, game seven... just kidding!)
- Additionally, we define the end of the inning as \"0 strikes, 3 outs, bases empty\". Eventually, every inning will end up here because the probability of staying in this state once we arrive is 100%. In markov chains this is called an \"absorbing state\" because we can never leave once we arrive.
\n
Transition probabilities - we simulate game events by rolling dice. For example, rolling a 1 and a 3 (the order doesn't matter) results in a base hit. If we are currently in a state of \"0 strikes, 0 outs, bases empty\", then we will transition to a new state \"0 strikes, 0 outs, runner on first\". We know that rolling a (1,3) with two dice will occur with probability $\\frac{1}{21}\\approx{4.8}\\%$ . On the other hand, there are four ways to roll a \"strike\", so the probability of moving from \"0 strikes, 0 outs, bases empty\" to \"1 strike, 0 outs, bases empty\" is $\\frac{4}{21}\\approx{19.0}\\%$ . It is impossible to move from \"0 strikes, 0 outs, bases empty\" to \"2 strikes, 0 outs, bases empty\" in a single move, so the probability is zero. In fact, most of the transition probabilities will be zero, because each game state may only transition to at most 11 other states. Here are several other examples:\n
- Dice roll (3,1): move from \"0 strikes, 0 outs, bases empty\" to \"0 strikes, 0 outs, runner on first\"
- Dice roll (1,3): move from \"2 strikes, 2 outs, runner on first\" to \"0 strikes, 2 outs, runners on first and third\" (because the runner on first is typically able to make it to third on a base hit.)
- Dice roll (1,3): move from \"1 strike, 1 out, runner on second\" to \"0 strikes, 1 out, bases empty\" (and we increase the run tally by one, because the runner scored from second on the base hit.)
\n
Rewards - certain game events score runs for the batting team. We track these runs (typically called \"rewards\" in the markov chain world), and add them up as we go from state to state. For example, if we move from a state of \"0 strikes, 0 outs, bases empty\" to \"0 strikes, 0 outs, bases empty\", it means we rolled a (6,6), and hit a home run. (In fact this is one of the rare cases where we stay in the same state, even though we increase the run count by one. Most other actions move us from one state to a different state.) Therefore, the reward for rolling a (6,6) from the initial state is +1. Here are some other examples:\n
- Dice roll (1,3): move from \"2 strikes, 2 outs, runner on first\" to \"0 strikes, 2 outs, runners on first and third\", no increase in runs.
- Dice roll (1,3): move from \"1 strike, 1 out, runner on second\" to \"0 strikes, 1 out, bases empty\". Reward of +1 for the single runner that scored.
- Dice roll (6,6): move from \"0 strikes, 2 outs, bases loaded\" to \"0 strikes, 2 outs, bases empty\". Reward of +4 because this was a grand slam.
\n

Now that we have the tools to describe our game, we need to specify all possible states, all possible transitions between states, and the rewards associated with each move. We'll use python to do the heavy lifting. The full code can be found at the bottom of this article.

Creating States

We can simplify the task of creating all states by taking advantage of independence among state components. For example, runners on base is independent from the number of strikes and the number of outs. Therefore, we can generate the possibilities separately and combine them for the overall list. There are three possibilities for strikes on an active batter: 0, 1, or 2. (We don't need the number 3 because if a batter has three strikes, then the next batter is up and we instantly reset to 0.) We also have three possibilities for the number of outs in an active inning: 0, 1, or 2, for the same reason as before. However, we do create a special state with 3 outs to signal the end of the inning. Next, we identify all the possibilities of bases that could be occupied: single runners on first, second, or third, runners on first and second, first and third, second and third, and bases loaded. We can express the runners as a tuple of three integers, where 1 means a base is occupied and 0 means it is empty. For example (0,0,0) is bases empty, (0,1,0) means a runner on second, and (1,1,1) means bases loaded. Once we generate each set of possibilities for strikes, outs, and runners, we can use python to assemble all the unique combinations, which results in a list of length $3\\times8\\times3+1=73$ .

To represent the current state, we need a data structure that has an attribute for strikes, outs, and runners. We can use the namedtuple data structure as an easy way to store this data. The code snipped below creates this class and instantiates a single instance representing 0 strikes, 1 out, and runners on first and third.

# create the \"Inning\" class and instantiate a single instance\nInning = namedtuple('Inning', ['strikes', 'outs', 'runners'])\nsample_state = Inning(0, 1, (1,0,1))\n

Calculating Transition Probabilities

This next part involves some manual work and a bit of baseball assumption-making. The objective is to identify all the ways that we can move from one state to another. If each state could transition to each other state, we would need to calculate $72\\times72=5184$ probabilities, which would be a tedious task. Instead, we can simplify this number substantially. For example, we know that it's impossible to go directly from 0 strikes to 2 strikes, or from bases empty to bases loaded in a single step. Therefore, many of the transition probabilities between states will be zero, which simplifies our task.

Another benefit of our dice game is that we don't have to deal with complicated probabilities. There are 21 unique combinations of two dice, and each combination is equally likely. Furthermore, several of the outcomes from unique dice rolls are the same (\"strike\", \"out at first\", etc.) As a result, each state has at most 11 potential moves to another state. Let's write them out with their effect on the game and the probability (out of 21).

\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n

Game Action	Number of Rolls	State Outcome
Strike	4	Increase strike count (also handle strikeouts and outs when necessary)
Out at first	4	Runners advance by one; runner on third scores (unless it's the third out); `out+=1`
Fly out	3	Runner on third scores (unless it's the third out); `out+=1`
Single	3	Runners on base advance by two; batter moves to first
Foul out	1	Runners stay where they are; `out+=1`
Double play	1	If nobody is on base, treat as a single out; otherwise tag out the most advanced two runners
Base on error	1	All runners advance a single base only
Walk	1	Batter advances to first; runners advance only if forced
Double	1	Everyone on base scores; batter advances to second base
Triple	1	Everyone on base scores; batter advances to third base
Home run	1	Everyone on base plus the batter scores

\n\n

Coding the Game Actions in Python

Now we need to encode how a given state will change as the results of a game action. We'll need 11 functions - one for each game action - that take a starting state as input and return the ending state and any runs that may have occurred as a result. Here's an example of one of these functions, that describes what happens when there's a \"fly out\". In this case, we assume a runner on third is able to score (called \"tagging up\"), but only if the pop fly is the first or second out. If it's the third out, the inning ends without the run counting. As I mentioned above, there is some subjectivity in the outcomes of each game event, and that's part of the fun of this problem!

Also note that the function below takes a single input: the game state, but returns two results: the subsequent game state and the number of runs that were scored. In this way, we can track the game state as it changes, and keep a running total of runs as they occur during the inning. You can find the other 10 game action functions below in the code.

def fly_out(inning):\n    \"\"\"\n    Update the inning for a fly out\n        * runner on third scores unless it's the third out\n    \"\"\"\n    outs = inning.outs + 1\n\n    if inning.runners == (0,0,1): runners, runs = (0,0,0), 1\n    elif inning.runners == (1,0,1): runners, runs = (1,0,0), 1\n    elif inning.runners == (0,1,1): runners, runs = (0,1,0), 1\n    elif inning.runners == (1,1,1): runners, runs = (1,1,0), 1\n    else: runners, runs = inning.runners, 0\n\n    if outs > 2:\n        return  Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(0, outs, runners), runs\n

Running a Single-Inning Simulation

Now we have all the tools we need to track the state of our game, the likelihood of moving to new states, and the rewards associated with certain actions. All innings start with 0 strikes, 0 outs, and bases empty: Inning(0, 0, (0,0,0)). From the starting state, we simulate dice rolls and play the game, updating the game state and tracking runs as we go. Here's a python function that plays a single inning and prints a summary of what happens. Note that the results are randomly generated according to the weighted probabilities described above, so the results will change every time it's run.

def single_inning(verbose=True):\n    \"\"\"\n    Simulate a single inning until three outs are recorded. Return the number\n    of runs scored during the inning. If verbose=True, print a \"play-by-play\"\n    summary of the inning for each action. If verbose=False, just return runs\n    \"\"\"\n    state, score = Inning(0, 0, (0,0,0)), 0\n    while state.outs < 3:\n        action = np.random.choice(ACTIONS, p=WEIGHTS)\n        state, runs = globals()[action](state)\n        score += runs\n        if verbose:\n            print(f'{action:15}: {state}, {score} total runs scored')\n    return score\n\n# sample output\n# -------------\n# single         : Inning(strikes=0, outs=0, runners=(1, 0, 0)), 0 total runs scored\n# strike         : Inning(strikes=1, outs=0, runners=(1, 0, 0)), 0 total runs scored\n# base_on_error  : Inning(strikes=0, outs=0, runners=(1, 1, 0)), 0 total runs scored\n# triple         : Inning(strikes=0, outs=0, runners=(0, 0, 1)), 2 total runs scored\n# strike         : Inning(strikes=1, outs=0, runners=(0, 0, 1)), 2 total runs scored\n# double         : Inning(strikes=0, outs=0, runners=(0, 1, 0)), 3 total runs scored\n# single         : Inning(strikes=0, outs=0, runners=(1, 0, 0)), 4 total runs scored\n# fly_out        : Inning(strikes=0, outs=1, runners=(1, 0, 0)), 4 total runs scored\n# base_on_error  : Inning(strikes=0, outs=1, runners=(1, 1, 0)), 4 total runs scored\n# double_play    : Inning(strikes=0, outs=3, runners=(0, 0, 0)), 4 total runs scored\n

Conclusion: Answering the Question

\n
... what’s the average number of runs that would be scored in nine innings of this dice game? What’s the distribution of the number of runs scored?
\n

Now that we can simulate a single inning, we can answer the question by repeating our simulation a large number of times to estimate the long-term distribution of runs scored. Fortunately, each inning is independent (at least in our dice game - no momentum or slumps to worry about). Therefore, if we accurately simulate a single inning, we can accurately simulate a single game by multiplying by nine.

Perhaps the truly detail-oriented among you may note that this answer isn't entirely correct because it precludes the possibility of extra innings. There is a small probability that both teams score the same number of runs after nine innings. If that happened, they would continue playing one inning at a time until one team wins. I may save this small addendum for a separate update later.

def simulate_innings(trials):\n    \"\"\"Simulate a large number of innings and return the total runs scored\"\"\"\n    return np.array([single_inning(verbose=False) for _ in range(trials)])\n\n# sample output of 1 million innings\n# ----------------------------------\n>>> results = simulate_innings(1000000).mean()\n1.611836\n

Ignoring the small possibility of ties and extra innings, we see that the expected number of runs per inning is roughly 1.61, which means the expected number of runs per nine-inning game is roughly 14.5. According to sportingcharts.com the actual total score of MLB games from 1990 to 2016 hovered between 8-10, which means each team scored between 4 and 5 runs. Our dice game certainly gives the advantage to the sluggers!

What's also interesting is that these results allow us to track not only the average number of runs scored per inning, but the full distribution: how many goose eggs (roughly 40% of the time) vs. quadruple-grand-slams (the highest inning recorded 22 runs). These results are best viewed as a histogram showing exactly how many simulated innings ended up with a given number of runs, which you can see below.

Reference: Full Python Code

\"\"\"\nSolves the fivethirtyeight Riddler problem from March 22, 2019\n\nEach inning is represented by an object called \"Inning\", that is comprised of\nstrikes, outs, and runner positions, e.g. Inning(0, 1, (0,1,0)) for 0 strikes,\n1 out, and a runner on second base.\n\nThere are 11 unique game actions that can occur. Each is represented by a\nfunction that takes an inning state as input and returns a tuple of the new\ninning state after the action and the number of runs that were scored as a\nresult of the action.\n\"\"\"\nimport numpy as np\nfrom collections import namedtuple\n\n\n# define a container for the current state of an inning\nInning = namedtuple('Inning', ['strikes', 'outs', 'runners'])\n\n# all possible game actions, handled with functions below\n__actions__ = [\n    ('strike', 4),\n    ('out_at_first', 4),\n    ('fly_out', 3),\n    ('single', 3),\n    ('base_on_error', 1),\n    ('double', 1),\n    ('double_play', 1),\n    ('foul_out', 1),\n    ('homerun', 1),\n    ('triple', 1),\n    ('walk', 1)\n]\nACTIONS = [a[0] for a in __actions__]\nWEIGHTS = [float(a[1]) for a in __actions__]\nWEIGHTS = [w / sum(WEIGHTS) for w in WEIGHTS]\n\ndef single_inning(verbose=True):\n    \"\"\"\n    Simulate a single inning until three outs are recorded. Return the number\n    of runs scored during the inning. If verbose=True, print a \"play-by-play\"\n    summary of the inning for each action. If verbose=False, just return runs\n    \"\"\"\n    state, score = Inning(0, 0, (0,0,0)), 0\n    while state.outs < 3:\n        action = np.random.choice(ACTIONS, p=WEIGHTS)\n        state, runs = globals()[action](state)\n        score += runs\n        if verbose:\n            print(f'{action:15}: {state}, {score} total runs scored')\n    return score\n\ndef simulate_innings(trials):\n    \"\"\"Simulate a large number of innings and return the total runs scored\"\"\"\n    return np.array([single_inning(verbose=False) for _ in range(trials)])\n\ndef base_on_error(inning):\n    \"\"\"\n    Update the inning for a base on error\n        * batter and runners advance one base each\n    \"\"\"\n    if inning.runners == (0,0,0): runners, runs = (1,0,0), 0\n    elif inning.runners == (1,0,0): runners, runs = (1,1,0), 0\n    elif inning.runners == (0,1,0): runners, runs = (1,0,1), 0\n    elif inning.runners == (0,0,1): runners, runs = (1,0,0), 1\n    elif inning.runners == (1,1,0): runners, runs = (1,1,1), 0\n    elif inning.runners == (1,0,1): runners, runs = (1,1,0), 1\n    elif inning.runners == (0,1,1): runners, runs = (1,0,1), 1\n    elif inning.runners == (1,1,1): runners, runs = (1,1,1), 1\n    return Inning(0, inning.outs, runners), runs\n\ndef double(inning):\n    \"\"\"\n    Update the inning for a double\n        * all runners score; batter advances to second\n        NOTE: in reality about 50% of runners on first score on a double\n    \"\"\"\n    return Inning(0, inning.outs, (0,1,0)), sum(inning.runners)\n\ndef double_play(inning):\n    \"\"\"\n    Update the inning for a double play\n        * if the bases are empty this is treated like a single out; otherwise\n        it's assumed the two runners farthest advanced are picked off.\n    \"\"\"\n    if inning.runners == (0,0,0):\n        # only one out available\n        runners = (0,0,0)\n        outs = inning.outs + 1\n    if inning.runners in [(1,0,0), (0,1,0), (0,0,1)]:\n        runners = (0,0,0)\n        outs = inning.outs + 2\n    elif inning.runners in [(1,1,0), (1,0,1), (0,1,1)]:\n        runners = (1,0,0)\n        outs = inning.outs + 2\n    elif inning.runners == (1,1,1):\n        runners = (1,1,0)\n        outs = inning.outs + 2\n    else:\n        runners = (0,0,0)\n    if outs > 2:\n        return  Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(0, outs, runners), 0\n\ndef fly_out(inning):\n    \"\"\"\n    Update the inning for a fly out\n        * runner on third scores unless it's the third out\n    \"\"\"\n    outs = inning.outs + 1\n\n    if inning.runners == (0,0,1): runners, runs = (0,0,0), 1\n    elif inning.runners == (1,0,1): runners, runs = (1,0,0), 1\n    elif inning.runners == (0,1,1): runners, runs = (0,1,0), 1\n    elif inning.runners == (1,1,1): runners, runs = (1,1,0), 1\n    else: runners, runs = inning.runners, 0\n\n    if outs > 2:\n        return  Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(0, outs, runners), runs\n\ndef foul_out(inning):\n    \"\"\"\n    Update the inning for a foul out\n        * runners stay where they are\n    \"\"\"\n    if inning.outs > 1:\n        return Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(0, inning.outs + 1, inning.runners), 0\n\ndef out_at_first(inning):\n    \"\"\"\n    Update the inning for an out at first\n        * runners advance one base\n    \"\"\"\n    outs = inning.outs + 1\n\n    if inning.runners == (0,0,0): runners, runs = (0,0,0), 0\n    elif inning.runners == (1,0,0): runners, runs = (0,1,0), 0\n    elif inning.runners == (0,1,0): runners, runs = (0,0,1), 0\n    elif inning.runners == (0,0,1): runners, runs = (0,0,0), 1\n    elif inning.runners == (1,1,0): runners, runs = (0,1,1), 0\n    elif inning.runners == (1,0,1): runners, runs = (0,1,0), 1\n    elif inning.runners == (0,1,1): runners, runs = (0,0,1), 1\n    elif inning.runners == (1,1,1): runners, runs = (0,1,1), 1\n\n    if outs > 2:\n        return  Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(0, outs, runners), runs\n\ndef single(inning):\n    \"\"\"\n    Update the inning for a single\n        * runners advance two bases; batter advances to first\n    \"\"\"\n    if inning.runners == (0,0,0): runners, runs = (1,0,0), 0\n    elif inning.runners == (1,0,0): runners, runs = (1,0,1), 0\n    elif inning.runners == (0,1,0): runners, runs = (1,0,0), 1\n    elif inning.runners == (0,0,1): runners, runs = (1,0,0), 1\n    elif inning.runners == (1,1,0): runners, runs = (1,0,1), 1\n    elif inning.runners == (1,0,1): runners, runs = (1,0,1), 1\n    elif inning.runners == (0,1,1): runners, runs = (1,0,0), 2\n    elif inning.runners == (1,1,1): runners, runs = (1,0,1), 2\n    return Inning(0, inning.outs, runners), runs\n\ndef strike(inning):\n    \"\"\"\n    Update the inning state for a strike\n    Returns a new Inning object and the number of runs scored\n    \"\"\"\n    strikes = inning.strikes + 1\n    if strikes > 2:\n        strikes, outs = 0, inning.outs + 1\n        if outs < 3:\n            return Inning(strikes, outs, inning.runners), 0\n        else:\n            return Inning(0, 3, (0,0,0)), 0\n    else:\n        return Inning(strikes, inning.outs, inning.runners), 0\n\ndef triple(inning):\n    \"\"\"\n    Update the inning for a triple\n        * all runners score; batter advances to third\n    \"\"\"\n    return Inning(0, inning.outs, (0,0,1)), sum(inning.runners)\n\ndef homerun(inning):\n    \"\"\"\n    Update the inning for a triple\n        * all runners and the batter score\n    \"\"\"\n    return Inning(0, inning.outs, (0,0,0)), sum(inning.runners) + 1\n\ndef walk(inning):\n    \"\"\"\n    Update the inning for a walk\n        * batter advances to first; runners advance if forced\n    \"\"\"\n    if inning.runners == (0,0,0):\n        runners, runs = (1,0,0), 0\n    elif inning.runners in [(1,0,0), (0,1,0)]:\n        runners, runs = (1,1,0), 0\n    elif inning.runners == (0,0,1):\n        runners, runs = (1,0,1), 0\n    elif inning.runners in [(1,1,0), (1,0,1), (0,1,1)]:\n        runners, runs = (1,1,1), 0\n    elif inning.runners == (1,1,1):\n        runners, runs = (1,1,1), 1\n    return Inning(0, inning.outs, runners), runs\n\n\nif __name__ == '__main__':\n    trials = 1000000\n    results = simulate_innings(trials)\n    print(f'Average score from {trials:,.0f} innings: {results.mean():,.2f}')\n

"},{"title":"Riddler Card Collecting","date":"Mar 1, 2019","slug":"riddler-card-collecting","excerpt":"The Riddler Express this week asks us about collecting sets of cards. In particular, we're interested in collecting a complete set of 144 unique cards. We purchase one random card at a time for $5 each. How many purchases should we expect to make - and how much money should we expect to spend - in order to collect at least one of every card?","tags":[],"status":"published","content":"

Introduction

The Riddler Express this week asks us about collecting sets of cards. In particular, we're interested in collecting a complete set of 144 unique cards. We purchase one random card at a time for $5 each. How many purchases should we expect to make - and how much money should we expect to spend - in order to collect at least one of every card?

This problem can be approached in two ways: analytically, in which we develop and solve a formula to arrive at an exact answer, and via simulation, in which we model the card collecting process over a large number of trials in order to learn about the true distribution of results. Let's walk through each method below.

Analytical Solution

We can model this problem as a set of \"states\" and likelihoods of moving between those states. Each state tells us how many cards we've collected. For example, we begin in a state of \"0 cards\". Then we move to a state of \"1 card\" after we purchase our first one. It doesn't matter which card we get, because we know it will be unique. In order to transition to a state of \"2 cards\", we need to buy another pack and see a card we don't already own. Because there are 143 unique cards remaining out of the total set of 144, our odds of transitioning from \"1 card\" to \"2 cards\" are $\\frac{143}{144}$ . On the other hand, our odds of staying in a state of \"1 card\" are $\\frac{1}{144}$ , because there is a small chance that we receive the exact card we already have.

After this process continues for some time, we will arrive in a state of \"143 cards\" - we've collected all but one of the total cards, and we need one last card to complete our collection. Each new pack we purchase has a $\\frac{1}{144}$ chance of giving us the card we're seeking, and a $\\frac{143}{144}$ chance of remaining in a state of \"143 cards\".

We can define every possible state and all possible transition probabilities in a transition matrix. The transition matrix specifies the state we're currently in on the vertical axis, and the states we could move into on the horizontal axis. Here's one way to create this matrix in python.

import numpy as np\n\ndef transition_matrix(n_cards=144):\n    \"\"\"\n    Create the transition matrix for any number of cards,\n    where the default is 144 (taken from the problem).\n\n    The matrix is all zeros except for the main diagonal and\n    the upper diagonal, which are the probabilities of moving\n    from one state to the next. All rows will sum to 1.0\n    \"\"\"\n    # create the matrix, initialized with all zeros\n    M = np.zeros(shape=(n_cards+1, n_cards+1), dtype=np.float64)\n\n    # set the first off-diagonal elements, decreasing from 1 -> 0\n    # this is the probability of finding a new card\n    idx = np.diag_indices(n_cards)\n    M[:-1, 1:][idx] = np.arange(n_cards, 0, -1) / n_cards\n\n    # set the diagonal elements, increasing from 0 -> 1\n    # this is the probability of finding a card we already have\n    idx = np.diag_indices(n_cards+1)\n    M[idx] = np.arange(n_cards+1) / n_cards\n\n    # confirm we have a valid transition matrix where rows sum to 1.0\n    assert M.sum(1).all() == 1.0\n    return M\n

One nice feature of the transition_matrix function is that we can create matrices of any size, representing any number of unique cards. For example, we can generate the matrix for a set of five cards below.

>>> transition_matrix(5)\narray([[0. , 1. , 0. , 0. , 0. , 0. ],\n       [0. , 0.2, 0.8, 0. , 0. , 0. ],\n       [0. , 0. , 0.4, 0.6, 0. , 0. ],\n       [0. , 0. , 0. , 0.6, 0.4, 0. ],\n       [0. , 0. , 0. , 0. , 0.8, 0.2],\n       [0. , 0. , 0. , 0. , 0. , 1. ]])\n

Each row represents the starting state of owning a number of cards, starting with zero at the top and moving to five at the bottom. Each column represents the ending state, also from zero to five, left to right. For example, we see a probability of 100% that we move from a state of zero (first row) to a state of one (second column), where we see the number \"1\". We also see a probability of 20% that we move from a state of four cards (second-to-last row) to five cards (last column). Finally, if we start in a state of five cards (last row), we see that we're always going to end up in the same state. This is called an absorbing state because it is impossible for us to move anywhere else once we end up here.

Transition matrices like these have a fascinating property that lets us calculate the amount of time it takes to move from one state to another. We subtract the non-absorbing subset of our matrix, which is every row and column except for the last ones, from the identity matrix, take the inverse, and we have our answer! Here's what it looks like for our simplified five-card set.

>>> np.linalg.inv(np.eye(5) - transition_matrix(5)[:-1, :-1]).sum(1)\narray([11.41666667, 10.41666667,  9.16666667,  7.5       ,  5.        ])\n

Each number in this array represents the time it takes to reach the absorbing state (where we have collected the entire set.) The array has the same length as the total number of cards. The first entry, 11.416, represents the time it takes to move from \"0 cards\" to \"5 cards\". The second entry, 10.416, represents the time it takes to move from \"1 card\" to \"5 cards\".

Now, to solve this week's riddler, all we have to do is apply the same logic to our full set of 144 cards. We're interested in the first entry in the array, which tells us how many cards we expect to see before we've collected every unique one.

>>> n_cards = 144\n>>> np.linalg.inv(np.eye(n_cards) - transition_matrix(n_cards)[:-1, :-1]).sum(1)\narray([799.27159218, 798.27159218, 797.26459918, 796.25051467, ... ])\n

We see that it takes an expected 799.27 random cards before we collect each of the 144 unique cards! At 5 dollars each, this means we have to spend roughly $3996 in order to collect the entire set.

Simulated Solution

Another way to solve this problem is to model the card collecting process and count the number of steps required to complete the set. However, because the process is random, every time we model it we will get a different answer. On the other hand, if we model the process a large number of times, say one million, then we would expect the average result to converge to the true result.

Here is the short python function that generates random trials. We run the function with a large number of trials to observe the distribution of results.

import numpy as np\nfrom random import randint\n\ndef model(trials, n_cards=144, price=5):\n    \"\"\"\n    Solve the riddler express via simulation: collecting cards, and\n    counting the number of steps required to collect the entire set\n    \"\"\"\n    for _ in range(trials):\n        i, collected = 0, set()\n        while len(collected) < n_cards:\n            collected.add(randint(1, n_cards))\n            i += 1\n        yield i * price\n\ntrials = 1000000\nresults = np.array(list(model(trials)))\n\n# print the average result\nprint(results.mean())\n# 3995.78149\n

Good news! Our simulated result is very close to our analytical result above, at roughly $3996. The simulation also gives us information about the full distribution of results as well. For example, while it is theortically possible to collect 144 unique cards by drawing 144 unique cards in a row, the odds are extremely slim. What was the lowest cost from our simulation? What was the highest? This can all be seen by analyzing the results directly, or visualized as a density plot, which shows how likely it is that we would pay a certain amount to collect the full set of cards.

>>> results.min()\n1795\n\n>>> results.max()\n13725\n

You'll notice in the chart that the most likely amount we'll pay to assemble the entire set is around 3500. However, the average amount we expect to pay is around 4000. Why are the numbers different? The average amount includes those tail scenarios where it takes us nearly 10,000 to collect the entire set, which moves it higher than the single most likely amount we would expect to pay. This is part of the reason why seeing the entire distribution, rather than just a single metric like the average, can be helpful in understanding the problem.

"},{"title":"Autograd and Taylor Series","date":"Jan 13, 2019","slug":"autograd-taylor-series","excerpt":"I've learned that there are many automatic differentiation libraries in the Python ecosystem. Often these libraries are also machine learning libraries, where automatic differentiation serves as a means to an end - for example in optimizing model parameters in a neural network. However, the autograd library might be one of the purest, \"simplest\" (relatively speaking) options out there. Its goal is to efficiently compute derivatives of numpy code, and its API is as close to numpy as possible. This means it's easy to get started right away if you're comfortable using numpy. In particular autograd claims to be able to differentiate as many times as one likes, and I thought a great way to test this would be to apply the Taylor Series approximation to some interesting functions.","tags":[],"status":"published","content":"

I've learned that there are many automatic differentiation libraries in the Python ecosystem. Often these libraries are also machine learning libraries, where automatic differentiation serves as a means to an end - for example in optimizing model parameters in a neural network. However, the autograd library might be one of the purest, \"simplest\" (relatively speaking) options out there. Its goal is to efficiently compute derivatives of numpy code, and its API is as close to numpy as possible. This means it's easy to get started right away if you're comfortable using numpy. In particular autograd claims to be able to differentiate as many times as one likes, and I thought a great way to test this would be to apply the Taylor Series approximation to some interesting functions.

Implementing Taylor Series using autograd

The Taylor Series is a way of approximating smooth curves using polynomials. Often, evaluating polynomials is much simpler than evaluating the smooth curves themselves. Technically speaking, the Taylor Series is an infinite sum of polynomial terms, but we typically gather a finite number of terms based on the desired accuracy of our approximation. The more terms we use, the better our approximation becomes. Here is the formula for the infinite series:

f(x) = \\sum_{n=0}^{\\infty} \\frac{f^{(n)}(a)}{n!}(x - a)^n

In python, using the autograd library, it is fairly straightforward to implement the Taylor Series up to a given degree. The subtle trick is to import autograd's numpy package, which has differentiable versions of most numpy functions. From there, we can use elementwise_grad to differentiate a function with respect to an array.

The taylor_expansion function below defines a sub-function, t, which represents the nth term of the Taylor Series expansion. By adding terms from degree 0 to the desired degree, eventually we end up with the Taylor Series curve we want.

import autograd.numpy as np\nfrom autograd import elementwise_grad as egrad\nfrom math import factorial\n\n\ndef taylor_expansion(f, a, x, degree):\n    \"\"\"\n    Return the taylor expansion of the function \"f\" with a given degree at point \"a\"\n    f(x) = f(a) + f'(a)*(x - a)**1/1! + f'(a)*(x - a)**2/2! + f'''(a)*(x - a)**3/3! + ...\n\n    Examples\n    --------\n    >>> f, a, x, degree = np.tanh, 0.5, np.linspace(-3, 3, 10000), 5\n    >>> taylor_expansion(f, a, x, degree)\n    array([36.30578455, 36.27651122, 36.24725546, ...,  2.45649329,\n        2.45779953,  2.45910638])\n    \"\"\"\n    t = lambda f, a, x, d: f(a) * (x - a)**d / factorial(d)\n\n    out = 0.0\n    for d in range(degree + 1):\n        out += t(f, a, x, d)\n        f = egrad(f)\n    return out\n

Examples

For example, suppose we have some function, $f$ . We know the function's value at a point, $x$ , and we know the derivative of $f$ at $x$ , which gives us the tangent line. We might approximate the value of $f(x + dx)$ using the tangent line, which is a Taylor Series with degree one. However, this approximation usually worsens as we move farther and farther from our original point. The Taylor Series incorporates derivatives upon derivatives of the original function, $f$ , in order to improve the approximation at points far from our original $x$ . This can be useful if our original function is costly to evaluate.

Here's another example. As an actuary, I'm often interested in testing the sensitivity of financial projections with respect to model inputs. Interest rates, lapse rates, mortality rates, and other inputs all play a role in determining the premium that should be charged for a given insurance product. Sometimes these models can be complex and time consuming to run. But if I can evaluate the function once to get $f(x)$ , and compute several derivatives, $f'(x)$ , $f''(x)$ , $f'''(x)$ , ..., then I can create a Taylor Series approximation of my model, which I could use to estimate how premium would change if my inputs changed.

Hyperbolic tangent function

The hyperbolic tangent function is sometimes used in neural networks to classify a training example between two options, say, \"dog\" vs. \"cat\". Its value falls between -1 and 1. We know the formula for this function, so we could easily calculate its true value at any point, but lets use a couple different Taylor Series approximations to see how well they perform.

This first example shows a fourth degree function, meaning we use up to the fourth derivative of our original function. We evaluate the Taylor Series at the point $f(0.5)$ , and it looks like we could use our new function to estimate points from roughly zero to 1.5. This is the section of the chart where both lines are nearly on top of one another. Note that I intentionally hid most axis ticks and lines in an effort to emphasize the function lines themselves.

\n $\"taylor$ \n

On the other hand, perhaps we can increase our accuracy if we use a Taylor Series with degree 6. This time we'll evaluate at a different point, $f(-1.0)$ . Here it looks as if our results are pretty good from -2 through 0, which is perhaps a slightly larger range than we had for our polynomial of degree 4.

\n $\"taylor$ \n

I think it is interesting to see how the Taylor Series polynomial changes as we change the degree and incorporate more and more derivatives of our original function. The table below shows the same original function with Taylor Series polynomials of increasing degree from 0 through 7.

Note that with degree 0 our guess for any point on the function is equal to $f(a)$ , which is hardly reasonable. When we use the tangent line our guesses are good for regions close to $a$ , but we quickly improve our approximation by using Series with degree 4 or higher.

\n $\"taylor$ \n

Other functions

Here is the same set of charts for a few other functions: $sin(x)$ , $e^x$ , and $\\sqrt{x}$ , with $a = 1$ . Most of the fits are excellent when degree is above 5. However, note how the Taylor Series polynomial flips up and down repeatedly as it struggles to converge for $\\sqrt{x}$ . This illustrates a key result for Taylor Series - that it is not always possible to extrapolate indefinitely along the curve from all points.

$sin(x)$

\n $\"taylor$ \n

$e^x$

\n $\"taylor$ \n

$\\sqrt{x}$

\n $\"taylor$ \n

Conclusions

I enjoyed using autograd for this article. I use numpy all the time, and it's great to be able to differentiate most of my numpy code simply by changing import numpy as np to import autograd.numpy as np. It feels like a pure approach to automatic differentiation compared to other machine learning languages where subtle changes in syntax can often slow down the development process. Furthermore, I'm impressed with the ability to differentiate functions an arbitrary number of times to create whichever degree Taylor Series I'm interested in. It's really as simple as calling grad!

I'm looking forward to using autograd for more complicated models. As I mentioned before, I'm particularly interested in applying automatic differentiation to actuarial work, where I think it could have a big impact on understanding complex insurance products. Feel free to contact me if this is something that interests you too - I'd love to connect.

"},{"title":"Riddler Elves","date":"Dec 21, 2018","slug":"riddler-elves","excerpt":"This week's holiday Riddler is a twist on the classic \"birthday problem\". The birthday problem asks us to calculate the probability that at least two people at a party have the same birthday. Most people hearing this problem for the first time are surprised at how few people you need - roughly 23 people results in 50% odds of finding at least one pair of birthdays! For this problem, we're interested in calculating how likely we are to hear the same song more than once from a shuffled playlist. Moreover, what can we infer about the size of the playlist, given that we hear repeats roughly half the time?","tags":[],"status":"published","content":"

Introduction

This week's holiday Riddler is a twist on the classic \"birthday problem\". The birthday problem asks us to calculate the probability that at least two people at a party have the same birthday. Most people hearing this problem for the first time are surprised at how few people you need - roughly 23 people results in 50% odds of finding at least one pair of birthdays! For this problem, we're interested in calculating how likely we are to hear the same song more than once from a shuffled playlist. Moreover, what can we infer about the size of the playlist, given that we hear repeats roughly half the time? Here is the exact problem we'll solve.

\nIn Santa’s workshop, elves make toys during a shift each day. On the overhead radio, Christmas music plays, with a program randomly selecting songs from a large playlist.\n
During any given shift, the elves hear 100 songs. A cranky elf named Cranky has taken to throwing snowballs at everyone if he hears the same song twice. This has happened during about half of the shifts. One day, a mathematically inclined elf named Mathy tires of Cranky’s sodden outbursts. So Mathy decides to use what he knows to figure out how large Santa’s playlist actually is.
\n
Help Mathy out: How large is Santa’s playlist?
\n

The Birthday Problem

The birthday problem is usually described like this: suppose you attend a party with $n$ total people, including yourself. What value of $n$ gives a 50% chance that at least two people share a birthday?

Often in questions of probability it helps to calculate the odds of the event we're not interested in, and then we find the probability we care about by the property of complementarity. We can do this, because there are only two options: either there are no shared birthdays at all, or there are at least two shared birthdays. Therefore, the probability of one outcome is one minus the probability of the other outcome. As a result, we will calculate the probability that nobody in the room shares a birthday, then subtract that value from one for the answer we really want.

In a group of two people, the probability of distinct birthdays is $\\frac{364}{365}$ . In other words, we only need to calculate the probability that the second person has any other birthday than the first person. In a group of three people, we need to check that the third person has a different birthday than the first person and the second person, so we get $\\frac{364}{365}\\times\\frac{363}{365}$ . We can continue this pattern for any number of people, and we get the following formula for a group of size $n$ :

\\frac{1}{365^n}\\times(365\\times364\\times363\\times...\\times(365-n+1))

Most people are surprised to learn that a group of 23 people has a 49.3% chance of all unique birthdays, or a 50.7% chance of at least one shared birthday. Fortunately, we can use the same framework to solve the Riddler.

Solution

Now we have a general purpose formula for the odds of picking $n$ unique elements from a group of size $k$ . In the birthday problem we are given $k=365$ and asked to solve for $n$ such that the outcome is 50%. This week's Riddler asks us a related question, where we are given $n=100$ and asked to solve for $k$ such that the outcome is 50%. Therefore we want to solve:

0.50 = \\frac{1}{k^{100}}\\times(k\\times(k-1)\\times(k-2)\\times...\\times(k-100+1))

Fortunately, we can delegate the computation to Python and quickly solve for any value of $k$ .

import numpy as np\n\ndef model(songs_heard, playlist_size):\n    \"\"\"\n    Returns the probability of hearing a repeat song, given\n    a number of \"songs_heard\" and a total \"playlist_size\"\n    \"\"\"\n    if songs_heard >= playlist_size:\n        return 1.\n    else:\n        s = np.arange(playlist_size - songs_heard + 1, playlist_size + 1) / playlist_size\n        return 1 - s.prod()\n\n# birthday problem\n>>> model(23, 365)\n0.5072972343239853\n\n# riddler example\n>>> model(100, 7500)\n0.48466504008664024\n

For $n=100$ and $k=7500$ , we expect to hear repeated songs 48.5% of the time. Therefore, we know that the actual playlist should have fewer than 7500 songs. (When we lower the number of total songs available, the probability of hearing the same song repeated goes up.) After a few trials, we find the following:

>>> model(100, 7175)\n0.4999798251579207\n\n>>> python(100, 7174)\n0.5000283570392747\n

If the playlist has 7175 songs in it and we listen to 100 randomly chosen songs, we'd expect to hear repeats 50% of the time. It's unclear if Cranky is accurate in his measurements out to the hundred-thousandths place, but the playlist with 7175 songs is the closest value to 50%, so that seems reasonable. Therefore, we conclude that Santa's playlist has 7175 songs in it.

The chart below plots the expected probability of hearing a repeat for various playlist sizes.

"},{"title":"Pricing Exotic Options in PyTorch","date":"Dec 13, 2018","slug":"pytorch-exotic-options","excerpt":"As a follow up to my prior article on Black-Scholes in PyTorch, I wanted to explore more complex applications of automatic differentiation. As I showed before, automatic differentiation can be used to calculate the sensitivities, or \"greeks\", of a stock option, even if we use monte carlo techniques to calculate option price. Many exotic options can only be priced using monte carlo techniques, so automatic differentiation may be able to provide more accurate sensitivities in less time than traditional methods.","tags":[],"status":"published","content":"

As a follow up to my prior article on Black-Scholes in PyTorch, I wanted to explore more complex applications of automatic differentiation. As I showed before, automatic differentiation can be used to calculate the sensitivities, or \"greeks\", of a stock option, even if we use monte carlo techniques to calculate option price. As it turns out, many exotic options can only be priced using monte carlo methods. Many exotic options are \"path dependent\", meaning their payoff depends not only on the final price of the underlying but also the behavior of the underlying throughout the time period. This often makes it impossible to use closed-form equations to calculate their price.

The traditional approach to value these options is to generate thousands of scenarios of stock prices and calculate the option payoff under each scenario. This is the essence of the monte carlo simulation. Often, to calculate option greeks, we re-run the monte carlo simulation several times with small differences in model inputs to see how the price changes. This process can be time-consuming when the number of inputs is large, or when the model is computationally intensive. Automatic differentiation may be able to provide more accurate sensitivities in less time than traditional methods.

In this article, I'll price five different exotic options contracts and use automatic differentiation to calculate the option greeks. I'll illustrate a few interesting scenarios from the thousands of monte carlo paths, and compare the sensitivity of the different options to the inputs of our simulation.

Creative financial engineering

Exotic options are amazing and creative. Chances are if you can imagine a bet you want to take on a stock there is a derivative contract for it. This is a short list of interesting contracts that we will price using the monte carlo scenarios.

Asian option: payoff is based on the daily arithmetic average underlying price over the entire time period, rather than the price on the expiration date.
Lookback option: payoff is based on the most optimal opportunity one might have had to exercise the option during the time period.
Barrier options: payoff is conditioned on the underlying security reaching (or failing to reach) a predefined threshold, called the barrier.
Cliquet option: this is a basket of forward-starting options that periodically settle and then reset over the time period.

Monte Carlo Scenarios

I'll use the same set of 1 million scenarios for each valuation to reduce the impact of random noise when we compare results. Each scenario will be comprised of 252 time steps (the approximate number of trading days in a given year.) As a result, we'll have a PyTorch tensor with size (1000000, 252). Each value in the tensor will be the total return for the stock on a given day for a given scenario.

I'll use the scenarios, which I'll call paths, to calculate a payoff tensor for each exotic option. The payoff tensor represents the cash flows generated from each scenario of our simulation. Because those cash flows happen at various times in the future, I'll discount them to today to calculate a present value. Then I'll calculate the average present value across all million scenarios in order to estimate the price of the option, which I'll call ov.

First, let's start by defining the variables that will be used to generate our scenarios. Then let's visualize 100 randomly generated stock paths to make sure things look reasonable.

# input tensors\nstock = torch.tensor(100.0, requires_grad=True)\nstrike = torch.tensor(100.0, requires_grad=True)\nvol = torch.tensor(0.16, requires_grad=True)\nrate = torch.tensor(0.035, requires_grad=True)\ndividend = torch.tensor(0.01, requires_grad=True)\n\n# geometric brownian motion\ntorch.manual_seed(42)\nscenarios = 1000000\nstep = 252\n\ndW = vol * torch.randn(size=(scenarios, step)) / step**0.5\npaths = (rate - dividend - vol*vol/2) / step + dW\npaths = stock * torch.exp(torch.cumsum(paths, dim=1))\n\n# discount rate per step\ndiscount = -torch.cumsum(rate.repeat(step), dim=0) / step\ndiscount = torch.exp(discount)\n

\n $\"monte$ \n

The Vanilla European option

For the sake of comparison, we'll calculate the value of a standard European put option. This should be very close to the Black-Scholes value we calculated in the prior article. (Note that the prior article used 100,000 scenarios instead of 1 million, so the option prices are slightly different.) We'll also illustrate a single scenario to show how the option payoff is calculated.

# european put option payoff\npayoff = torch.max(strike - paths[:,-1], torch.zeros(size=(scenarios,)))\nov = torch.mean(discount[-1] * payoff)\n\n>>> print(ov)\n5.0827\n

\n $\"monte$ \n

Asian option

An asian option payoff is based on the daily arithmetic average of underlying price over the time period. This requires a simple change to our formula above. As we see, the price of this option is roughly 40% less than the standard European put option. Intuitively this makes sense, because the averaging mechanism makes it less likely for extreme option payoffs by the time we reach expiry. This is true for both call and put options.

# asian put option payoff\npayoff = torch.max(strike - torch.mean(paths, dim=1), torch.zeros(size=(scenarios,)))\nov = torch.mean(discount[-1] * payoff)\n\n>>> print(ov)\n3.0117\n

\n $\"monte$ \n

Lookback option

A lookback option payoff is equal to the optimal exercise value achieved at any point during the time period. In other words, the option owner is allowed to \"look back\" at the underlying price and choose the value that would result in the highest payoff.

For a lookback put option with a fixed strike of $100, the option holder will choose the minimum underlying price over the time period as the exercise price. In cases where the minimum is still higher than the strike, the option payoff will be zero, otherwise it will be the strike price minus the minimum value. Because the lookback put option is so advantageous, it often costs considerably more than a plain vanilla put option, as we see below.

# lookback put option payoff\npayoff = torch.max(strike - torch.min(paths, dim=1)[0], torch.zeros(size=(scenarios,)))\nov = torch.mean(discount[-1] * payoff)\n\n>>> print(ov)\n10.2009\n

\n $\"monte$ \n

Barrier options

Barrier options, also called \"knock-out\" or \"knock-in\" options, have a secondary condition for exercise. In the case of a knock-out put option, if the underlying price falls below a certain barrier, then the option is invalidated and the payoff is zero. In the case of a knock-in put option, the underlying security must reach the barrier, or else the payoff is zero.

As expected, the option price for either barrier option is less than the price of a plain vanilla put option because of the more restrictive clause in the contract. It is also worth noting that the price of the knock-out option plus the price of the knock-in option equals the vanilla put option price. Intuitively, this makes sense, because the knock-in and knock-out options are like mirror images of one another. Owning both options would guarantee the exact same cash flows as the plain vanilla put option, which means the price should be the same too.

# barrier tensor\nbarrier = torch.tensor(80.0, requires_grad=True)\n\n# determine if the option gets knocked out or knocked in\nknockout = (paths > barrier).all(dim=1).type(torch.float32)\nknockin = (paths > barrier).any(dim=1).type(torch.float32)\n\n# knock-out put option payoff\npayoff = torch.max(strike - paths[:,-1], torch.zeros(size=(scenarios,)))\nknockout = torch.mean(discount[-1] * payoff * knockout)\nknockin = torch.mean(discount[-1] * payoff * knockin)\n\n>>> print(knockout, knockin)\n2.4708, 2.6118\n\n>>> print(knockout + knockin)\n5.0827\n

Cliquet option

A cliquet option is a basket of forward-starting options that periodically settle and reset over the time period. For example, a monthly cliquet option over a one year time period is a portfolio of 12 forward-starting options - one for each month of the year. The starting strike price is fixed, in our case at $100, but at the end of each month, the prior option payoff is calculated and a new option is issued with a strike set equal to the current underlying price. In other words, a cliquet option is a way of paying for a portfolio of at-the-money options up front, without knowing what the future strike prices of the options will be.

The code for this option is slightly more complex. First, we identify the days that our options will settle and reset. For monthly put options, that will be every 21 days. Then we use the values of each simulated path on those days as our settlement and strike prices. The option payoffs for each month are equal to the prior strike minus the new strike. The periodic settlements are paid each month, so we discount them back to today's dollars to calculate a net present value. Finally, we average across all scenarios to estimate the option price.

Note that the price of a 1-month at-the-money put option with the same interest rate and volatility assumptions is 1.7369. Thus our cliquet option price of 20.7419 is roughly equal to $12 \\times 1.7369 = 20.8430$ .

# determine the indices and values on the reset dates: every 21 days\nstrike_idx = np.arange(20, step, 21)\nstrike_val = paths[:, strike_idx]\n\n# calculate the monthly stream of payoffs for each scenario\nstart = torch.cat([strike.repeat(scenarios, 1), strike_val[:,:-1]], dim=1)\npayoff = torch.max(start - strike_val, torch.zeros_like(start))\nov = discount[strike_idx] * payoff\nov = ov.sum(dim=1).mean()\n\n>>> print(ov)\n20.7419\n

\n $\"monte$ \n

Comparison

The amazing thing about our simulations is that each option's greeks can be calculated using automatic differentiation. Because the option value is calculated from tensors whose gradients we are tracking, we simply call ov.backward() to tell PyTorch to propagate gradients backward, then call variable.grad for each of our inputs to calculate option greeks. I think it's incredible that despite the various idiosyncrasies of each option, it's possible to use the exact same automatic differentiation method to calculate option greeks. Now, let's compare option prices and greeks for our portfolio of exotic options.

                 Vanilla      Asian   Lookback  Knock_out   Knock_in    Cliquet\nOption Value:     5.0827     3.0117    10.2009     2.4708     5.0926    20.7419\n------------------------------------------------------------------------------\n       Delta:    -0.4025    -0.4215    -0.8260    -0.2991    -0.1034    -0.2817\n         Rho:   -45.3357   -23.8184   -49.8733   -32.3804   -12.9553   -48.7485\n        Vega:    38.3756    22.2014    67.4165    21.6336    16.7419   137.1079\n     Epsilon:    40.2530    20.8067    39.6724    29.9096    10.3434    37.5303\n Strike Sens:     0.4534     0.4517     0.9280     0.3238     0.1296     0.4861\n------------------------------------------------------------------------------\n

There are several interesting comparisons to make among the different options.

We see muted greeks for the asian option. Overall it is less sensitive to all model inputs except stock price. This clearly reflects the averaging component of the payoff.
Next, we notice the lookback option vega is almost double the plain vanilla put option. This also makes sense: with the ability to choose the optimal value to exercise the option, we benefit significantly from volatile stocks that are likely to exhibit larger swings in price.
The knock-out and knock-in options are like two halves of the plain vanilla put option. The sum of both options together get us back to the plain vanilla option, both for price and for greeks.
The cliquet option represents a portfolio of 12 forward-starting options, and its price is roughly 12 times the price of a one month option. We notice that it is highly sensitive to volatility (the vega is nearly 4 times higher than the baseline!), which makes sense given its frequent resets throughout the year.

Overall, this was a fun exercise to use monte carlo simulation to explore some non-traditional financial derivatives. This is a viable technique for many financial valuation problems, and I look forward to exploring more applications in future articles.

"},{"title":"Black Scholes in PyTorch","date":"Dec 9, 2018","slug":"pytorch-black-scholes","excerpt":"I've been experimenting with several machine learning frameworks lately, including Tensorflow, PyTorch, and Chainer. I'm fascinated by the concept of automatic differentiation. It's incredible to me that these libraries can calculate millions of partial derivatives of virtually any function with only one extra pass through the code. Automatic differentiation is critical for deep learning models, but I wanted to see how it could be applied to value financial derivatives.","tags":[],"status":"published","content":"

I've been experimenting with several machine learning frameworks lately, including Tensorflow, PyTorch, and Chainer. I'm fascinated by the concept of automatic differentiation. It's incredible to me that these libraries can calculate potentially millions of partial derivatives of virtually any function with only one extra pass through the code.

Automatic differentiation is critical for deep learning models, but I wanted to see how it could be applied elsewhere. I've always been interested in financial derivatives like stock options, and calculating greeks (the partial derivatives of option price) can often be a slow process of running and re-running models repeatedly. The process gets even more complicated for complex, path-dependent options. As I found while writing this article, PyTorch can make this process much faster and more exact.

Goals for this article

The purpose of this article is to use PyTorch to implement four methods of calculating European put option price and greeks. I'll demonstrate how automatic differentiation can be used to calculate option greeks, and measure the time it takes for each implementation.

Use the Black-Scholes formula and the closed-form equations for option greeks.
Use the Black-Scholes formula and calculate option greeks using the \"finite difference\" method.
Use the Black-Scholes formulas for option value and use PyTorch to automatically differentiate the output and calculate the option greeks.
Use a monte carlo simulation of option values in PyTorch. Then use automatic differentiation to calculate option greeks.

A brief primer on European stock options:

A European stock option is a financial instrument that gives the owner the right, but not the obligation, to buy or sell an underlying security for a pre-determined price at a specific future date. It goes without saying that the future values of financial securities are uncertain. Therefore, options on those securities can be difficult to price.

There are plenty of resources available to learn about options, from the basics all the way through stochastic calculus and exotic option varieties. In fact, many of the techniques that I'm going to demonstrate become much more relevant and powerful for more complex options. However, for the purposes of this article I'm going to focus exclusively on a simple European put option. Fortunately, if we make certain simplifying assumptions, the European put option can be valued in closed-form using the famous Black-Scholes formula.

In addition to knowing the value of the option, it is also useful to understand how the value will change if certain assumptions change. In other words, it is useful to understand the partial derivatives of option value with respect to the inputs to the Black-Scholes formula. These sensitivities are typically called \"the greeks\". We'll use closed-form equations as well as PyTorch's automatic differentiation to calculate the greeks.

The Black-Scholes Formula

This is the formula we'll use to calculate the price of the European put option. There are formulas for each of the greeks too: delta, rho, vega, theta, epsilon, etc., but I'll spare the math for now.

P = Ke^{-\\mu t} \\phi(-d_2) - Se^{-\\delta t} \\phi(-d_1)

d_1 = \\frac{\\ln({\\frac{S}{K})} + (\\mu -\\delta + \\frac{\\sigma^2}{2})t}{\\sigma\\sqrt{t}}

d_2 = \\frac{\\ln({\\frac{S}{K})} + (\\mu -\\delta - \\frac{\\sigma^2}{2})t}{\\sigma\\sqrt{t}}

where

$P$ is the put option price
$S$ is the stock price
$K$ is the strike (exercise) price
$\\mu$ is the annual continuously compounded risk free interest rate
$\\sigma$ is the annual volatility of the underlying security
$t$ is the time to expiry in years
$\\delta$ is the annual continuous dividend rate
$\\phi(x)$ is the standard normal CDF evaluated at $x$

PyTorch setup

Like many deep learning frameworks available today, PyTorch provides high-performance numerical computation, automatic differentiation, and the ability to run on distributed grids of hardware accelerators, like GPUs. PyTorch computational graphs are created on the fly, as opposed to the static graphs you build in a language like Tensorflow. But both libraries provide automatic differentiation out of the box.

To enable automatic differentiation, we must identify the inputs to our formulas as tensors and start gradient tracking for those inputs. PyTorch will keep track of the operations on those inputs from the beginning to the end. Once we're finished with our computation and we have our output, we can run reverse mode automatic differentiation to calculate the gradient of the output with respect to each input.

Throughout this article, I'll use the following six input tensors and their defined values for the Black-Scholes formula. I'll also create two utility functions that we'll use as we go along.

# black-scholes inputs\nstock = torch.tensor(100.0, requires_grad=True)\nstrike = torch.tensor(100.0, requires_grad=True)\nrate = torch.tensor(0.035, requires_grad=True)\nvol = torch.tensor(0.16, requires_grad=True)\ntime = torch.tensor(1.0, requires_grad=True)\ndividend = torch.tensor(0.01, requires_grad=True)\n\n# utility functions\ncdf = torch.distributions.Normal(0,1).cdf\npdf = lambda x: torch.distributions.Normal(0,1).log_prob(x).exp()\n

Method 1: Black-Scholes Formula for Option Value and Greeks

The first method is purely formulaic. We'll use the Black-Scholes formula plus the formulas for all option greeks. PyTorch is certainly overkill for this method - we could use virtually any programming language to implement this.

# black-scholes formula\nd1 = (torch.log(stock/strike) + (rate - dividend + vol*vol/2)*time) / (vol*time**0.5)\nd2 = (torch.log(stock/strike) + (rate - dividend - vol*vol/2)*time) / (vol*time**0.5)\nov = strike*torch.exp(-rate*time)*cdf(-d2) - stock*torch.exp(-dividend*time)*cdf(-d1)\n\n# black-scholes greeks\ndelta = torch.exp(-dividend*time) * (cdf(d1) - 1)\nrho = -strike * time * torch.exp(-rate*time) * cdf(-d2)\nvega = stock * torch.exp(-dividend*time) * pdf(d1) * time**0.5\ntheta = -(\n    rate * strike * torch.exp(-rate*time) * cdf(-d2)\n    - stock * torch.exp(-dividend*time) * pdf(d1) * vol / (2*time**0.5)\n    - dividend * stock * torch.exp(-dividend*time) * cdf(-d1)\n)\nepsilon = stock * time * torch.exp(-dividend*time) * cdf(-d1)\nstrike_greek = torch.exp(-rate*time) * cdf(-d2)\n

When we run this code with our inputs from above, we get the following table of outputs. This option price is $5.09. Plus, we can estimate how the price will change if any of our model inputs changes. For example, a Delta of -0.4026 implies that if the underlying security increases in value by $1 (from $100 to $101), the option price should decrease by roughly $0.40. Similarly, if we were to decrease the time-to-expiry of this option from 1.0 years to 0.9 years, we would expect option price to decrease by roughly 10% of the option theta, or 0.18883.

Option Value:     5.0885   # sensitivity of option price to:\n------------------------   ---------------------------------\n       Delta:    -0.4026   # underlying price\n         Rho:   -45.3458   # interest rates\n        Vega:    38.4103   # volatility\n       Theta:     1.8883   # time\n     Epsilon:    40.2573   # dividend rate\n Strike Sens:     0.4535   # strike price\n

Method 2: Black-Scholes Formula with Finite Difference Greeks

With most models, a simple way of calculating partial derivatives is to re-run the model many times with slightly different inputs and observe how the output changes with each new run. This is often called the \"finite difference\" or \"bump-and-revalue\" method. It doesn't require you to derive the greeks of the formula by hand - indeed this can often be impossible. This method provides an estimate of the true partial derivative, and is based on the following formula:

f\\prime(x) \\approx \\frac{f(x + \\delta) - f(x)}{\\delta}

As an example, let's estimate put option delta using this method. We originally valued the option at $5.0885 (above), given a stock input of $100. If we re-run our model after changing stock to $101 and keeping everything else constant, the option price decreases to $4.6978. Then, according to the formula above, our estimate of delta is:

f\\prime(x) \\approx \\frac{5.0885 - 4.6978}{1} \\approx -0.3907

Let's implement this in code. Again, PyTorch is overkill here because we're simply using the same Black-Scholes formula from Method 1 and re-running it six extra times to calculate our option greeks.

# black-scholes formula\ndef bs(stock, strike, rate, vol, time, dividend):\n    d1 = (torch.log(stock/strike) + (rate - dividend + vol*vol/2)*time) / (vol*time**0.5)\n    d2 = (torch.log(stock/strike) + (rate - dividend - vol*vol/2)*time) / (vol*time**0.5)\n    ov = strike*torch.exp(-rate*time)*cdf(-d2) - stock*torch.exp(-dividend*time)*cdf(-d1)\n    return ov\n\n# baseline option value and 1% sensitivities\nov = bs(stock, strike, rate, vol, time, dividend)\ndelta = bs(1.01*stock, strike, rate, vol, time, dividend)\nrho = bs(stock, strike, 1.01*rate, vol, time, dividend)\nvega = bs(stock, strike, rate, 1.01*vol, time, dividend)\ntheta = bs(stock, strike, rate, vol, 1.01*time, dividend)\nepsilon = bs(stock, strike, rate, vol, time, 1.01*dividend)\nstrike_greek = bs(stock, 1.01*strike, rate, vol, time, dividend)\n\n# scaling; in each case, δ is 1% of the starting value\ndelta = (delta - ov) / (0.01*stock)\nrho = (rho - ov) / (0.01*rate)\nvega = (vega - ov) / (0.01*vol)\ntheta = (theta - ov) / (0.01*time)\nepsilon = (epsilon - ov) / (0.01*dividend)\nstrike_greek = (strike_greek - ov) / (0.01*strike)\n

We see that the option greeks from this method vary slightly compared to the exact formulas used in Method 1. This is because we can only approximate the partial derivatives through finite difference. I used 1% sensitivities, which is fairly standard. Smaller values, like 0.1%, would result in greeks closer to the exact values, but wouldn't reflect as much convexity in the option price. That is typically the tradeoff with the finite differences method.

Option Value:     5.0885   # sensitivity of option price to:\n------------------------   ---------------------------------\n       Delta:    -0.3907   # underlying price\n         Rho:   -45.2968   # interest rates\n        Vega:    38.4164   # volatility\n       Theta:     1.8803   # time\n     Epsilon:    40.2069   # dividend rate\n Strike Sens:     0.4654   # strike price\n

Method 3: Black-Scholes Formula with PyTorch Automatic Differentiation

Now the fun part. Before, we either had to carefully program complex formulas for option greeks (missing a negative sign here or there is a common and frustrating error), or re-run our model several times and scale the outputs. It's easy to make mistakes in either case.

Instead, let's start to leverage PyTorch's automatic differentiation. As before, we program the Black-Scholes formula (you'll notice the implementation is exactly the same). Once we have the option value, we simply call ov.backward() to tell PyTorch that we want to calculate the partial derivatives of our model. Because we tagged each input with require_grad=True, we can call .grad on each input to get its gradient.

# black-scholes formula\nd1 = (torch.log(stock/strike) + (rate - dividend + vol*vol/2)*time) / (vol*time**0.5)\nd2 = (torch.log(stock/strike) + (rate - dividend - vol*vol/2)*time) / (vol*time**0.5)\nov = strike*torch.exp(-rate*time)*cdf(-d2) - stock*torch.exp(-dividend*time)*cdf(-d1)\n\n# run backpropagation to calculate option greeks\nov.backward()\ndelta = stock.grad\nrho = rate.grad\nvega = vol.grad\ntheta = time.grad\nepsilon = dividend.grad\nstrike_greek = strike.grad\n

Each value in the table below is identical to our original calculations using Method 1. And I would argue that the code above is significantly simpler to write, read, and debug. Furthermore, I can be confident that the gradients are correct because I didn't have to input complex formulas by hand.

Option Value:     5.0885   # sensitivity of option price to:\n------------------------   ---------------------------------\n       Delta:    -0.4026   # underlying price\n         Rho:   -45.3458   # interest rates\n        Vega:    38.4103   # volatility\n       Theta:     1.8883   # time\n     Epsilon:    40.2573   # dividend rate\n Strike Sens:     0.4535   # strike price\n

Method 4: Monte Carlo simulation of stock prices with Automatic Differentiation

The fourth method is unlike the first three in that it doesn't use the Black-Scholes formula at all. Instead, it uses the principle upon which the formula is based, called Geometric Brownian Motion (GBM). GBM is a model for simulating future distributions of stock returns. It is a stochastic method, which means we'll draw thousands of samples from a normal distribution of stock returns in order to understand the potential future values of the stock on the exercise date.

Once we have several thousand randomly drawn future stock values, we simply calculate the option payoff under each scenario. We then discount the future payoffs to today and take the average value of all the scenarios we ran. If we run enough scenarios, then the average should converge to the Black-Scholes price of the option.

\n $\"monte$ \n

# geometric brownian motion (single time step)\ntorch.manual_seed(42)\nscenarios = 1000000\ndW = vol * time**0.5 * torch.randn(size=(scenarios,))\nr = torch.exp((rate - dividend - vol*vol/2) * time + dW)\n\n# put option payoff & discounting\npayoff = torch.max(strike - stock*r, torch.zeros(size=(scenarios,)))\nov = torch.mean(payoff) * torch.exp(-rate*time)\n\n# run backpropagation to calculate option greeks\nov.backward()\ndelta = stock.grad\nrho = rate.grad\nvega = vol.grad\ntheta = time.grad\nepsilon = dividend.grad\nstrike_greek = strike.grad\n

Did you notice that we were able to use automatic differentiation in our stochastic simulation? This means we can potentially develop extremely complex simulation models and use automatic differentiation to understand the effects of every single model input. In this case, our simulation is fairly simple, but the prospects for this technique are exciting! We also see that our results are close to the values from our prior methods.

Option Value:     5.0926   # sensitivity of option price to:\n------------------------   ---------------------------------\n       Delta:    -0.4025   # underlying price\n         Rho:   -45.3420   # interest rates\n        Vega:    38.4292   # volatility\n       Theta:     1.8899   # time\n     Epsilon:    40.2495   # divi

Snippets