In this tutorial, we will explore Bertrand's postulate along with its illustrations in the C++ programming language.
What is the Bertrand's Postulate?
Joseph Bertrand, a renowned French mathematician, is credited with formulating Bertrand's Postulate, a significant mathematical theory named after him. Initially proposed by Bertrand in 1845, this theorem was later rigorously proven by Pafnuty Lytovich Chebyshev, a distinguished Russian mathematician, in 1852. Bertrand's Postulate asserts that for any positive integer n greater than 3, there exists a prime number p such that n < p < 2n. This fundamental principle has profound implications on the distribution of prime numbers. As we delve deeper into this topic, we will explore its application in the context of C++ programming. By implementing Bertrand's Postulate in C++, we aim to demonstrate how the theorem can be utilized to find the smallest prime number p greater than a given integer n through an iterative approach.
Example 1:
Let's consider an example to demonstrate Bertrand's postulate using C++.
#include <bits/stdc++.h>
using namespace std;
bool isprimeNum(int num)
{
//The condition for checking the number is prime
for (int i = 2; i * i <= num; i++)
if (num % i == 0) // if i is a factor
return false;
return true;
}
int main() {
int num = 20;
//the condition for Bertrand's postulate principle
cout << "The prime numbers in the range (" << num << ", "
<< 2 * num - 2 << ")\n";
for (int i = num + 1; i < 2 * num - 2; i++)
if (isprimeNum(i))
cout << i << "\n";
return 0;
}
Output:
The prime numbers in the range (20, 38)
23
29
31
37
Explanation:
In this particular script, the isprimeNum function is defined to evaluate whether a given integer is a prime number. The function iterates from 2 up to the square root of the number, looking for a single divisor. If a divisor is found, the function returns False, indicating that the number is not prime. Conversely, if no divisor is found, it returns false, indicating that the number is composite.
The main function is set to receive an upper limit of 20 for the range of prime numbers. It then proceeds to calculate the highest element within this range by performing a multiplication operation involving the number multiplied by 2 and subtracted by 2. Following this calculation, the loop initiates starting from num + 1 up to 2 times num minus 2, iterating through each element in the specified range.
For each number within this range, the isprimeNum function is called to determine whether it is a prime number. If the number is indeed prime, it is then displayed on the console.
Example 2:
Let's provide an illustration to demonstrate Bertrand's postulate using C++ code.
#include <iostream>
#include <cmath>
// function for finding the prime number
bool isPrimeNumber(int val)
{
if (val<= 1)
{ return false;
}
if (val== 2)
{
return true;
}
if (val % 2 == 0)
{
return false;
}
for (int i = 3; i <= std::sqrt(val); i += 2)
{
if (val % i == 0)
{
return false;
}
}
return true;
} //logic to find the next prime number
int findtheNextPrimeValue(int num)
{
if (num <= 1)
{
return 2;
}
int nextPrime = (num % 2 == 0) ? num + 1 : num + 2;
while (!isPrimeNumber(nextPrime))
{
nextPrime += 2;
}
return nextPrime;
}
int main()
{
int number; std::cout << "Please enter the number: ";
std::cin >> number;
int pVal = findtheNextPrimeValue(number);
std::cout << "The least(smallest) prime number which is greater than " << number << " is " << pVal<< std::endl; return 0;
}
Output:
Please enter the number: 24
The least(smallest) prime number which is greater than 24 is 29
Explanation:
In this illustration, the program executes Bertrand's Postulate in C++. It defines a pair of functions: validatePrime, utilized to ascertain if the number is a prime and manages any exceptional scenarios, and iterates through odd numbers. discoverNextPrimeNumber is a function that identifies the subsequent prime number greater than the given value with specific conditions and must increment by 2 until the prime number is identified. Within the main function, the user is prompted to provide a number. Additionally, the program will invoke the discoverNextPrimeNumber function with the input value pVal, which will be retained in the recently identified prime number there. Subsequently, it outputs the smallest prime number that exceeds the provided input. Ultimately, the program accurately demonstrates Lord Bertrand's hypothesis by determining the highest prime number among all those greater than the user input.
Bertrand's theorem was employed to elucidate potential scenarios such as achieving a single price equilibrium for uniform goods within a market. In this scenario, a perfectly elastic demand can lead to a uniform price prevailing throughout the supply.
Applications of the Bertrand's Postulate or Bertrand's Theorem
Bertrand's Postulate or Bertrand's Theorem has many applications in C++ programming. Some of the applications are as follows:
- Prime Number Generation: The computational advantage of Berntrand's Postulate is one of those that make the whole process of finding prime numbers within a given range very easy. Using looping range and applying Bertrand's Postulate, we will be able not only to locate but also to store the prime numbers very productively.
- Primality Testing: Number testing, which is the main means of primality testing on very large numbers, can be Bertrand's Postulate applied. Using a procedure called "Bertrand's Postulate check", we can quickly assess whether the number is a composite or has the potential of being a prime one.
- Cryptography: Bertrand's Postulate is used in several cryptographic algorithms that operate on prime numbers. For example, it is an algorithm that produces large prime numbers for RSA encryption and elliptic curve cryptography.
- Optimization and Algorithm Design: Despite a possible lack of formal proof up to this date, Bertrand's postulate has an even greater significance of a heuristic used for solving some optimization problems or initiating an algorithm. This property helps us make assumptions about prime numbers and leads to devising faster algorithms by already supporting the prime numbers.
Conclusion:
In summary, Bertrand's Postulate, also known as Bertrand's Conjecture, stands as a significant mathematical principle concerning the distribution of prime numbers. This theorem states that for any integer n>3, there exists a prime number within the range of n < p < 2n. Renowned mathematicians such as Joseph Bertrand and Pafnuty Chebyshev have successfully proven this theorem. Within the realm of C++ programming, Bertrand's Postulate holds importance in various areas including prime number generation, primality testing, cryptography, and optimization algorithms. By integrating the principles of Bertrand's Postulate into program design, developers can accomplish tasks like generating prime numbers within specific ranges, conducting primality tests, or implementing cryptographic algorithms and optimization techniques that rely on prime number assumptions.
