Lehmann’s Primality Test

An integer p greater than one is prime iff the only divisors of p are 1 and p. First few prime numbers are 2, 3, 5, 7, 11, 13, …

The Lehmann’s test is a probabilistic primality test for an natural number n, it can test the primality of any kind of number(whether a large odd number is prime or not). The Lehmann’s test is a variation of Fermat’s Primality Test.

The approach used is as follows:
If ‘n’ is an odd number and ‘a’ is a random integer less than n but greater than 1, then

x = (a^((n-1)/2)) (mod n)

It is computed.

  1. If x is 1 or -1(or n-1), then n may be prime.
  2. If x is not 1 or -1(or n-1), then n is definitely composite.

The fact that any composite number can be turned out to be a prime, in this case, depends on the random value ‘a’. If all the values of a and n are co-prime, then n can be said as a prime number.

Example-1:
Input: n = 13 
Output: 13 is Prime 

Explanation: 
Let a = 3, then, 
3^((13-1)/2) % 13 = 729 % 13 = 1
Hence, 13 is Prime.

Example-2:
Input: n = 91
Output: 91 is Composite

Explanation: 
Let a = 3, then, 
3^((91-1)/2) % 91 = 27
Hence, 91 is Composite. 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ code for Lehmann's Primality Test
#include<stdio.h>
#include<stdlib.h>
#include<ctime>
#include<bits/stdc++.h>
using namespace std;
  
// function to check Lehmann's test
int lehmann(int n, int t)
{
  
    // generating a random base less than n
    int a = 2 + (rand() % (n - 1));
  
    // calculating exponent
    int e = (n - 1) / 2;
  
    // iterate to check for different base values 
    // for given number of tries 't'
    while(t > 0)
    {
  
        // calculating final value using formula
        int result =((int)(pow(a, e)))% n;
  
        //if not equal, try for different base
        if((result % n) == 1 || (result % n) == (n - 1)) 
        {
            a = 2 + (rand() % (n - 1));
            t -= 1;
        }
  
        // else return negative
        else
            return -1;
    }
  
    // return positive after attempting
    return 1;
}
  
// Driver code
int main()
{
    int n = 13 ; // number to be tested
    int t = 10 ; // number of tries
  
    // if n is 2, it is prime
    if(n == 2)
    cout << "2 is Prime.";
  
    // if even, it is composite
    if(n % 2 == 0)
        cout << n << " is Composite";
  
    // if odd, check
    else
    {
        int flag = lehmann(n, t);
      
        if(flag ==1)
            cout << n << " may be Prime.";
      
        else
            cout << n << " is Composite.";
    
}
  
// This code is contibuted by chitranayal

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java code for Lehmann's Primality Test 
      
// importing "random" for random operations 
import java.util.Random;
  
class GFG
{
  
    // function to check Lehmann's test 
    static int lehmann(int n, int t)
    {
      
        // create instance of Random class 
        Random rand = new Random(); 
          
        // generating a random base less than n 
        int a = rand.nextInt(n - 3) + 2;
      
        // calculating exponent 
        float e = (n - 1) / 2;
      
        // iterate to check for different base values 
        // for given number of tries 't' 
        while(t > 0)
        {
      
            // calculating final value using formula 
            int result = ((int)(Math.pow(a, e))) % n;
      
            // if not equal, try for different base 
            if((result % n) == 1 || (result % n) == (n - 1))
            {
                a = rand.nextInt(n - 3) + 2;
                t -= 1;
            }
      
            // else return negative 
            else
                return -1;
                  
        }
          
        // return positive after attempting 
        return 1;
    }
      
    // Driver code 
    public static void main (String[] args)
    {
    int n = 13; // number to be tested 
    int t = 10; // number of tries 
      
    // if n is 2, it is prime 
    if(n == 2)
        System.out.println(" 2 is Prime."); 
      
    // if even, it is composite 
    if(n % 2 == 0)
        System.out.println(n + " is Composite");
      
    // if odd, check 
    else
    {
        long flag = lehmann(n, t);
      
        if(flag == 1)
            System.out.println(n + " may be Prime.");
      
        else
            System.out.println(n + " is Composite."); 
    }
}
}
  
// This code is contributed by AnkitRai01

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python code for Lehmann's Primality Test
  
# importing "random" for random operations
import random
  
# function to check Lehmann's test
def lehmann(n, t):
  
    # generating a random base less than n
    a = random.randint(2, n-1)
  
    # calculating exponent
    e =(n-1)/2
  
    # iterate to check for different base values 
    # for given number of tries 't'
    while(t>0):
  
        # calculating final value using formula
        result =((int)(a**e))% n
  
        # if not equal, try for different base
        if((result % n)== 1 or (result % n)==(n-1)):
            a = random.randint(2, n-1)
            t-= 1
  
        # else return negative
        else:
            return -1
  
    # return positive after attempting
    return 1
  
# Driver code
n = 13    # number to be tested
t = 10    # number of tries
  
# if n is 2, it is prime
if(n is 2):
    print("2 is Prime.")
  
# if even, it is composite
if(n % 2 == 0):
    print(n, "is Composite")
  
# if odd, check
else:
    flag = lehmann(n, t)
  
    if(flag is 1):
        print(n, "may be Prime.")
  
    else:
        print(n, "is Composite.")

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# code for Lehmann's Primality Test 
using System;
  
class GFG
{
  
// function to check Lehmann's test 
static int lehmann(int n, int t)
{
  
    // create instance of Random class 
    Random rand = new Random(); 
      
    // generating a random base less than n 
    int a = rand.Next(n - 3) + 2;
  
    // calculating exponent 
    float e = (n - 1) / 2;
  
    // iterate to check for different base values 
    // for given number of tries 't' 
    while(t > 0)
    {
  
        // calculating final value using formula 
        int result = ((int)(Math.Pow(a, e))) % n;
  
        // if not equal, try for different base 
        if((result % n) == 1 || 
           (result % n) == (n - 1))
        {
            a = rand.Next(n - 3) + 2;
            t -= 1;
        }
  
        // else return negative 
        else
            return -1;
              
    }
      
    // return positive after attempting 
    return 1;
}
  
// Driver code 
public static void Main (String[] args)
{
    int n = 13; // number to be tested 
    int t = 10; // number of tries 
      
    // if n is 2, it is prime 
    if(n == 2)
        Console.WriteLine(" 2 is Prime."); 
      
    // if even, it is composite 
    if(n % 2 == 0)
        Console.WriteLine(n + " is Composite");
      
    // if odd, check 
    else
    {
        long flag = lehmann(n, t);
      
        if(flag == 1)
            Console.WriteLine(n + " may be Prime.");
      
        else
            Console.WriteLine(n + " is Composite."); 
    }
}
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

13 may be Prime.

Attention reader! Don’t stop learning now. Get hold of all the important CS Theory concepts for SDE interviews with the CS Theory Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.