Jonathan P. Sorenson

Two fast GCD algorithms

Abstract We present two new algorithms for computing greatest common divisors: the right- and left-shift k -ary GCD algorithms. These algorithms are generalizations of the binary and left-shift binary algorithms. Interestingly, both new algorithms have sequential versions that are practical and efficient and parallel versions that rival the best previous parallel GCD algorithms. We show that sequential versions of both algorithms take Θ( n 2 /log n ) bit operations in the worst case to compute the GCD of two n -bit integers. This compares favorably to the Euclidean and both binary algorithms, which take Θ( n 2 ) time. In practice, we implemented multiple-precision versions of these GCD algorithms, and we found that both k -ary algorithms are faster than the Euclidean and binary algorithms on inputs of 100 to 1000 decimal digits in length. We show that parallel versions of both algorithms match the complexity of the best previous parallel GCD algorithm due to Chor and Goldreich. Specifically, if log n ≤ k ≤ 2 n and k is a power of two, then both algorithms run in O ( n /log k + log 2 n log log n ) time using a number of processors bounded by a polynomial in n and k on a common CRCW PRAM. We also discuss extended versions of both algorithms.

Explicit bounds for primes in residue classes

Let E/K be an abelian extension of number fields, with E ¬= Q. Let Δ and n denote the absolute discriminant and degree of E. Let σ denote an element of the Galois group of E/K. We prove the following theorems, assuming the Extended Riemann Hypothesis: (1) There is a degree-1 prime p of K such that (p/E/K) = σ, satisfying Np ≤ (1+ o(1))(logΔ + 2n) 2 . (2) There is a degree-1 prime p of K such that (p/E/K) generates the same group as σ, satisfying Np ≤ (1 + o(1))(log Δ) 2 . (3) For K = Q, there is a prime p such that (p/E/Q) = σ, satisfying P ≤ (1 + o(1))(log Δ) 2 . In (1) and (2) we can in fact take p to be unramified in K/Q. A special case of this result is the following. (4) If gcd(m,q) = 1, the least prime p? m (mod q) satisfies p ≤ (1 + o(1))(φ(q)log q) 2 . It follows from our proof that (1)-(3) also hold for arbitrary Galois extensions, provided we replace σ by its conjugacy class . Our theorems lead to explicit versions of (1)-(4), including the following: the least prime p? m (mod q) is less than 2(q log q) 2 .

Efficient Algorithms for Computing the Jacobi Symbol

We present two new algorithms for computing the Jacobi Symbol: the right-shift and left-shiftk-ary algorithms. For inputs of at mostnbits in length, both algorithms takeO(n2/logn) time andO(n) space. This is asymptotically faster than the traditional algorithm, which is based in Euclids algorithm for computing greatest common divisors. In practice, we found our new algorithms to be about twice as fast for inputs of 100 to 1000 decimal digits in length. We also present parallel versions of both algorithms for the CRCW PRAM. One version takesO?(n/ loglogn) time usingO(n1+?) processors, giving the first sublinear parallel algorithms for this problem. The other version takes polylog time using a subexponential number of processors.

A binary algorithm for the Jacobi symbol

We present a new algorithm to compute the Jacobi symbol, based on Steins binary algorithm for the greatest common divisor, and we determine the worst-case behavior of this algorithm. Our implementation of the algorithm runs approximately 7--25% faster than traditional methods on inputs of size 100--1000 decimal digits.

An analysis of Lehmer's Euclidean GCD algorithm

Let u and v be positive integers. We show that a slightly modified version of D. H. Lehmer’s greatest common divisor algorithm will compute gcd(u, v) (with u > u) using at most o{(log u log v)/k + k log v + log u + ,%2} bit operations and O(log u + k22k ) space, where k is the number of bits in the multiprecision base of the algorithm. This is faster than Euclid’s algorithm by a factor that is roughly proportional to k. Letting n be the number of bits in u and W, and setting k = [(log n)/4], we obtain a sub quadratic running time of 0(n2 / log n) in linear space.

Sieve algorithms for perfect power testing

A positive integern is a perfect power if there exist integersx andk, both at least 2, such thatn=xk. The usual algorithm to recognize perfect powers computes approximatekth roots fork≤log2n, and runs in time O(log3n log log logn).First we improve this worst-case running time toO(log3n) by using a modified Newtons method to compute approximatekth roots. Parallelizing this gives anNC2 algorithm.Second, we present a sieve algorithm that avoidskth-root computations by seeing if the inputn is a perfectkth power modulo small primes. Ifn is chosen uniformly from a large enough interval, the average running time isO(log2n).Third, we incorporate trial division to give a sieve algorithm with an average running time ofO(log2 n/log2 logn) and a median running time ofO(logn).The two sieve algorithms use a precomputed table of small primes. We give a heuristic argument and computational evidence that the largest prime needed in this table is (logn)1+O(1); assuming the Extended Riemann Hypothesis, primes up to (logn)2+O(1) suffice. The table can be computed in time roughly proportional to the largest prime it contains.We also present computational results indicating that our sieve algorithms perform extremely well in practice.

Modular exponentiation via the explicit Chinese remainder theorem

Fix pairwise coprime positive integers p 1 ,P 2 ,..., p a . We propose representing integers u modulo m, where m is any positive integer up to roughly p 1 p 2 ... P s , as vectors (u mod p 1 , u mod p 2 ,.., u mod p s ). We use this representation to obtain a new result on the parallel complexity of modular exponentiation: there is an algorithm for the Common CRCW PRAM that, given positive integers x, e, and m in binary, of total bit length n, computes x e mod m in time O(n/lglgn) using n O(1) processors. For comparison, a parallelization of the standard binary algorithm takes superlinear time; Adleman and Kompella gave an O((lg n) 3 ) expected time algorithm using exp(O(n lg n)) processors; von zur Gathen gave an NC algorithm for the highly special case that m is polynomially smooth.

Approximating the number of integers free of large prime factors

Define Ψ(x,y) to be the number of positive integers n ≤ x such that n has no prime divisor larger than y. We present a simple algorithm that approximates Ψ(x,y) in O(y{loglogx/logy + 1/loglogy}) floating point operations. This algorithm is based directly on a theorem of Hildebrand and Tenenbaum. We also present data which indicate that this algorithm is more accurate in practice than other known approximations, including the well-known approximation Ψ(x, y) xp(log x/ log y), where p(u) is Dickmans function.

The pseudosquares prime sieve

We present the pseudosquares prime sieve, which finds all primes up to n. Define p to be the smallest prime such that the pseudosquare Lp> n/(π(p)(logn)2); here π(x) is the prime counting function. Our algorithm requires only O(π(p)n) arithmetic operations and O(π(p)logn) space. It uses the pseudosquares primality test of Lukes, Patterson, and Williams. Under the assumption of the Extended Riemann Hypothesis, we have p≤2(logn)2, but it is conjectured that

A space-efficient fast prime number sieve

p\sim \frac{1}{\log 2}\log n \log\log n