From 8a40e42170a809252661ea88e1aa3b17a9670794 Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Wed, 7 Jan 2026 23:51:50 -0800 Subject: [PATCH] Add files via upload --- ipynb/TruncatablePrimes.ipynb | 375 ++++++++++++++++++---------------- 1 file changed, 195 insertions(+), 180 deletions(-) diff --git a/ipynb/TruncatablePrimes.ipynb b/ipynb/TruncatablePrimes.ipynb index 8ba4587..a74de01 100644 --- a/ipynb/TruncatablePrimes.ipynb +++ b/ipynb/TruncatablePrimes.ipynb @@ -23,9 +23,9 @@ " 37 is prime\n", " 7 is prime\n", "\n", - "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). I thought I would write a program to find other truncatable primes.\n", + "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). \n", "\n", - "My function `left_truncatable_primes` below starts with the list of one-digit primes: [2, 3, 5, 7]. Then it places each possible digit 1–9 to the left of each of the one-digit primes, giving a list of two-digit candidates. From the candidates it filters out just the primes. 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 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." ] }, { @@ -35,13 +35,12 @@ "metadata": {}, "outputs": [], "source": [ - "from sympy import isprime # isprime checks if a number is a prime\n", + "from sympy import isprime # isprime(n) returns True if n is a prime\n", "\n", - "def left_truncatable_primes(starting_primes=[2, 3, 5, 7]) -> list[int]:\n", + "def left_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", " \"\"\"All left-truncatable primes, in ascending order.\"\"\"\n", - " candidates = [int(d + str(p)) for d in \"123456789\" for p in starting_primes]\n", - " new_primes = [n for n in candidates if isprime(n)]\n", - " return starting_primes + (left_truncatable_primes(new_primes) if new_primes else [])" + " 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" ] }, { @@ -229,11 +228,10 @@ "metadata": {}, "outputs": [], "source": [ - "def right_truncatable_primes(starting_primes=[2, 3, 5, 7]) -> list[int]:\n", + "def right_truncatable_primes(primes=[2, 3, 5, 7]) -> list[int]:\n", " \"\"\"All right-truncatable primes, in ascending order.\"\"\"\n", - " candidates = [10 * p + d for p in starting_primes for d in (1, 3, 7, 9)]\n", - " new_primes = list(filter(isprime, candidates))\n", - " return starting_primes + (right_truncatable_primes(new_primes) if new_primes else [])" + " 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" ] }, { @@ -241,7 +239,7 @@ "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. 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", + "(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:" ] @@ -354,63 +352,16 @@ "\n", "# Note on Primality Checking\n", "\n", - "I was very impressed by the speed of `sympy.isprime`, so I wanted to look more deeply into the topic of primality checking. I'm going to write some prime-checking functions, so the first thing I will do is define a function to test that a prime checker correctly returns True when passed a prime and False when passed a composite number, for some given test cases." + "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:" ] }, { "cell_type": "code", "execution_count": 10, - "id": "4f377075-e352-46f9-a716-f1de673a7086", - "metadata": {}, - "outputs": [], - "source": [ - "from typing import Callable, Iterable\n", - "\n", - "def test_prime_checker(checker: Callable, \n", - " primes=(2, 3, 5, 7, 11, 37, 73, 101, 11939, 65537, 117223, 7629137),\n", - " composites=(0, 1, 4, 6, 8, 9, 10, 256, 11939*11939, 11939*117223)) -> Callable:\n", - " \"\"\"Test that a primality checking function correctly handles some primes and composites.\"\"\"\n", - " for n in primes:\n", - " assert checker(n) == True, f'{n} should be prime'\n", - " for n in composites:\n", - " assert checker(n) == False, f'{n} should be composite'\n", - " return checker # This allows us to use @test_prime_checker as a @decorator" - ] - }, - { - "cell_type": "markdown", - "id": "c08ed813-2942-42da-aed3-d5044b0b403a", - "metadata": {}, - "source": [ - "Here's how we would use this to check the `isprime` function:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "008cd6fd-86eb-4b45-bea9-c030273c4eb1", - "metadata": {}, - "outputs": [], - "source": [ - "assert test_prime_checker(isprime)" - ] - }, - { - "cell_type": "markdown", - "id": "6b307b24-a93e-4353-9bee-fba739072bd1", - "metadata": {}, - "source": [ - "But I can also use `@test_prime_checker` as a decorator to test the function right where it is defined; I'll do that for `isprime_simple`, which follows the definition of a prime number almost verbatim:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, "id": "1d460931-3d70-485d-807f-8fb360ef4ef2", "metadata": {}, "outputs": [], "source": [ - "@test_prime_checker\n", "def isprime_simple(n: int) -> bool:\n", " \"\"\"Simple primality checker. 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", @@ -425,21 +376,20 @@ "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 big. The small idea is to cut the run time in half by only checking the odd divisors. Once we determine that 2 is a prime and all other even numbers are composite, we only need to check odd divisors. 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 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." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "647fb66b-32ae-494a-8945-cf7358c2f958", "metadata": {}, "outputs": [], "source": [ "from math import sqrt\n", "\n", - "@test_prime_checker\n", "def isprime_faster(n: int) -> bool:\n", - " \"\"\"More sophisticated primality checker: go to square root, checking odd divisors only.\"\"\"\n", + " \"\"\"More sophisticated primality checker: check 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", @@ -458,37 +408,37 @@ "\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*(*n* - 1) ≡ 1 (mod *n*). \n", "\n", - "That means we can check if *n* is prime by choosing a random *a* and testing if *a*(*n* - 1) ≡ 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. 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.\n", - "Some examples:\n", + "That means we can check if *n* is prime by choosing a random *a* and testing if *a*(*n* - 1) ≡ 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", + "For example:\n", "\n", "\n", "|*n*|*a*|*a*(*n* - 1) (mod *n*)|Conclusion|\n", "|--:|--:|:--:|:--|\n", "|12|5|5|*12 is definitely composite*|\n", "|221|18|1|*221 could be prime or composite*|\n", - "|221|2|16|*221 is definitely 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", "\n", "\n", - "Here is an implementation:" + "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:" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "476282dd-a48a-4eb5-8fed-8495d4878ec2", "metadata": {}, "outputs": [], "source": [ "import random\n", + "from typing import Iterable\n", "\n", - "def sample(lo: int, hi: int, k: int) -> Iterable[int]:\n", - " \"\"\"Randomly sample k integers from range(lo, hi), one by one.\"\"\"\n", - " return (random.randrange(lo, hi) for _ in range(k))\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", - "@test_prime_checker\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", @@ -502,7 +452,7 @@ "id": "1ec7bba6-ea89-4255-a73c-bc25a32da883", "metadata": {}, "source": [ - "Note that the built-in [modular exponentiation](https://en.wikipedia.org/wiki/Modular_exponentiation) function `pow(b, e, m)` computes *b**e* (mod *m*), and does it in an efficient way that doesn't have to multiply *b* by itself *e* times, and doesn't have to deal with any numbers larger than *m*." + "(Note that `pow(a, n - 1, n)` efficiently computes *a*(*n* - 1) (mod *n*); more on this at the bottom of this notebook.)" ] }, { @@ -510,23 +460,22 @@ "id": "15ef6884-253d-4a3a-b58f-397ac73f552d", "metadata": {}, "source": [ - "**The problem** is that there are some composite numbers *n* for which *a*(*n* - 1) ≡ 1 (mod *n*) for some values of *a*, and thus `isprime_fermat` can lie: it can incorrectly report a **false prime** for a composite number *n*. \n", + "**The problem** is that there are some composite numbers *n* for which *a*(*n* - 1) ≡ 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", "\n", - "How common are these false primes? Here's a function to estimate the percentage of false primes in the range `lo` to `hi` when `isprime_fermat` is allowed `k` choices of the `a` parameter:" + "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": 15, + "execution_count": 13, "id": "45a11a93-9ef3-48d1-80fa-e0113041346e", "metadata": {}, "outputs": [], "source": [ - "def false_prime_percent(lo: int, hi: int, k: int, repeat=100_000) -> float:\n", - " \"\"\"The estimated probability of a false prime from isprime_fermat(n, k) for n in range(lo, hi).\"\"\"\n", - " composites = (n for n in sample(lo, hi, repeat) if not isprime(n))\n", - " counts = Counter(isprime_fermat(n, k) for n in composites) \n", - " return 100 * counts[True] / (counts[True] + counts[False])" + "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)" ] }, { @@ -534,37 +483,37 @@ "id": "778c3a9b-dcc7-4ad2-9092-d66aecd1d93c", "metadata": {}, "source": [ - "We'll choose ranges that represent digit-lengths, and for now use 1 for the value of `k`:" + "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`:" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "9eba96df-c298-4d71-b68a-3bf36bf15095", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{3: 1.5219868933421978,\n", - " 4: 0.44898977301072585,\n", - " 5: 0.15980955110048164,\n", - " 6: 0.02713174088102189,\n", - " 7: 0.007483109552723852,\n", - " 8: 0.003178740582981023,\n", + "{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}" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "{d: false_prime_percent(10**(d-1), 10**d, k=1) for d in range(3, 13)}" + "{d: false_prime_percent(sample(10**(d-1), 10**d, 100_000), k=1) for d in range(3, 13)}" ] }, { @@ -572,12 +521,14 @@ "id": "f3fe25d6-5f0a-478b-90d0-6c89e092e92e", "metadata": {}, "source": [ - "We see that 3-digit composites are falsely called prime about 1.5% of the time, but onnce we get to 10-digit composites, false primes are very rare indeed. Let's see how we reduce false primes by allowing up to 30 choices of `a`:" + "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", + "\n", + "Let's see how we reduce false primes by allowing `k=25` choices of `a`:" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "id": "8880c588-32f5-46e8-b59c-f9b49d492d3b", "metadata": {}, "outputs": [ @@ -587,7 +538,7 @@ "{3: 0.0,\n", " 4: 0.0,\n", " 5: 0.0,\n", - " 6: 0.001082461951462406,\n", + " 6: 0.0,\n", " 7: 0.0,\n", " 8: 0.0,\n", " 9: 0.0,\n", @@ -596,13 +547,13 @@ " 12: 0.0}" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "{d: false_prime_percent(10**(d-1), 10**d, k=30) for d in range(3, 13)}" + "{d: false_prime_percent(sample(10**(d-1), 10**d, 100_000), k=25) for d in range(3, 13)}" ] }, { @@ -617,27 +568,27 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "id": "7871aaa7-af1c-462b-85bb-d46818ccabea", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{561: 55.4,\n", - " 1105: 68.8,\n", - " 1729: 77.0,\n", - " 2465: 76.2,\n", - " 2821: 76.6,\n", - " 6601: 81.7,\n", - " 8911: 80.0,\n", - " 41041: 68.2,\n", - " 101101: 70.3,\n", - " 825265: 59.4,\n", - " 321197185: 68.6}" + "{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}" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -645,7 +596,7 @@ "source": [ "carmichael_numbers = (561, 1105, 1729, 2465, 2821, 6601, 8911, 41041, 101101, 825265, 321197185)\n", "\n", - "{n: false_prime_percent(n, n + 1, k=1, repeat=1000) for n in carmichael_numbers}" + "{n: false_prime_percent([n] * 1000, k=1) for n in carmichael_numbers}" ] }, { @@ -653,12 +604,12 @@ "id": "4ecd2289-66d5-4b0f-ac00-5db0ad92dde9", "metadata": {}, "source": [ - "That seems seriously bad; they all are above 50% error rate. But if we set `k=50`, we eliminate most (and on some runs all) of the errors:" + "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:" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "id": "de492047-77b6-46a3-8a77-46308f219efd", "metadata": {}, "outputs": [ @@ -669,7 +620,7 @@ " 1105: 0.0,\n", " 1729: 0.0,\n", " 2465: 0.0,\n", - " 2821: 0.0,\n", + " 2821: 0.01,\n", " 6601: 0.0,\n", " 8911: 0.0,\n", " 41041: 0.0,\n", @@ -678,13 +629,13 @@ " 321197185: 0.0}" ] }, - "execution_count": 19, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "{n: false_prime_percent(n, n + 1, k=50, repeat=10_000) for n in carmichael_numbers}" + "{n: false_prime_percent([n] * 10_000, k=40) for n in carmichael_numbers}" ] }, { @@ -698,25 +649,41 @@ "\n", "# Speed of Primality Checking\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 make a chart:" + "**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):" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, + "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", + " 2728487949505050529272727777, 24444666666888888889999999991, 100003100019100043100057100069,\n", + " 9999999999999999777777775555331, 55555555555555555555555555555559])" + ] + }, + { + "cell_type": "markdown", + "id": "6b2cbdc7-e8a9-4b83-aa0d-1e7cc83de071", + "metadata": {}, + "source": [ + "Now let's make a chart of all the prime functions running on the big primes:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, "id": "8109d9fc-bbae-4ef0-a75c-908d9746a557", "metadata": {}, "outputs": [], "source": [ "import timeit\n", "\n", - "big_primes = ([int('357686312646216567629137'[-i:]) for i in range(5, 25)] +\n", - " # The following primes sourced from t5k.org/curios/\n", - " [1000000000000000035000061, 59999999999899999999999999, 100000109999990000011000001,\n", - " 2728487949505050529272727777, 24444666666888888889999999991, 100003100019100043100057100069,\n", - " 9999999999999999777777775555331, 55555555555555555555555555555559])\n", - "\n", - "def plot_run_times(functions=(isprime_simple, isprime_faster, isprime_fermat, isprime), primes=big_primes):\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", " plt.figure(figsize=(9, 6))\n", " for function in functions:\n", @@ -732,13 +699,13 @@ " \"\"\"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 = 100 # Start with 100 repeats, but reduce when times get longer\n", + " repeat = (1 if function == isprime_simple else 500)\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\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", " repeat = 1\n", " return D, T" @@ -746,13 +713,13 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "b1ab0f3d-6ce6-4b8c-9d4d-bb78bb1ac432", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -762,58 +729,12 @@ } ], "source": [ - "plot_run_times()" + "plot_run_times(big_primes)" ] }, { "cell_type": "markdown", - "id": "408ba0fc-9bd9-4929-8ff3-1f9582ffa483", - "metadata": {}, - "source": [ - "We can test that our two Fermat functions work on the big primes and on the carmichael numbers, and get some more timing data:" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "7eacb754-e6ee-482e-82fd-8725845aad7e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.25 ms, sys: 0 ns, total: 1.25 ms\n", - "Wall time: 1.25 ms\n" - ] - } - ], - "source": [ - "%time test_prime_checker(isprime, primes=big_primes, composites=carmichael_numbers);" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "389cc455-6b9c-40f6-9fc2-2ae129159761", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 3.47 ms, sys: 0 ns, total: 3.47 ms\n", - "Wall time: 3.47 ms\n" - ] - } - ], - "source": [ - "%time test_prime_checker(isprime_fermat, primes=big_primes, composites=carmichael_numbers);" - ] - }, - { - "cell_type": "markdown", - "id": "1347399a-24f2-4d5f-aa7f-822951126bf5", + "id": "159833b0-afaf-486f-9c8e-1c8d2a11d9bf", "metadata": {}, "source": [ "What have we learned about timing?\n", @@ -822,10 +743,104 @@ "- `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`; but that's quite good for `isprime_fermat` considering how simple it is\n", - "- `isprime` produces no known incorrect answers; `isprime_fermat` will on rare occasion produce a false prime\n", + "- `isprime` is about twice as fast as `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" + ] + }, + { + "cell_type": "markdown", + "id": "4c76de9d-4803-4db5-b6c5-811a6a1c6da1", + "metadata": {}, + "source": [ + "It is good to get the timing results, but I should also run some test cases to demonstrate correctness:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "4f377075-e352-46f9-a716-f1de673a7086", + "metadata": {}, + "outputs": [], + "source": [ + "for fn in (isprime, isprime_simple, isprime_faster, isprime_fermat):\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" + ] + }, + { + "cell_type": "markdown", + "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", "\n", - "I hope you have enjoyed this excursion into the land of prime numbers.\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)`, 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 log2(1024) is only 80. The basic idea is that *b*2*e* is equal to (*b* × *b*)*e*. Here is an implementation:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "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", + " 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", + " modpow((b * b) % m, e // 2, m) * b % m)" + ] + }, + { + "cell_type": "markdown", + "id": "6baf40c3-db36-40ba-b2d7-45afa21f811f", + "metadata": {}, + "source": [ + "We can see this function is fast and that it correctly computes the remainder of 1 for the follwoing:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "01838139-52dd-48a0-8f62-bcdef351345e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 24 μs, sys: 0 ns, total: 24 μs\n", + "Wall time: 24.8 μs\n" + ] + }, + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 123456789012345678901234\n", + "n = 357686312646216567629137\n", + "\n", + "%time modpow(a, n - 1, n)" + ] + }, + { + "cell_type": "markdown", + "id": "4be033d1-93a0-4ef5-853e-81da0782ed20", + "metadata": {}, + "source": [ + "I hope you have enjoyed this excursion into the world of primes!" ] } ],