A system for post-quantum cryptographic partitioning and a method thereof

Abstract

The present disclosure provides a system (102) for postquantum cryptographic partitioning and a method thereof. The system (102) generates a base wheel including a first element representing an integer and a list of prime numbers. The system (102) generates a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers. The system (102) generates a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial is a product of all primes up to a selected prime number. Further, the system (102) generates a wheel by removing elements that are present in the culled list from the temporary list.

Description

A SYSTEM FOR POST-QUANTUM CRYPTOGRAPHIC PARTITIONING AND A METHOD THEREOFTECHNICAE FIELD

[0001] The embodiments of the present disclosure generally relate to the field of postquantum cryptography, quantum computing, high-performance computing and computational number theory. More particularly, the present disclosure relates to a system for postquantum cryptographic partitioning and a method thereof.BACKGROUND

[0002] The following description of the related art is intended to provide background information pertaining to the field of the disclosure. This section may include certain aspects of the art that may be related to various features of the present disclosure. However, it should be appreciated that this section is used only to enhance the understanding of the reader with respect to the present disclosure, and not as admissions of the prior art.

[0003] The advent of quantum computing poses a significant threat to current cryptographic systems, necessitating the development of post-quantum cryptographic solutions. Prime number generation and factorization, fundamental to many cryptographic algorithms, require efficient handling of extremely large numerical domains. Traditional methods, such as the Sieve of Eratosthenes and wheel factorization, while effective for classical computations, struggle with the memory and processing demands of post-quantum cryptography. The Sieve of Eratosthenes, a classic algorithm for prime number generation, suffers from limitations in memory usage and computational efficiency, particularly when dealing with the vast numerical spaces required for post-quantum security. Wheel factorization, while enhancing efficiency by reducing candidate checks, still encounters scalability issues in large-scale computations.

[0004] Existing optimization efforts, such as those by Pritchard and Sorenson have explored variations of these methods, but a more efficient and memory-optimized approach remains crucial. The generation of prime numbers, using methods such as the Sieve of Eratosthenes and wheel factorization, forms a foundational element in cryptography. These techniques are widely employed for secure key generation in classical encryption algorithms. However, conventional approaches present significant limitations when applied to the computational demands of post-quantum cryptography (PQC). One such limitation is memory and processing inefficiency. The Sieve of Eratosthenes, while conceptually simple, requiressubstantial memory and computational resources, making it impractical for the very large numerical ranges needed in PQC applications. Another limitation concerns the scalability of optimization techniques. Methods such as wheel factorization can improve efficiency by reducing redundant computations, yet they still encounter scalability challenges when applied to large-scale computations required for post-quantum security.

[0005] Therefore, there is a need for a system and a method that can mitigate the specified problems.OBJECTS OF THE PRESENT DISCLOSURE

[0006] Some of the objects of the present disclosure, which at least one embodiment herein satisfies are listed herein below.

[0007] It is an object of the present disclosure to provide a post-quantum cryptographic system and method that generates a base including a first element representing an integer and a list of prime numbers.

[0008] It is an object of the present disclosure to provide a post-quantum cryptographic system that generates a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers.

[0009] It is an object of the present disclosure to provide a post-quantum cryptographic system that generates a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial is a product of all primes up to a selected prime number.

[0010] It is an object of the present disclosure to provide a post-quantum cryptographic system that generates a wheel by removing elements that are present in the culled list from the temporary list.SUMMARY

[0011] This section is provided to introduce certain objects and aspects of the present disclosure in a simplified form that are further described below in the detailed description. This summary is not intended to identify the key features or the scope of the claimed subject matter.

[0012] In an aspect, the present disclosure relates to a system for optimized partitioning. The system includes a processor and a memory operatively coupled with the processor, where said memory stores instructions which, when executed by the processor, cause the processor to generate a base wheel including a first element representing an integer and a list of prime numbers. The processor generates a culled list by multiplying each element of the base wheelby a selected prime number from the list of prime numbers. The processor generates a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial is a product of all primes up to a selected prime number. The processor generates a wheel by removing elements that are present in the culled list from the temporary list.

[0013] In an embodiment, the processor may be configured to define the primorial as one for the first prime number in the list of prime numbers.

[0014] In an embodiment, the culled list may include composite numbers that are multiples of the selected prime number.

[0015] In an embodiment, the processor may be configured to generate the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

[0016] In an embodiment, the wheel may include a modular sequence of numbers not divisible by any of the prime numbers up to the selected prime number.

[0017] In an embodiment, the processor may be configured to iteratively generate the wheel using successive prime numbers from the list of prime numbers until a desired modulus is generated.

