diff --git a/ipynb/TruncatablePrimes.ipynb b/ipynb/TruncatablePrimes.ipynb index a99cff6..826b2c8 100644 --- a/ipynb/TruncatablePrimes.ipynb +++ b/ipynb/TruncatablePrimes.ipynb @@ -23,14 +23,14 @@ " 37 is prime\n", " 7 is prime\n", "\n", - "Numbers like this are called [**truncatable primes**](https://en.wikipedia.org/wiki/Truncatable_prime). \n", + "Numbers like this are called [**left-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 works as follows:\n", + "My function `left_truncatable_primes` 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", + "- On each iteration create 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." + "- If there are any new primes, the function recursively adds digits to them, giving us even longer primes.\n", + "- In the end, the function returns all the left-truncatable primes." ] }, { @@ -42,12 +42,12 @@ "source": [ "from sympy import isprime # isprime(n) returns True if n is a prime\n", "\n", - "def truncatable_primes(primes=(2, 3, 5, 7)) -> tuple[int]:\n", - " \"\"\"Truncatable primes, in ascending order.\"\"\"\n", + "def left_truncatable_primes(primes=(2, 3, 5, 7)) -> tuple[int]:\n", + " \"\"\"All left-truncatable primes, in ascending order.\"\"\"\n", " new_numbers = (int(d + str(p)) for d in \"123456789\" for p in primes)\n", " new_primes = tuple(filter(isprime, new_numbers))\n", " if new_primes:\n", - " return primes + truncatable_primes(new_primes)\n", + " return primes + left_truncatable_primes(new_primes)\n", " else:\n", " return primes" ] @@ -78,9 +78,9 @@ } ], "source": [ - "TP = truncatable_primes()\n", + "LTP = left_truncatable_primes()\n", "\n", - "len(TP)" + "len(LTP)" ] }, { @@ -88,7 +88,7 @@ "id": "a32b56c4-587b-48d5-91ec-1abcef2e909f", "metadata": {}, "source": [ - "There are **4260** of these truncatable primes. Here are the smallest and largest 16 of them:" + "There are **4260**; here are the smallest and largest 16 of them:" ] }, { @@ -109,7 +109,7 @@ } ], "source": [ - "TP[:16]" + "LTP[:16]" ] }, { @@ -145,7 +145,7 @@ } ], "source": [ - "TP[-16:]" + "LTP[-16:]" ] }, { @@ -155,7 +155,7 @@ "source": [ "## Right-Truncatable Primes\n", "\n", - "What if you sharpen the pencil from the other end? That gives you **right-trunctable primes**:" + "What if you sharpen the pencil from the other end? You get `right-trunctable primes`:" ] }, { @@ -194,9 +194,9 @@ } ], "source": [ - "TPr = right_truncatable_primes()\n", + "RTP = right_truncatable_primes()\n", "\n", - "len(TPr)" + "len(RTP)" ] }, { @@ -222,7 +222,7 @@ } ], "source": [ - "print(TPr)" + "print(RTP)" ] }, { @@ -251,7 +251,7 @@ } ], "source": [ - "set(TP) & set(TPr)" + "set(LTP) & set(RTP)" ] }, { @@ -286,7 +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 TPr if is_omni_truncatable_prime(p)]" + "[p for p in RTP if is_omni_truncatable_prime(p)]" ] }, { @@ -318,7 +318,7 @@ "outputs": [], "source": [ "def isprime_simple(n: int) -> bool:\n", - " \"\"\"Simple primality tester. A prime number is defined as an integer greater than 1 \n", + " \"\"\"Is n prime? 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)" @@ -345,12 +345,12 @@ "\n", "def isprime_faster(n: int) -> bool:\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", + " if n <= 4: # Handle small numbers up to 4\n", + " return n in (2, 3)\n", + " elif n % 2 == 0: # Even numbers other than 2 are composite\n", " return False\n", - " else: # test odd divisors up to √n\n", - " divisors = range(11, int(sqrt(n)) + 1, 2) \n", + " else: # Test odd divisors up to √n\n", + " divisors = range(3, int(sqrt(n)) + 1, 2) \n", " return not any(n % d == 0 for d in divisors)" ] }, @@ -359,9 +359,9 @@ "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. The major idea wasn't enough; 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", + "## Probabilistic Primality Testing\n", "\n", "**Fortunately**, [Pierre de Fermat](https://en.wikipedia.org/wiki/Pierre_de_Fermat) provided the massive breakthrough in 1640! \n", "\n", @@ -369,21 +369,23 @@ "\n", "        *a*(*n* - 1) ≡ 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*(*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 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", + "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*(*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 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. 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*. \n", + "\n", + "Some examples of testing *n* by choosing random values of *a*:\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|*try again with new **a** value: 221 is definitely composite*|\n", + "|221|2|16|*try again with new value for **a**; 221 is definitely composite*|\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", + "|2137|7|1|*try again: 2137 could still be prime or composite*|\n", + "|2137|99|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: it can incorrectly report a **false prime** for a composite number *n*. Here is a simple implementation:" + "Here is a simple implementation:" ] }, { @@ -433,12 +435,12 @@ "id": "15ef6884-253d-4a3a-b58f-397ac73f552d", "metadata": {}, "source": [ - "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*:" + "How common are false primes? I define one function to estimate the probability of a false prime by testing a sample of integers, and another function to print a table of false prime probabilities, over various values of *k*, and various ranges of numbers *n*:" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "45a11a93-9ef3-48d1-80fa-e0113041346e", "metadata": {}, "outputs": [ @@ -447,13 +449,13 @@ "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", + " 3 digits 1.431% 0.007% 0.000% 0.000%\n", + " 4 digits 0.471% 0.027% 0.001% 0.000%\n", + " 5 digits 0.120% 0.003% 0.003% 0.001%\n", + " 6 digits 0.031% 0.002% 0.002% 0.000%\n", + " 7 digits 0.011% 0.000% 0.000% 0.000%\n", + " 8 digits 0.003% 0.000% 0.000% 0.000%\n", + " 9 digits 0.001% 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" @@ -469,8 +471,9 @@ " 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", + "def report_false_primes(label_start_stop_triples: Iterable, k_values=(1, 5, 10, 20), num_samples=100_000):\n", + " \"\"\"Report false prime probability for different digit ranges, and k values.\n", + " First arg is a list of triples such as (\"3 digits\", 100, 1000).\"\"\"\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", @@ -485,16 +488,16 @@ "id": "f3fe25d6-5f0a-478b-90d0-6c89e092e92e", "metadata": {}, "source": [ - "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", + "We see that with *k* = 1, 3-digit composites (such as 123 or 747) 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 (such as 1234567891), or increase *k* to 10 or more repetitions, 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", + "The so-called [**Carmichael numbers**](https://en.wikipedia.org/wiki/Carmichael_number) are composite numbers with a very high false prime probability. [Some Carmichael numbers](https://oeis.org/A033502) are worse than others. \n", "\n", "We can test some of them:\n" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "id": "7871aaa7-af1c-462b-85bb-d46818ccabea", "metadata": {}, "outputs": [ @@ -503,24 +506,24 @@ "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" + " 1105 69.560% 2.560% 0.000% 0.000% 0.000%\n", + " 1729 75.350% 5.450% 0.010% 0.000% 0.000%\n", + " 2465 72.460% 3.900% 0.020% 0.000% 0.000%\n", + " 2821 76.310% 6.910% 0.090% 0.000% 0.000%\n", + " 6601 80.270% 10.530% 0.130% 0.000% 0.000%\n", + " 8911 79.820% 10.910% 0.150% 0.000% 0.000%\n", + " 41041 70.160% 2.470% 0.000% 0.000% 0.000%\n", + " 101101 71.590% 3.590% 0.010% 0.000% 0.000%\n", + " 294409 95.080% 60.040% 22.570% 0.550% 0.000%\n", + " 340561 81.990% 14.420% 0.160% 0.000% 0.000%\n", + " 825265 60.780% 0.520% 0.000% 0.000% 0.000%\n", + " 56052361 99.110% 91.720% 77.240% 41.920% 0.010%\n", + " 118901521 99.350% 93.090% 81.470% 50.970% 0.150%\n", + " 172947529 99.350% 94.220% 83.660% 53.970% 0.200%\n", + " 216821881 99.470% 94.170% 84.640% 56.180% 0.430%\n", + "1299963601 99.700% 97.030% 91.020% 73.300% 4.720%\n", + "2301745249 99.790% 97.720% 92.210% 78.380% 8.150%\n", + "9624742921 99.870% 98.340% 95.090% 85.480% 20.660%\n" ] } ], @@ -538,7 +541,44 @@ "id": "4ecd2289-66d5-4b0f-ac00-5db0ad92dde9", "metadata": {}, "source": [ - "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." + "This is bad; some Carmichael numbers have false prime probability above 99% with *k* = 1, and still over 50% with *k* = 100." + ] + }, + { + "cell_type": "markdown", + "id": "4c76de9d-4803-4db5-b6c5-811a6a1c6da1", + "metadata": {}, + "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 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", + "Below I test that all the primality test functions agree with `sympy.isprime` on the first 1,000 integers and a selection of larger primes and composites. (I don't use an `assert` because it is possible that `isprime_fermat` could fail, but a score of 100 indicates 100% success.)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "4f377075-e352-46f9-a716-f1de673a7086", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'isprime_simple': 100, 'isprime_faster': 100, 'isprime_fermat': 100}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "integers = [*range(1000), 11939, 65537, 117223, 7629137, 11939*11939, 11939*65537]\n", + "prime_fns = (isprime_simple, isprime_faster, isprime_fermat, isprime)\n", + "\n", + "{fn.__name__: 100 * mean(fn(n) == isprime(n) for n in integers) \n", + " for fn in prime_fns if fn != isprime}" ] }, { @@ -546,36 +586,11 @@ "id": "bfd71dc7-7f6d-4c98-9886-5c242d9b297a", "metadata": {}, "source": [ - "So our Fermat test is mostly reliable, but a few composite numbers will consistently be identified as false primes.\n", + "## Speed of Primality testing\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` 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", + "**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. \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 with different digit-lengths:" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2a10367d-45c1-4425-a630-96892555c1b7", - "metadata": {}, - "outputs": [], - "source": [ - "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]" - ] - }, - { - "cell_type": "markdown", - "id": "6b2cbdc7-e8a9-4b83-aa0d-1e7cc83de071", - "metadata": {}, - "source": [ - "Next make a chart of the speeds of all the primality checking functions running on the big primes:" + "I'll make a chart of the speeds of all the primality checking functions running on primes with digit-lengths ranging from 5 to 32. For small *n* we repeat the test multiple time to get less noisy timing results; when a test takes over a second we skip the bigger primes." ] }, { @@ -587,10 +602,11 @@ "source": [ "import matplotlib.pyplot as plt\n", "import timeit\n", + "import sympy\n", "\n", - "prime_tests = (isprime_simple, isprime_faster, isprime_fermat, isprime)\n", + "big_primes = [sympy.nextprime(3 * 10 ** d) for d in range(4, 32)]\n", "\n", - "def plot_run_times(primes, functions=prime_tests):\n", + "def plot_run_times(primes, functions=prime_fns):\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", @@ -602,19 +618,18 @@ " plt.ylabel('Run time in seconds (log scale)')\n", " plt.legend()\n", "\n", - "def time_test(function, primes) -> tuple[list[int], list[float]]:\n", - " \"\"\"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", + "def time_test(function, primes, repeat=40) -> tuple[list[int], list[float]]:\n", + " \"\"\"Time the function on each of the primes, repeated `repeat` times, stopping \n", + " when one exceeds a second. Return two lists: digit sizes and 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 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 # Stop tsting a function once it takes over a second of run time\n", - " elif time > 1e-3:\n", - " repeat = 1\n", + " if time > 1.0:\n", + " break # Stop testing a function once it takes over a second of run time\n", + " elif time > .01:\n", + " repeat = 1 # Reset `repeat` to 1 if it took .01 second\n", " return D, T" ] }, @@ -626,7 +641,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -648,31 +663,11 @@ "- `isprime_simple` has a run time of *O*(*n*)\n", "- `isprime_faster` has a run time of *O*(√*n*); we see its slope is half as steep on the log-log graph\n", "- `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 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" - ] - }, - { - "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": 19, - "id": "4f377075-e352-46f9-a716-f1de673a7086", - "metadata": {}, - "outputs": [], - "source": [ - "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" + "- `isprime_simple` takes more than a second for an 8-digit prime; `isprime_faster is 10,000 times faster for that prime\n", + "- `isprime_faster` takes more than a second for a 17-digit prime; `isprime_fermat` is over 10,000 times faster for that prime\n", + "- `isprime_fermat` and `isprime` are well under a millisecond run time all the way out to a 32-digit prime\n", + "- `isprime_fermat` is about ten times slower than `isprime`\n", + " - (But that's pretty good for `isprime_fermat` considering how much simpler it is: 8 lines versus about 800.)" ] }, { @@ -684,7 +679,7 @@ "\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", + "## 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 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", @@ -699,7 +694,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 19, "id": "e71eb140-7e1a-4146-87a7-8c4eebf61486", "metadata": {}, "outputs": [], @@ -722,7 +717,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 20, "id": "01838139-52dd-48a0-8f62-bcdef351345e", "metadata": {}, "outputs": [ @@ -730,8 +725,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 21 μs, sys: 1e+03 ns, total: 22 μs\n", - "Wall time: 22.2 μs\n" + "CPU times: user 25 μs, sys: 1 μs, total: 26 μs\n", + "Wall time: 26.9 μs\n" ] }, { @@ -740,7 +735,7 @@ "1" ] }, - "execution_count": 21, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -763,9 +758,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "Python [conda env:base] *", "language": "python", - "name": "python3" + "name": "conda-base-py" }, "language_info": { "codemirror_mode": {