2.1. Prime numbers and their properties

A prime number is a natural number greater than 1 that has no divisors other than 1 and itself. The first few prime numbers are 2, 3, 5, 7, 11, 13, 17, and so on [6]. The generation of a prime factor from the prime number is based on dividing the prime number by another number, where each prime number has a unique set of prime factors. Prime numbers have several unique properties that make them the subject of intense study in number theory and other branches of mathematics. Some of the most important properties of prime numbers are:

• Every natural number greater than 1 can be factored into a unique product of prime numbers. This is known as the Fundamental Theorem of Arithmetic.
• There are an infinite number of prime numbers. This was first proved by Euclid more than 2,000 years ago.
• The distribution of prime numbers becomes less dense as numbers get larger. The Prime Number Theorem states that the number of primes less than or equal to a given number ’x’ is approximately equal to x/ln(x) where ln(x) is the natural algorithm of ’x’.
• Some conjectures about prime numbers, such as the Goldbach Conjecture and the Twin Prime Conjecture, remain unproven despite extensive computational evidence supporting their validity.

2.2. Prime number applications

The applications of prime numbers are classified into various topics based on the objectives. Cryptography applications are considered the most widely used topics that apply prime numbers [5–10]. The prime numbers are used for creating secure encryption keys where it is difficult to factor the generated large numbers into their prime factors. Public key cryptography uses public and private keys to encrypt the message between the sender and receiver. It is difficult to factor large numbers into their prime factors, and therefore, the difficulty of predicting the private key from intruders will increase. The prime numbers can generate unpredictable numbers embedded into different algorithms to produce one-time-password (OTP) applied in recent security applications.

The prime numbers can also be generated using genetic algorithms (GA) [11], where the population’s chromosomes represent the prime numbers. The GA’s fitness function calculates the likelihood that a certain chromosome has a prime number. Only the fittest chromosomes are chosen to procreate. After being evaluated, the best progeny of the chosen chromosomes is then chosen for reproduction. This procedure is repeated until a prime number is discovered.

A prime number is a powerful tool for securing communication [12], such as Diffie-Hellman key exchange and the Elliptic curve that create secure communication channels between the two parties. The prime number can also be used in digital signatures for authenticating messages between the sender and receiver. The prime numbers can also produce pseudorandom numbers that can be applied in number theory, gaming, and simulations [13]. In number theory, the characteristics of other mathematical entities, such as polynomials and matrices, are also studied using prime numbers [14,15]. For instance, it is possible to demonstrate using the Fundamental Theorem of Arithmetic that every polynomial with integer coefficients may be factored into a sum of prime polynomials.

2.3. Existing prime number generation algorithms

A certain prime number generation algorithm is chosen depending on the particular application. For instance, the sieve of Eratosthenes is a good option if you need to produce many prime numbers. The sieve of Sundaram or the sieve of Atkin would be preferable if you need to generate a few prime numbers. Over the years, numerous algorithms have been developed for generating prime numbers. Some of the most well-known algorithms are:

2.3.5. AKS primality test.

The AKS primality test is a deterministic algorithm for checking whether a given number is prime or not. The main mechanism is based on using the property of a polynomial to verify if the number is composite and must have a factor that is smaller than its square root [21]. The AKS algorithm checks all numbers that are smaller than the square root of a specified number. If the resulted numbers contain no factors, then the specified number is prime and vice versa. The time complexity of AKS is. Other research methodologies [22] stated that the time complexity of AKS is as low as O(log n⁶). Although the AKS is slower than the Miller-Rabin primality test, it provides a definitive answer to whether a number is prime or composite. Like the Miller-Rabin test, the AKS test is not designed for prime number generation and must be combined with other techniques for this purpose. As presented in Table 1, a comparison of different prime number methods with their objectives, complexity, and limitations is provided.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 1. Prime number methods and their time complexity.

https://doi.org/10.1371/journal.pone.0311782.t001

2.4 Prime number generation in specific ranges