[0018] In an embodiment, the processor may be configured to determine a size of the wheel based on a totient function of the primorial, wherein the totient function defines a count of numbers coprime to the primorial.

[0019] In an aspect, the present disclosure relates to a method for optimized partitioning. The method includes generating, by a processor, associated with a system, a base wheel including a first element representing an integer and a list of prime numbers. The method includes generating, by the processor, a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers. The method includes generating, by the processor, a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial is a product of all primes up to a selected prime number. The method includes generating, by the processor, a wheel by removing elements that are present in the culled list from the temporary list.

[0020] In an embodiment, the method may include defining, by the processor, the primorial as one for the first prime number in the list of prime numbers.

[0021] In an embodiment, the method may include generating, by the processor, the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

[0022] In an embodiment, the method may include generating, by the processor, the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

[0023] In an embodiment, the wheel may include a modular sequence of numbers not divisible by any of the prime numbers up to the selected prime number.

[0024] In an embodiment, the method may include iteratively generating, by the processor, the wheel using successive prime numbers from the list of prime numbers until a desired modulus is generated.

[0025] In an embodiment, the method may include determining, by the processor, a size of the wheel based on a totient function of the primorial, wherein the totient function defines a count of numbers coprime to the primorial.

[0026] In an aspect, a non-transitory computer readable medium including a processor and causing the processor to generate a base wheel including a first element representing an integer and a list of prime numbers. The processor generates a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers. The processor generates a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial is a product of all primes up to a selected prime number. The processor generates a wheel by removing elements that are present in the culled list from the temporary list.BRIEF DESCRIPTION OF DRAWINGS

[0027] The accompanying drawings, which are incorporated herein, and constitute a part of this disclosure, illustrate exemplary embodiments of the disclosed methods and systems which like reference numerals refer to the same parts throughout the different drawings. Components in the drawings are not necessarily to scale, emphasis instead being placed upon clearly illustrating the principles of the present disclosure. Some drawings may indicate the components using block diagrams and may not represent the internal circuitry of each component. It will be appreciated by those skilled in the art that disclosure of such drawingsincludes the disclosure of electrical components, electronic components, or circuitry commonly used to implement such components.

[0028] FIG. 1 illustrates an example system architecture (100) of the proposed system (102), in accordance with an embodiment of the present disclosure.

[0029] FIG. 2 illustrates an example block diagram (200) of a proposed system (102), in accordance with an embodiment of the present disclosure.

[0030] FIG. 3 illustrates a flow diagram (300) of an example method implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0031] FIG. 4 illustrates a flow diagram (400) of a wheel generation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0032] FIG. 5 illustrates a flow diagram (500) of an initialization process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0033] FIG. 6 illustrates a flow diagram (600) of a cullout process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0034] FIG. 7 illustrates a flow diagram (700) of a wheel generation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0035] FIG. 8 illustrates a flow diagram (800) of a partition block formation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0036] FIG. 9 illustrates a flow diagram (900) of a block header formation process for X(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0037] FIG. 10 illustrates a flow diagram (1000) of ablock completion process forX(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0038] FIG. 11 illustrates a flow diagram (1100) of a block header formation process for Y (n) implemented by the proposed system ( 102), in accordance with an embodiment of the present disclosure.

[0039] FIG. 12 illustrates a flow diagram of a block completion process for Y(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0040] The foregoing shall be more apparent from the following more detailed description of the disclosure.DETAILED DESCRIPTION

[0041] In the following description, for the purposes of explanation, various specific details are set forth in order to provide a thorough understanding of embodiments of the present disclosure. It will be apparent, however, that embodiments of the present disclosure may be practiced without these specific details. Several features described hereafter can each be used independently of one another or with any combination of other features. An individual feature may not address all of the problems discussed above or might address only some of the problems discussed above. Some of the problems discussed above might not be fully addressed by any of the features described herein.

[0042] The present disclosure describes a partitioning method that extends and optimizes the Sieve of Eratosthenes and wheel factorization, enabling the division of infinite integer sets into finite blocks of infinite integers. This partitioning significantly improves memory efficiency and processing speed, making the partitioning method suitable for the demanding computations of post-quantum cryptographic systems. The ability to manage and manipulate these partitioned number spaces is critical for generating secure cryptographic keys, implementing error correction codes, and designing hash functions that can withstand quantum computer attacks. This approach provides a vital tool for the development of robust postquantum security protocols, ensuring the confidentiality and integrity of digital information in the quantum era.

