This article mainly introduced the Python prime number detection method, the example analyzes the Python prime number detection related skill, needs the friend to be possible to refer to the next
This article illustrates the method of detecting Python primes. Share to everyone for your reference. Specifically as follows:
Detection factor, Time complexity O (n^ (1/2))
|1 2 3 4 5 6 7||def is_prime (n): if n < 2:return false for I in xrange (2, int (n**0.5+1)): If n%i = 0:return False return True|
Fermat's little theorem:
If n is a prime number, and A is any positive integer less than n, then the N-second square of A and a modulo n congruence
Select a base (for example, 2), for a large integer p, if 2^ (p-1) and 1 are not modulo p with the remainder, p must not be prime; otherwise, p is probably a prime number.
2** (n-1)%n is not an easy to calculate number
Modular Operation Rules:
|1 2||(a^b)% P = ((a% p) ^b)% P (A * b)% P = (a% p * b% p)% p|
Calculate x^n (% P)
If N is an even number, then X^n = (x*x) ^[N/2];
If N is odd, then x^n = x*x^ (N-1) = X * (x*x) ^[N/2];
|1 2 3 4 5 6 7||def xn_mod_p (x, N, p): if n = = 0:return 1 res = xn_mod_p ((x*x)%p, n>>1, p) if n&1!= 0:res = (res*x)%p return Res|
Can also be summed up as the following algorithm two functions are the same
|1 2 3 4 5 6 7 8||def xn_mod_p2 (x, N, p): res = 1 N_bin = Bin (n) [2:] for I in range (0, Len (n_bin)): res = res**2% p if n_bin[i] = = ' 1 ': res = res * x% P return res|
With the fast processing of the modular power operation, we can realize the pony detection
Fermat's test is accurate when giving a negative conclusion, but the positive conclusion may be wrong, the efficiency of large integers is very high, and the rate of miscalculation decreases with the increment of integers.
|1 2 3 4 5 6 7||def fermat_test_prime (n): if n = = 1:return False if n = 2:return True res = xn_mod_p (2, n-1, n) Return res = = 1|
Miller-rabin detection is a kind of widely used
Two-time detection theorem: If P is a prime number, and 0
Fermat's little theorem: a^ (p-1) ≡1 (mod p)
This is the Miller-rabin test method. Constantly extracting factor 2 from the exponential n-1, n-1 is represented as D*2^r (where D is an odd number). Then what we need to compute becomes the d*2^r of a, divided by the remainder of N. Thus, a^ (d * 2^ (R-1)) is either equal to 1 or equal to n-1. If a^ (d * 2^ (r-1)) equals 1, the theorem continues to apply to a^ (d * 2^ (r-2)) so that it is continuously opened until the 2^i mod n-1 or a^d is used up for an I satisfying a^ (d * n=1) mod n = n-1 or the final index of 2. In this way, the Fermat small theorem is strengthened to the following form:
Extract factor 2 as much as possible, n-1 as D*2^r, if N is a prime, then either A^d mod n=1, or some I make a^ (d*2^i) mod n=n-1 (0<=i
Theorem: If n is a prime number, A is a positive integer less than n, then N to the Miller test based on a, the result is true.
The miller test is performed k times and the error probability of treating composite numbers as primes is no more than 4^ (k)
|1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30||Def miller_rabin_witness (A, p): if p = = 1:return False if p = = 2:return True #p-1 = u*2^t solver U, t n = p-1 t = Int (math . Floor (Math.log (n, 2)) U = 1 while t > 0:u = n/2**t if n% 2**t = 0 and u% 2 = 1:break T = t-1 B1 = B2 = Xn_m OD_P2 (A, U, p) for I in range (1, T + 1): b2 = b1**2% p If b2 = 1 and B1!= 1 and B1!= (p-1): return False B1 = B2 If B1!= 1:return False return True def prime_test_miller_rabin (P, K): While k > 0:a = Randint (1, p-1) if not miller_r Abin_witness (A, p): return False k = k-1 return True|
I hope this article will help you with your Python programming.