# Fermat primality test

The **Fermat primality test** is a probabilistic test to determine whether a number is a probable prime.

## Concept[edit]

Fermat's little theorem states that if *p* is prime and *a* is not divisible by *p*, then

If one wants to test whether *p* is prime, then we can pick random integers *a* not divisible by *p* and see whether the equality holds. If the equality does not hold for a value of *a*, then *p* is composite.
This congruence is unlikely to hold for a random *a* if *p* is composite.^{[1]}
Therefore, if the equality does hold for one or more values of *a*, then we say that *p* is probably prime.

However, note that for , the above congruence holds trivially.
It also holds trivially if *p* is odd and .
For this reason, one usually chooses a number *a* in the interval .

Any *a* such that

when *n* is composite *a* is known as a *Fermat liar*. In this case *n* is called Fermat pseudoprime to base *a*.

If we do pick an *a* such that

then *a* is known as a *Fermat witness* for the compositeness of *n*.

## Example[edit]

Suppose we wish to determine whether *n* = 221 is prime. Randomly pick 1 < *a* < 220, say *a* = 38. We check the above equality and find that it holds:

Either 221 is prime, or 38 is a Fermat liar, so we take another *a*, say 24:

So 221 is composite and 38 was indeed a Fermat liar. Furthermore, 24 is a Fermat witness for the compositeness of 221.

## Algorithm[edit]

The algorithm can be written as follows:

**Inputs**:*n*: a value to test for primality,*n*>3;*k*: a parameter that determines the number of times to test for primality**Output**:*composite*if*n*is composite, otherwise*probably prime*- Repeat
*k*times:- Pick
*a*randomly in the range [2,*n*− 2] - If , then return
*composite*

- Pick
- If composite is never returned: return
*probably prime*

The *a* values 1 and *n*-1 are not used as the equality holds for all *n* and all odd *n* respectively, hence testing them adds no value.

### Complexity[edit]

Using fast algorithms for modular exponentiation and multiprecision multiplication, the running time of this algorithm is O(*k* log^{2}*n* log log *n*) = Õ(*k* log^{2}*n*), where *k* is the number of times we test a random *a*, and *n* is the value we want to test for primality; see Miller–Rabin primality test for details.

## Flaw[edit]

First, there are infinitely many Fermat pseudoprimes.

A more serious flaw is that there are infinitely many Carmichael numbers. These are numbers for which __all__ values of with are Fermat liars. For these numbers, repeated application of the Fermat primality test performs the same as a simple random search for factors. While Carmichael numbers are substantially rarer than prime numbers (Erdös' upper bound for the number of Carmichael numbers is lower than the prime number function n/log(n))^{[2]} there are enough of them that Fermat's primality test is not often used in the above form. Instead, other more powerful extensions of the Fermat test, such as Baillie–PSW, Miller–Rabin, and Solovay–Strassen are more commonly used.

In general, if is a composite number that is not a Carmichael number, then at least half of all

- (i.e. )

are Fermat witnesses. For proof of this, let be a Fermat witness and , , ..., be Fermat liars. Then

and so all for are Fermat witnesses.

## Applications[edit]

As mentioned above, most applications use a Miller–Rabin or Baillie–PSW test for primality. Sometimes a Fermat test (along with some trial division by small primes) is performed first to improve performance. GMP since version 3.0 uses a base-210 Fermat test after trial division and before running Miller–Rabin tests. Libgcrypt uses a similar process with base 2 for the Fermat test, but OpenSSL does not.

In practice with most big number libraries such as GMP, the Fermat test is not noticeably faster than a Miller–Rabin test, and can be slower for many inputs.^{[3]}

As an exception, OpenPFGW uses only the Fermat test for probable prime testing. The program is typically used with multi-thousand digit inputs with a goal of maximum speed with very large inputs. Another well known program that relies only on the Fermat test is PGP where it is only used for testing of self-generated large random values (an open source counterpart, GNU Privacy Guard, uses a Fermat pretest followed by Miller–Rabin tests).

## References[edit]

- Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein (2001). "Section 31.8: Primality testing".
*Introduction to Algorithms*(Second ed.). MIT Press; McGraw-Hill. p. 889–890. ISBN 0-262-03293-7.CS1 maint: multiple names: authors list (link)

**^**Carl Pomerance; John L. Selfridge; Samuel S. Wagstaff, Jr. (July 1980). "The pseudoprimes to 25·10^{9}" (PDF).*Mathematics of Computation*.**35**(151): 1003–1026. doi:10.1090/S0025-5718-1980-0572872-7. JSTOR 2006210.**^**Paul Erdős (1956). "On pseudoprimes and Carmichael numbers".*Publ. Math. Debrecen*.**4**: 201–206.**^**Joe Hurd (2003),*Verification of the Miller–Rabin Probabilistic Primality Test*, p. 2, CiteSeerX 10.1.1.105.3196