[0043] Various embodiments of the present disclosure will be explained in detail with reference to FIGs. 1-11.

[0044] FIG. 1 illustrates an example system architecture (100) of the proposed system (102), in accordance with an embodiment of the present disclosure.

[0045] In an embodiment, the system (102) may receive inputs from one or more computing devices (104-1, 104-2... 104-N). The one or more computing devices (104-1, 104-2... 104-N) may be connected to the system (102) through a network (104). The request may be based on optimized partitioning for post-quantum cryptographic systems. The system (102) provides a method for partitioning infinite sets of integers into a finite number of "infinite blocks". This may be achieved by creating a special construct called a "wheel," which represents numbers not divisible by an initial set of small prime numbers. By systematically extending this wheel and using the wheel as a basis, the method allows for highly efficientmanagement and processing of the large number spaces critical to Post-Quantum Cryptography (PQC).

[0046] In an embodiment, the system (102) may generate a wheel sequence for the first n prime numbers. The wheel may include only numbers that are coprime to the selected primes, thereby excluding any numbers sharing a factor with these primes. The size of the wheel may be determined using a totient function that calculates the number of coprime integers within the wheel’s range. The system (102) may then identify the next prime number in sequence for refinement of the wheel in subsequent iterations. Hence, the system (102) provides a compact numerical structure that inherently excludes unwanted multiples, reducing computational overhead in later steps.

[0047] In an embodiment, the system (102) may multiply each element of the current wheel by the next prime number to produce a list of candidate numbers (Cnow). This list identifies the exact positions in the wheel that must be removed in the next refinement step. This embodiment precomputes the specific numbers for exclusion, eliminating the need to check each number individually and thereby accelerating filtering operations.

[0048] In an embodiment, the system (102) may generate a new wheel by comparing numbers from the current wheel against the Cullout list. Numbers absent from the Cullout list may be retained, while numbers present in the Cullout list may be discarded. The resulting wheel incorporates one additional prime in its construction, yielding a progressively refined and selective filter. This embodiment incrementally strengthens the sieve mechanism without reconstructing the wheel from scratch at each iteration, enabling computational efficiency.

[0049] In an embodiment, once the wheel is generated, numbers may be organised by the system (102) into partition blocks. An X(n) block may be formed by selecting a header value from the wheel and generating subsequent values by successively adding the product of the first n primes. The resulting block provides a structured, grid-like set of numbers, where rows and columns can be directly indexed. This embodiment yields predictable and repeatable block layouts, allowing rapid generation of extended sequences without iterative trial-and-error checks.

[0050] In an embodiment, the system (102) may generate a Y(n) block similar to the X(n) block, but derived from numbers in the Cullout list instead of the wheel. The increment used in generating the block is the product of the first n+1 primes. This embodiment efficiently tracks numbers that are multiples of the newly added prime while preserving the same structured, block-based layout, ensuring consistency and simplifying retrieval.

[0051] In an embodiment, the system (102) may loop through rows and columns of a partition block table to populate values. The process begins by initialising the table entries with either wheel-derived values (for X(n) blocks) or Cullout-derived values (for Y(n) blocks). Subsequent entries in each row or column may be generated by the system (102) by adding the corresponding prime product increment to the initial value. This embodiment ensures that block sequences are generated deterministically, eliminating redundant prime-checking operations and significantly improving efficiency for large-scale number generation.

[0052] In one embodiment, the system (102) may perform prime-based computations across multiple domains, including cryptography, blockchain, high-performance computing (HPC), scientific simulation, and data analytics. The system (102) may include one or more processors, memory storing executable instructions, and optional hardware accelerators, where the processors may be configured to execute the instructions to implement the methods described herein.

[0053] In the domain of cryptography and cybersecurity, the system (102) may be configured to generate large prime numbers suitable for use in encryption algorithms such as RS A, Elliptic Curve Cryptography (ECC), and post-quantum cryptography (PQC) variants. The system (102) may further include instructions for efficient key space exploration in postquantum cryptography by sieving candidate numbers using prime and coprime techniques. In certain embodiments, the system (102) may be configured to optimize primality testing pipelines in hardware security modules (HSMs), thereby reducing computational time, energy consumption, and hardware resource usage during secure key generation. The system (102) may be embedded in commercial secure communication products, including virtual private networks (VPNs), secure messaging systems, and certificate authorities, or licensed to cryptographic library providers or secure chip manufacturers.

