From 9333518be1dae0e91f3b1b3d7fc63c2c8ed8c707 Mon Sep 17 00:00:00 2001
From: Peter Norvig <peter.norvig@gmail.com>
Date: Thu, 8 Jan 2026 21:07:08 -0800
Subject: [PATCH] Add files via upload

---
 ipynb/TruncatablePrimes.ipynb | 625 +++++++++++++++++++++-------------
 1 file changed, 392 insertions(+), 233 deletions(-)

diff --git a/ipynb/TruncatablePrimes.ipynb b/ipynb/TruncatablePrimes.ipynb
index a74de01..b439976 100644
--- a/ipynb/TruncatablePrimes.ipynb
+++ b/ipynb/TruncatablePrimes.ipynb
@@ -3,7 +3,9 @@
   {
    "cell_type": "markdown",
    "id": "8812d495-6014-4669-97ae-003be4f54605",
-   "metadata": {},
+   "metadata": {
+    "jp-MarkdownHeadingCollapsed": true
+   },
    "source": [
     "<div style=\"text-align:right\"><i>Peter Norvig<br>Jan 2026</i></div>\n",
     "\n",
@@ -17,7 +19,7 @@
     "\n",
     "    357686312646216567629137 is prime\n",
     "     57686312646216567629137 is prime\n",
-    "      7686312646216567629137 is prime\n",
+    "      7686312646216567629137 is prime|\n",
     "                 ...\n",
     "                         137 is prime\n",
     "                          37 is prime\n",
@@ -25,7 +27,7 @@
     "\n",
     "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). \n",
     "\n",
-    "I thought I would write a program for this. My function `left_truncatable_primes` below starts with the list of one-digit primes: [2, 3, 5, 7]. Then it creates a list of one-digit-longer new primes by placing each possible digit 1–9 to the left of each of the one-digit primes, and checking if each resulting number is prime. If there are any new primes, it recursively adds digits to them, giving us three-digit primes, then four-digit primes, and so on, stopping when there are no more new primes. In the end, the function gathers up all the truncatable primes and returns them in sorted order."
+    "I thought I would write a program to find all the truncatable primes. My function `truncatable_primes` below starts with the list of one-digit primes: [2, 3, 5, 7]. Then it creates a list of one-digit-longer new primes by placing each possible digit 1–9 to the left of each of the one-digit primes, and testing if each resulting number is prime. If there are any new primes, it recursively adds digits to them, giving us three-digit primes, then four-digit primes, and so on, stopping when there are no more new primes. In the end, the function returns all the truncatable primes in sorted order."
    ]
   },
   {
@@ -37,10 +39,13 @@
    "source": [
     "from sympy import isprime # isprime(n) returns True if n is a prime\n",
     "\n",
-    "def left_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n",
-    "    \"\"\"All left-truncatable primes, in ascending order.\"\"\"\n",
+    "def truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n",
+    "    \"\"\"All truncatable primes, in ascending order.\"\"\"\n",
     "    new_primes = [dp for d in \"123456789\" for p in primes if isprime(dp := int(d + str(p)))]\n",
-    "    return (primes + left_truncatable_primes(new_primes)) if new_primes else primes"
+    "    if new_primes:\n",
+    "        return primes + truncatable_primes(new_primes)\n",
+    "    else:\n",
+    "        return primes"
    ]
   },
   {
@@ -69,9 +74,9 @@
     }
    ],
    "source": [
-    "P = left_truncatable_primes()\n",
+    "TP = truncatable_primes()\n",
     "\n",
-    "len(P)"
+    "len(TP)"
    ]
   },
   {
@@ -79,7 +84,7 @@
    "id": "a32b56c4-587b-48d5-91ec-1abcef2e909f",
    "metadata": {},
    "source": [
-    "There are 4260 left-truncatable primes. Here are the smallest and largest of them:"
+    "There are **4260** of these truncatable primes. Here are the smallest and largest of them:"
    ]
   },
   {
@@ -100,7 +105,7 @@
     }
    ],
    "source": [
-    "P[:16]"
+    "TP[:16]"
    ]
   },
   {
@@ -136,7 +141,184 @@
     }
    ],
    "source": [
-    "P[-16:]"
+    "TP[-16:]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e82700e8-8fb2-45cf-bcf0-7805e46174bb",
+   "metadata": {},
+   "source": [
+    "What if you sharpen the pencil from the other end? The primes we found so far are called **left-truncatable primes**; there are also **right-trunctable primes**:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3870bc47-5833-4879-b622-2094b4247239",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def right_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n",
+    "    \"\"\"All right-truncatable primes, in ascending order.\"\"\"\n",
+    "    # Only consider (1, 3, 7, 9) as the digit on the right; placing any other digit forms a composite number\n",
+    "    new_primes = [pd for p in primes for d in (1, 3, 7, 9) if isprime(pd := 10 * p + d)]\n",
+    "    if new_primes:\n",
+    "        return primes + right_truncatable_primes(new_primes)\n",
+    "    else:\n",
+    "        return primes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7b39ffb5-ba52-42e6-a270-79bc10b26c2c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "83"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "TPr = right_truncatable_primes()\n",
+    "\n",
+    "len(TPr)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5323ae60-285d-49d6-a133-5c476eb4c5e5",
+   "metadata": {},
+   "source": [
+    "There are only 83 right-truncatable primes. Here they are:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e3780212-2b86-469f-9df0-81bd6fcc9c94",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2, 3, 5, 7, 23, 29, 31, 37, 53, 59, 71, 73, 79, 233, 239, 293, 311, 313, 317, 373, 379, 593, 599, 719, 733, 739, 797, 2333, 2339, 2393, 2399, 2939, 3119, 3137, 3733, 3739, 3793, 3797, 5939, 7193, 7331, 7333, 7393, 23333, 23339, 23399, 23993, 29399, 31193, 31379, 37337, 37339, 37397, 59393, 59399, 71933, 73331, 73939, 233993, 239933, 293999, 373379, 373393, 593933, 593993, 719333, 739391, 739393, 739397, 739399, 2339933, 2399333, 2939999, 3733799, 5939333, 7393913, 7393931, 7393933, 23399339, 29399999, 37337999, 59393339, 73939133]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(TPr)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "976c7f1f-79c5-48c3-8909-62b809993057",
+   "metadata": {},
+   "source": [
+    "We can also find the **two-sided truncatable primes**, which are both right- and left-truncatable. It turns out there are only 15 of them:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b87ae26e-0dee-4c95-914f-c897fda17508",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{2, 3, 5, 7, 23, 37, 53, 73, 313, 317, 373, 797, 3137, 3797, 739397}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "set(TP) & set(TPr)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "82fc3133-4a17-47ec-b742-7a37f78421a8",
+   "metadata": {},
+   "source": [
+    "There isn't an official name for a truncatable prime that remains prime for all possible choices of truncating either the rightmost or leftmost digit at each step. I'll call them **omni-truncatable primes**. I can compute them like this:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "28f12184-b247-4cea-86d4-6b0e07e2a63f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[2, 3, 5, 7, 23, 37, 53, 73, 373]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def is_omni_truncatable_prime(n: int) -> bool:\n",
+    "    \"\"\"Is n a truncatable prime for all possible choices of truncating digits from left or right?\"\"\"\n",
+    "    return (isprime(n) and\n",
+    "            (n < 10 or (is_omni_truncatable_prime(int(str(n)[1:])) and\n",
+    "                        is_omni_truncatable_prime(int(str(n)[:-1])))))\n",
+    "\n",
+    "[p for p in TP if is_omni_truncatable_prime(p)]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b316527-f437-439f-ac64-ef7980ecf6ff",
+   "metadata": {},
+   "source": [
+    "There are only 9 of them, with 373 the largest.\n",
+    "\n",
+    "What about primes that are both truncatable and [**palindromic primes**](https://en.wikipedia.org/wiki/Palindromic_prime)?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "403a6451-c486-4868-acdc-7dd80a4c8f9d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{2, 3, 5, 7, 313, 353, 373, 383, 797, 76367, 79397, 7693967, 799636997}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{p for p in TP if str(p) == str(p)[::-1]}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cd0da3ad-54c0-47dc-979c-4eecc935425c",
+   "metadata": {},
+   "source": [
+    "There are 13 **palindromic truncatable primes**."
    ]
   },
   {
@@ -144,12 +326,40 @@
    "id": "853d5a6c-936e-4ab4-afc3-2082641063fc",
    "metadata": {},
    "source": [
-    "Below is the count for each digit-length, with a bar chart. We see there is only one 24-digit left-truncatable prime, the one on the pencil, and that the most common number of digits is 9.\n"
+    "# Digit Lengths\n",
+    "\n",
+    "How many digits are in these truncatable primes? The function `digit_lengths` returns a {number_of_digits: count_of_primes_with_that_many_digits} dict, and plots a bar chart for that data:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 11,
+   "id": "28b0bc97-1b22-449f-b33a-6f8c84fd890d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "from collections import Counter\n",
+    "\n",
+    "def digit_lengths(primes) -> dict[int, int]:\n",
+    "    \"\"\"Plot a bar chart and return a dict of the number of digits in these primes.\"\"\"\n",
+    "    digits = Counter(len(str(p)) for p in primes)\n",
+    "    plt.bar(list(digits), list(digits.values()))\n",
+    "    plt.xlabel('Number of digits'); plt.ylabel('Count')\n",
+    "    return dict(digits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "09bc98cf-2f43-4f58-b414-f3eff2d834b3",
+   "metadata": {},
+   "source": [
+    "First for the **left-truncatable primes**:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
    "id": "defd769e-9f92-4e4f-a12b-88a653b6efee",
    "metadata": {},
    "outputs": [
@@ -182,7 +392,7 @@
        " 24: 1}"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -198,122 +408,30 @@
     }
    ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "from collections import Counter\n",
-    "\n",
-    "def digit_lengths(primes) -> Counter:\n",
-    "    \"\"\"Plot a bar chart and return a Counter of the number of digits in these primes.\"\"\"\n",
-    "    digits = Counter(len(str(p)) for p in primes)\n",
-    "    plt.bar(list(digits), list(digits.values()))\n",
-    "    plt.xlabel('Number of digits'); plt.ylabel('Count')\n",
-    "    return digits\n",
-    "\n",
-    "dict(digit_lengths(P))"
+    "digit_lengths(TP)"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "e82700e8-8fb2-45cf-bcf0-7805e46174bb",
+   "id": "ec4c6f1d-d298-48de-884a-efee0b81fd19",
    "metadata": {},
    "source": [
-    "# Right-Truncatable Primes\n",
-    "\n",
-    "What if you sharpen the pencil from the other end? For our 357686312646216567629137 pencil it wouldn't work; removing the \"7\" from the right results in a composite number. But it is possible to build up the  **right-truncatable** primes:"
+    "And for the **right-truncatable** primes:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "3870bc47-5833-4879-b622-2094b4247239",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def right_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n",
-    "    \"\"\"All right-truncatable primes, in ascending order.\"\"\"\n",
-    "    new_primes = [pd for p in primes for d in (1, 3, 7, 9) if isprime(pd := 10 * p + d)]\n",
-    "    return (primes + right_truncatable_primes(new_primes)) if new_primes else primes"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "976c7f1f-79c5-48c3-8909-62b809993057",
-   "metadata": {},
-   "source": [
-    "(Note that I only try placing the digits (1, 3, 7, 9) to the right: placing an even digit or a 5 would always result in a composite number. Since there are fewer digits to add, I expect there to be fewer right-truncatable primes in total. Also, note that I don't have to do string concatenation to form the new candidates; it is simpler to do `10 * p + d`.)\n",
-    "\n",
-    "Let's find and count the right-truncatable primes:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "7b39ffb5-ba52-42e6-a270-79bc10b26c2c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "83"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "Q = right_truncatable_primes()\n",
-    "\n",
-    "len(Q)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5323ae60-285d-49d6-a133-5c476eb4c5e5",
-   "metadata": {},
-   "source": [
-    "There are only 83 right-truncatable primes, so we might as well see them all:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "e3780212-2b86-469f-9df0-81bd6fcc9c94",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[2, 3, 5, 7, 23, 29, 31, 37, 53, 59, 71, 73, 79, 233, 239, 293, 311, 313, 317, 373, 379, 593, 599, 719, 733, 739, 797, 2333, 2339, 2393, 2399, 2939, 3119, 3137, 3733, 3739, 3793, 3797, 5939, 7193, 7331, 7333, 7393, 23333, 23339, 23399, 23993, 29399, 31193, 31379, 37337, 37339, 37397, 59393, 59399, 71933, 73331, 73939, 233993, 239933, 293999, 373379, 373393, 593933, 593993, 719333, 739391, 739393, 739397, 739399, 2339933, 2399333, 2939999, 3733799, 5939333, 7393913, 7393931, 7393933, 23399339, 29399999, 37337999, 59393339, 73939133]\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(Q)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "d4abc561-5a2d-4e93-a18e-b78b104f7b7c",
-   "metadata": {},
-   "source": [
-    "Here is the count of digit lengths:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 13,
    "id": "09f29951-d8f2-47a3-b666-bfa6fd5d1c87",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "Counter({4: 16, 5: 15, 3: 14, 6: 12, 2: 9, 7: 8, 8: 5, 1: 4})"
+       "{1: 4, 2: 9, 3: 14, 4: 16, 5: 15, 6: 12, 7: 8, 8: 5}"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 13,
      "metadata": {},
      "output_type": "execute_result"
     },
@@ -329,7 +447,7 @@
     }
    ],
    "source": [
-    "digit_lengths(Q)"
+    "digit_lengths(TPr)"
    ]
   },
   {
@@ -337,33 +455,43 @@
    "id": "f2323985-2518-41d1-8a3b-6e21e40d27be",
    "metadata": {},
    "source": [
-    "# Summary of Truncatable Primes\n",
+    "# Summary of Truncatable Prime Facts\n",
     "\n",
     "Here's what we learned:\n",
     "\n",
     "- Left-trunctable primes:\n",
-    "  - There are 4260 of them\n",
-    "  - The largest has 24 digits: 357686312646216567629137\n",
-    "  - The plurality have 9 digits; few have more than 20 digits\n",
+    "  - Count: 4260\n",
+    "  - Largest: 357686312646216567629137 (24 digits)\n",
+    "  - The plurality have 9 digits; only 13 have more than 20 digits\n",
     "- Right-truncatable primes:\n",
-    "  - There are only 83 of them\n",
-    "  - The largest has 8 digits: 73939133\n",
+    "  - Count: 83\n",
+    "  - Largest: 73939133 (8 digits)\n",
     "  - The plurality have 4 digits\n",
+    "- Two-sided truncatable primes:\n",
+    "  - Count: 15\n",
+    "  - Largest: 739397 (6 digits)\n",
+    "- Omni-truncatable primes:\n",
+    "  - Count: 9\n",
+    "  - Largest: 373\n",
+    "- Palindromic truncatable primes:\n",
+    "  - Count: 13\n",
+    "  - Largest: 799636997 (9 digits)\n",
     "\n",
-    "# Note on Primality Checking\n",
     "\n",
-    "I was very impressed by the speed of `sympy.isprime`, and I wanted to examine the topic of primality checking. I'll start by defining `isprime_simple`, which follows the definition of a prime number almost verbatim:"
+    "# Primality Testing\n",
+    "\n",
+    "I was very impressed with the function [`sympy.isprime`](https://github.com/sympy/sympy/blob/master/sympy/ntheory/primetest.py), and I wanted to investigate the topic of primality testing. I'll start by defining `isprime_simple`, which follows the definition of a prime number almost verbatim:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 14,
    "id": "1d460931-3d70-485d-807f-8fb360ef4ef2",
    "metadata": {},
    "outputs": [],
    "source": [
     "def isprime_simple(n: int) -> bool:\n",
-    "    \"\"\"Simple primality checker. A prime number is defined as an integer greater than 1 \n",
+    "    \"\"\"Simple primality tester. A prime number is defined as an integer greater than 1 \n",
     "    that cannot be evenly divided by any whole number other than 1 and itself.\"\"\"\n",
     "    divisors = range(2, n)\n",
     "    return n > 1 and not any(n % d == 0 for d in divisors)"
@@ -376,12 +504,12 @@
    "source": [
     "To test a *d*-digit prime we have to iterate through nearly 10<sup>d</sup> divisors, which will be noticeably slow for anything larger than about 7-digit numbers.\n",
     "\n",
-    "We can speed things up a bit with two ideas, one small and one big. The small idea is to cut the run time in half by only checking the odd divisors (after determining that 2 is a prime and all other even numbers are composite). The big idea is that we only need to check divisors up to √*n*, not up to *n*. If *n* is composite, then *n* is the product of two numbers, and one of them must be less than or equal to √*n*, so we can stop there."
+    "We can speed things up a bit with two ideas, one small and one bigger. The small idea is to cut the run time in half by only testing the odd divisors (after determining that 2 is a prime and all other even numbers are composite). The bigger idea is that we only need to test divisors up to √*n*, not up to *n*. If *n* is composite, then *n* is the product of two numbers, and one of them must be less than or equal to √*n*, so we can stop there."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 15,
    "id": "647fb66b-32ae-494a-8945-cf7358c2f958",
    "metadata": {},
    "outputs": [],
@@ -389,12 +517,12 @@
     "from math import sqrt\n",
     "\n",
     "def isprime_faster(n: int) -> bool:\n",
-    "    \"\"\"More sophisticated primality checker: check only odd divisors up to √n.\"\"\"\n",
+    "    \"\"\"More sophisticated primality tester: test only odd divisors up to √n.\"\"\"\n",
     "    if n <= 10:                   # Handle small numbers up to 10\n",
     "        return n in (2, 3, 5, 7)\n",
     "    elif n % 2 == 0:              # Even numbers other than 2 are composite\n",
     "        return False\n",
-    "    else:                         # Check odd divisors up to sqrt(n)\n",
+    "    else:                         # test odd divisors up to sqrt(n)\n",
     "        divisors = range(11, int(sqrt(n)) + 1, 2) \n",
     "        return not any(n % d == 0 for d in divisors)"
    ]
@@ -404,11 +532,17 @@
    "id": "05b8cbf7-ea10-4047-bcdb-a5ac7981384b",
    "metadata": {},
    "source": [
-    "That's a noticeable improvement, but handling 24-digit numbers is still completely infeasible. We need a big breakthrough. \n",
+    "That's a noticeable improvement, but testing a 24-digit number would still take hours. We need a massive breakthrough. \n",
     "\n",
-    "Fortunately, [Pierre de Fermat](https://en.wikipedia.org/wiki/Pierre_de_Fermat) provided that  breakthrough in 1640, [showing](https://en.wikipedia.org/wiki/Fermat_primality_test) that if *n* is prime and *a* is not divisible by *n*, then *a*<sup>(*n* - 1)</sup> ≡ 1 (mod *n*). \n",
+    "Fortunately, [Pierre de Fermat](https://en.wikipedia.org/wiki/Pierre_de_Fermat) provided that  breakthrough in 1640! \n",
     "\n",
-    "That means we can check if *n* is prime by choosing a random *a* and testing if *a*<sup>(*n* - 1)</sup> ≡ 1 (mod *n*). If the test is false then *n* is definitely composite. If the test is true, then we're not sure: *n* might be prime, might be composite. But if we choose multiple values of *a* and they all give a remainder of 1 (mod *n*), then that is stronger evidence that *n* is probably prime. \n",
+    "# Probabilistic Primality Testing\n",
+    "\n",
+    "[Fermat's little theorem](https://en.wikipedia.org/wiki/Fermat%27s_little_theorem) states that if *n* is prime and *a* is not divisible by *n*, then:\n",
+    "\n",
+    "&nbsp; &nbsp; &nbsp; &nbsp; *a*<sup>(*n* - 1)</sup> ≡ 1 (mod *n*). \n",
+    "\n",
+    "We can use the theorem to create a [Fermat primality test](https://en.wikipedia.org/wiki/Fermat_primality_test): given an integer *n*, choose a random *a* and test if *a*<sup>(*n* - 1)</sup> ≡ 1 (mod *n*). If the test is false then *n* is definitely composite. If the test is true, then we're not sure: *n* might be prime, might not. But if we choose multiple values of *a* and they all give a remainder of 1 (mod *n*), then that is stronger evidence that *n* is probably prime. \n",
     "For example:\n",
     "\n",
     "\n",
@@ -418,33 +552,33 @@
     "|221|18|1|*221 could be prime or composite*|\n",
     "|221|2|16|*try again with new **a** value: 221 is definitely composite*|\n",
     "|5|2|1|*5 could be prime or composite*|\n",
-    "|5|3|1|*5 could be prime or composite*|\n",
-    "|5|4|1|*5 could be prime or composite, but we have a lot of evidence that it is prime*|\n",
+    "|5|3|1|*try again: 5 could still be prime or composite*|\n",
+    "|5|4|1|*try again: 5 could still be prime or composite, but a lot of evidence that it is prime*|\n",
     "\n",
     "\n",
-    "This is called a [Monte Carlo algorithm](https://en.wikipedia.org/wiki/Monte_Carlo_algorithm); an algorithm that uses randomization, and can sometimes be wrong. Here is an implementation:"
+    "This is called a [Monte Carlo algorithm](https://en.wikipedia.org/wiki/Monte_Carlo_algorithm); an algorithm that uses [randomization](https://en.wikipedia.org/wiki/Randomized_algorithm), and can sometimes be wrong. Here is an implementation:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 16,
    "id": "476282dd-a48a-4eb5-8fed-8495d4878ec2",
    "metadata": {},
    "outputs": [],
    "source": [
-    "import random\n",
-    "from typing import Iterable\n",
-    "\n",
-    "def sample(start: int, stop: int, k: int) -> Iterable[int]:\n",
-    "    \"\"\"Randomly sample `k` integers from range(start, stop), one by one.\"\"\"\n",
-    "    return (random.randrange(start, stop) for _ in range(k))\n",
-    "    \n",
     "def isprime_fermat(n: int, k=20) -> bool:\n",
     "    \"\"\"n is probably a prime if this returns True; definitely composite if it returns False.\"\"\"\n",
     "    if n <= 10:\n",
     "        return n in (2, 3, 5, 7)\n",
     "    else:\n",
-    "        return all(pow(a, n - 1, n) == 1 for a in sample(2, n, k))"
+    "        return all(pow(a, n - 1, n) == 1 for a in sample(2, n, k))\n",
+    "\n",
+    "import random\n",
+    "from typing import Iterable\n",
+    "    \n",
+    "def sample(start: int, stop: int, k: int) -> Iterable[int]:\n",
+    "    \"\"\"Randomly sample `k` integers from range(start, stop), one by one.\"\"\"\n",
+    "    return (random.randrange(start, stop) for _ in range(k))"
    ]
   },
   {
@@ -452,7 +586,7 @@
    "id": "1ec7bba6-ea89-4255-a73c-bc25a32da883",
    "metadata": {},
    "source": [
-    "(Note that `pow(a, n - 1, n)` efficiently computes *a*<sup>(*n* - 1)</sup> (mod *n*); more on this at the bottom of this notebook.)"
+    "(*Note* that `pow(a, n - 1, n)` computes *a*<sup>(*n* - 1)</sup> (mod *n*) very efficiently; see the last section of this notebook.)"
    ]
   },
   {
@@ -460,22 +594,24 @@
    "id": "15ef6884-253d-4a3a-b58f-397ac73f552d",
    "metadata": {},
    "source": [
-    "**The problem** is that there are some composite numbers *n* for which *a*<sup>(*n* - 1)</sup> ≡ 1 (mod *n*) for some values of *a*. In other words `isprime_fermat` can lie: it can incorrectly report a **false prime** for a composite number *n*. \n",
+    "**Unfortunately**, `isprime_fermat` can lie: it can incorrectly report a **false prime** for a composite number *n*. \n",
     "\n",
     "How common are these false primes? Here's a function to test a sample of numbers and report the the percentage of false primes when `isprime_fermat` is allowed `k` choices of the `a` parameter:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "id": "45a11a93-9ef3-48d1-80fa-e0113041346e",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from statistics import mean\n",
+    "\n",
     "def false_prime_percent(samples: Iterable[int], k: int) -> float:\n",
     "    \"\"\"The estimated percentage of false primes from isprime_fermat(n, k) for n across the samples.\"\"\"\n",
-    "    composites = [n for n in samples if not isprime(n)]\n",
-    "    return 100 * sum(isprime_fermat(n, k) for n in composites) / len(composites)"
+    "    composites = (n for n in samples if not isprime(n))\n",
+    "    return mean(100 * isprime_fermat(n, k) for n in composites)"
    ]
   },
   {
@@ -483,37 +619,37 @@
    "id": "778c3a9b-dcc7-4ad2-9092-d66aecd1d93c",
    "metadata": {},
    "source": [
-    "We'll choose sample ranges that represent digit-lengths, sample 100,000 times for each digit-length, and for now use 1 for the value of `k`:"
+    "We'll choose sample ranges that represent digit-lengths, sample 200,000 times for each digit-length, and for now look at `k=1` values of *a*:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 18,
    "id": "9eba96df-c298-4d71-b68a-3bf36bf15095",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{3: 1.4432622005587588,\n",
-       " 4: 0.46280016787849226,\n",
-       " 5: 0.12571126108244013,\n",
-       " 6: 0.0335378057620114,\n",
-       " 7: 0.007482149728504852,\n",
-       " 8: 0.0021168501270110076,\n",
-       " 9: 0.0,\n",
-       " 10: 0.0,\n",
-       " 11: 0.0,\n",
-       " 12: 0.0}"
+       "{3: 1.420427496905646,\n",
+       " 4: 0.4795347492645433,\n",
+       " 5: 0.13674836646356595,\n",
+       " 6: 0.03350572569618954,\n",
+       " 7: 0.010703085699607196,\n",
+       " 8: 0.0010595970352474955,\n",
+       " 9: 0.0010529807251878254,\n",
+       " 10: 0,\n",
+       " 11: 0,\n",
+       " 12: 0}"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 18,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "{d: false_prime_percent(sample(10**(d-1), 10**d, 100_000), k=1) for d in range(3, 13)}"
+    "{d: false_prime_percent(sample(10**(d-1), 10**d, 200_000), k=1) for d in range(3, 13)}"
    ]
   },
   {
@@ -521,39 +657,39 @@
    "id": "f3fe25d6-5f0a-478b-90d0-6c89e092e92e",
    "metadata": {},
    "source": [
-    "We see that 3-digit composites are falsely called prime about 1.4% of the time, and 4-digit comnposites about 0.5%, but once we get to 10-digit composites, false primes are very rare indeed. \n",
+    "We see that 3-digit composites are falsely called prime about 1.4% of the time, and 4-digit comnposites about 0.5%, but once we get to 9- or 10-digit composites, false primes are very rare indeed. Remember these are percents, not probabilities, so 0.001% is one in a hundred thousand.\n",
     "\n",
     "Let's see how we reduce false primes by allowing `k=25` choices of  `a`:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 19,
    "id": "8880c588-32f5-46e8-b59c-f9b49d492d3b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{3: 0.0,\n",
-       " 4: 0.0,\n",
-       " 5: 0.0,\n",
-       " 6: 0.0,\n",
-       " 7: 0.0,\n",
-       " 8: 0.0,\n",
-       " 9: 0.0,\n",
-       " 10: 0.0,\n",
-       " 11: 0.0,\n",
-       " 12: 0.0}"
+       "{3: 0,\n",
+       " 4: 0,\n",
+       " 5: 0,\n",
+       " 6: 0.0010824385174922064,\n",
+       " 7: 0,\n",
+       " 8: 0,\n",
+       " 9: 0,\n",
+       " 10: 0,\n",
+       " 11: 0,\n",
+       " 12: 0}"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "{d: false_prime_percent(sample(10**(d-1), 10**d, 100_000), k=25) for d in range(3, 13)}"
+    "{d: false_prime_percent(sample(10**(d-1), 10**d, 200_000), k=25) for d in range(3, 13)}"
    ]
   },
   {
@@ -561,42 +697,53 @@
    "id": "61ee44c3-f963-4fb1-ac20-4a27adc90f83",
    "metadata": {},
    "source": [
-    "In some runs this produces no false primes; in some runs one or two get through. \n",
+    "In most runs this produces no false primes; in some runs one or two get through. \n",
     "\n",
-    "There are a few numbers, called [**Carmichael numbers**](https://en.wikipedia.org/wiki/Carmichael_number), that have a particularly  high false prime percentage. We can test some of them:"
+    "There are a few numbers, called [**Carmichael numbers**](https://en.wikipedia.org/wiki/Carmichael_number), that have a  high false prime percentage. [Some Carmichael numbers](https://oeis.org/A033502) are worse than others. \n",
+    "\n",
+    "We can test some of them:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 20,
    "id": "7871aaa7-af1c-462b-85bb-d46818ccabea",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{561: 54.7,\n",
-       " 1105: 69.8,\n",
-       " 1729: 74.0,\n",
-       " 2465: 72.0,\n",
-       " 2821: 75.2,\n",
-       " 6601: 79.7,\n",
-       " 8911: 78.4,\n",
-       " 41041: 69.8,\n",
-       " 101101: 74.0,\n",
-       " 825265: 61.4,\n",
-       " 321197185: 63.5}"
+       "{561: 56.32,\n",
+       " 1105: 68.95,\n",
+       " 1729: 74.45,\n",
+       " 2465: 72.27,\n",
+       " 2821: 77.05,\n",
+       " 6601: 80.08,\n",
+       " 8911: 80.47,\n",
+       " 41041: 71.11,\n",
+       " 101101: 71.25,\n",
+       " 294409: 95.19,\n",
+       " 340561: 82.67,\n",
+       " 825265: 59.95,\n",
+       " 56052361: 98.96,\n",
+       " 118901521: 99.4,\n",
+       " 172947529: 99.43,\n",
+       " 216821881: 99.55,\n",
+       " 1299963601: 99.65,\n",
+       " 2301745249: 99.82,\n",
+       " 9624742921: 99.86}"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "carmichael_numbers = (561, 1105, 1729, 2465, 2821, 6601, 8911, 41041, 101101, 825265, 321197185)\n",
+    "carmichael_numbers = (561, 1105, 1729, 2465, 2821, 6601, 8911, 41041, 101101, 294409, 340561, 825265, \n",
+    "                      56052361, 118901521, 172947529, 216821881, 1299963601, 2301745249, 9624742921)\n",
     "\n",
-    "{n: false_prime_percent([n] * 1000, k=1) for n in carmichael_numbers}"
+    "{n: false_prime_percent([n] * 10_000, k=1) for n in carmichael_numbers}"
    ]
   },
   {
@@ -604,38 +751,46 @@
    "id": "4ecd2289-66d5-4b0f-ac00-5db0ad92dde9",
    "metadata": {},
    "source": [
-    "That seems seriously bad; they all are above 50% error rate. But if we set `k=40`, we eliminate most (and on some runs all) of the errors:"
+    "This is bad; some error rates are above 99%. Increasing `k` can fix the numbers with a 60% or 70% error rate, but not the ones with a 99% error rate:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 21,
    "id": "de492047-77b6-46a3-8a77-46308f219efd",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{561: 0.0,\n",
-       " 1105: 0.0,\n",
-       " 1729: 0.0,\n",
-       " 2465: 0.0,\n",
-       " 2821: 0.01,\n",
-       " 6601: 0.0,\n",
-       " 8911: 0.0,\n",
-       " 41041: 0.0,\n",
-       " 101101: 0.0,\n",
-       " 825265: 0.0,\n",
-       " 321197185: 0.0}"
+       "{561: 0,\n",
+       " 1105: 0,\n",
+       " 1729: 0,\n",
+       " 2465: 0,\n",
+       " 2821: 0,\n",
+       " 6601: 0,\n",
+       " 8911: 0,\n",
+       " 41041: 0,\n",
+       " 101101: 0,\n",
+       " 294409: 8.05,\n",
+       " 340561: 0,\n",
+       " 825265: 0,\n",
+       " 56052361: 64.72,\n",
+       " 118901521: 71.33,\n",
+       " 172947529: 74.18,\n",
+       " 216821881: 75.86,\n",
+       " 1299963601: 85.84,\n",
+       " 2301745249: 87.53,\n",
+       " 9624742921: 92.3}"
       ]
      },
-     "execution_count": 17,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "{n: false_prime_percent([n] * 10_000, k=40) for n in carmichael_numbers}"
+    "{n: false_prime_percent([n] * 10_000, k=50) for n in carmichael_numbers}"
    ]
   },
   {
@@ -643,27 +798,27 @@
    "id": "bfd71dc7-7f6d-4c98-9886-5c242d9b297a",
    "metadata": {},
    "source": [
-    "So our Fermat test is mostly reliable, but it will on rare occasion let a false prime slip through.\n",
+    "So our Fermat test is mostly reliable, but a few composite numbers will consistently be identified as false primes.\n",
     "\n",
-    "Fortunately there are variations on Fermat's idea that always give the right answer. `sympy.isprime` ([source code here](https://github.com/sympy/sympy/blob/master/sympy/ntheory/primetest.py)) uses the [Miller-Rabin test](https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test) (sometimes called Rabin-Miller, but I give Gary Miller precedence because he is my former colleague). The algorithm is guaranteed to give the right answer, but it does start to get slow for very large numbers. `sympy.isprime` gains efficiency by breaking the range of *n* values into subranges and cleverly precomputing a list of *a* values that work for every *n* in a subrange. For numbers greater than 2<sup>64</sup>, `sympy.isprime` falls back on the [Baillie–PSW test](https://en.wikipedia.org/wiki/Baillie%E2%80%93PSW_primality_test), which is faster than Miller-Rabin, but is probabilistic. There are no known counterexamples found so far (no equivalent of the Carmichael numbers for the Baillie-PSW test), but no proof that such numbers don't exist.\n",
+    "**Fortunately**, there are variations on Fermat's idea that always give the right answer. `sympy.isprime` ([source code here](https://github.com/sympy/sympy/blob/master/sympy/ntheory/primetest.py)) uses the [Miller-Rabin test](https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test) (sometimes called Rabin-Miller, but I give Gary Miller precedence because he is my former colleague). The algorithm is guaranteed to give the right answer, but it does start to get slow for very large numbers. `sympy.isprime` gains efficiency by breaking the range of *n* values into subranges and cleverly precomputing a list of *a* values that work for every *n* in a subrange. For numbers greater than 2<sup>64</sup>, `sympy.isprime` falls back on the [Baillie–PSW test](https://en.wikipedia.org/wiki/Baillie%E2%80%93PSW_primality_test), which is faster than Miller-Rabin, but is probabilistic. There are no known counterexamples found so far (no equivalent of the Carmichael numbers for the Baillie-PSW test), but no proof that such numbers don't exist.\n",
     "\n",
-    "# Speed of Primality Checking\n",
+    "# Speed of Primality testing\n",
     "\n",
-    "**The great thing** about `isprime_fermat` and `sympy.isprime` is that they are **very fast**, handling 32-digit primes in well under a millisecond. Let's create a list of big primes in ascending order of digit-length from 5 to 32, and measure how fast the functions are (while also verifying that they work correctly on Carmichael numbers):"
+    "**The great thing** about `isprime_fermat` and `sympy.isprime` is that they are **very fast**, handling 32-digit primes in well under a millisecond. Let's create a list of big primes in ascending order of digit-length from 5 to 32:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 22,
    "id": "be5f2fe7-b1e0-4a02-b7f0-7903e865c4b8",
    "metadata": {},
    "outputs": [],
    "source": [
-    "big_primes = ([int('357686312646216567629137'[-i:]) for i in range(5, 25)] # left-truncated primes\n",
-    "              + # The following primes sourced from t5k.org/curios/\n",
-    "              [1000000000000000035000061, 59999999999899999999999999, 100000109999990000011000001,\n",
+    "big_primes = [*[int('357686312646216567629137'[-i:]) for i in range(5, 25)], # left-truncated primes\n",
+    "              # The following primes sourced from t5k.org/curios/\n",
+    "              1000000000000000035000061, 59999999999899999999999999, 100000109999990000011000001,\n",
     "              2728487949505050529272727777, 24444666666888888889999999991, 100003100019100043100057100069,\n",
-    "              9999999999999999777777775555331, 55555555555555555555555555555559])"
+    "              9999999999999999777777775555331, 55555555555555555555555555555559]"
    ]
   },
   {
@@ -676,15 +831,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 23,
    "id": "8109d9fc-bbae-4ef0-a75c-908d9746a557",
    "metadata": {},
    "outputs": [],
    "source": [
     "import timeit\n",
     "\n",
-    "def plot_run_times(primes, functions=(isprime_simple, isprime_faster, isprime_fermat, isprime)):\n",
-    "    \"\"\"For each primality-checking function, plot its run time on primes of different digit-lengths.\"\"\"\n",
+    "prime_tests = (isprime_simple, isprime_faster, isprime_fermat, isprime)\n",
+    "\n",
+    "def plot_run_times(primes, functions=prime_tests):\n",
+    "    \"\"\"For each primality-testing function, plot its run time on primes of different digit-lengths.\"\"\"\n",
     "    plt.figure(figsize=(9, 6))\n",
     "    for function in functions:\n",
     "        plt.plot(*time_test(function, primes), 'o-', label=function.__name__)\n",
@@ -699,27 +856,27 @@
     "    \"\"\"Time the function on each of the primes, stopping when one exceeds a second.\n",
     "    Return a list of the digit sizes and a list of the corresponding run times.\"\"\"\n",
     "    D, T = [], [] # D is length of primes in digits; T is time in seconds\n",
-    "    repeat = (1 if function == isprime_simple else 500)\n",
+    "    repeat = (1 if function == isprime_simple else 200)\n",
     "    for p in primes:\n",
     "        time = timeit.timeit(lambda: function(p), number=repeat) / repeat\n",
     "        D.append(len(str(p)))\n",
     "        T.append(time)\n",
     "        if time > 1:\n",
-    "            break # Don't make a function do bigger primes if it took over a second on this one\n",
-    "        if time > 1/1000:\n",
+    "            break # Stop tsting a function once it takes over a second of run time\n",
+    "        elif time > 1e-3:\n",
     "            repeat = 1\n",
     "    return D, T"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 24,
    "id": "b1ab0f3d-6ce6-4b8c-9d4d-bb78bb1ac432",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 900x600 with 1 Axes>"
       ]
@@ -758,12 +915,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 25,
    "id": "4f377075-e352-46f9-a716-f1de673a7086",
    "metadata": {},
    "outputs": [],
    "source": [
-    "for fn in (isprime, isprime_simple, isprime_faster, isprime_fermat):\n",
+    "for fn in prime_tests:\n",
     "    assert all(fn(p) for p in (2, 3, 5, 7, 11, 37, 73, 101, 11939, 65537, 117223, 7629137))   # primes\n",
     "    assert all(fn(n) is False for n in (0, 1, 4, 6, 8, 9, 10, 256, 11939*11939, 11939*65537)) # composites"
    ]
@@ -773,16 +930,18 @@
    "id": "1347399a-24f2-4d5f-aa7f-822951126bf5",
    "metadata": {},
    "source": [
-    "This was fun for me! I remember learning about Fermat's Little Theorem and its application to primality testing in [Michael Rosen's](https://mathematics.brown.edu/people/michael-rosen) number theory class in college, and was impressed with it then, but I never worked through the details of how often the test gives a false prime result until now.\n",
+    "This was fun for me! I remember learning being excited about Fermat's Little Theorem in [Prof. Michael Rosen's](https://mathematics.brown.edu/people/michael-rosen) number theory class in college, but I never worked through the details of how often the test gives a false prime result until now.\n",
     "\n",
     "# Note on Modular Exponentiation\n",
     "\n",
-    "Just one more thing: none of this would work unless we can efficiently compute *a*<sup>(*n* - 1)</sup> (mod *n*).  How does the `pow` builtin function do it? When *a* and *n* are 24-digit numbers, if we naively tried to compute `a ** (n - 1)`, we'd have two problems: we'd need about a billion petabytes to store the result, and we'd need centuries to compute it. The way around these problems is to use [modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation) where we (1) apply the modulus to intermediate results, so we don't need petabytes of storage, and (2) cut the exponent in half each iteration, so we need only do *O*(log *n*) multiplications, not *O*(*n*). That's a big difference because log<sub>2</sub>(10<sup>24</sup>) is only 80. The basic idea is that *b*<sup>2*e*</sup> is equal to (*b* × *b*)<sup>*e*</sup>. Here is an implementation:"
+    "Just one more thing: none of this would work unless we can efficiently compute *a*<sup>(*n* - 1)</sup> (mod *n*).  How does the `pow` builtin function do it? When *a* and *n* are 24-digit numbers, if we naively tried to compute `a ** (n - 1)`, we'd have two problems: we'd need about a billion petabytes to store the result, and we'd need centuries to compute it. The way around these problems is to use [modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation) where we apply the modulus to each intermediate result, and cut the exponent in half each iteration, so we need only do *O*(log *n*) multiplications, not *O*(*n*). That's a big difference because log<sub>2</sub>(10<sup>24</sup>) is only 80. \n",
+    "\n",
+    "The key idea is that *b*<sup>2*e*</sup> is equal to (*b* × *b*)<sup>*e*</sup>. Here is an implementation:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 26,
    "id": "e71eb140-7e1a-4146-87a7-8c4eebf61486",
    "metadata": {},
    "outputs": [],
@@ -805,7 +964,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 27,
    "id": "01838139-52dd-48a0-8f62-bcdef351345e",
    "metadata": {},
    "outputs": [
@@ -813,8 +972,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 24 μs, sys: 0 ns, total: 24 μs\n",
-      "Wall time: 24.8 μs\n"
+      "CPU times: user 25 μs, sys: 1 μs, total: 26 μs\n",
+      "Wall time: 28.1 μs\n"
      ]
     },
     {
@@ -823,7 +982,7 @@
        "1"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }