# Primality test

__: Algorithm for determining whether a number is prime__

**Short description**A **primality test** is an algorithm for determining whether an input number is prime. Among other fields of mathematics, it is used for cryptography. Unlike integer factorization, primality tests do not generally give prime factors, only stating whether the input number is prime or not. Factorization is thought to be a computationally difficult problem, whereas primality testing is comparatively easy (its running time is polynomial in the size of the input). Some primality tests prove that a number is prime, while others like Miller–Rabin prove that a number is composite. Therefore, the latter might more accurately be called *compositeness tests* instead of primality tests.

## Simple methods

The simplest primality test is *trial division*: given an input number, *n*,
check whether it is evenly divisible by any prime number between 2 and √n (i.e. that the division leaves no remainder). If so, then *n* is composite. Otherwise, it is prime.^{[1]} In fact, for any divisor [math]\displaystyle{ p\gt \sqrt n }[/math], there must be another divisor [math]\displaystyle{ n/p \lt \sqrt n }[/math], and therefore looking for divisors smaller than √n is sufficient.

For example, consider the number 100, which is evenly divisible by these numbers:

- 2, 4, 5, 10, 20, 25, 50

Note that the largest factor, 50, is half of 100. This holds true for all *n*: all divisors are less than or equal to *n*/2.

When all possible divisors up to *n*/2 are tested, some factors will be discovered *twice*. To observe this, rewrite the list of divisors as a list of products, each equal to 100:

- 2 × 50, 4 × 25, 5 × 20, 10 × 10, 20 × 5, 25 × 4, 50 × 2

Notice that products past 10 × 10 merely repeat numbers which appeared in earlier products, merely commuted. For example, 5 × 20 and 20 × 5 consist of the same numbers in opposite order. This holds true for all *n*: all unique divisors of *n* are numbers less than or equal to √*n*, so we need not search past that.^{[1]} (In this example, √*n* = √100 = 10.)

All even numbers greater than 2 can also be eliminated: if an even number can divide *n*, so can 2.

An example is to use trial division to test the primality of 17. We need only test for divisors up to √*n*, i.e. integers less than or equal to [math]\displaystyle{ \scriptstyle \sqrt{17} \approx 4.12 }[/math], namely 2, 3, and 4. 4 can be skipped because it is an even number: if 4 could evenly divide 17, 2 would too, and 2 is already in the list. That leaves 2 and 3. Divide 17 with each of these numbers, and we find that neither divides 17 evenly—both divisions leave a remainder. So, 17 is prime.

This method can improve further. Observe that all primes greater than 3 are of the form 6*k* ± 1, where *k* is any integer greater than 0. This is because all integers can be expressed as (6*k* + *i*), where *i* = −1, 0, 1, 2, 3, or 4. Note that 2 divides (6*k* + 0), (6*k* + 2), and (6*k* + 4) and 3 divides (6*k* + 3). So, a more efficient method is to test whether *n* is divisible by 2 or 3, then to check through all numbers of the form [math]\displaystyle{ \scriptstyle 6k \ \pm \ 1 \leq\sqrt n }[/math]. This is 3 times faster than testing all numbers up to √*n*.

Generalising further, all primes greater than *c*# (c primorial) are of the form *c*# · *k* + *i*, for *i* < *c*#, where *c* and *k* are integers and *i* represents the numbers that are coprime to c#. For example, let *c* = 6. Then *c*# = 2 · 3 · 5 = 30. All integers are of the form 30*k* + *i* for i in *i* = 0, 1, 2,...,29 and *k* an integer. However, 2 divides 0, 2, 4,..., 28; 3 divides 0, 3, 6, ..., 27; and 5 divides 0, 5, 10, ..., 25. So all prime numbers greater than 30 are of the form 30*k* + *i* for *i* = 1, 7, 11, 13, 17, 19, 23, 29 (i.e. for *i* < 30 such that gcd(*i*,30) = 1). Note that if *i* and 30 were not coprime, then 30*k* + *i* would be divisible by a prime divisor of 30, namely 2, 3, or 5, and would therefore not be prime. In order to match the previous method of allowing for negative i, instead of checking each i from 1 to *c*#-1 (because 0 and *c*# are always even), check each i from 1 to *c*#/2, which will be the list of values *i* such that all integers are of the form *c*#*k* ± *i*. In this example, 30*k* ± *i* for *i* = 1, 7, 11, 13. Note that this list will always include 1 and the set of primes greater than *c* but smaller than *c*#/2. Not all numbers which meet the aforementioned conditions are prime. For example, 437 is of the form of *c*#*k* + *i* for *c* = 7, *c*#=210, *k*=2, *i*=17. However, 437 is a composite number equal to 19*23. That is why the numbers of the given form still need to be tested for primality.