[0054] In the domain of blockchain and digital ledger technologies, the system (102) may be configured to implement mining algorithms wherein cryptographic puzzles leverage prime-based number theory. The system (102) may generate random numbers subject to coprime constraints to support blockchain consensus mechanisms, ensuring secure and efficient validation of transactions. This embodiment increases the speed and energy efficiency of blockchain mining operations and can be integrated into blockchain software development kits (SDKs), middleware solutions, or Web3 project frameworks for monetization.

[0055] In the domain of high-performance computing (HPC) and scientific simulation, the system (102) may be configured to perform advanced number theory research, including analysis of prime gaps, prime constellations, and integer factorization. The system can furtherimplement signal processing applications requiring prime-based sampling or coprime frequency generation. In certain embodiments, the system (102) may accelerate large-scale combinatorial simulations, scientific computation workloads, and research operations requiring optimized mathematical constructs. This embodiment can be licensed to supercomputing centers, academic institutions, research laboratories, or integrated into commercial scientific software suites.

[0056] In the domain of search optimization in data analytics, the system (102) may be configured to generate hash tables utilizing coprime intervals to reduce collisions and improve search efficiency. The system (102) may implement optimized scheduling algorithms that require non-overlapping cycles, leveraging prime-based calculations. This embodiment can be integrated into database indexing engines for big data platforms, such as Snowflake, Oracle, and SAP HANA, or provided as a licensable application programming interface (API) for analytics and optimization engines in commercial enterprise software.

[0057] In further aspects, the system (102) may include mechanisms to dynamically adjust the selection of primes and coprime sets based on application-specific requirements, thereby increasing computational efficiency, scalability, and adaptability. The methods disclosed herein reduce computational time and energy consumption, improve data security, enhance system performance, and provide opportunities for licensing and commercial deployment across multiple domains, including cybersecurity, blockchain, HPC, scientific research, and big data analytics.

[0058] In one embodiment, the system (102) may enable performing of coprime -based computations in telecommunications, signal systems, and artificial intelligence / machine learning applications. In the domain of telecommunications and signal systems, the system (102) may be configured to implement frequency hopping in wireless communications using coprime sequences to minimize interference and improve signal integrity. The system (102) may further enable spread spectrum communication protocols by generating non-overlapping, deterministic frequency sequences based on prime and coprime numbers. In certain embodiments, the system (102) may be embedded into the firmware of communication devices, including base stations, mobile devices, and loT modules, and may be licensed to telecommunications equipment manufacturers. In the domain of artificial intelligence and machine learning optimization, the system (102) may be configured to generate pseudorandom number sequences for use in training data shuffling, ensuring deterministic but non-repetitive sequences to enhance model training efficiency. The system (102) may further generate number sequences for hyperparameter tuning, providing optimized coverage of the parameter spacewithout repetition or bias. This embodiment may be integrated into Artificial Intelligence (Al) frameworks as a high-performance random sequence generator, improving reproducibility and computational efficiency in AI / Machine Learning (ML) workflows.

[0059] In further aspects, the system (102) may dynamically adjust the selection of primes and coprime sequences based on application-specific requirements, thereby improving computational efficiency, reducing interference in communications, and providing deterministic randomness in AI / ML applications. The methods disclosed herein offer commercial benefits including integration into communication device firmware, enhanced network reliability, and licensing potential for Al frameworks and telecommunications equipment manufacturers.

[0060] In one embodiment, the system (102) enables partitioning of large number spaces using a generated wheel and culled list, where the partitioning method may serve as a foundational tool for developing robust post-quantum cryptography (PQC) systems. By dividing infinite sets of integers into manageable blocks, the method improves memory efficiency and processing speed, making large-scale computations feasible for quantumresistant cryptographic applications. The partitioning method can be applied to the development of various families of post-quantum cryptographic algorithms, including latticebased cryptography, code -based cryptography, and hash-based cryptography. By structuring number spaces using the wheel and culled list, the method enables optimized arithmetic and modular computations, facilitating secure and efficient algorithm implementations. The present disclosure thus provides a foundation for constructing cryptographic systems that maintain security even in the presence of quantum computing capabilities.

[0061] In another aspect, the system (102) supports the efficient generation of large cryptographic keys that are resilient to quantum attacks. By leveraging the partitioned number sets, the system (102) can rapidly identify candidate primes and generate key components with reduced computational overhead. This capability enhances the practical deployment of secure key generation protocols across both hardware and software platforms. The method can also be applied to the design and implementation of secure hash functions capable of resisting quantum attacks. By utilizing the partitioning structure, hash computations can be optimized for memory and processing efficiency while ensuring strong collision resistance. Similarly, principles of the partitioning method may be used in the implementation of error correction codes, which are essential components in certain PQC systems, such as code-based cryptography.