Generating prime numbers within a specific range is more challenging than generating prime numbers up to a given limit. While sieve-based algorithms such as the Sieve of Eratosthenes, the Sieve of Sundaram, and the Sieve of Atkin are highly efficient for generating prime numbers up to a given limit, they are not well-suited for generating prime numbers within a specific range, as they require significant modifications to adapt to this problem. Several approaches have been proposed for generating prime numbers within specific ranges. Some of these approaches involve primality tests such as the Miller-Rabin test or the AKS test combined with other techniques for generating potential prime candidates. However, these methods are less efficient than sieve-based algorithms for generating prime numbers up to a given limit. The choice of a specific range method depends on the application’s requirements. For example, the Sieve of Eratosthenes is a very efficient algorithm for generating prime numbers in a large range, but it can be slow for generating prime numbers in a small range. The Miller-Rabin Primality Test is a more accurate algorithm than the Sieve of Eratosthenes but also slower. The AKS Primality Test is the most accurate algorithm but also the slowest.

3.1. Cryptographic protocols

Apart from RSA encryption, prime numbers are fundamental to various other cryptographic protocols:

• Diffie-Hellman Key Exchange:

Prime numbers are used to establish a shared secret between two parties over an insecure channel. The efficiency of prime number generation can enhance the security and speed of key exchanges.

• ElGamal Encryption:

This public-key cryptosystem also relies on large prime numbers for its security. Efficient prime generation improves the overall performance of the encryption and decryption processes.

3.2 Secure communication systems

Prime numbers play a crucial role in securing communication systems:

• Digital Signatures:

Algorithms like DSA (Digital Signature Algorithm) require prime numbers for generating secure digital signatures. Fast prime number generation can enhance the efficiency of signing and verifying digital documents.

• Pseudorandom Number Generators (PRNGs):

Prime numbers are used in PRNGs to generate secure and unpredictable sequences of numbers. Applications in secure communication, gaming, and simulations benefit from efficient prime generation.

3.3 Computational number theory

Prime number generation is essential in various number-theoretic problems and mathematical research:

• Prime Testing and Factorization:

Efficient algorithms for generating primes assist in testing the primality of numbers and in factorizing large numbers, which are central problems in computational number theory.

• Mathematical Conjectures:

Research in prime numbers supports the study and verification of conjectures such as the Goldbach Conjecture and the Twin Prime Conjecture. Generating large primes helps in providing computational evidence for these conjectures.

3.4. Security applications

Prime numbers enhance security in various applications beyond traditional cryptographic systems:

• Secure Multiparty Computation:

In protocols where multiple parties compute a function securely, prime numbers ensure that intermediate computations remain secure and private.

• Zero-Knowledge Proofs:

These cryptographic protocols, which allow one party to prove to another that a statement is true without revealing any information, often use prime numbers to maintain security and privacy.

Our proposed algorithms use secure random number generators (RNGs) to seed the prime generation process. These RNGs are designed to provide cryptographically secure seeds, ensuring the unpredictability of the generated primes. The proposed algorithms have been carefully designed and evaluated to ensure their security and robustness, particularly in cryptographic applications. By incorporating secure random number generation, rigorous primality testing, and secure implementation practices, we aim to mitigate potential vulnerabilities and provide reliable prime generation for cryptographic systems.

In a final analysis, our proposed algorithms for prime number generation contributes to futureproofing cryptography against threats like quantum computing, but remember, robust key management and exploring alternative solutions like Post-Quantum Cryptography are equally crucial. Ultimately, your work is a significant step in the ongoing effort to secure our digital world.

4.1. Algorithm 1: Prime number generation within a limit

As presented in Algorithm 1, the prime number generation algorithm takes a single parameter called a limit L, and is responsible for generating prime numbers up to the given limit. The following formula generates the odd composite number as follows: (1)

The algorithm starts by calculating the values of N and N₁ then N and N₁ can be determined using the following formulas: (2) (3)

Given that L = 2y is the last number in interval and m<L

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

https://doi.org/10.1371/journal.pone.0311782.t002

The algorithm initializes a list b with all odd numbers in the range [1, L]. It then iterates through each value of n in the range [1, N], and for each n, it calculates the odd composite number m based on Formula (1). To explain Algorithm 1 in detail, the following example summarizes the overall process for generating the prime numbers based on a limit.

Example 1: (Prime Generation within a limit): if we want to find the prime numbers from [1,100].

