Prime Numbers

128 Chapter 3 RECOGNIZING PRIMES AND COMPOSITES
3.3 Recognizing smooth numbers
A very important subroutine in many number-theoretic algorithms involves
identifying the smooth numbers in a given list of numbers. We have many
methods for recognizing these smooth numbers, since any factorization
algorithm will do. However, some factorization algorithms, such as trial
division, find the smaller prime factors of the number being factored before
finding the larger prime factors. Such a method could presumably reject a
number for not being y-smooth before completely factoring it. Factorization
methods with this property include trial division, the Pollard rho method, and
the Lenstra elliptic curve method, the latter two methods being discussed later
in the book. Used as smoothness tests, these three factorization methods have
the following rough complexities: Trial division takes y 1+o(1) operations per
number examined, the rho method takes y 1/2+o(1) operations, and the elliptic
curve method takes about exp((2 ln y ln ln y) 1/2 )=y o(1) operations. Here an
“operation” is an arithmetic step with numbers the size of the specific number
being examined. (It should be pointed out that the complexity estimates for
both the rho method and the elliptic curve method are heuristic.)
Sometimes we can use a sieve to recognize smooth numbers, and when we
can, it is very fast. For example, if we have a string of consecutive integers
or more generally a string of consecutive values of a polynomial with integer
coefficients (and with low degree), and if this string has length L ≥ y, with
maximal member M, then the time to examine every single one of the L
numbers for y-smoothness is about L ln ln M ln ln y, or about ln ln M ln ln y
bit operations per number. (The factor ln ln M arises from using approximate
logarithms, as discussed in Section 3.2.5.) In fact, sieving is so fast that the
run time is dominated more by retrieving numbers from memory than by
doing actual computations.
In this section we shall discuss an important new method of D. Bernstein
(see [Bernstein 2004d]), which can recognize the smooth numbers in any set
of at least y numbers, and whose amortized time per number examined is
almost as fast as sieving: It is (ln 2 y ln M) 1+o(1) bit operations per number,
if the numbers are at most M. To achieve this complexity, though, one must
use sophisticated subroutines for large-integer arithmetic, such as the fast
Fourier transform or equivalent convolution techniqes (see our Chapter 8.8
and [Bernstein 2004e]).
We shall illustrate the Bernstein method with the smoothness bound y set
at 20, and with the set of numbers being examined being 1001, 1002,...,1008.
(It is not important that the numbers be consecutive, it is just easier to
keep track of them for the illustration.) A moment’s inspection shows the 20smooth
numbers in the list to be the first and last, namely 1001 and 1008.
The algorithm not only tells us this, it gives the largest 20-smooth divisor for
each number in the list.
The plan of the Bernstein algorithm, as applied to this example, is first
to find the product of all of the primes up to 20, namely 9699690, and then
reduce this product modulo each of the eight numbers on our list. Say x is on