[0062] Furthermore, the system (102) facilitates the creation of advanced security protocols that ensure the confidentiality, integrity, and authenticity of data in post-quantum environments. By dynamically adjusting the selection of primes, the size of the primorial, and the composition of the wheel and culled list, the system (102) may provide scalable, high-performance solutions for cryptography, making the system (102) suitable for integration into secure communications, cryptographic libraries, and hardware security modules.

[0063] In one embodiment, the system (102) may manage large number spaces using the generated wheel and culled list. The system (102) may partition infinite sets of integers into a finite number of manageable blocks, enabling efficient computation and memory usage. Numbers not divisible by the early primes used to generate the wheel may be divided into fixed infinite blocks, each defined by a base number from the finalized Wheel combined with multiples of the final primorial. Similarly, multiples of a specific prime that are not divisible by any smaller primes can be partitioned into blocks using numbers from the culled list as the base and adding multiples of the primorial. This partitioning method allows for structured management of large number sets, which is critical for high-performance cryptographic and computational applications.

[0064] In another embodiment, the system (102) may apply the partitioning method using post-quantum cryptography (PQC). By improving memory efficiency and processing speed, the method supports the development of robust PQC systems, including lattice-based cryptography, code-based cryptography, and hash-based cryptography. The system (102) may enable efficient generation of large, secure cryptographic keys that are resilient to quantum attacks. Additionally, the system (102) may be applied to the design of secure hash functions capable of resisting quantum computing attacks and to the implementation of error correction codes essential in certain PQC systems. These capabilities facilitate the creation of advanced security protocols that ensure data confidentiality, integrity, and authenticity in post-quantum environments.

[0065] In a further embodiment, the system (102) may provide applications in telecommunications and signal systems. The system (102) may use coprime sequences to implement frequency hopping in wireless communications, reducing interference, and improving signal reliability. The system (102) may also support spread spectrum communication protocols by generating non-overlapping, deterministic frequency sequences. These embodiments can be embedded into device firmware for communication equipment, including mobile devices, base stations, and loT modules.

[0066] In yet another embodiment, the system (102) may provide applications in artificial intelligence (Al) and machine learning (ML). The system (102) may generate pseudorandom number sequences fortraining data shuffling and model hyperparameter tuning. By producing deterministic but non-repetitive sequences, the system (102) may enhance training efficiency and reproducibility. The system (102) can be integrated into Al frameworks as an optimized random sequence generator, supporting efficient and scalable AI / ML workflows.

[0067] In additional embodiments, the system (102) may extend to blockchain, high-performance computing (HPC), and data analytics. For blockchain applications, prime-based computations may facilitate efficient mining algorithms and consensus mechanisms, improving validation speed and energy efficiency. In HPC and scientific simulations, the system (102) may accelerate number theory research, combinatorial computations, and signal processing tasks that require coprime or prime-based structures. In data analytics, the system (102) may support hash table design using coprime intervals to reduce collisions and optimizes scheduling algorithms requiring non-overlapping cycles. These embodiments can be integrated into database engines, analytics platforms, supercomputing centers, or commercial software suites.

[0068] FIG. 2 illustrates an example block diagram (200) of a proposed system (102), in accordance with an embodiment of the present disclosure.

[0069] Referring to FIG. 2, the system (102) may comprise one or more processor(s) (202) that may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, logic circuitries, and / or any devices that process data based on operational instructions. Among other capabilities, the one or more processor(s) (202) may be configured to fetch and execute computer-readable instructions stored in a memory (204) of the system (102). The memory (204) may be configured to store one or more computer-readable instructions or routines in a non-transitory computer readable storage medium, which may be fetched and executed to create or share data packets over a network service. The memory (204) may comprise any non-transitory storage device including, for example, volatile memory such as random-access memory (RAM), or non-volatile memory such as erasable programmable read only memory (EPROM), flash memory, and the like.

[0070] In an embodiment, the system (102) may include an interface(s) (206). The interface(s) (206) may comprise a variety of interfaces, for example, interfaces for data input and output (I / O) devices, storage devices, and the like. The interface(s) (206) may also provide a communication pathway for one or more components of the system (102). Examples of suchcomponents include, but are not limited to, processing engine(s) (208), a database (210), and a data ingestion engine (212).