Step 1: Calculate the set of odd numbers in the range [1,100] using the Formula 2 n+1 and then removes 1 from the generated set as explained in Table 2.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 2. Generation of odd numbers.

https://doi.org/10.1371/journal.pone.0311782.t003

Step 2: Given that y = 50 then

Step 3: The generation of odd composite numbers are calculated based on Formula (1) as follows:

The resulting numbers from the formula are removed to generate the prime numbers in Table 3.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 3. Generation of prime numbers based on a limit.

https://doi.org/10.1371/journal.pone.0311782.t004

The list of odd composite numbers, `prim_list`, is created by adding all `m`values obtained in this process. Finally, the algorithm returns the prime numbers by eliminate the set of odd composite numbers from the set of odd numbers in the range, and list the result set with number 2 as the first number.

• Given that n = 1 and l = 0 then m = 9. The value of N₁ refers to the multiply of 3 by odd number. The removed numbers are [9–15–21–27–33–39–45–51–57–63–69–75–81–87–93–99].
• Given that n = 2 and l = 0 then m = 25. The value of N₁ refers to the multiply of 5 by odd number. The removed numbers are [25–35–55–65–85–95].
• When l = 8 then m = 105, we stop calculated because m must be less than 2y (or m<2y)
• Given that n = 3 and l = 0 then m = 49. The value of N₁ refers to the multiply of 7 by odd number. The removed numbers are [49–77–91].

When l = 4 then m = 105, we stop calculated because m must be less than 2y (or m<2y).

Finally, the result set of prime number with the number 2 is:

[].

4.2. Algorithm 2: Prime number generation within a range

In cryptography, generating prime numbers inside a given range is essential, especially for techniques like RSA. The efficiency of key pair generation is increased by limiting the generation to a certain range, and the security of RSA is predicated on the difficulty of factoring the product of two large prime numbers. The algorithm’s cryptographic strength is guaranteed by choosing primes that fall inside this range. Moreover, defining a range improves the unpredictability and security of cryptographic keys and initialization vectors in cryptographic protocols that use random prime number generation. One of the most important steps in strengthening the cryptographic foundations of different security protocols is the careful examination of a specific range in prime number creation.

As proposed in Algorithm 2, the prime number generation within a range algorithm takes two parameters, `start`and `end`, and generates prime numbers within the specified range or interval [a,b] where a is the start of the interval and b is the end of the interval as presented in Formulas (4) and (5).

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

https://doi.org/10.1371/journal.pone.0311782.t005

The algorithm initializes two empty lists, `A1`and `B1`, to store the odd composite numbers in the specified range. The algorithm iterates through each value of `n`in the range `[0,N] `, and for each `n`, it calculates the odd composite numbers `m `and `m<sub>1</sub>`using the following formulas: (4) (5) (6) (7)

Where a is the start of the range and b is the end of the range. The remaining parameters in the formulas can be determined as follows: (8) (9) (10) (11)

The code will be stop when m₁>2y

To explain Algorithm 2 in detail, the following example summarizes the overall process for generating the prime numbers based on a range.

Example 2: (Prime Generation within a range): if we want to find the prime numbers from [200,400].

Step 1: identify the start value of the range a = 200 and end value of the range b = 400

Step 2: identify the value of y = 100 and y₁ = 200

Step 3: calculate the parameters x₁,N₁,g as follows:

Step 4: calculate the odd composite numbers m as follows: (12)

Due to the equality of = x₁, the value of n = 7, the following parameters will be extracted to find the odd composite numbers.

Given that n = 7 and l = 0 then m = 225. The value of N₁ refers to the multiply of 15 by odd number. The removed numbers are [225−255−285−315−345−375].

Given that n = 8 and l = 0 then m = 289. The value of N₁ refers to the multiply of 17 by odd number. The removed numbers are [289−323−357−391].

Then store all odd composite numbers generated from Eq (12) in the set A1.

Step 5: identify the value of g based on Formula (11) as follows:

The algorithm then eliminates the set of odd composite numbers obtained from `m<sub>1</sub>`from the set of odd composite numbers obtained from `m`to get the prime numbers within the specified range as follows:

n₁ = 1,g = 32,l₁ = 32: 66 multiply of 3 by odd number from 69 to 133.