As *c* → ∞, the number of values that *c*#*k* + *i* can take over a certain range decreases, and so the time to test *n* decreases. For this method, it is also necessary to check for divisibility by all primes that are less than *c*. Observations analogous to the preceding can be applied recursively, giving the Sieve of Eratosthenes.

One way to speed up these methods (and all the others mentioned below) is to pre-compute and store a list of all primes up to a certain bound, such as all primes up to 200. (Such a list can be computed with the Sieve of Eratosthenes or by an algorithm that tests each incremental *m* against all known primes < √*m*). Then, before testing *n* for primality with a serious method, *n* can first be checked for divisibility by any prime from the list. If it is divisible by any of those numbers then it is composite, and any further tests can be skipped.

A simple but very inefficient primality test uses Wilson's theorem, which states that *p* is prime if and only if:

- [math]\displaystyle{ (p-1)! \equiv -1\pmod p \, }[/math]

Although this method requires about *p* modular multiplications, rendering it impractical, theorems about primes and modular residues form the basis of many more practical methods.

### Example code

#### Python

The following is a simple primality test in Python using the simple 6*k* ± 1 optimization mentioned earlier. More sophisticated methods described below are much faster for large *n*.

from math import isqrt def is_prime(n: int) -> bool: if n <= 3: return n > 1 if n % 2 == 0 or n % 3 == 0: return False limit = isqrt(n) for i in range(5, limit+1, 6): if n % i == 0 or n % (i+2) == 0: return False return True

#### C, C++, C# & D

The following is a primality test in the C family of languages using the same optimization as above.

bool IsPrime(int n) { if (n == 2 || n == 3) return true; if (n <= 1 || n % 2 == 0 || n % 3 == 0) return false; for (int i = 5; i * i <= n; i += 6) { if (n % i == 0 || n % (i + 2) == 0) return false; } return true; }

#### Java

The following is a primality test in Java using the same optimization as above.

import java.util.*; public static boolean isPrime(int n){ if (n <= 1) return false; if (n == 2 || n == 3) return true; if (n % 2 == 0 || n % 3 == 0) return false; for (int i = 5; i <= Math.sqrt(n); i = i + 6) if (n % i == 0 || n % (i + 2) == 0) return false; return true; }

#### JavaScript

The following is a primality test in JavaScript using the same optimization as above.

function isPrime(num) { if (num == 2 || num == 3) return true; if (num <= 1 || num % 2 == 0 || num % 3 == 0) return false; for (let i = 5; i * i <= num ; i+=6) if (num % i == 0 || num % (i + 2) == 0) return false; return true; }

#### R

The following is a primality test in R (programming language) using the same optimization as above.

is.prime <- function(number) { if (number <= 1) { return (FALSE) } else if (number <= 3) { return (TRUE) } if (number %% 2 == 0 || number %% 3 == 0) { return (FALSE) } i <- 5 while (i*i <= number) { if (number %% i == 0 || number %% (i+2) == 0) { return (FALSE) } i = i + 6 } return (TRUE) }

#### Dart

The following is a primality test in Dart (programming language) using the same optimization as above.

checkIfPrimeNumber(number) { if (number == 2 || number == 3) { return 'true'; } else if (number <= 1 || number % 2 == 0 || number % 3 == 0) { return 'false'; } for (int i = 5; i * i <= number; i += 6) { if (number % i == 0 || number % (i + 2) == 0) { return 'false'; } } return 'true'; }

#### Free Pascal

The following is a primality test in Free Pascal using the same optimization as above.

function IsPrime(N:Integer):Boolean; var I:Integer; begin if ((N = 2) or (N = 3)) then Exit(True); if ((N <= 1) or (N mod 2 = 0) or (N mod 3 = 0)) then Exit(False); I := 5; while (I * I <= N) do begin if ((N mod I = 0) or (N mod (I+2) = 0)) then Exit(False); Inc(I, 6); end; Exit(True); end;

#### Go

The following is a primality test in Golang using the same optimization as above.

func IsPrime(num int) bool { if num > 1 && num <= 3 { return true } if num <= 1 || num%2 == 0 || num%3 == 0 { return false } for i := 5; i*i <= num; i += 6 { if num%i == 0 || num%(i+2) == 0 { return false } } return true }

## Heuristic tests

These are tests that seem to work well in practice, but are unproven and therefore are not, technically speaking, algorithms at all.
The Fermat test and the Fibonacci test are simple examples, and they are *very* effective when combined. John Selfridge has conjectured that if *p* is an odd number, and *p* ≡ ±2 (mod 5), then *p* will be prime if both of the following hold:

- 2
^{p−1}≡ 1 (mod*p*), *f*_{p+1}≡ 0 (mod*p*),

where *f _{k}* is the

*k*-th Fibonacci number. The first condition is the Fermat primality test using base 2.

In general, if *p* ≡ a (mod *x*^{2}+4), where *a* is a quadratic non-residue (mod *x*^{2}+4) then *p* should be prime if the following conditions hold:

- 2
^{p−1}≡ 1 (mod*p*), *f*(*1*)_{p+1}≡ 0 (mod*p*),

*f*(*x*)_{k} is the *k*-th Fibonacci polynomial at *x*.

Selfridge, Carl Pomerance, and Samuel Wagstaff together offer $620 for a counterexample.^{[2]}

## Probabilistic tests

Probabilistic tests are more rigorous than heuristics in that they provide provable bounds on the probability of being fooled by a composite number.
Many popular primality tests are probabilistic tests. These tests use, apart from the tested number *n*, some other numbers *a* which are chosen at random from some sample space; the usual randomized primality tests never report a prime number as composite, but it is possible for a composite number to be reported as prime. The probability of error can be reduced by repeating the test with several independently chosen values of *a*; for two commonly used tests, for *any* composite *n* at least half the *a*'s detect *n*'s compositeness, so *k* repetitions reduce the error probability to at most 2^{−k}, which can be made arbitrarily small by increasing *k*.

The basic structure of randomized primality tests is as follows:

- Randomly pick a number
*a*. - Check equality (corresponding to the chosen test) involving
*a*and the given number*n*. If the equality fails to hold true, then*n*is a composite number and*a*is a*witness*for the compositeness, and the test stops. - Get back to the step one until the required accuracy is reached.

After one or more iterations, if *n* is not found to be a composite number, then it can be declared probably prime.

### Fermat primality test

The simplest probabilistic primality test is the Fermat primality test (actually a compositeness test). It works as follows:

- Given an integer
*n*, choose some integer*a*coprime to*n*and calculate*a*^{n}^{ − 1}modulo*n*. If the result is different from 1, then*n*is composite. If it is 1, then*n*may be prime.

If *a ^{n}*

^{−1}(modulo

*n*) is 1 but

*n*is not prime, then

*n*is called a pseudoprime to base

*a*. In practice, we observe that, if

*a*

^{n}^{−1}(modulo

*n*) is 1, then

*n*is usually prime. But here is a counterexample: if

*n*= 341 and

*a*= 2, then

- [math]\displaystyle{ 2^{340} \equiv 1\pmod{341} }[/math]

even though 341 = 11·31 is composite. In fact, 341 is the smallest pseudoprime base 2 (see Figure 1 of
^{[3]}).

There are only 21853 pseudoprimes base 2 that are less than 2.5×10^{10} (see page 1005 of ^{[3]}). This means that, for *n* up to 2.5×10^{10}, if *2 ^{n}*

^{−1}(modulo

*n*) equals 1, then

*n*is prime, unless

*n*is one of these 21853 pseudoprimes.

Some composite numbers (Carmichael numbers) have the property that *a ^{n}*

^{ − 1}is 1 (modulo

*n*) for every

*a*that is coprime to

*n*. The smallest example is

*n*= 561 = 3·11·17, for which

*a*is 1 (modulo 561) for all

^{560}*a*coprime to 561. Nevertheless, the Fermat test is often used if a rapid screening of numbers is needed, for instance in the key generation phase of the RSA public key cryptographic algorithm.

### Miller–Rabin and Solovay–Strassen primality test

The Miller–Rabin primality test and Solovay–Strassen primality test are more sophisticated variants, which detect all composites (once again, this means: for *every* composite number *n*, at least 3/4 (Miller–Rabin) or 1/2 (Solovay–Strassen) of numbers *a* are witnesses of compositeness of *n*). These are also compositeness tests.

The Miller–Rabin primality test works as follows:
Given an integer *n*, choose some positive integer *a* < *n*. Let 2^{s}*d* = *n* − 1, where *d* is odd. If

- [math]\displaystyle{ a^{d} \not\equiv \pm 1\pmod{n} }[/math]

and

- [math]\displaystyle{ a^{2^rd} \not\equiv -1\pmod{n} }[/math] for all [math]\displaystyle{ 0 \le r \le s - 1, }[/math]

then *n* is composite and *a* is a witness for the compositeness. Otherwise, *n* may or may not be prime.
The Miller–Rabin test is a strong probable prime test (see PSW^{[3]} page 1004).

The Solovay–Strassen primality test uses another equality: Given an odd number *n*, choose some integer *a* < *n*, if

- [math]\displaystyle{ a^{(n-1)/2} \not\equiv \left(\frac{a}{n}\right) \pmod n }[/math], where [math]\displaystyle{ \left(\frac{a}{n}\right) }[/math] is the Jacobi symbol,

then *n* is composite and *a* is a witness for the compositeness. Otherwise, *n* may or may not be prime.
The Solovay–Strassen test is an Euler probable prime test (see PSW^{[3]} page 1003).

For each individual value of *a*, the Solovay–Strassen test is weaker than the Miller–Rabin test. For example, if *n* = 1905 and *a* = 2, then the Miller-Rabin test shows that *n* is composite, but the Solovay–Strassen test does not. This is because 1905 is an Euler
pseudoprime base 2 but not a strong pseudoprime base 2 (this is illustrated in Figure 1 of PSW^{[3]}).

### Frobenius primality test

The Miller–Rabin and the Solovay–Strassen primality tests are simple and are much faster than other general primality tests. One method of improving efficiency further in some cases is the Frobenius pseudoprimality test; a round of this test takes about three times as long as a round of Miller–Rabin, but achieves a probability bound comparable to seven rounds of Miller–Rabin.

The Frobenius test is a generalization of the Lucas probable prime test.

### Baillie–PSW primality test

The Baillie–PSW primality test is a probabilistic primality test that combines a Fermat or Miller–Rabin test with a Lucas probable prime test to get a primality test that has no known counterexamples. That is, there are no known composite *n* for which this test reports that *n* is probably prime.^{[4]}^{[5]} It has been shown that there are no counterexamples for *n* [math]\displaystyle{ \lt 2^{64} }[/math].

### Other tests

Leonard Adleman and Ming-Deh Huang presented an errorless (but expected polynomial-time) variant of the elliptic curve primality test. Unlike the other probabilistic tests, this algorithm produces a primality certificate, and thus can be used to prove that a number is prime.^{[6]} The algorithm is prohibitively slow in practice.

If quantum computers were available, primality could be tested asymptotically faster than by using classical computers. A combination of Shor's algorithm, an integer factorization method, with the Pocklington primality test could solve the problem in [math]\displaystyle{ O((\log n)^3 (\log\log n)^2 \log\log\log n) }[/math].^{[7]}

## Fast deterministic tests

Near the beginning of the 20th century, it was shown that a corollary of Fermat's little theorem could be used to test for primality.^{[8]} This resulted in the Pocklington primality test.^{[9]} However, as this test requires a partial factorization of *n* − 1 the running time was still quite slow in the worst case. The first deterministic primality test significantly faster than the naive methods was the cyclotomy test; its runtime can be proven to be O((log *n*)^{c log log log n}), where *n* is the number to test for primality and *c* is a constant independent of *n*. Many further improvements were made, but none could be proven to have polynomial running time. (Note that running time is measured in terms of the size of the input, which in this case is ~ log *n*, that being the number of bits needed to represent the number *n*.) The elliptic curve primality test can be proven to run in O((log *n*)^{6}), if some conjectures on analytic number theory are true.^{[which?]} Similarly, under the generalized Riemann hypothesis, the deterministic Miller's test, which forms the basis of the probabilistic Miller–Rabin test, can be proved to run in Õ((log *n*)^{4}).^{[10]} In practice, this algorithm is slower than the other two for sizes of numbers that can be dealt with at all. Because the implementation of these two methods is rather difficult and creates a risk of programming errors, slower but simpler tests are often preferred.