[0071] In an embodiment, the processing engine(s) (208) may be implemented as a combination of hardware and programming (for example, programmable instructions) to implement one or more functionalities ofthe processing engine(s) (208). In examples described herein, such combinations of hardware and programming may be implemented in several different ways. For example, the programming for the processing engine(s) (208) may be processor-executable instructions stored on a non-transitory machine -readable storage medium and the hardware for the processing engine(s) (208) may comprise a processing resource (for example, one or more processors), to execute such instructions. In the present examples, the machine-readable storage medium may store instructions that, when executed by the processing resource, implement the processing engine(s) (208). In such examples, the system (102) may comprise the machine-readable storage medium storing the instructions and the processing resource to execute the instructions, or the machine-readable storage medium may be separate but accessible to the system (102) and the processing resource. In other examples, the processing engine(s) (208) may be implemented by electronic circuitry.

[0072] In an embodiment, the processor (202) may receive inputs from one or more computing devices (104-1, 104-2... 104-N) through the data ingestion engine (212). The processor (202) may record the inputs in the database (210). The request may be based on optimized partitioning for post-quantum cryptographic systems.

[0073] In an embodiment, the processor (202) may generate a base wheel including a first element representing an integer and a list of prime numbers.

[0074] In an embodiment, the processor (202) may generate a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers. The culled list may include composite numbers that are multiples of the selected prime number.

[0075] In an embodiment, the processor (202) may generate a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial may be a product of all primes up to a selected prime number. The processor (202) may generate the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number. The processor (202) may define the primorial as one for the first prime number in the list of prime numbers. In an embodiment, the processor (202) may generate a wheel by removing elements that are present in the culled list from the temporary list. The wheel may include a modular sequence of numbers not divisible by any of the prime numbers up to the selected prime number. Theprocessor (202) may iteratively generate the wheel using successive prime numbers from the list of prime numbers until a desired modulus is generated. The processor (202) may determine a size of the wheel based on a totient function of the primorial, where the totient function may define a count of numbers coprime to the primorial.

[0076] FIG. 3 illustrates a flow diagram (300) of an example method implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0077] As illustrated in FIG. 3, at step 302, the method may include generating, by a system (102), a base wheel including a first element representing an integer and a list of prime numbers. At step 304, the method may include generating, by the system (102), a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers. At step 306, the method may include generating, by the system (102), a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, where the primorial may be a product of all primes up to a selected prime number. At step 308, the method may include generating, by the system (102), a wheel by removing elements that are present in the culled list from the temporary list.

[0078] FIG. 4 illustrates a flow diagram (400) of a wheel generation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0079] As illustrated in FIG. 4, in an embodiment, at step 402, the system (102) may perform initialization for the wheel generation process. The initialization may include creating a base wheel sequence that contains numbers coprime to a set of initial prime numbers. At step 404, the system (102) may perform a cullout operation, where a culled list may be generated by multiplying elements of the current wheel with a next selected prime number, thereby identifying numbers that must be removed in the subsequent refinement. At step 406, the system (102) may generate the next wheel by comparing the current wheel against the culled list, retaining only those numbers that are not marked for removal. The resulting wheel may incorporate the new prime into its filtering structure, thereby creating a progressively refined sequence of candidate numbers.

[0080] In an embodiment, the wheel generation process may be conceptualized as forming a circular filter for identifying numbers that conform to prime-based constraints. The process begins by establishing initial candidate values, continues by systematically removing non-conforming numbers (culling), and then regenerates the wheel in a refined form. This stepwise refinement allows the wheel to exclude multiples of progressively larger primes while preserving a deterministic and compact structure.

[0081] FIG. 5 illustrates a flow diagram (500) of an initialization process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0082] As illustrated in FIG. 5, in an embodiment, at step 502, the system (102) may define / initialize Wnow as the current wheel associated with a prime set P(n), where P(n) represents the first n prime numbers. The wheel Wnow may include candidate values that are coprime to all primes in P(n), thereby serving as the current filter for subsequent refinement.

[0083] In another embodiment, at step 504, the system (102) may identify pnext as the next prime number following the primes included in P(n). This prime may be generated by the system (102) for incorporation into the next iteration of wheel refinement. The system (102) may compute <bnow, a totient-based function that determines the count of integers coprime to the first n primes. The value of <bnow corresponds to the number of valid slots in the current wheel Wnow. The system (102) may computes Gnext, a totient-based function that determines the count of integers coprime to the first n+ 1 prime. The value of Gnext may establish the number of slots that will define the next wheel to be generated upon incorporation of pnext. By explicitly defining the wheel structure, the next prime to be introduced, and the totient-based slot functions, this system (102) provides a precise framework for progressively refining primebased numerical filters. Further, the use of totient functions ensures deterministic sizing of each wheel, enabling efficient transitions from one iteration to the next. At step 506, the system (102) may terminate the process.