• Given that . The value of N₁ refers to the multiply of 3 by odd number from 69 to 133. The removed numbers are [].
• Given that . The value of N₁ refers to the multiply of 5 by odd number from 41 to 79. The removed numbers are [].
• Given that . The value of N₁ refers to the multiply of 7 by odd number from 29 to 57. The removed numbers are [203−217−231…399].

Then store all odd composite numbers generated from Eq (13) in the set B1.

We combine the two sets A1 and B1 in the set A which represent all odd composite numbers in the specified range.

Finally, the algorithm returns the prime numbers by eliminate the set A of odd composite numbers from the set of odd numbers in the range. The resulting values are presented in Table 4.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 4. Generation of prime numbers based on a range.

https://doi.org/10.1371/journal.pone.0311782.t006

4.3. Time and space complexity analysis

The time complexity of the proposed algorithms can be analyzed based on the operations performed. Based on the prime generation within a limit presented in Algorithm 1, the main loop iterates for N times, where N is approximately equal to. The time complexity of Algorithm 1 can be analyzed as follows:

1. Initializing the list of odd numbers in the range [1,L] takes O(L/2) time.
2. The outer loop runs N times, where N≈2y+1
3. Inside the loop, generating each odd composite number mm involves constant-time operations.

Therefore, the overall time complexity for Algorithm 1 is approximately.

Based on the prime generation within a range presented in Algorithm 2, the main loop iterates for x times, where x is approximately equal to. Similar to Algorithm 1, there is an inner loop that iterates for N₁ times, where N₁ is approximately equal to ((2×y₁)−9)/6. The time complexity of Algorithm 2 can be analyzed as follows:

1. Initializing the empty lists A1 and B1 involves constant-time operations.
2. The outer loop runs N times, where N≈2y₁
3. Inside the loop, generating each odd composite number m and m1 involves constant-time operations.

Therefore, the overall time complexity for Algorithm 2 is approximately O(N) = O(2y₁) = O(b)

It is essential to note that the time complexity of the proposed algorithms mainly depends on the size of the range (`y`for Algorithm 1 and `y<sub>1</sub> `for Algorithm 2). The algorithms perform well, especially when generating prime numbers within a moderate range, with acceptable performance. The space complexity of Algorithm 1 can be analyzed as follows:

1. The list of odd numbers in the range [1, L] requires O(L/2) space.
2. The list of prime numbers (prime_list) also requires O(L/2) space.

Therefore, the overall space complexity for Algorithm 1 is O(L).

The space complexity of Algorithm 2 can be analyzed as follows:

1. The lists A1 and B1 store odd composite numbers, requiring O (b−a) space.

Therefore, the overall space complexity for Algorithm 2 is O (b−a)

4.4. Algorithms comparison

The proposed algorithms, Algorithms 1 and 2, have distinct advantages compared to other prime number generation algorithms, such as the Sieve of Eratosthenes and the Sieve of Sundaram. One of the primary benefits is their capability to generate prime numbers within a specified range, which is particularly useful for applications requiring prime numbers from a certain interval. Furthermore, the proposed algorithms demonstrate acceptable performance, especially when generating prime numbers within a moderate range. This is due to the relationship between odd composite numbers and the factors the algorithms exploit to identify prime numbers efficiently.

Algorithm 1 and Algorithm 2 are both effective algorithms for generating prime numbers. They have several advantages over other algorithms, such as generating prime numbers within a specified range and demonstrating acceptable performance when generating prime numbers within a moderate range. The authors of [25] proposed a new algorithm for generating prime numbers that use a probabilistic primality test. The algorithm is considered efficient for generating prime numbers within a specified range. The algorithm is not deterministic, so there is a small chance it will incorrectly identify a composite number as prime.

As presented in [26], a new prime number generator algorithm is generated based on the wheel sieve. The generator is faster than the Sieve of Eratosthenes and the Sieve of Sundaram for generating prime numbers within a moderate range. In this paper, the generator is very fast for generating prime numbers within a moderate range. However, the generator could more efficiently generate prime numbers within a large range. The authors of [27] proposed a new prime number generator based on the Sieve of Atkin. The generator is efficient for generating prime numbers within a large range. The generator is very efficient for generating prime numbers within a large range, but it is more complex to implement than the other two. In order to explore the effectiveness of the algorithm 1 and 2, Table 5 explains a comparison between recent algorithms with the proposed algorithms.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 5. Comparative analysis of proposed algorithms with state-of-the-art prime algorithms.