In 2002, the first provably unconditional deterministic polynomial time test for primality was invented by Manindra Agrawal, Neeraj Kayal, and Nitin Saxena. The AKS primality test runs in Õ((log *n*)^{12}) (improved to Õ((log *n*)^{7.5})^{[11]} in the published revision of their paper), which can be further reduced to Õ((log *n*)^{6}) if the Sophie Germain conjecture is true.^{[12]} Subsequently, Lenstra and Pomerance presented a version of the test which runs in time Õ((log *n*)^{6}) unconditionally.^{[13]}

Agrawal, Kayal and Saxena suggest a variant of their algorithm which would run in Õ((log *n*)^{3}) if Agrawal's conjecture is true; however, a heuristic argument by Hendrik Lenstra and Carl Pomerance suggests that it is probably false.^{[11]} A modified version of the Agrawal's conjecture, the Agrawal–Popovych conjecture,^{[14]} may still be true.

## Complexity

In computational complexity theory, the formal language corresponding to the prime numbers is denoted as PRIMES. It is easy to show that PRIMES is in **Co-NP**: its complement COMPOSITES is in **NP** because one can decide compositeness by nondeterministically guessing a factor.

In 1975, Vaughan Pratt showed that there existed a certificate for primality that was checkable in polynomial time, and thus that PRIMES was in NP, and therefore in [math]\displaystyle{ \mathsf{NP \cap coNP} }[/math]. See primality certificate for details.

The subsequent discovery of the Solovay–Strassen and Miller–Rabin algorithms put PRIMES in coRP. In 1992, the Adleman–Huang algorithm^{[6]} reduced the complexity to [math]\displaystyle{ \mathsf{ {\color{Blue} ZPP} = RP \cap coRP} }[/math], which superseded Pratt's result.

The Adleman–Pomerance–Rumely primality test from 1983 put PRIMES in **QP** (quasi-polynomial time), which is not known to be comparable with the classes mentioned above.

Because of its tractability in practice, polynomial-time algorithms assuming the Riemann hypothesis, and other similar evidence, it was long suspected but not proven that primality could be solved in polynomial time. The existence of the AKS primality test finally settled this long-standing question and placed PRIMES in **P**. However, PRIMES is not known to be P-complete, and it is not known whether it lies in classes lying inside **P** such as NC or L. It is known that PRIMES is not in AC^{0}.^{[15]}

## Number-theoretic methods

Certain number-theoretic methods exist for testing whether a number is prime, such as the Lucas test and Proth's test. These tests typically require factorization of *n* + 1, *n* − 1, or a similar quantity, which means that they are not useful for general-purpose primality testing, but they are often quite powerful when the tested number *n* is known to have a special form.

The Lucas test relies on the fact that the multiplicative order of a number *a* modulo *n* is *n* − 1 for a prime *n* when *a* is a primitive root modulo n. If we can show *a* is primitive for *n*, we can show *n* is prime.

## References