[0084] FIG. 6 illustrates a flow diagram (600) of a cullout process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0085] As illustrated in FIG. 6, in an embodiment, at step 602, the cullout process begins with initialization. At step 604, the counter variable is set to i=0. At step 606, a decision step may be performed to check whether i<(|)now. At step 608, if the condition is satisfied, the current cullout element may be generated by multiplying the element of the existing wheel with the next prime number. At step 610, when the condition fails, the loop terminates and the cullout process ends.

[0086] FIG. 7 illustrates a flow diagram (700) of a wheel generation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0087] As illustrated in FIG. 7, at step 702, the next wheel begins. At step 704, the counters may be initialized. At step 706, a decision step checks whether a condition i<Phim is satisfied. At step 708, if the condition is not satisfied, the process may terminate. At step 710, if the condition is satisfied, the next element may be generated. At step 712, a second decisionmay then determine whether the generated element is equal to Cnow[jj. At step 714, if it matches, the counter may be incremented by one and after which the process loops back to the condition check at step 706. At step 716, if it does not match, the generated element may be stored in the next wheel list after which the process may also loop back to the condition check at step 706. This sequence may continue until the termination condition is reached, at which point the generation of the next wheel concludes.

[0088] FIG. 8 illustrates a flow diagram (800) of a partition block formation process implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0089] As illustrated in FIG. 8, in an embodiment, at step 802, the system (102) may generate X(N), set of numbers prime to the first n prime, including 1. At step 804, the system (102) may compute Y(N), set of all multiples of nth prime which are not divisible by lesser primes.

[0090] FIG. 9 illustrates a flow diagram (900) of a block header formation process for X(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0091] As illustrated in FIG. 9, in an embodiment, at step 902, the system (102) may perform an initialization process. At step 904, the system (102) may determine i as the index of a block, the index varying from 0 to (phin-1) and determine j as the index varying from 0 to (N-l) of the number in any block. At step 906, the system (102) may initialize i=0. At step 908, the system (102) may determine if i is less than Phin. At step 910, if the condition is not satisfies, the system (102) may terminate the process. At step 912, if the condition is satisfied, the system (102) may perform B[i,0] = Cnow[i] i=i+I .

[0092] FIG. 10 illustrates a flow diagram (1000) of ablock completion process forX(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0093] As illustrated in FIG. 10, in an embodiment, at step 1002, the system (102) begins with an initialization process. At step 1004, the system (102) may check if a condition i<Phin is satisfied. At step 1006, if the condition is satisfied, the system (102) may compute B[i,j] = B[i,(j-1)]+P(n) and i=i+l. At step 1008, if the condition is not satisfied, the system (102) may perform) =j+l. At step 1010, may determine a second condition j<N. At step 1012, if the second condition is met, the system (102) may terminate the process. At step 1014, if the second condition is not met, the system (102) may step i =0 and go to step 1004.

[0094] FIG. 11 illustrates a flow diagram (1100) of a block header formation process for Y (n) implemented by the proposed system ( 102), in accordance with an embodiment of the present disclosure.

[0095] As illustrated in FIG. 11, in an embodiment, at step 1102, the system (102) may perform an initialization process. At step 1104, the system (102) may determine i as the index of a block, the index varying from 0 to (phin-1) and determine j as the index varying from 0 to (N-l) of the number in any block. At step 1106, the system (102) may initialize i=0. At step 1108, the system (102) may determine if i is less than Phin. At step 1110, if the condition is not satisfies, the system (102) may terminate the process. At step 1112, if the condition is satisfied, the system (102) may perform B[i,0] = Cnow[i] i=i+I .

[0096] FIG. 12 illustrates a flow diagram of a block completion process for Y(n) implemented by the proposed system (102), in accordance with an embodiment of the present disclosure.

[0097] As illustrated in FIG. 12, in an embodiment, in an embodiment, at step 1202, the system (102) begins with an initialization process. At step 1204, the system (102) may check if a condition i<Phin is satisfied. At step 1206, if the condition is satisfied, the system (102) may compute B[I,J] = B[I,(J-1)]+P(N) AND i=i+l . At step 1208, if the condition is not satisfied, the system (102) may perform) =j +1. At step 1210, the system (102) may determine if a second condition j<N. At step 1212, if the second condition is not satisfied, the system (102) may terminate the process. At step 1214, if the second condition is satisfied, the system (102) may set i=0 and go to step 1004.

