Building Abstractions with Procedures
1.2 Procedures and the Processes They Generate
1.2.6 Example: Testing for Primality
is section describes two methods for checking the primality of an in-teger n, one with order of growth Θ(√n), and a “probabilistic” algorithm with order of growth Θ(log n). e exercises at the end of this section suggest programming projects based on these algorithms.
Searching for divisors
Since ancient times, mathematicians have been fascinated by problems concerning prime numbers, and many people have worked on the prob-lem of determining ways to test if numbers are prime. One way to test if a number is prime is to find the number’s divisors. e following pro-gram finds the smallest integral divisor (greater than 1) of a given num-ber n. It does this in a straightforward way, by testing n for divisibility by successive integers starting with 2.
(define (smallest-divisor n) (find-divisor n 2))
(define (find-divisor n test-divisor) (cond ((> (square test-divisor) n) n)
((divides? test-divisor n) test-divisor) (else (find-divisor n (+ test-divisor 1))))) (define (divides? a b) (= (remainder b a) 0))
We can test whether a number is prime as follows: n is prime if and only if n is its own smallest divisor.
(define (prime? n)
(= n (smallest-divisor n)))
e end test forfind-divisoris based on the fact that if n is not prime it must have a divisor less than or equal to√n.44is means that the algo-rithm need only test divisors between 1 and√
n. Consequently, the num-ber of steps required to identify n as prime will have order of growth Θ(√n).
The Fermat test
e Θ(log n) primality test is based on a result from number theory known as Fermat’s Lile eorem.45
44If d is a divisor of n, then so is n/d. But d and n/d cannot both be greater than√n.
45Pierre de Fermat (1601-1665) is considered to be the founder of modern number the-ory. He obtained many important number-theoretic results, but he usually announced just the results, without providing his proofs. Fermat’s Lile eorem was stated in a leer he wrote in 1640. e first published proof was given by Euler in 1736 (and an earlier, identical proof was discovered in the unpublished manuscripts of Leibniz). e most famous of Fermat’s results—known as Fermat’s Last eorem—was joed down in 1637 in his copy of the book Arithmetic (by the third-century Greek mathematician Diophantus) with the remark “I have discovered a truly remarkable proof, but this mar-gin is too small to contain it.” Finding a proof of Fermat’s Last eorem became one of the most famous challenges in number theory. A complete solution was finally given in 1995 by Andrew Wiles of Princeton University.
Fermat’s Lile Theorem:If n is a prime number and a is any positive integer less than n, then a raised to the nth power is congruent to a modulo n.
(Two numbers are said to be congruent modulo n if they both have the same remainder when divided by n. e remainder of a number a when divided by n is also referred to as the remainder of a modulo n, or simply as a modulo n.)
If n is not prime, then, in general, most of the numbers a < n will not satisfy the above relation. is leads to the following algorithm for testing primality: Given a number n, pick a random number a < n and compute the remainder of an modulo n. If the result is not equal to a, then n is certainly not prime. If it is a, then chances are good that n is prime. Now pick another random number a and test it with the same method. If it also satisfies the equation, then we can be even more con-fident that n is prime. By trying more and more values of a, we can increase our confidence in the result. is algorithm is known as the Fermat test.
To implement the Fermat test, we need a procedure that computes the exponential of a number modulo another number:
(define (expmod base exp m) (cond ((= exp 0) 1)
((even? exp) (remainder
(square (expmod base (/ exp 2) m)) m))
(else (remainder
(* base (expmod base (- exp 1) m)) m))))
is is very similar to thefast-exptprocedure ofSection 1.2.4. It uses successive squaring, so that the number of steps grows logarithmically with the exponent.46
e Fermat test is performed by choosing at random a number a be-tween 1 and n−1 inclusive and checking whether the remainder modulo nof the nthpower of a is equal to a. e random number a is chosen us-ing the procedurerandom, which we assume is included as a primitive in Scheme.randomreturns a nonnegative integer less than its integer input. Hence, to obtain a random number between 1 and n− 1, we call
randomwith an input of n− 1 and add 1 to the result:
(define (fermat-test n) (define (try-it a)
(= (expmod a n n) a))
(try-it (+ 1 (random (- n 1)))))
e following procedure runs the test a given number of times, as spec-ified by a parameter. Its value is true if the test succeeds every time, and false otherwise.
(define (fast-prime? n times) (cond ((= times 0) true)
((fermat-test n) (fast-prime? n (- times 1))) (else false)))
46e reduction steps in the cases where the exponent e is greater than 1 are based on the fact that, for any integers x, y, and m, we can find the remainder of x times y modulo m by computing separately the remainders of x modulo m and y modulo m, multiplying these, and then taking the remainder of the result modulo m. For instance, in the case where e is even, we compute the remainder of be/2modulo m, square this, and take the remainder modulo m. is technique is useful because it means we can perform our computation without ever having to deal with numbers much larger than m. (CompareExercise 1.25.)
Probabilistic methods
e Fermat test differs in character from most familiar algorithms, in which one computes an answer that is guaranteed to be correct. Here, the answer obtained is only probably correct. More precisely, if n ever fails the Fermat test, we can be certain that n is not prime. But the fact that n passes the test, while an extremely strong indication, is still not a guarantee that n is prime. What we would like to say is that for any number n, if we perform the test enough times and find that n always passes the test, then the probability of error in our primality test can be made as small as we like.
Unfortunately, this assertion is not quite correct. ere do exist num-bers that fool the Fermat test: numnum-bers n that are not prime and yet have the property that an is congruent to a modulo n for all integers a < n.
Such numbers are extremely rare, so the Fermat test is quite reliable in practice.47
ere are variations of the Fermat test that cannot be fooled. In these tests, as with the Fermat method, one tests the primality of an integer n by choosing a random integer a< n and checking some condition that depends upon n and a. (SeeExercise 1.28for an example of such a test.) On the other hand, in contrast to the Fermat test, one can prove that, for any n, the condition does not hold for most of the integers a < n unless n is prime. us, if n passes the test for some random choice of
47 Numbers that fool the Fermat test are called Carmichael numbers, and lile is known about them other than that they are extremely rare. ere are 255 Carmichael numbers below 100,000,000. e smallest few are 561, 1105, 1729, 2465, 2821, and 6601.
In testing primality of very large numbers chosen at random, the chance of stumbling upon a value that fools the Fermat test is less than the chance that cosmic radiation will cause the computer to make an error in carrying out a “correct” algorithm. Considering an algorithm to be inadequate for the first reason but not for the second illustrates the difference between mathematics and engineering.
a, the chances are beer than even that n is prime. If n passes the test for two random choices of a, the chances are beer than 3 out of 4 that n is prime. By running the test with more and more randomly chosen values of a we can make the probability of error as small as we like.
e existence of tests for which one can prove that the chance of error becomes arbitrarily small has sparked interest in algorithms of this type, which have come to be known as probabilistic algorithms. ere is a great deal of research activity in this area, and probabilistic algorithms have been fruitfully applied to many fields.48
Exercise 1.21:Use thesmallest-divisorprocedure to find the smallest divisor of each of the following numbers: 199, 1999, 19999.
Exercise 1.22:Most Lisp implementations include a prim-itive calledruntimethat returns an integer that specifies the amount of time the system has been running (mea-sured, for example, in microseconds). e following
timed-prime-testprocedure, when called with an integer n, prints nand checks to see if n is prime. If n is prime, the procedure prints three asterisks followed by the amount of time used in performing the test.
48One of the most striking applications of probabilistic prime testing has been to the field of cryptography. Although it is now computationally infeasible to factor an arbi-trary 200-digit number, the primality of such a number can be checked in a few seconds with the Fermat test. is fact forms the basis of a technique for constructing “unbreak-able codes” suggested byRivest et al. (1977). e resulting RSA algorithm has become a widely used technique for enhancing the security of electronic communications. Be-cause of this and related developments, the study of prime numbers, once considered the epitome of a topic in “pure” mathematics to be studied only for its own sake, now turns out to have important practical applications to cryptography, electronic funds transfer, and information retrieval.
(define (timed-prime-test n) (newline)
(display n)
(start-prime-test n (runtime))) (define (start-prime-test n start-time)
(if (prime? n)
(report-prime (- (runtime) start-time)))) (define (report-prime elapsed-time)
(display " *** ") (display elapsed-time))
Using this procedure, write a proceduresearch-for-primes
that checks the primality of consecutive odd integers in a specified range. Use your procedure to find the three small-est primes larger than 1000; larger than 10,000; larger than 100,000; larger than 1,000,000. Note the time needed to test each prime. Since the testing algorithm has order of growth of Θ(√
n), you should expect that testing for primes around 10,000 should take about√
10 times as long as testing for primes around 1000. Do your timing data bear this out?
How well do the data for 100,000 and 1,000,000 support the Θ(√
n)prediction? Is your result compatible with the notion that programs on your machine run in time proportional to the number of steps required for the computation?
Exercise 1.23:esmallest-divisorprocedure shown at the start of this section does lots of needless testing: Aer it checks to see if the number is divisible by 2 there is no point in checking to see if it is divisible by any larger even num-bers. is suggests that the values used fortest-divisor
should not be 2, 3, 4, 5, 6, . . ., but rather 2, 3, 5, 7, 9, . . ..
To implement this change, define a procedurenextthat re-turns 3 if its input is equal to 2 and otherwise rere-turns its in-put plus 2. Modify thesmallest-divisorprocedure to use
(next test-divisor) instead of (+ test-divisor 1). Withtimed-prime-testincorporating this modified ver-sion of smallest-divisor, run the test for each of the 12 primes found inExercise 1.22. Since this modification halves the number of test steps, you should expect it to run about twice as fast. Is this expectation confirmed? If not, what is the observed ratio of the speeds of the two algorithms, and how do you explain the fact that it is different from 2?
Exercise 1.24:Modify thetimed-prime-testprocedure of Exercise 1.22to usefast-prime?(the Fermat method), and test each of the 12 primes you found in that exercise. Since the Fermat test has Θ(log n) growth, how would you expect the time to test primes near 1,000,000 to compare with the time needed to test primes near 1000? Do your data bear this out? Can you explain any discrepancy you find?
Exercise 1.25:Alyssa P. Hacker complains that we went to a lot of extra work in writingexpmod. Aer all, she says, since we already know how to compute exponentials, we could have simply wrien
(define (expmod base exp m)
(remainder (fast-expt base exp) m))
Is she correct? Would this procedure serve as well for our fast prime tester? Explain.
Exercise 1.26:Louis Reasoner is having great difficulty do-ingExercise 1.24. Hisfast-prime?test seems to run more slowly than hisprime? test. Louis calls his friend Eva Lu Ator over to help. When they examine Louis’s code, they find that he has rewrien theexpmodprocedure to use an explicit multiplication, rather than callingsquare:
(define (expmod base exp m) (cond ((= exp 0) 1)
((even? exp)
(remainder (* (expmod base (/ exp 2) m) (expmod base (/ exp 2) m)) m))
(else
(remainder (* base
(expmod base (- exp 1) m)) m))))
“I don’t see what difference that could make,” says Louis.
“I do.” says Eva. “By writing the procedure like that, you have transformed the Θ(log n) process into a Θ(n) process.”
Explain.
Exercise 1.27:Demonstrate that the Carmichael numbers listed inFootnote 1.47really do fool the Fermat test. at is, write a procedure that takes an integer n and tests whether anis congruent to a modulo n for every a< n, and try your procedure on the given Carmichael numbers.
Exercise 1.28:One variant of the Fermat test that cannot be fooled is called the Miller-Rabin test (Miller 1976;Rabin 1980). is starts from an alternate form of Fermat’s Lile
eorem, which states that if n is a prime number and a is any positive integer less than n, then a raised to the (n−1)-st power is congruent to 1 modulo n. To test the primality of a number n by the Miller-Rabin test, we pick a random num-ber a< n and raise a to the (n − 1)-st power modulo n using theexpmodprocedure. However, whenever we perform the squaring step inexpmod, we check to see if we have discov-ered a “nontrivial square root of 1 modulo n,” that is, a num-ber not equal to 1 or n−1 whose square is equal to 1 modulo n. It is possible to prove that if such a nontrivial square root of 1 exists, then n is not prime. It is also possible to prove that if n is an odd number that is not prime, then, for at least half the numbers a < n, computing an−1 in this way will reveal a nontrivial square root of 1 modulo n. (is is why the Miller-Rabin test cannot be fooled.) Modify theexpmod procedure to signal if it discovers a nontrivial square root of 1, and use this to implement the Miller-Rabin test with a procedure analogous tofermat-test. Check your pro-cedure by testing various known primes and non-primes.
Hint: One convenient way to makeexpmodsignal is to have it return 0.