https://doi.org/10.1371/journal.pone.0311782.t007

4.5. Handling edge cases and boundary conditions

In this section, the proposed algorithms are applied to handle edge cases and boundary conditions to verify the robustness and reliability of algorithms as follows:

4.6 Error handling

Our proposed algorithms include several mechanisms to handle potential errors and exceptional cases effectively as follows:

• Input Validation:
• Range and Limit Checks: Before processing, the algorithms validate the input range or limit to ensure they are within acceptable bounds. If the input is invalid (e.g., negative values, non-integer inputs), the algorithms return an appropriate error message or handle the input gracefully.
• Boundary Conditions: The algorithms handle boundary conditions, such as the smallest possible limit (1) and ranges where the start value is greater than the end value, by returning an empty list of primes or adjusting the range appropriately.
• Primality Testing Errors:
• False Positives: In probabilistic primality tests, there is a small chance of false positives. To mitigate this, our algorithms use multiple rounds of testing to reduce the probability of error. For deterministic tests, additional checks are implemented to ensure the accuracy of the results.
• Overflow and Underflow: For very large numbers, there is a risk of overflow or underflow errors. Our algorithms include safeguards to handle such cases by using appropriate data types and arithmetic operations that support large integers.
• Resource Management:
• Memory Allocation Errors: The algorithms monitor memory usage and include error handling for cases where memory allocation fails. This ensures that the algorithms do not crash due to insufficient memory.
• Timeouts: For extremely large inputs, the algorithms include timeout mechanisms to prevent excessive computation time. If an operation exceeds the predefined time limit, the algorithm terminates gracefully and returns a partial result or an error message.
• Algorithm-Specific Error Handling:
• Algorithm 1 (Limit-Based Generation): Handles cases where the limit is very small or very large by adjusting the internal parameters and ensuring that the prime generation process completes successfully.
• Algorithm 2 (Range-Based Generation): Manages cases where the range is invalid or spans a very large interval by segmenting the range into smaller, manageable parts and processing each part sequentially.

4.7 Robustness and resilience

Our proposed algorithms are designed to be robust and resilient to input variations and unexpected conditions. The following features contribute to their robustness:

• Dynamic Adaptation:
• The algorithms dynamically adapt their internal parameters based on the input size and characteristics. This ensures that they maintain optimal performance and accuracy regardless of the specific input values.
• Error Logging and Reporting:
• Comprehensive error logging and reporting mechanisms are integrated into the algorithms. This allows for detailed tracking of errors and facilitates debugging and improvement of the algorithms.
• Graceful Degradation:
• In cases where errors or unexpected conditions occur, the algorithms degrade gracefully. Instead of failing abruptly, they return partial results or informative error messages, ensuring that users receive meaningful output even in adverse conditions.
• Extensive Testing:
• The algorithms have been extensively tested under various scenarios, including edge cases and stress conditions. This rigorous testing ensures that they can handle a wide range of inputs and maintain their reliability and performance.

4.8. Performance optimization

To further optimize the performance of the proposed algorithms, several techniques can be employed:

1. Parallelization: The calculations for `m`and `m<sub>1</sub>`in Algorithm 2 can be executed concurrently, which can significantly speed up the algorithm’s execution when processing large input ranges.
2. Memory optimization: The algorithms can be optimized to use less memory by employing data structures such as bit arrays to represent the odd composite numbers and prime numbers.
3. Incremental computation: The algorithms can be modified to compute the prime numbers incrementally instead of generating them all at once. This approach is useful when the required prime numbers are needed one at a time or when the complete list of prime numbers is not necessary.

