From 42960b72dd72eb6929fa99429cb4663baa6c223f Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Wed, 23 Sep 2026 23:41:14 -0700 Subject: [PATCH] Add files via upload --- ipynb/TruncatablePrimes.ipynb | 705 +++++++--------------------------- 1 file changed, 132 insertions(+), 573 deletions(-) diff --git a/ipynb/TruncatablePrimes.ipynb b/ipynb/TruncatablePrimes.ipynb index b76a1a2..a99cff6 100644 --- a/ipynb/TruncatablePrimes.ipynb +++ b/ipynb/TruncatablePrimes.ipynb @@ -25,7 +25,12 @@ "\n", "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). \n", "\n", - "I thought I would write a program to find all the truncatable primes. (It is not immediately obvious that there is a finite number of them, but it turns out to be true.) My function `truncatable_primes` below starts with the list of one-digit primes, [2, 3, 5, 7], and on each iteration creates a list of new numbers that are one digit longer by placing each possible digit 1–9 to the left of each prime. Then out of those numbers we find just the new primes. If there are any new primes, the function 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." + "I thought I would write a program to find all the truncatable primes. (It is not immediately obvious that there is a finite number of them, but it turns out to be true.) My function `truncatable_primes` below works as follows:\n", + "- Start with the one-digit primes, (2, 3, 5, 7).\n", + "- On each iteration creates a list of new numbers that are one digit longer by placing each possible digit 1–9 to the left of each prime.\n", + "- Out of those new numbers, find just the new primes.\n", + "- If there are any new primes, the function recursively adds digits to them, giving us longer primes.\n", + "- In the end, the function returns all the truncatable primes." ] }, { @@ -37,10 +42,10 @@ "source": [ "from sympy import isprime # isprime(n) returns True if n is a prime\n", "\n", - "def truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", + "def truncatable_primes(primes=(2, 3, 5, 7)) -> tuple[int]:\n", " \"\"\"Truncatable primes, in ascending order.\"\"\"\n", " new_numbers = (int(d + str(p)) for d in \"123456789\" for p in primes)\n", - " new_primes = [n for n in new_numbers if isprime(n)]\n", + " new_primes = tuple(filter(isprime, new_numbers))\n", " if new_primes:\n", " return primes + truncatable_primes(new_primes)\n", " else:\n", @@ -83,7 +88,7 @@ "id": "a32b56c4-587b-48d5-91ec-1abcef2e909f", "metadata": {}, "source": [ - "There are **4260** of these truncatable primes. Here are the smallest and largest of them:" + "There are **4260** of these truncatable primes. Here are the smallest and largest 16 of them:" ] }, { @@ -95,7 +100,7 @@ { "data": { "text/plain": [ - "[2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113]" + "(2, 3, 5, 7, 13, 17, 23, 37, 43, 47, 53, 67, 73, 83, 97, 113)" ] }, "execution_count": 3, @@ -116,7 +121,7 @@ { "data": { "text/plain": [ - "[66276812967623946997,\n", + "(66276812967623946997,\n", " 67986315421273233617,\n", " 86312646216567629137,\n", " 315396334245663786197,\n", @@ -131,7 +136,7 @@ " 57686312646216567629137,\n", " 95918918997653319693967,\n", " 96686312646216567629137,\n", - " 357686312646216567629137]" + " 357686312646216567629137)" ] }, "execution_count": 4, @@ -150,7 +155,7 @@ "source": [ "## Right-Truncatable Primes\n", "\n", - "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**:" + "What if you sharpen the pencil from the other end? That gives you **right-trunctable primes**:" ] }, { @@ -160,11 +165,11 @@ "metadata": {}, "outputs": [], "source": [ - "def right_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", + "def right_truncatable_primes(primes=(2, 3, 5, 7)) -> tuple[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_numbers = (10 * p + d for p in primes for d in (1, 3, 7, 9))\n", - " new_primes = [n for n in new_numbers if isprime(n)]\n", + " new_primes = tuple(filter(isprime, new_numbers))\n", " if new_primes:\n", " return primes + right_truncatable_primes(new_primes)\n", " else:\n", @@ -212,7 +217,7 @@ "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" + "(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" ] } ], @@ -281,350 +286,7 @@ " (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", - "## Palindromic Primes\n", - "\n", - "What about primes that are both truncatable and [**palindromic**](https://en.wikipedia.org/wiki/Palindromic_prime) (the same when you reverse the digits)?" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5a705ef4-b2b7-4006-b518-6e030de8fd30", - "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 + TPr if str(p) == str(p)[::-1]}" - ] - }, - { - "cell_type": "markdown", - "id": "cd0da3ad-54c0-47dc-979c-4eecc935425c", - "metadata": {}, - "source": [ - "There are 13 **palindromic truncatable primes**, with only 4 of them longer than 3 digits.\n", - "\n", - "**Aside**: Now I'm curious about [**palindromic primes**](https://en.wikipedia.org/wiki/Palindromic_prime) in general. There are probably an infinite number of them, so I'll define `palindromic_primes(d)` to list all the palindromic primes up to `d` digits. To find them, I'll enumerate the \"first half\" of numbers, and then concatenate the reverse of the first half, forming both odd- and even-length numbers, e.g. when the first half is 123, `palindromes(123)` produces (12321, 123321). Then all we have to do is check each palindrome for primality." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "fc208a86-c3f4-4426-913d-62ec0a639576", - "metadata": {}, - "outputs": [], - "source": [ - "def palindromic_primes(digit_length: int) -> list[int]:\n", - " \"\"\"Generate all palindromic primes of up to `digit_length` digits.\"\"\"\n", - " end = 10 ** ((digit_length + 1) // 2)\n", - " return [n for half in range(1, end)\n", - " for n in palindromes(half)\n", - " if isprime(n)]\n", - "\n", - "def palindromes(half: int) -> tuple[int]:\n", - " \"\"\"Given the left half of a palindrome, make two full palindromes,\n", - " one without the middle digit repeated, one with.\"\"\"\n", - " left = str(half)\n", - " right = left[::-1]\n", - " return int(left + right[1:]), int(left + right)\n", - "\n", - "assert palindromes(123) == (12321, 123321)" - ] - }, - { - "cell_type": "markdown", - "id": "ec5f9d5a-c89e-4dc9-812b-232437e4801e", - "metadata": {}, - "source": [ - "Let's count the palindromic primes of up to 11 digits, and peek at some of them:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "3f9c6d25-8d40-4267-a45f-c0284b910c86", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "47995" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "PP = palindromic_primes(11)\n", - "\n", - "len(PP)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "69149eb4-d79d-4cfa-8e48-40946e54c48f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[11,\n", - " 2,\n", - " 3,\n", - " 5,\n", - " 7,\n", - " 101,\n", - " 131,\n", - " 151,\n", - " 181,\n", - " 191,\n", - " 313,\n", - " 353,\n", - " 373,\n", - " 383,\n", - " 727,\n", - " 757,\n", - " 787,\n", - " 797,\n", - " 919,\n", - " 929,\n", - " 10301,\n", - " 10501,\n", - " 10601,\n", - " 11311,\n", - " 11411]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "PP[:25]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "3bebaad1-8fb2-4892-87f8-8846062d92d4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[99985958999,\n", - " 99986068999,\n", - " 99988688999,\n", - " 99988988999,\n", - " 99991819999,\n", - " 99994349999,\n", - " 99995759999,\n", - " 99998189999,\n", - " 99998989999,\n", - " 99999199999]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "PP[-10:]" - ] - }, - { - "cell_type": "markdown", - "id": "853d5a6c-936e-4ab4-afc3-2082641063fc", - "metadata": {}, - "source": [ - "# Digit Lengths\n", - "\n", - "How many digits are in the primes in all these lists? 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": 15, - "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')\n", - " 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": 16, - "id": "defd769e-9f92-4e4f-a12b-88a653b6efee", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1: 4,\n", - " 2: 11,\n", - " 3: 39,\n", - " 4: 99,\n", - " 5: 192,\n", - " 6: 326,\n", - " 7: 429,\n", - " 8: 521,\n", - " 9: 545,\n", - " 10: 517,\n", - " 11: 448,\n", - " 12: 354,\n", - " 13: 276,\n", - " 14: 212,\n", - " 15: 117,\n", - " 16: 72,\n", - " 17: 42,\n", - " 18: 24,\n", - " 19: 13,\n", - " 20: 6,\n", - " 21: 5,\n", - " 22: 4,\n", - " 23: 3,\n", - " 24: 1}" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAKBhJREFUeJzt3QlU1WX+x/EvyKKiuKWgiWi57+ZKpZkSpObo6JmpxjEqszI1l8mUyS2tMCs1HcypY+qcySxnsnLJxH1KXMLMNUY7eqQUKE1RS0W4//N9/v97/1wFQ7xwLw/v1zm/c/kt997n93CBD8/y+/k5HA6HAAAAWMrf2wUAAAAoToQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrBXi7AL4gNzdXTpw4IZUrVxY/Pz9vFwcAABSCXirw3LlzUqdOHfH3L7j9hrAjYoJOREREYeoVAAD4mLS0NKlbt26B+wk7IqZFx1lZoaGhJffdAQAARZaVlWUaK5x/xwtC2BFxdV1p0CHsAABQuvzWEBQGKAMAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsFuDtAgAouvoTVhf5ucdm9KHqAZQJtOwAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWC3A2wUAypr6E1YX+bnHZvTxaFkAoCygZQcAAFiNsAMAAKxGNxYAg+41ALaiZQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGpeDTtTp04VPz8/t6Vp06au/RcvXpThw4dLjRo1pFKlSjJw4EDJyMhwe43jx49Lnz59pGLFilKrVi0ZN26cXLlyxQtnAwAAfJHXr7PTokULWb9+vWs9IOD/izRmzBhZvXq1LF++XKpUqSIjRoyQAQMGyJdffmn25+TkmKATHh4u27Ztk5MnT8ojjzwigYGB8sorr3jlfAAAgG/xetjRcKNh5Wpnz56VhQsXytKlS6VHjx5m26JFi6RZs2ayfft26dKli6xbt04OHjxowlJYWJi0bdtWpk+fLuPHjzetRkFBQV44IwAA4Eu8Pmbn8OHDUqdOHbnttttk0KBBpltKpaSkSHZ2tkRHR7uO1S6uevXqSXJyslnXx1atWpmg4xQbGytZWVly4MCBAt/z0qVL5pi8CwAAsJNXw07nzp1l8eLFsnbtWnnrrbfk6NGj0rVrVzl37pykp6eblpmqVau6PUeDje5T+pg36Dj3O/cVJCEhwXSLOZeIiIhiOT8AAFDGu7F69erl+rp169Ym/ERGRsqHH34oFSpUKLb3jY+Pl7Fjx7rWtWWHwAMAgJ283o2Vl7biNG7cWI4cOWLG8Vy+fFnOnDnjdozOxnKO8dHHq2dnOdfzGwfkFBwcLKGhoW4LAACwk0+FnfPnz8t3330ntWvXlvbt25tZVRs2bHDtT01NNWN6oqKizLo+7tu3TzIzM13HJCUlmfDSvHlzr5wDAADwLV7txnruueekb9++puvqxIkTMmXKFClXrpw8/PDDZizNkCFDTHdT9erVTYAZOXKkCTg6E0vFxMSYUDN48GCZOXOmGaczceJEc20ebb0BAADwatj5/vvvTbA5deqU1KxZU+6++24zrVy/VrNnzxZ/f39zMUGdQaUzrebPn+96vgajVatWybBhw0wICgkJkbi4OJk2bZoXzwoAAPgSr4adZcuWXXd/+fLlJTEx0SwF0VahNWvWFEPpAACADXxqzA4AAICnEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVArxdAAD2qT9hdZGfe2xGH4+WBQBo2QEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAatwIFCgEbmwJAKUXLTsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAVvOZsDNjxgzx8/OT0aNHu7ZdvHhRhg8fLjVq1JBKlSrJwIEDJSMjw+15x48flz59+kjFihWlVq1aMm7cOLly5YoXzgAAAPginwg7u3btkr///e/SunVrt+1jxoyRlStXyvLly2XLli1y4sQJGTBggGt/Tk6OCTqXL1+Wbdu2yZIlS2Tx4sUyefJkL5wFAADwRV4PO+fPn5dBgwbJO++8I9WqVXNtP3v2rCxcuFBmzZolPXr0kPbt28uiRYtMqNm+fbs5Zt26dXLw4EH55z//KW3btpVevXrJ9OnTJTEx0QSggly6dEmysrLcFgAAYCevhx3tptLWmejoaLftKSkpkp2d7ba9adOmUq9ePUlOTjbr+tiqVSsJCwtzHRMbG2vCy4EDBwp8z4SEBKlSpYpriYiIKJZzAwAAZTzsLFu2THbv3m3Cx9XS09MlKChIqlat6rZdg43ucx6TN+g49zv3FSQ+Pt60HDmXtLQ0D50RAADwNQHeemMNGKNGjZKkpCQpX758ib53cHCwWQAAgP281rKj3VSZmZlyxx13SEBAgFl0EPLcuXPN19pCo+Nuzpw54/Y8nY0VHh5uvtbHq2dnOdedxwAAgLLNa2GnZ8+esm/fPtmzZ49r6dChgxms7Pw6MDBQNmzY4HpOamqqmWoeFRVl1vVRX0NDk5O2FIWGhkrz5s29cl4AAMC3eK0bq3LlytKyZUu3bSEhIeaaOs7tQ4YMkbFjx0r16tVNgBk5cqQJOF26dDH7Y2JiTKgZPHiwzJw504zTmThxohn0TDcVAADwatgpjNmzZ4u/v7+5mKBOF9eZVvPnz3ftL1eunKxatUqGDRtmQpCGpbi4OJk2bZpXyw0AAHyHT4WdzZs3u63rwGW9Zo4uBYmMjJQ1a9aUQOkAAEBp5PXr7AAAABQnwg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrBXi7AABwPfUnrC5yBR2b0YfKBUDLDgAAsBvdWAAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVArxdAKC41J+wusjPPTajj0fLAgDwHlp2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWK1LYue222+TUqVPXbD9z5ozZBwAAUKrDzrFjxyQnJ+ea7ZcuXZIffvjBE+UCAAAo+Ssof/rpp66vP//8c6lSpYprXcPPhg0bpH79+p4pGQAAQEmHnf79+5tHPz8/iYuLc9sXGBhogs4bb7zhiXIBAACUfNjJzc01jw0aNJBdu3bJLbfc4plSAAAA+NKYnaNHj3ok6Lz11lvSunVrCQ0NNUtUVJR89tlnrv0XL16U4cOHS40aNaRSpUoycOBAycjIcHuN48ePS58+faRixYpSq1YtGTdunFy5cuWmywYAAMr4Xc91fI4umZmZrhYfp3fffbdQr1G3bl2ZMWOGNGrUSBwOhyxZskT69esnX3/9tbRo0ULGjBkjq1evluXLl5vxQSNGjJABAwbIl19+6RonpEEnPDxctm3bJidPnpRHHnnEdKm98sorRT01AABQ1sPOiy++KNOmTZMOHTpI7dq1zRieoujbt6/b+ssvv2xae7Zv326C0MKFC2Xp0qXSo0cPs3/RokXSrFkzs79Lly6ybt06OXjwoKxfv17CwsKkbdu2Mn36dBk/frxMnTpVgoKCilQuAABQxsPOggULZPHixTJ48GCPFURbabQF58KFC6Y7KyUlRbKzsyU6Otp1TNOmTaVevXqSnJxswo4+tmrVygQdp9jYWBk2bJgcOHBA2rVrl+976RR5XZyysrI8dh4AAMCCMTuXL1+WO++80yMF2LdvnxmPExwcLE8//bSsWLFCmjdvLunp6aZlpmrVqm7Ha7DRfUof8wYd537nvoIkJCSYbjHnEhER4ZFzAQAAloSdJ554wnQveUKTJk1kz549smPHDtMio1PatWuqOMXHx8vZs2ddS1paWrG+HwAAKGXdWDpL6u233zZjZXQ2lQ4IzmvWrFmFfi1tvWnYsKH5un379mZK+5tvvikPPvigaUHSW1Dkbd3R2Vg6IFnp486dO91ezzlby3lMfrQVSRcAAGC/IoWdvXv3msHAav/+/W77ijpY2Ulndul4Gg0+GqJ0xpdOOVepqalmqrmO6VH6qIOadUaYTjtXSUlJZhq7doUBAAAUKexs2rTJY91JvXr1MoOOz507Z7rGNm/e7LoVxZAhQ2Ts2LFSvXp1E2BGjhxpAo4OTlYxMTEm1OhA6ZkzZ5pxOhMnTjTX5qHlBgAA3NR1djxBW2T0ujh6fRwNN9olpkHnvvvuM/tnz54t/v7+pmVHW3t0ptX8+fNdzy9XrpysWrXKjPXREBQSEmLG/Oi0eAAAgCKHnXvvvfe63VUbN24s1OvodXSup3z58pKYmGiWgkRGRsqaNWsK9X4AAKDsKVLYcY7XcdLr4eiMKh2/c/UNQgEAAEpd2NHupfzoVYvPnz9/s2UCAADw7nV2CvLnP/+50PfFAgAAKHVhR2/foONsAAAASnU3lt55PC+9Y7nOqPrqq69k0qRJniobAACAd8KOThPPS6eH620fdMq3XvsGAACgVIedRYsWeb4kAAAAvnZRwZSUFDl06JD5ukWLFtKuXTtPlQsAAMB7YUevfPzQQw+ZWzs4b9KpN+zUiw0uW7ZMatas6ZnSAYAH1Z+wusjPPTajD98LoCzNxtJ7VOm9rA4cOCCnT582i15QMCsrS5599lnPlxIAAKAkW3bWrl0r69evl2bNmrm26Q059bYODFAGAAClvmUnNzdXAgMDr9mu23QfAABAqQ47PXr0kFGjRsmJEydc23744QcZM2aM9OzZ05PlAwAAKPmw87e//c2Mz6lfv77cfvvtZmnQoIHZNm/evJsrEQAAgLfH7ERERMju3bvNuJ1vv/3WbNPxO9HR0Z4sGwAAQMm27GzcuNEMRNYWHD8/P7nvvvvMzCxdOnbsaK6185///OfmSwUAAOCNsDNnzhwZOnSohIaG5nsLiaeeekpmzZrlqbIBAACUbNj55ptv5P777y9wv04716sqAwAAlMqwk5GRke+Uc6eAgAD58ccfPVEuAACAkg87t956q7lSckH27t0rtWvX9kS5AAAASj7s9O7dWyZNmiQXL168Zt+vv/4qU6ZMkQceeMAzJQMAACjpqecTJ06Ujz76SBo3biwjRoyQJk2amO06/VxvFZGTkyMvvPCCJ8oFAABQ8mEnLCxMtm3bJsOGDZP4+HhxOBxmu05Dj42NNYFHjwEAAPAVN3xRwcjISFmzZo38/PPPcuTIERN4GjVqJNWqVSueEgIAAJT0FZSVhhu9kCAAAIB198YCAAAoLQg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1QK8XQAAKG3qT1h9U88/NqOPx8oC4LfRsgMAAKxG2AEAAFYj7AAAAKt5NewkJCRIx44dpXLlylKrVi3p37+/pKamuh1z8eJFGT58uNSoUUMqVaokAwcOlIyMDLdjjh8/Ln369JGKFSua1xk3bpxcuXKlhM8GAAD4Iq+GnS1btpggs337dklKSpLs7GyJiYmRCxcuuI4ZM2aMrFy5UpYvX26OP3HihAwYMMC1PycnxwSdy5cvy7Zt22TJkiWyePFimTx5spfOCgAA+BKvzsZau3at27qGFG2ZSUlJkW7dusnZs2dl4cKFsnTpUunRo4c5ZtGiRdKsWTMTkLp06SLr1q2TgwcPyvr16yUsLEzatm0r06dPl/Hjx8vUqVMlKCjIS2cHAAB8gU+N2dFwo6pXr24eNfRoa090dLTrmKZNm0q9evUkOTnZrOtjq1atTNBxio2NlaysLDlw4EC+73Pp0iWzP+8CAADs5DNhJzc3V0aPHi133XWXtGzZ0mxLT083LTNVq1Z1O1aDje5zHpM36Dj3O/cVNFaoSpUqriUiIqKYzgoAAHibz4QdHbuzf/9+WbZsWbG/V3x8vGlFci5paWnF/p4AAKAMX0F5xIgRsmrVKtm6davUrVvXtT08PNwMPD5z5oxb647OxtJ9zmN27tzp9nrO2VrOY64WHBxsFgAAYD+vtuw4HA4TdFasWCEbN26UBg0auO1v3769BAYGyoYNG1zbdGq6TjWPiooy6/q4b98+yczMdB2jM7tCQ0OlefPmJXg2AADAFwV4u+tKZ1p98skn5lo7zjE2Oo6mQoUK5nHIkCEyduxYM2hZA8zIkSNNwNGZWEqnqmuoGTx4sMycOdO8xsSJE81r03oDAAC8Gnbeeust89i9e3e37Tq9/NFHHzVfz549W/z9/c3FBHUWlc60mj9/vuvYcuXKmS6wYcOGmRAUEhIicXFxMm3atBI+G3j7BovcXBEA4HNhR7uxfkv58uUlMTHRLAWJjIyUNWvWeLh0AADABj4zGwsAAKA4EHYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYLcDbBQCAsqz+hNU39fxjM/p4rCyArWjZAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYzathZ+vWrdK3b1+pU6eO+Pn5yccff+y23+FwyOTJk6V27dpSoUIFiY6OlsOHD7sdc/r0aRk0aJCEhoZK1apVZciQIXL+/PkSPhMAAOCrvBp2Lly4IG3atJHExMR898+cOVPmzp0rCxYskB07dkhISIjExsbKxYsXXcdo0Dlw4IAkJSXJqlWrTIB68sknS/AsAACAL/PqFZR79epllvxoq86cOXNk4sSJ0q9fP7PtH//4h4SFhZkWoIceekgOHToka9eulV27dkmHDh3MMfPmzZPevXvL66+/blqM8nPp0iWzOGVlZRXL+QEAAO/z2TE7R48elfT0dNN15VSlShXp3LmzJCcnm3V91K4rZ9BRery/v79pCSpIQkKCeS3nEhERUcxnAwAAvMVn742lQUdpS05euu7cp4+1atVy2x8QECDVq1d3HZOf+Ph4GTt2rFvLDoHHO/f24b4+AIAyG3aKU3BwsFkAAID9fLYbKzw83DxmZGS4bdd15z59zMzMdNt/5coVM0PLeQwAACjbfDbsNGjQwASWDRs2uHU36VicqKgos66PZ86ckZSUFNcxGzdulNzcXDO2BwAAwKvdWHo9nCNHjrgNSt6zZ48Zc1OvXj0ZPXq0vPTSS9KoUSMTfiZNmmRmWPXv398c36xZM7n//vtl6NChZnp6dna2jBgxwszUKmgmFgAAKFu8Gna++uoruffee13rzkHDcXFxsnjxYnn++efNtXj0ujnagnP33Xebqebly5d3Pee9994zAadnz55mFtbAgQPNtXkAAAC8Hna6d+9urqdTEL2q8rRp08xSEG0FWrp0aTGVEAAAlHY+O2YHAADAEwg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqXr1dBADAc+pPWH1Tzz82o4/HygL4Elp2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgBAABWI+wAAACrEXYAAIDVCDsAAMBqhB0AAGA1wg4AALAaYQcAAFiNsAMAAKxG2AEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYLUAbxcAAOB76k9YXeTnHpvRx6NlAW4WLTsAAMBqtOyUUfzXBgAoK2jZAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsxkUFAQDFiouYwtto2QEAAFYj7AAAAKsRdgAAgNUIOwAAwGqEHQAAYDXCDgAAsBpTzwEApQbT2FEUtOwAAACr0bJTivAfDQAAN46WHQAAYDXCDgAAsJo13ViJiYny2muvSXp6urRp00bmzZsnnTp18naxAABlYGgAwwx8mxVh54MPPpCxY8fKggULpHPnzjJnzhyJjY2V1NRUqVWrllfLxg8AAIC/G95lRdiZNWuWDB06VB577DGzrqFn9erV8u6778qECRO8XTwAALyCf7gtCTuXL1+WlJQUiY+Pd23z9/eX6OhoSU5Ozvc5ly5dMovT2bNnzWNWVpbHy5d76ZciP/fq8vBa1BefCd/4GbqZ1ykLr8Xn1M76ajnl8yK/1v4XY6U4OMvocDiuf6CjlPvhhx/0DB3btm1z2z5u3DhHp06d8n3OlClTzHNYqAM+A3wG+AzwGeAzIKW+DtLS0q6bFUp9y05RaCuQjvFxys3NldOnT0uNGjXEz8/vN1NkRESEpKWlSWhoaAmUFtS9d/GZp+7LIj73paPetUXn3LlzUqdOneseV+rDzi233CLlypWTjIwMt+26Hh4enu9zgoODzZJX1apVb+h99ZtA2PEO6p56L2v4zFP3ZU3oDfyNrVKliv3X2QkKCpL27dvLhg0b3FpqdD0qKsqrZQMAAN5X6lt2lHZJxcXFSYcOHcy1dXTq+YULF1yzswAAQNllRdh58MEH5ccff5TJkyebiwq2bdtW1q5dK2FhYR5/L+3+mjJlyjXdYCh+1L13UO/eQ91T92VNcDH9jfXTUcoefUUAAAAfUurH7AAAAFwPYQcAAFiNsAMAAKxG2AEAAFYj7NyAxMREqV+/vpQvX97cXX3nzp3F952BMXXqVHNV67xL06ZNqZ1isHXrVunbt6+5EqnW88cff+y2X+cy6IzH2rVrS4UKFcz95w4fPsz3ogTq/tFHH73m5+D++++n7m9SQkKCdOzYUSpXriy1atWS/v37S2pqqtsxFy9elOHDh5sr7FeqVEkGDhx4zUVsUTx1371792s+908//XQR3o2wU2gffPCBuZ6PTonbvXu3tGnTRmJjYyUzM7NIFY/Ca9GihZw8edK1fPHFF1RfMdBrU+nnWkN9fmbOnClz586VBQsWyI4dOyQkJMT8DOgfAxRv3SsNN3l/Dt5//32q/SZt2bLFBJnt27dLUlKSZGdnS0xMjPl+OI0ZM0ZWrlwpy5cvN8efOHFCBgwYQN2XQN2roUOHun3u9fdQkXjyppw205uKDh8+3LWek5PjqFOnjiMhIcGr5bKd3rS1TZs23i5GmaO/GlasWOFaz83NdYSHhztee+0117YzZ844goODHe+//76XSlk26l7FxcU5+vXr57UylRWZmZmm/rds2eL6jAcGBjqWL1/uOubQoUPmmOTkZC+W1P66V/fcc49j1KhRDk+gG6sQLl++LCkpKabZ3snf39+sJycnFy1lotC0q0Sb92+77TYZNGiQHD9+nNorYUePHjUX7Mz7M6D3o9HuXH4GSsbmzZtNc3+TJk1k2LBhcurUqRJ657Lj7Nmz5rF69ermUX/va4tD3s+9dqPXq1ePz30x173Te++9Z+6B2bJlS3MT719++aXsXkG5uP3000+Sk5NzzRWZdf3bb7/1WrnKAv1junjxYvMLXpswX3zxRenatavs37/f9PWiZGjQUfn9DDj3ofhoF5Z2nTRo0EC+++47+etf/yq9evUyf3D1Rsi4eXpPxdGjR8tdd91l/rAq/Wzr/RevvlE0n/vir3v1pz/9SSIjI80/u3v37pXx48ebcT0fffTRDb8HYQc+TX+hO7Vu3dqEH/3wf/jhhzJkyBCvlg0oKQ899JDr61atWpmfhdtvv9209vTs2ZNvhAfo+BH9J4oxgb5T908++aTb514nR+jnXQO/fv5vBN1YhaBNaPrf09Uj8HU9PDz8hiocN0f/w2rcuLEcOXKEqixBzs85PwO+Qbt09fcSPweeMWLECFm1apVs2rRJ6tat6/a512EMZ86ccTue3/3FX/f50X92VVE+94SdQtBmzPbt28uGDRvcmt10PSoq6oYrHUV3/vx5k+o14aPkaPeJ/uLP+zOQlZVlZmXxM1Dyvv/+ezNmh5+Dm6PjwfWP7YoVK2Tjxo3mc56X/t4PDAx0+9xrN4qOG+RzX7x1n589e/aYx6J87unGKiSddh4XFycdOnSQTp06yZw5c8wUuccee+yGKx2F99xzz5nrj2jXlU751Kn/2sr28MMPU43FECTz/sekg5L1l4sOGNQBmdqn/tJLL0mjRo3ML6ZJkyaZvnS9PgaKr+510bFqen0XDZwa9p9//nlp2LChmfqPm+s+Wbp0qXzyySdmDKBz/JkOvtdrSemjdpfr73/9PoSGhsrIkSNN0OnSpQtVX4x1r59z3d+7d29zjSMds6OXAejWrZvpxr1hHpnTVUbMmzfPUa9ePUdQUJCZir59+3ZvF8l6Dz74oKN27dqmzm+99VazfuTIEW8Xy0qbNm0yUz+vXnTas3P6+aRJkxxhYWFmynnPnj0dqamp3i629XX/yy+/OGJiYhw1a9Y006AjIyMdQ4cOdaSnp3u72KVefnWuy6JFi1zH/Prrr45nnnnGUa1aNUfFihUdv//97x0nT570arnLQt0fP37c0a1bN0f16tXN75uGDRs6xo0b5zh79myR3s/v/94UAADASozZAQAAViPsAAAAqxF2AACA1Qg7AADAaoQdAABgNcIOAACwGmEHAABYjbADAACsRtgB4FXHjh0TPz8/131vfMG3335rbgdQvnx5adu2baGf1717d3NbDaf69eubW8uU5roAbEDYAcq4Rx991PyBnTFjhtv2jz/+2Gwvi/QebCEhIeamj3lvAnmjdu3aJU8++WShj4+IiJCTJ09Ky5YtzfrmzZvN9+Dqu24DuDGEHQCmBePVV1+Vn3/+2ZrauHz5cpGfqzchvPvuu80NaPUmhEVVs2ZNqVixYqGP15vc6s0+AwK4RzPgSYQdABIdHW3+yCYkJBRYG1OnTr2mS0e7aLSrJm8rkd4F/ZVXXpGwsDCpWrWqTJs2Ta5cuSLjxo0zd46uW7euLFq0KN+uozvvvNMEL23Z2LJli9v+/fv3S69evaRSpUrmtQcPHiw//fSTWxfSiBEjTDfSLbfcUuAdwXNzc02ZtBzBwcHmnNauXevary0pKSkp5hj9Ws87PxcuXJBHHnnElKd27dryxhtvXHPM1d1Yeo4aovQcmzdvLuvXrzfvoa1oV3dj6df33nuv2V6tWjWzXetX/etf/5JWrVqZu0NrGNPvn5YHQP4IOwBMi4IGlHnz5sn3339/UzWyceNGOXHihGzdulVmzZpluoQeeOAB8wd7x44d8vTTT8tTTz11zftoGPrLX/4iX3/9tURFRUnfvn3l1KlTZp924/To0UPatWsnX331lQknGRkZ8sc//tHtNZYsWSJBQUHy5ZdfyoIFC/It35tvvmmCyeuvvy579+41oeh3v/udHD582OzXbqQWLVqYsujXzz33XL6vo+XVQPbJJ5/IunXrTJfT7t27C6yXnJwcEwS1pUfr4e2335YXXnjhul1a//73v83X2p2mZdGy6+PDDz8sjz/+uBw6dMi874ABA4R7OgPX4dmbtgMobeLi4hz9+vUzX3fp0sXx+OOPm69XrFjhyPsrYsqUKY42bdq4PXf27NmOyMhIt9fS9ZycHNe2Jk2aOLp27epav3LliiMkJMTx/vvvm/WjR4+a95kxY4brmOzsbEfdunUdr776qlmfPn26IyYmxu2909LSzPNSU1PN+j333ONo167db55vnTp1HC+//LLbto4dOzqeeeYZ17qep55vQc6dO+cICgpyfPjhh65tp06dclSoUMExatQo1zatC60j9dlnnzkCAgIcJ0+edO1PSkoy56B1nbcuvv76a7O+adMms/7zzz+7npOSkmK2HTt27DfPFcD/omUHgIuO29HWEW0xKCptFfH3//9fLdrlpF0ueVuRtOslMzPT7XnamuOkY1Y6dOjgKsc333wjmzZtMl1GzqVp06au8TVO7du3v27ZsrKyTKvTXXfd5bZd12/knPU9dUxQ586dXdu0i65JkyYFPkdbZ7S1RrsLnTp16iQ3qk2bNtKzZ09Tp3/4wx/knXfesWqsFVAcCDsAXLp162a6deLj46/9ZeHvf01XSXZ29jXHBQYGuq3rWJP8tunYmcI6f/686dbSsSx5F+160jI76Qwq22lYTEpKks8++8yM+9GuRw1ZR48e9XbRAJ9F2AHgRqegr1y5UpKTk6+ZWZSenu4WeDx5PZjt27e7vtYBzTpIuFmzZmb9jjvukAMHDpgBvw0bNnRbbiTghIaGSp06dcyYnrx0XYNDYd1+++0mwOnYGydtXfnvf/9b4HM0kKSlpZmxRnmnpl+Pjj9yjve5Oixqa9SLL75oxjjpcStWrCh0+YGyhrADwI12jwwaNEjmzp3rtl1nO/34448yc+ZM042TmJhoWhc8RV9P/2DrjKXhw4eb8KCDcJWunz592gzM1YCg7//555/LY489dk0Q+C06sFi76z744APTtTRhwgQT2kaNGlXo19ButCFDhpjX0gHZOlNMZ0rl7b672n333WdCUlxcnBkYrQFr4sSJZl9B1zPSqe+6b9WqVabutYVLA5YOJteB2sePH5ePPvrI7HMGQwDXIuwAuIZOu766m0n/mM6fP9+EEh03snPnzgJnKhW1RUkXfe0vvvhCPv30UzOFXDlbYzTYxMTEmECmU8x1avv1AkZ+nn32WRk7dqyZbaWvozO79L0aNWp0Q6/z2muvSdeuXU33mk791inl1xszpN1POsVcA0vHjh3liSeecM3G0qno+bn11ltN640GMh37pFPrtXVKZ7r17t1bGjdubAKTzi7TafkA8ueno5QL2AcAKEYa4DQkHTlyxLT6ACgehB0AKCHaTaddYNqKpAFHu870+kPakgWg+HBNcgAoIefOnZPx48ebsTbaRafdX/ldeRmAZ9GyAwAArMYAZQAAYDXCDgAAsBphBwAAWI2wAwAArEbYAQAAViPsAAAAqxF2AACA1Qg7AABAbPY/SY5kJ5KwxVUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "digit_lengths(TP)" - ] - }, - { - "cell_type": "markdown", - "id": "ec4c6f1d-d298-48de-884a-efee0b81fd19", - "metadata": {}, - "source": [ - "And for the **right-truncatable** primes:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "09f29951-d8f2-47a3-b666-bfa6fd5d1c87", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{1: 4, 2: 9, 3: 14, 4: 16, 5: 15, 6: 12, 7: 8, 8: 5}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "digit_lengths(TPr)" - ] - }, - { - "cell_type": "markdown", - "id": "8618e5bc-ea92-4116-aa74-2380fbfd0dc3", - "metadata": {}, - "source": [ - "Finally, for the **palindromic primes**, we find that \"11\" is the only even-digit-length palindromic prime. (It turns out that any even-digit-length palindromic number is [divisible by 11](https://www.geeksforgeeks.org/dsa/g-fact-all-palindromes-with-an-even-number-of-digits-are-divisible-by-11/).) The counts of primes grow so quickly that it is better to use a log scale on the y axis: " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "ed392e12-7480-4d96-994f-96cdb786f8f9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{2: 1, 1: 4, 3: 15, 5: 93, 7: 668, 9: 5172, 11: 42042}" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.yscale('log')\n", - "digit_lengths(PP)" + "[p for p in TPr if is_omni_truncatable_prime(p)]" ] }, { @@ -632,31 +294,16 @@ "id": "f2323985-2518-41d1-8a3b-6e21e40d27be", "metadata": {}, "source": [ - "# Summary \n", + "There are only 9 of them: 4 one-digit, 4 two-digit, and 1 three-digit.\n", "\n", - "Here's what we learned:\n", - "\n", - "- Left-trunctable primes:\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", - " - 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", - "- Palindromic primes:\n", - " - Count: probably infinite; 47995 of them up to 11 digits\n", - " - All except \"11\" have an odd number of digits\n", + "## Summary \n", "\n", + "|Kind|Count|Largest|Digits|\n", + "|---|---:|---:|---:|\n", + "|Left-truncatable primes|4260|357686312646216567629137|24|\n", + "|Right-truncatable primes|83|73939133 |8|\n", + "|Two-sided primes|15|739397 |6|\n", + "|Omni-truncatable primes|9|373 |3|\n", "\n", "# Primality Testing\n", "\n", @@ -665,7 +312,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 10, "id": "1d460931-3d70-485d-807f-8fb360ef4ef2", "metadata": {}, "outputs": [], @@ -684,12 +331,12 @@ "source": [ "To test a *d*-digit prime we have to iterate through nearly 10d 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 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." + "We can speed things up a bit with two ideas, one minor and one major. The minor 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 major 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": 20, + "execution_count": 11, "id": "647fb66b-32ae-494a-8945-cf7358c2f958", "metadata": {}, "outputs": [], @@ -702,7 +349,7 @@ " return n in (2, 3, 5, 7)\n", " elif n % 2 == 0: # Even numbers other than 2 are composite\n", " return False\n", - " else: # test odd divisors up to sqrt(n)\n", + " else: # test odd divisors up to √n\n", " divisors = range(11, int(sqrt(n)) + 1, 2) \n", " return not any(n % d == 0 for d in divisors)" ] @@ -712,11 +359,11 @@ "id": "05b8cbf7-ea10-4047-bcdb-a5ac7981384b", "metadata": {}, "source": [ - "For a 24-digit prime, `isprime_simple` would need to test septillions of divisors, while `isprime_faster` would \"only\" need to test trillions. That's the difference between never completing versus taking a few hours. But we would like to get the time down from hours to milliseconds. We need a massive breakthrough. \n", + "For a 24-digit prime, `isprime_simple` would need to test septillions of divisors, while `isprime_faster` would \"only\" need to test trillions. That's the difference between never completing versus taking a few hours. But we would like to get the time down from hours to milliseconds. The major idea wasn't enough; we need a massive breakthrough. \n", "\n", "# Probabilistic Primality Testing\n", "\n", - "**Fortunately**, [Pierre de Fermat](https://en.wikipedia.org/wiki/Pierre_de_Fermat) provided the big breakthrough in 1640! \n", + "**Fortunately**, [Pierre de Fermat](https://en.wikipedia.org/wiki/Pierre_de_Fermat) provided the massive breakthrough in 1640! \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", @@ -731,28 +378,29 @@ "|12|5|5|*12 is definitely composite*|\n", "|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|*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", + "|2137|2|1|*2137 could be prime or composite*|\n", + "|2137|3|1|*try again: 2137 could still be prime or composite*|\n", + "|2137|7|1|*try again: 2137 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](https://en.wikipedia.org/wiki/Randomized_algorithm), and can sometimes be wrong. Here is a simple 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: it can incorrectly report a **false prime** for a composite number *n*. Here is a simple implementation:" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 12, "id": "c8a59c5e-a01c-49be-a931-c1547c4ac712", "metadata": {}, "outputs": [], "source": [ "def isprime_fermat(n: int, k=20) -> bool:\n", - " \"\"\"If isprime_fermat(n) is False then n is definitely composite; if True then n is probably prime.\n", + " \"\"\"If isprime_fermat(n) is True then n is probably prime; if False then n is definitely composite.\n", " Increase `k` to decrease the probability of false primes.\"\"\"\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 \n", + " for a in sample(2, n, k))" ] }, { @@ -767,14 +415,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 13, "id": "476282dd-a48a-4eb5-8fed-8495d4878ec2", "metadata": {}, "outputs": [], "source": [ "import random\n", "from typing import Iterable\n", - " \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))" @@ -785,62 +433,51 @@ "id": "15ef6884-253d-4a3a-b58f-397ac73f552d", "metadata": {}, "source": [ - "**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:" + "How common are false primes? Here's a function to report a table of false prime probabilities, over various values of *k*, and various ranges of numbers *n*:" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 22, "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 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 mean(100 * isprime_fermat(n, k) for n in composites)" - ] - }, - { - "cell_type": "markdown", - "id": "778c3a9b-dcc7-4ad2-9092-d66aecd1d93c", - "metadata": {}, - "source": [ - "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": 24, - "id": "9eba96df-c298-4d71-b68a-3bf36bf15095", - "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "{3: 1.408066267526657,\n", - " 4: 0.4848670443525749,\n", - " 5: 0.1327436065501534,\n", - " 6: 0.03568377685744872,\n", - " 7: 0.011224724326115657,\n", - " 8: 0.0015893702914905115,\n", - " 9: 0,\n", - " 10: 0,\n", - " 11: 0,\n", - " 12: 0}" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " label k = 1 k = 5 k = 10 k = 20 \n", + " 3 digits 1.469% 0.010% 0.001% 0.000%\n", + " 4 digits 0.453% 0.019% 0.003% 0.001%\n", + " 5 digits 0.125% 0.006% 0.001% 0.001%\n", + " 6 digits 0.033% 0.001% 0.001% 0.000%\n", + " 7 digits 0.006% 0.000% 0.001% 0.000%\n", + " 8 digits 0.001% 0.000% 0.000% 0.000%\n", + " 9 digits 0.000% 0.000% 0.000% 0.000%\n", + "10 digits 0.000% 0.000% 0.000% 0.000%\n", + "11 digits 0.000% 0.000% 0.000% 0.000%\n", + "12 digits 0.000% 0.000% 0.000% 0.000%\n" + ] } ], "source": [ - "{d: false_prime_percent(sample(10**(d-1), 10**d, 200_000), k=1) for d in range(3, 13)}" + "from statistics import mean\n", + "\n", + "def false_prime_probability(samples: Iterable[int], k: int) -> float:\n", + " \"\"\"The probability 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 mean(isprime_fermat(n, k) for n in composites)\n", + " \n", + "\n", + "def report_false_primes(label_start_stop_triples: Iterable, k_values=(1, 5, 10, 20), num_samples=200_000):\n", + " \"\"\"Report false prime probability for different digit lengths, and k values.\"\"\"\n", + " print(' label ', *[f'k = {k:<4}' for k in k_values])\n", + " for (label, start, stop) in label_start_stop_triples:\n", + " samples = list(sample(start, stop, num_samples))\n", + " print(f'{label:10} ', *[f'{false_prime_probability(samples, k):8.3%}' for k in k_values])\n", + "\n", + "report_false_primes([(f'{d:2} digits', 10 ** (d - 1), 10 ** d) \n", + " for d in range(3, 13)])" ] }, { @@ -848,93 +485,52 @@ "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 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": 25, - "id": "8880c588-32f5-46e8-b59c-f9b49d492d3b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{3: 0,\n", - " 4: 0,\n", - " 5: 0.00036752274965820385,\n", - " 6: 0.0007220216606498195,\n", - " 7: 0,\n", - " 8: 0,\n", - " 9: 0,\n", - " 10: 0,\n", - " 11: 0,\n", - " 12: 0}" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "{d: false_prime_percent(sample(10**(d-1), 10**d, 300_000), k=25) for d in range(3, 13)}" - ] - }, - { - "cell_type": "markdown", - "id": "61ee44c3-f963-4fb1-ac20-4a27adc90f83", - "metadata": {}, - "source": [ - "The results are randomized, and in some runs this produces no false primes; in some runs a few get through. \n", + "We see that with *k* = 1, 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 numbers, and *k* at 10 or more, false primes are very rare indeed. \n", "\n", "The so-called [**Carmichael numbers**](https://en.wikipedia.org/wiki/Carmichael_number) are composite numbers with a very high false prime percentage. [Some Carmichael numbers](https://oeis.org/A033502) are worse than others. \n", "\n", - "We can test some of them:" + "We can test some of them:\n" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 23, "id": "7871aaa7-af1c-462b-85bb-d46818ccabea", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "{561: 57.14,\n", - " 1105: 69.55,\n", - " 1729: 74.87,\n", - " 2465: 72.6,\n", - " 2821: 76.78,\n", - " 6601: 80.01,\n", - " 8911: 79.49,\n", - " 41041: 70.78,\n", - " 101101: 71.57,\n", - " 294409: 95.12,\n", - " 340561: 82.24,\n", - " 825265: 60.79,\n", - " 56052361: 99.04,\n", - " 118901521: 99.29,\n", - " 172947529: 99.32,\n", - " 216821881: 99.31,\n", - " 1299963601: 99.58,\n", - " 2301745249: 99.88,\n", - " 9624742921: 99.8}" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + " label k = 1 k = 10 k = 30 k = 100 k = 1000\n", + " 1105 69.790% 2.780% 0.000% 0.000% 0.000%\n", + " 1729 75.240% 5.300% 0.020% 0.000% 0.000%\n", + " 2465 72.190% 3.970% 0.010% 0.000% 0.000%\n", + " 2821 76.750% 6.990% 0.020% 0.000% 0.000%\n", + " 6601 79.830% 11.100% 0.130% 0.000% 0.000%\n", + " 8911 80.370% 10.280% 0.130% 0.000% 0.000%\n", + " 41041 69.760% 2.770% 0.010% 0.000% 0.000%\n", + " 101101 70.840% 3.330% 0.000% 0.000% 0.000%\n", + " 294409 95.410% 60.260% 21.680% 0.580% 0.000%\n", + " 340561 81.760% 13.160% 0.250% 0.000% 0.000%\n", + " 825265 60.220% 0.750% 0.000% 0.000% 0.000%\n", + " 56052361 99.180% 91.410% 77.270% 41.040% 0.010%\n", + " 118901521 99.330% 93.910% 80.950% 50.660% 0.180%\n", + " 172947529 99.350% 94.020% 83.620% 54.680% 0.260%\n", + " 216821881 99.570% 94.530% 84.460% 58.240% 0.420%\n", + "1299963601 99.770% 97.190% 91.170% 73.480% 4.660%\n", + "2301745249 99.720% 97.530% 92.990% 78.900% 8.150%\n", + "9624742921 99.840% 98.420% 95.070% 85.410% 20.370%\n" + ] } ], "source": [ - "carmichael_numbers = (561, 1105, 1729, 2465, 2821, 6601, 8911, 41041, 101101, 294409, 340561, 825265, \n", + "carmichael_numbers = (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] * 10_000, k=1) for n in carmichael_numbers}" + "report_false_primes([(c, c, c + 1) \n", + " for c in carmichael_numbers], \n", + " k_values=(1, 10, 30, 100, 1000), num_samples=10_000)" ] }, { @@ -942,46 +538,7 @@ "id": "4ecd2289-66d5-4b0f-ac00-5db0ad92dde9", "metadata": {}, "source": [ - "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. Below we increase `k` to 50, and some Carmichael numbers still claim to be prime most of the time:" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "de492047-77b6-46a3-8a77-46308f219efd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{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: 9,\n", - " 340561: 0,\n", - " 825265: 0,\n", - " 56052361: 61,\n", - " 118901521: 64,\n", - " 172947529: 80,\n", - " 216821881: 77,\n", - " 1299963601: 85,\n", - " 2301745249: 85,\n", - " 9624742921: 96}" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "{n: false_prime_percent([n] * 100, k=50) for n in carmichael_numbers}" + "This is bad; some Carmichael numbers have false prime probability above 99% with *k* = 1. Increasing `k` helps, but even with *k* = 1000, some Carmichael numbers still have a high false prime probability." ] }, { @@ -991,25 +548,26 @@ "source": [ "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 264, `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 264, `sympy.isprime` gives up on guaranteed correct answers and 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 false positives for the Baillie-PSW test, but no proof that they don't exist.\n", "\n", "# Speed of Primality testing\n", "\n", - "**The great thing** about `isprime_fermat` and `sympy.isprime` is that they are **very fast**, handling even 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:" + "**The great thing** about `isprime_fermat` and `sympy.isprime` is that they are **very fast**, handling even 32-digit primes in well under a millisecond. Let's create a list of big primes with different digit-lengths:" ] }, { "cell_type": "code", - "execution_count": 28, - "id": "be5f2fe7-b1e0-4a02-b7f0-7903e865c4b8", + "execution_count": 16, + "id": "2a10367d-45c1-4425-a630-96892555c1b7", "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", - " 2728487949505050529272727777, 24444666666888888889999999991, 100003100019100043100057100069,\n", - " 9999999999999999777777775555331, 55555555555555555555555555555559]" + "big_primes = [ # One prime of each digit length from 5 to 32\n", + " 29137, 629137, 7629137, 67629137, 567629137, 6567629137, 16567629137, 216567629137, 6216567629137, 46216567629137, \n", + " 646216567629137, 2646216567629137, 12646216567629137, 312646216567629137, 6312646216567629137, 86312646216567629137, \n", + " 686312646216567629137, 7686312646216567629137, 57686312646216567629137, 357686312646216567629137, 1000000000000000035000061, \n", + " 59999999999899999999999999, 100000109999990000011000001, 2728487949505050529272727777, 24444666666888888889999999991, \n", + " 100003100019100043100057100069, 9999999999999999777777775555331, 55555555555555555555555555555559]" ] }, { @@ -1017,16 +575,17 @@ "id": "6b2cbdc7-e8a9-4b83-aa0d-1e7cc83de071", "metadata": {}, "source": [ - "Now let's make a chart of all the primality checking functions running on the big primes:" + "Next make a chart of the speeds of all the primality checking functions running on the big primes:" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 17, "id": "8109d9fc-bbae-4ef0-a75c-908d9746a557", "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", "import timeit\n", "\n", "prime_tests = (isprime_simple, isprime_faster, isprime_fermat, isprime)\n", @@ -1061,13 +620,13 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 18, "id": "b1ab0f3d-6ce6-4b8c-9d4d-bb78bb1ac432", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1091,7 +650,7 @@ "- `isprime_fermat` and `isprime` ([according to Wikipedia](https://en.wikipedia.org/wiki/Fermat_primality_test)) have a run time of *O*(*k* log2*n*), where *k* is the number of repeats \n", "- `isprime_faster` is more than 10,000 times faster than `isprime_simple` on 8-digit primes\n", "- `isprime_fermat` is more than 10,000 times faster than `isprime_faster` on 17 digit primes\n", - "- `isprime` is about twice as fast as `isprime_fermat`\n", + "- `isprime` is about ten times faster than `isprime_fermat`\n", " - (but that's quite good for `isprime_fermat` considering how much simpler it is: 10 lines versus 800)\n", "- `isprime` produces no known incorrect answers; `isprime_fermat` will on rare occasion produce a false prime" ] @@ -1106,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 19, "id": "4f377075-e352-46f9-a716-f1de673a7086", "metadata": {}, "outputs": [], @@ -1123,11 +682,11 @@ "source": [ "This was fun for me! I remember being amazed by Fermat's Little Theorem when I learned about it 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", - "That number theory class was important for me in several ways. First, it was hard fun. Second, it was the first class that felt like actually *doing* math, rather than being taught some techniques to prepare you to do math some time in the future. And third, I learned a valuable lesson: there was a take-home final exam, handed out Friday and due Monday. I worked on it all day Saturday, and couldn't answer a single one of the ten problems. At that point, I thought to myself \"This never happens on my computer science assignments; I guess I'm more cut out for CS than math.\" On Sunday I came back to it and eventually got answers to most of the problems. (I remember that on one problem, Prof. Rosen said \"You had a very elegant solution for that one, better than the answer I expected. But then I realized it was so good, it could be extended to be a trivial solution to this known difficult problem, and so I looked more closely and noticed a flaw in your argument. Too bad.\")\n", + "That number theory class was important for me in several ways. First, it was [hard fun](https://dailypapert.com/hard-fun/). Second, it was the first class that felt like actually *doing* math, rather than being taught some techniques to prepare you to do math some time in the future. And third, I learned a valuable lesson: there was a take-home final exam, handed out Friday and due Monday. I worked on it all day Saturday, and couldn't answer a single one of the ten problems. At that point, I thought to myself \"This never happens on my computer science assignments; I guess I'm more cut out for CS than math.\" On Sunday I came back to it and eventually got answers to most of the problems. (I remember that on one problem, Prof. Rosen said \"You had a very elegant solution for that one, better than the answer I expected. But then I realized it was so good, it could be extended to be a trivial solution to this known difficult problem, and so I looked more closely and noticed a flaw in your argument. Too bad.\")\n", "\n", "# Note on Modular Exponentiation\n", "\n", - "Just one more thing: none of this would work unless we can efficiently compute *a*(*n* - 1) (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)` and then apply (mod *n*), we'd have two problems: we'd need nearly 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: 1024 is a trillion trillion, and log2(1024) is only 80. \n", + "Just one more thing: none of this would work unless we can efficiently compute *a*(*n* - 1) (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)` and then apply (mod *n*), we'd have two problems: we'd need 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: 1024 is a trillion trillion, and log2(1024) is only 80. \n", "\n", "There are two key ides that make this work:\n", "1) *b*2*e* = (*b* × *b*)*e*\n", @@ -1140,13 +699,13 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 20, "id": "e71eb140-7e1a-4146-87a7-8c4eebf61486", "metadata": {}, "outputs": [], "source": [ "def modpow(b: int, e: int, m: int) -> int:\n", - " \"\"\"Compute b**e mod m, efficiently.\"\"\"\n", + " \"\"\"Compute b ** e mod m, efficiently.\"\"\"\n", " return (1 if e == 0 else\n", " b if e == 1 else\n", " modpow((b * b) % m, e // 2, m) if e % 2 == 0 else\n", @@ -1163,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 21, "id": "01838139-52dd-48a0-8f62-bcdef351345e", "metadata": {}, "outputs": [ @@ -1171,8 +730,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 27 μs, sys: 0 ns, total: 27 μs\n", - "Wall time: 28.8 μs\n" + "CPU times: user 21 μs, sys: 1e+03 ns, total: 22 μs\n", + "Wall time: 22.2 μs\n" ] }, { @@ -1181,7 +740,7 @@ "1" ] }, - "execution_count": 33, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -1218,7 +777,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.3" + "version": "3.13.9" } }, "nbformat": 4,