- ↑
^{1.0}^{1.1}Riesel (1994) pp.2-3 - ↑ John Selfridge.
- ↑
^{3.0}^{3.1}^{3.2}^{3.3}^{3.4}Carl Pomerance; John L. Selfridge; Samuel S. Wagstaff, Jr. (July 1980). "The pseudoprimes to 25·10^{9}".*Mathematics of Computation***35**(151): 1003–1026. doi:10.1090/S0025-5718-1980-0572872-7. https://www.math.dartmouth.edu/~carlp/PDF/paper25.pdf. - ↑ Robert Baillie; Samuel S. Wagstaff, Jr. (October 1980). "Lucas Pseudoprimes".
*Mathematics of Computation***35**(152): 1391–1417. doi:10.1090/S0025-5718-1980-0583518-6. https://mpqs.free.fr/LucasPseudoprimes.pdf. - ↑ Robert Baillie; Andrew Fiori; Samuel S. Wagstaff, Jr. (July 2021). "Strengthening the Baillie-PSW Primality Test".
*Mathematics of Computation***90**(330): 1931–1955. doi:10.1090/mcom/3616. - ↑
^{6.0}^{6.1}Adleman, Leonard M.; Huang, Ming-Deh (1992).*Primality testing and Abelian varieties over finite field*. Lecture notes in mathematics.**1512**. Springer-Verlag. ISBN 3-540-55308-8. - ↑ Chau, H. F.; Lo, H.-K. (1995). "Primality Test Via Quantum Factorization". arXiv:quant-ph/9508005.
- ↑ Pocklington, H. C. (1914). "The determination of the prime or composite nature of large numbers by Fermat's theorem".
*Cambr. Phil. Soc. Proc.***18**: 29–30. - ↑ Weisstein, Eric W.. "Pocklington's Theorem". http://mathworld.wolfram.com/PocklingtonsTheorem.html.
- ↑ Gary L. Miller (1976). "Riemann's Hypothesis and Tests for Primality".
*Journal of Computer and System Sciences***13**(3): 300–317. doi:10.1016/S0022-0000(76)80043-8. - ↑
^{11.0}^{11.1}Agrawal, Manindra; Kayal, Neeraj; Saxena, Nitin (2004). "Primes is in P".*Annals of Mathematics***160**(2): 781–793. doi:10.4007/annals.2004.160.781. http://annals.math.princeton.edu/wp-content/uploads/annals-v160-n2-p12.pdf. - ↑ Agrawal, Manindra; Kayal, Neeraj; Saxena, Nitin (2004). "PRIMES is in P".
*Annals of Mathematics***160**(2): 781–793. doi:10.4007/annals.2004.160.781. http://www.cse.iitk.ac.in/users/manindra/algebra/primality_v6.pdf. - ↑ "Primality testing with Gaussian periods". July 20, 2005. http://www.math.dartmouth.edu/~carlp/PDF/complexity12.pdf.
- ↑ Popovych, Roman (December 30, 2008). "A note on Agrawal conjecture". http://eprint.iacr.org/2009/008.pdf.
- ↑ E. Allender, M. Saks, and I.E. Shparlinski, A lower bound for primality,
*J. Comp. Syst. Sci.***62**(2001), pp. 356–366.

## Sources

- Richard Crandall and Carl Pomerance (2005).
*Prime Numbers: A Computational Perspective*(2nd ed.). Springer. ISBN 0-387-25282-7. Chapter 3: Recognizing Primes and Composites, pp. 109–158. Chapter 4: Primality Proving, pp. 159–190. Section 7.6: Elliptic curve primality proving (ECPP), pp. 334–340. - Knuth, Donald (1997). "section 4.5.4".
*The Art of Computer Programming*.**2:**(Third ed.). Addison–Wesley. pp. 391–396. ISBN 0-201-89684-2.*Seminumerical Algorithms* - Thomas H. Cormen; Charles E. Leiserson; Ronald L. Rivest; Clifford Stein (2001). "Section 31.8: Primality testing".
*Introduction to Algorithms*(Second ed.). MIT Press and McGraw–Hill. pp. 887–896. ISBN 0-262-03293-7. - Papadimitriou, Christos H. (1993). "Section 10.2: Primality".
*Computational Complexity*(1st ed.). Addison Wesley. pp. 222–227. ISBN 0-201-53082-1. https://archive.org/details/computationalcom00papa. - Riesel, Hans (1994).
*Prime Numbers and Computer Methods for Factorization*. Progress in Mathematics.**126**(second ed.). Boston, MA: Birkhäuser. ISBN 0-8176-3743-5.

## External links

- – Implementation of the Solovay-Strassen primality test in Maple
- Distinguishing prime numbers from composite numbers, by D.J. Bernstein (cr.yp.to)
- The Prime Pages (primes.utm.edu)
- PRIMABOINCA is a research project that uses Internet-connected computers to search for a counterexample to some conjectures. The first conjecture (Agrawal's conjecture) was the basis for the formulation of the first deterministic prime test algorithm in polynomial time (AKS algorithm).

Original source: https://en.wikipedia.org/wiki/Primality test.
Read more |