Algorithmic optimizations can significantly enhance the efficiency of algorithms through various techniques. Parallelization can be implemented via data parallelism, where the input range is divided into smaller, concurrently processed segments, and task parallelism, which separates algorithm tasks into parallel processes to optimize CPU usage. Incremental sieve updates, such as dynamic sieve adjustment, incrementally update the sieve as new ranges are processed, saving computational resources and memory. Memory-efficient data structures, like bitwise operations and sparse data structures (e.g., hash sets, bloom filters), can reduce memory usage. Mathematical optimizations include advanced prime-checking techniques like the Baillie-PSW test and using the Number Theoretic Transform (NTT) for fast polynomial multiplication. Analyzing computational complexity reveals that segmented sieves and wheel factorization can reduce time complexity, while compressed data structures and lazy evaluation can lower memory usage by only generating primes as needed.

In conclusion, the proposed algorithms offer a new and efficient approach to prime number generation within a specified range. The algorithms leverage relationships between odd composite numbers and their factors to identify prime numbers effectively, resulting in acceptable performance and outperforming other prime generation algorithms in specific scenarios.

6.1. Experimental setup

The performance of our proposed algorithm was evaluated using a variety of range sizes and maximum prime numbers. The algorithm was implemented in Python, and the experiments were conducted on a computer with an Intel Core i7 processor and 16 GB of RAM. We compared the execution times of our proposed algorithm with those of the Miller-Rabin test, the Sieve of Atkin, the Sieve of Eratosthenes, and the Sieve of Sundaram, which were also implemented in Python.

6.2. Results and discussion

We evaluated the performance of our proposed algorithm for generating prime numbers within a specific range in comparison with existing algorithms, including the Miller-Rabin test, the Sieve of Atkin, the Sieve of Eratosthenes, and the Sieve of Sundaram. As presented in Fig 1, we present the results of our evaluation and discuss the implications of these findings. For 10⁶ random numbers, the proposed algorithm achieved 0.7 seconds while Sieve of Atkin and Miller-Rabin algorithms recorded 1.4 seconds and 2.2 seconds. For 10⁷ random numbers, the proposed algorithm achieved better results with 7.3 seconds while Sieve of Sundaram, Sieve of Atkin and Miller-Rabin algorithms recorded 8.3 seconds, 13.9 seconds, and 22.7 seconds respectively. For 10⁸ random numbers, the proposed algorithm recorded 88.4 seconds while Sieve of Sundaram, Sieve of Atkin and Miller-Rabin algorithms recorded 93.9 seconds, 139.8 seconds, and 234.5 seconds respectively.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. Proposed algorithm performance time with prime number algorithms.

https://doi.org/10.1371/journal.pone.0311782.g001

As presented in Table 6, our proposed algorithm consistently outperforms the other algorithms in terms of execution time. The mean execution time for our algorithm is significantly lower than that of the other algorithms, demonstrating its efficiency in generating prime numbers within a specific range. This is particularly notable for larger maximum prime numbers, where the difference in execution times becomes more pronounced.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 6. Execution times (in seconds) of various prime number generation algorithms.

https://doi.org/10.1371/journal.pone.0311782.t008

Table 7 illustrates the performance of our proposed algorithm in generating prime numbers within various ranges. The execution times remain relatively stable as the range size and maximum prime number increase, indicating that our algorithm is capable of handling large ranges and maximum prime numbers efficiently.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 7. Execution times (in seconds) of the proposed algorithm for generating prime numbers within various ranges.

https://doi.org/10.1371/journal.pone.0311782.t009

6.3 Results validation

To validate the performance of our proposed algorithms, we used the following datasets:

1. Small Range Dataset:
   • Prime numbers within the range of [1, 1,000].
   • Used to evaluate the performance for small inputs.
2. Medium Range Dataset:
   • Prime numbers within the range of [1, 10,000,000].
   • Used to evaluate the performance for moderate-sized inputs.
3. Large Range Dataset:
   • Prime numbers within the range of [1, 1,000,000,000].
   • Used to evaluate the performance for large inputs.
4. Custom Range Dataset:
   • Prime numbers within specific custom ranges, such as [10,000,000, 20,000,000] and [100,000,000, 110,000,000].
   • Used to evaluate the performance for arbitrary ranges.

Our proposed algorithms have been designed to generate prime numbers efficiently, making them suitable for real-time applications. The key factors contributing to their real-time performance include:

1. 1. Fast Execution:

