Recent from talks
Nothing was collected or created yet.
Fermat primality test
View on WikipediaThe 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 congruence holds. If it 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 the above congruence holds trivially for , because the congruence relation is compatible with exponentiation. It also holds trivially for if p is odd, for the same reason. That is why one usually chooses a random a in the interval .
Any a such that
when n is composite 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 congruence 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
- 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 log2n log log n) = Õ(k log2n), 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]There are infinitely many Fermat pseudoprimes to any given basis a > 1.[1]: Theorem 1 Even worse, there are infinitely many Carmichael numbers.[2] 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[3] is lower than the prime number function n/log(n)) 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.
Corollaries
[edit]Analogous to the Lucas–Lehmer residue, is called the Fermet residue of n to base a. There are a few variants that produce different types of residues,[4] most importantly the strong probable prime (SPRP) residue.[5]
If the residue r for n to base a is known, then for any proper divisor k of n, it is possible to perform a quick though weaker primality test on n/k. If n/k is prime, by Fermat's theorem and . As a result , which can be much more efficiently checked for values of k much smaller than n. (This is the method used by the Great Internet Mersenne Prime Search for testing cofactors.)[4]
A even weaker form of the test can be conducted with a truncated if storage space for the residue is a concern, so long as and . Let , then for some w. Take this mod 2t and we have . n/k is composite if . A similar test can be done on truncated Lucas–Lehmer residues.[6]
It is also true that if all bases a are systematically checked in the interval , each demonstrating congruence to 1, the test is effectively deterministic. We may say that n is definitely prime. At cursory glance one may assume that n exists in the union of both primes and Carmichael numbers for such a scenario, but if a-values are systematically checked in the interval, one is bound to be a prime factor of a composite n at some point before , thus making a and n not coprime, and failing the congruence, even if n is indeed a Carmichael number. Carmichael numbers do fail Fermat's congruence to 1 if the base used is not coprime. Though this is more computationally expensive than brute force divisibility checking (trial division), it is of theoretical value.
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.[7]
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).
Prime number search projects
[edit]Internet volunteer computing projects such as Great Internet Mersenne Prime Search (GIMPS) and PrimeGrid use the Fermat primality test because there is an efficient proof scheme (Gerbicz-Li) for modular exponentiation. Selected intermediate results, combined with a verifiable delay function, are used to generate a "proof" file for verifying the authenticity and correctness of the computation, protecting against both hardware error and malicious actors. This proof is hard to forge given a low order assumption. The original form of the verification (Gerbicz-Pietrzak) only worked with n being derivable from powers of 2, such as in the case of Mersenne primes, Mersenne cofactors, and Proth primes; Li's modification generalizes it to any n.[8]
The GIMPS in particular tests Mersenne primes and Mersenne cofactors. The default is to use a = 3 as all Mersenne numbers would pass the test with a = 2.
References
[edit]- ^ a b Carl Pomerance; John L. Selfridge; Samuel S. Wagstaff, Jr. (July 1980). "The pseudoprimes to 25·109" (PDF). Mathematics of Computation. 35 (151): 1003–1026. doi:10.1090/S0025-5718-1980-0572872-7. JSTOR 2006210.
- ^ Alford, W. R.; Granville, Andrew; Pomerance, Carl (1994). "There are Infinitely Many Carmichael Numbers" (PDF). Annals of Mathematics. 140 (3): 703–722. doi:10.2307/2118576. JSTOR 2118576.
- ^ Paul Erdős (1956). "On pseudoprimes and Carmichael numbers". Publ. Math. Debrecen. 4: 201–206. MR 0079031.
- ^ a b "primenet.h".
There are (at least) 5 PRP residue types for testing N=(k*b^n+c)/d: (1) Fermat PRP. Calculate a^(N-1) mod N. PRP if result = 1. (2) SPRP variant. Calculate a^((N-1)/2) mod N. PRP if result = +/-1. (3) Type 1 variant,b=2,d=1. Calculate a^(N-c) mod N. PRP if result = a^-(c-1). (4) Type 2 variant,b=2,d=1. Calculate a^((N-c)/2) mod N. PRP if result = +/-a^-((c-1)/2). (5) Cofactor variant. Calculate a^(N*d-1) mod N*d. PRP if result = a^(d-1) mod N.
- ^ "The Prime Glossary: strong probable prime". t5k.org.
- ^ Gerbicz, Robert (2018-06-22). "Saving tons of PRP-C and (hypotetical) LL-C tests, a new method". www.mersenneforum.org.
- ^ Joe Hurd (2003), Verification of the Miller–Rabin Probabilistic Primality Test, p. 2, CiteSeerX 10.1.1.105.3196
- ^ Darren Li; Yves Gallot (8 Feb 2023). "An Efficient Modular Exponentiation Proof Scheme". arXiv.
- 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.
Fermat primality test
View on GrokipediaBackground
Fermat's Little Theorem
Fermat's Little Theorem states that if is a prime number and is an integer such that , then .[4] This congruence highlights a fundamental property of primes in modular arithmetic, where the exponent acts as the order of the multiplicative group modulo .[4] The theorem was first proposed by Pierre de Fermat in a 1640 letter to Frénicle de Bessy, though Fermat provided no proof and claimed only to have discovered one.[4] The first published proof appeared in 1736 from Leonhard Euler, who used mathematical induction on the binomial expansion of .[4] Euler later offered additional proofs, including ones aligning with emerging group-theoretic ideas.[4] A modern proof relies on group theory: Consider the multiplicative group , which consists of the integers from 1 to under multiplication modulo and has order .[5] For coprime to , generates a subgroup of , where the order of is the smallest positive integer such that .[5] By Lagrange's theorem, divides , so for some integer , and thus .[5] Special cases clarify the theorem's scope. For , the congruence holds trivially since .[4] However, if , since is prime this implies divides , so and ; the theorem requires coprimality.[4] The theorem underpins efficient modular exponentiation, as exponents can be reduced modulo when computing powers coprime to , enabling fast algorithms like binary exponentiation essential for primality testing procedures.[4]Overview of Probabilistic Primality Tests
Primality testing involves algorithms designed to determine whether a given positive integer is prime or composite, a fundamental problem in number theory with applications in cryptography and computational mathematics. Efficient primality tests are essential for identifying large primes required in secure systems, such as generating keys for public-key encryption.[6] Deterministic primality tests, which provide absolute certainty without randomization, face significant challenges for large numbers. Simple methods like trial division, which check divisibility up to the square root of the number, have a time complexity of O(√n), rendering them impractical for numbers with hundreds of bits, as in cryptographic contexts. Even advanced deterministic algorithms, such as the AKS test introduced in 2002, achieve polynomial time complexity—originally O(log^{12+ε} n) and later improved to O(log^{6} n)—but remain computationally expensive due to high constants and massive storage requirements; for instance, verifying a 1024-bit number can demand billions of gigabytes of memory and excessive operations in polynomial congruence checks.[6][7] Probabilistic primality tests address these limitations by using randomization to achieve high confidence in results with far greater efficiency. These tests select random witnesses (bases) and verify number-theoretic conditions that primes satisfy, declaring a number "probably prime" if it passes multiple trials; the probability of error—misidentifying a composite as prime—decreases exponentially, typically bounded by less than (1/2)^k for k independent trials. This approach ensures that for practical purposes, such as in cryptography, the error rate can be made negligibly small, like 2^{-80}, with modest computational overhead.[8][9] The development of probabilistic tests gained prominence in the 1970s, driven by the emergence of public-key cryptography, which necessitated fast primality verification for enormous integers. Early methods, including the Fermat test based on Fermat's Little Theorem, were among the first to exploit randomization for speed, predating more robust variants like Solovay-Strassen (1977). Their key advantage lies in leveraging efficient modular exponentiation, with time complexity around O(log^3 n) per trial, enabling practical testing of numbers up to thousands of bits in seconds on modern hardware—vastly outperforming deterministic alternatives for real-world applications.[10][6][2]Description of the Test
Core Principle
The Fermat primality test is grounded in Fermat's Little Theorem, which states that if is a prime number and is an integer coprime to , then .[3] This theorem provides the foundational congruence that the test leverages to assess the primality of an odd integer . The core principle of the test relies on the contrapositive of Fermat's Little Theorem: if is composite and there exists an integer coprime to such that , then is definitely composite.[11] In this scenario, such an serves as a witness to the compositeness of . Conversely, if holds for a randomly selected coprime to , then passes the test and is considered probably prime; however, if is actually composite, this acts as a liar.[3] Bases for the test are typically chosen from the range with to ensure coprimality.[11] To increase confidence in the result, multiple distinct bases are tested iteratively, as a single liar does not rule out compositeness. For composite that are not Carmichael numbers, at least half of the possible bases coprime to are witnesses, yielding an error probability of at most per test under these conditions.[11]Testing Procedure and Witnesses
The Fermat primality test begins by handling trivial cases: numbers such as or even are immediately determined to be not prime, as they fail basic primality conditions and do not satisfy the conditions of Fermat's Little Theorem.[12][13] For odd integers , the procedure relies on the contrapositive of Fermat's Little Theorem, testing whether behaves like a prime under modular exponentiation.[12] To apply the test, select random bases such that and , ensuring coprimality to align with the theorem's assumptions. In practice, to avoid computing gcd beforehand, a random in 2 to is selected; if , then is composite.[13] For each base, compute using efficient methods like binary exponentiation. If for any , then is definitively composite. If the congruence holds for all bases, output "probably prime," with the error probability (false positive for composites) bounded above by for non-Carmichael composites in the worst case among such numbers, providing a confidence level of under those conditions.[12][13] A base (with and ) is termed a Fermat witness to the compositeness of if , as this violation proves is not prime. Conversely, a Fermat liar is a base for which the congruence holds () despite being composite, potentially misleading the test into suggesting primality.[12][13] The proportion of witnesses versus liars determines the test's reliability for a given composite , with at least half of the possible bases typically serving as witnesses for non-Carmichael composites.[12]Examples and Illustrations
Basic Example with a Composite Number
Consider the composite number , which factors as . To apply the Fermat primality test, select bases coprime to 91 and compute . If the result is not 1 for any such , then is a Fermat witness proving composite; if it equals 1 for all tested , may be prime or a pseudoprime to those bases.[2] First, take (with ). Compute using the binary exponentiation method, which efficiently calculates large powers via repeated squaring and multiplication. The binary representation of 90 is . Initialize result and base ; process the exponent from least significant bit:- Exponent 90 (even): , exponent .
- Exponent 45 (odd): , , exponent .
- Exponent 22 (even): (since ), exponent .
- Exponent 11 (odd): (since ), (since ), exponent .
- Exponent 5 (odd): (since ), , exponent .
- Exponent 2 (even): , exponent .
- Exponent 1 (odd): , , exponent .
Example with a Prime Number
Consider the number , which is a prime.[14] To demonstrate the Fermat primality test succeeding on a prime, select bases and (both coprime to 97) and verify that in each case, as required by the test procedure.[2] For , compute using repeated squaring, which efficiently reduces the exponentiation to multiplications modulo 97:- (since )
- (since )
- (since )
- (since )
- (since )
- (since )
- (since )
- (since )
Algorithm and Implementation
Step-by-Step Algorithm
The Fermat primality test is implemented as a probabilistic algorithm that verifies whether an input integer satisfies Fermat's Little Theorem for randomly selected bases, declaring composite if it fails for any base or probably prime after a specified number of successful trials.[15] The algorithm takes two inputs: an integer to test for primality, and an integer specifying the number of independent trials, with typical values of 10 to 20 used in cryptographic applications to achieve a low error probability (e.g., less than ).[15][16] The following pseudocode outlines the core procedure, assuming efficient modular exponentiation for the power computation:function FermatPrimalityTest(n, k):
if n < 2 or n == 2:
return "Prime" if n == 2 else "Composite"
if n % 2 == 0:
return "Composite"
if n == 3:
return "Prime"
for i from 1 to k:
a = random integer in [2, n-2]
if gcd(a, n) > 1:
return "Composite"
r = a^(n-1) mod n // using [modular exponentiation](/page/Modular_exponentiation)
if r != 1:
return "Composite"
return "Probably Prime"
function FermatPrimalityTest(n, k):
if n < 2 or n == 2:
return "Prime" if n == 2 else "Composite"
if n % 2 == 0:
return "Composite"
if n == 3:
return "Prime"
for i from 1 to k:
a = random integer in [2, n-2]
if gcd(a, n) > 1:
return "Composite"
r = a^(n-1) mod n // using [modular exponentiation](/page/Modular_exponentiation)
if r != 1:
return "Composite"
return "Probably Prime"