[0098] In an embodiment, the system (102) may provide a step-by-step outline for filling the block table from the wheel. The system (102) may iteratively loop over all rows and columns to fill in values based on the initial wheel and the prime product step size. This process may enable building of a big table of numbers, including the base wheel and allow addition of a constant value to fill the base wheel. The system (102) may initialize the values of B[i, 0] = Wheel (P(n))[i] for i = 0 to (phin-1) and then store B[i, j]=B[i, (j-l)]+P(n) for i=0 to (phin-1) and j=l to (N-l). The following steps may be subsequently implemented by the system (102).Step 1 : i = 0Step 2: If (i<phin) {B[i,0] =Wnow[i]; i =i+l} else {end}Step 3 : j = 1 ; i = 0;Step4: If (i<phin) {B[i,j] = B[i,j-1] + P(n); i =i+l} else {i =0; j =j+l}

[0099] While considerable emphasis has been placed herein on the preferred embodiments, it will be appreciated that many embodiments can be made and that manychanges can be made in the preferred embodiments without departing from the principles of the disclosure. These and other changes in the preferred embodiments of the disclosure will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be implemented merely as illustrative of the disclosure and not as a limitation.ADVANTAGES OF THE INVENTION

[0100] The present disclosure focuses on the development of partitioning techniques for large numerical spaces, optimized prime number generation, and efficient modular arithmetic within cryptographic applications.

[0101] The present disclosure partitions infinite number sets into finite blocks of infinite numbers has direct implications for lattice-based cryptography, code-based cryptography, hash-based cryptography, and other post-quantum cryptographic methods, enabling the creation of advanced security protocols that are resilient to quantum computational attacks.

Claims

I Claim:

1. A system (102) for optimized partitioning, comprising:a processor (202); anda memory (204) operatively coupled with the processor (202), wherein said memory (204) stores instructions which, when executed by the processor (202), cause the processor (202) to:generate a base wheel comprising a first element representing an integer and a list of prime numbers;generate a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers;generate a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, wherein the primorial is a product of all primes up to a selected prime number; andgenerate a wheel by removing elements that are present in the culled list from the temporary list.

2. The system (102) of claim 1, wherein the processor (102) is configured to define the primorial as one for the first prime number in the list of prime numbers.

3. The system (102) of claim 1, wherein the culled list comprises composite numbers that are multiples of the selected prime number.

4. The system (102) of claim 1, wherein the processor (102) is configured to generate the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

5. The system (102) of claim 1, wherein the wheel comprises a modular sequence of numbers not divisible by any of the prime numbers up to the selected prime number.

6. The system (102) of claim 1, wherein the processor (102) is configured to iteratively generate the wheel using successive prime numbers from the list of prime numbers until a desired modulus is generated.

7. The system (102) of claim 1, wherein the processor (102) is configured to determine a size of the wheel based on a totient function of the primorial, wherein the totient function defines a count of numbers coprime to the primorial.

8. A method (300) for optimized partitioning, the method (300) comprising:generating (302), by a processor (202), associated with a system (102), a base wheel comprising a first element representing an integer and a list of prime numbers;generating (304), by the processor (202), a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers;generating (306), by the processor (202), a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, wherein the primorial is a product of all primes up to a selected prime number; andgenerating (308), by the processor (202), a wheel by removing elements that are present in the culled list from the temporary list.

9. The method as claimed in claim 8, comprising defining, by the processor (202), the primorial as one for the first prime number in the list of prime numbers.

10. The method (300) as claimed in claim 8, comprising generating, by the processor (202), the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

11. The method (300) as claimed in claim 8, comprising generating, by the processor (202), the temporary list by appending multiples of the primorial ranging from one up to a value less than the selected prime number.

12. The method (300) as claimed in claim 8, wherein the wheel comprises a modular sequence of numbers not divisible by any of the prime numbers up to the selected prime number.

13. The method (300) as claimed in claim 8, comprising iteratively generating, by the processor (202), the wheel using successive prime numbers from the list of prime numbers until a desired modulus is generated.

14. The method (300) as claimed in claim 8, comprising determining, by the processor (202), a size of the wheel based on a totient function of the primorial, wherein the totient function defines a count of numbers coprime to the primorial.

15. A non-transitory computer readable medium comprising a processor and causing the processor to:generate a base wheel comprising a first element representing an integer and a list of prime numbers;generate a culled list by multiplying each element of the base wheel by a selected prime number from the list of prime numbers;generate a temporary list by using each element of the base wheel and appending one or more multiples of a primorial to each element of the base wheel, wherein the primorial is a product of all primes up to a selected prime number; andgenerate a wheel by removing elements that are present in the culled list from the temporary list.

Images