The empirical results demonstrate that our algorithms can generate prime numbers quickly. For example, Algorithm 1 can handle up to 10 Million numbers with a mean execution time of 7.307 seconds, and Algorithm 2 can generate primes in the range of [1,000,000,000, 1,10,000,000] in 0.469 seconds.

These performance metrics indicate that the algorithms can meet the demands of real-time systems where prompt prime generation is essential.

1. 2. Scalability:

The algorithms exhibit linear scalability, ensuring consistent performance as input sizes increase. This scalability is crucial for real-time applications that require handling varying data loads efficiently.

During our experiments, we generated prime numbers of various sizes using the proposed algorithms. The size of the prime numbers produced is crucial for cryptographic applications like RSA, which typically require large primes (at least 1024 bits) for secure key generation.

1. Small Primes:
   • Range: [1, 1,000]
   • Example Primes: 2, 3, 5, 7, 11, 13,…, 997
   • Size: Up to 10 bits
2. Medium Primes:
   • Range: [1, 10,000,000]
   • Example Primes: 2, 3, 5, 7, 11, 13,…, 9,999,991
   • Size: Up to 24 bits
3. Large Primes:
   • Range: [1, 1,000,000,000]
   • Example Primes: 2, 3, 5, 7, 11, 13,…, 999,999,937
   • Size: Up to 30 bits
4. Cryptographic Primes:
   • Custom Range: [2^1023, 2^1024]
   • Example Primes: Generated within this range
   • Size: 1024 bits

The proposed algorithms are compared to RSA algorithm to explore its practicality as follows:

• RSA Encryption: For secure RSA encryption, primes of at least 1024 bits are required. Our proposed algorithms can efficiently generate primes of this size, as demonstrated in the experimental results.
• Practical Application: The ability to generate 1024-bit primes ensures that our algorithms meet the security standards for RSA key generation.

In our evaluation, we observed that the proposed algorithm offers several advantages over existing prime number generation algorithms. Not only does it provide faster execution times, but it also maintains its efficiency even as the range size and maximum prime numbers increase. This scalability is essential for applications requiring prime numbers within large ranges or for higher maximum prime numbers. In addition to its performance benefits, our proposed algorithm can generate prime numbers from range to range with acceptable performance. This flexibility allows users to efficiently generate prime numbers within any desired range, making it a versatile tool for various applications. While our algorithm shows promising results, it is important to consider the limitations of the evaluation. For instance, we have yet to explore the impact of different hardware and software configurations on the algorithm’s performance. The execution times may vary depending on the specific setup. Furthermore, our evaluation primarily focused on execution time as a performance metric, which may only capture some aspects of the algorithms’ performance. Future research could explore alternative performance metrics, such as memory usage, to provide a more comprehensive understanding of the algorithm’s efficiency. To explore the performance, efficiency, and scalability of the proposed algorithms, the following sections are provided.

• Performance Comparison:
• Proposed Algorithm 1: Outperforms other algorithms such as the Miller-Rabin test, Sieve of Atkin, Sieve of Eratosthenes, and Sieve of Sundaram in terms of execution time, especially for large ranges and maximum prime numbers.
• Proposed Algorithm 2: Specifically designed for range-based prime generation, demonstrating consistent performance across various ranges, making it suitable for cryptographic applications.
• Efficiency and Scalability: Both proposed algorithms exhibit linear time complexity, ensuring efficient handling of large inputs. The performance metrics indicate scalability, maintaining efficiency even as the input range size increases.
• Memory Usage: The memory usage of the proposed algorithms is linear with respect to the input size. This is comparable to other sieve-based algorithms and better than some primality tests which may have higher memory overhead.
• Accuracy: Both proposed algorithms accurately generate prime numbers, ensuring correctness in identifying primes within the specified limits and ranges. This accuracy is critical for cryptographic applications where prime number correctness is paramount.

6.4 Compliance with FIPS 140–2 and FIPS 140–3 standards

The FIPS 140–2 and FIPS 140–3 standards specify criteria for the prime numbers used in cryptographic algorithms like RSA. Key requirements include the size of the primes and the methods used to ensure their primality. The Criteria from FIPS Standards are as follows:

1. Prime Size: Primes must be at least 1024 bits in length.
2. Primality Testing: Primes must be verified using reliable primality tests to ensure they are true primes.
   • Experimental Validation:
3. Prime Size Compliance:
   • We generated primes within the range [2^1023, 2^1024], ensuring that the primes are at least 1024 bits in length.
   • Our experiments confirm that the generated primes meet the size requirement specified in the FIPS standards.
4. Primality Testing Compliance:
   • Each generated prime was subjected to rigorous primality testing using the Miller-Rabin and Baillie-PSW tests.
   • These tests ensure that the primes are true primes, fulfilling the primality verification criteria outlined in the FIPS standards.
   • Experimental Results:
   • Prime Sizes: Generated primes of 1024 bits.
   • Primality Verification: All generated primes passed the Miller-Rabin and Baillie-PSW primality tests.

In conclusion, our proposed algorithm for generating prime numbers within a specific range demonstrates significant performance improvements over existing algorithms, particularly in execution time. With its scalability, flexibility, and efficiency, this algorithm has the potential to be a valuable tool for a wide range of applications that require the generation of prime numbers within large ranges or for higher maximum prime numbers.

7.1 Formal analysis for Algorithm 1

• Time Complexity

1. Initialization
   • Initializing the list of odd numbers in the range [1,L] takes O(L/2) time.
2. Loop Execution:
   • The outer loop runs N times, where
   • Inside the loop, calculating the odd composite number mm involves constant-time operations.

Therefore, the overall time complexity for Algorithm 1 is

• Space Complexity:

1. List Initialization:
   • The list of odd numbers in the range [1,L] requires O(L/2) space.
2. Prime List:
   • The list of prime numbers also requires O(L/2) space.
   • Therefore, the overall space complexity for Algorithm 1 is: O(L)

• Worst-Case Scenario:

In the worst-case scenario, the algorithm processes up to the highest possible limit L which means it iterates times. Therefore, the complexity remains:

• Average-Case Scenario:

The average-case time complexity is also as the operations within each iteration remain constant regardless of the specific input.

7.2. Formal analysis for Algorithm 2

• Time Complexity
  1. Initialization
• Initializing the empty lists A1 and B1 involves constant-time operations.
  1. Loop Execution:
• The outer loop runs N times, where
• Inside the loop, generating each odd composite number 1 involves constant-time operations.

Therefore, the overall time complexity for Algorithm 2 is

• Space Complexity:
  1. List Initialization:
• The lists A1 and B1 stores odd composite numbers, requires O(b−a) space.
• Worst-Case Scenario:

In the worst-case scenario, the algorithm processes the maximum range where a is very small, and b is very large. Therefore, the complexity remains:

• Average-Case Scenario:

The average-case time complexity is also as the operations within each iteration remain constant regardless of the specific input.

Table 8 summarizes the overall formal analysis for both Algorithm 1 and Algorithm 2.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Table 8. Formal analysis for Algorithm 1 and Algorithm 2.

https://doi.org/10.1371/journal.pone.0311782.t010

Our algorithms integrate with advanced prime generation methods, incorporating techniques like the Sieve of Atkin, segmented sieve methods, and probabilistic tests such as Miller-Rabin or Baillie-PSW to improve efficiency, especially for large ranges. A hybrid approach, combining sieve methods to filter out composites followed by probabilistic tests, enhances the generation of large primes. Incremental sieve updates allow dynamic adjustments, making the algorithms suitable for ongoing prime generation.

The algorithms offer extensive parameter tuning and customization. Users can specify custom ranges, adjust sieve size for memory and performance balance, and control prime density. For cryptographic applications, primes of specific bit lengths can be generated to meet security requirements. In distributed systems, the algorithms support prime generation across multiple nodes for optimal load balancing. They can also be customized for scientific computing to generate primes meeting specific criteria, such as twin primes or primes in arithmetic progressions.

The proposed algorithms advance prime number theory and facilitate cryptographic research by offering efficient prime generation methods. They enhance cryptographic applications in industry by improving the speed and security of key generation, supporting real-time security solutions, and optimizing performance through reduced computational costs and improved resource efficiency. The algorithms’ scalability suits large datasets and high-frequency transactions, benefiting sectors like financial services and cloud computing. Engagement with the research community through workshops, conferences, and open-source contributions ensures the algorithms meet real-world needs.