A Novel Quantum Circuit for Integer Factorization: Evaluation via Simulation and Real Quantum Hardware

1. Introduction

Quantum computing systems are anticipated to surpass their classical counterpart by implementing quantum mechanic principles like superposition, entanglement, and interference [1,2]. Driven by this potential, Quantum Computing has been drawing attention from researchers and investors alike. The funding towards the development of quantum technologies, from both public and private investors, has increased 54% between 2023 and 2024, amassing US$ 2.0 billions worldwide, and is expected to reach around US$ 16.4 billions by 2027 [3,4]. This trend is also reflected in the rapid growth of quantum-focused companies such as D-Wave, IonQ, and Quantinuum, which have increased their market value by more than 2,530%, 800%, and 812%, respectively, over the past 12 months, reaching a combined market capitalization of approximately US$50 billion [5,6,7]. The massive investments in this sector allowed for significant advancements in multidisciplinary fields, such as finances [8,9], material science [10,11], chemistry [12], pharmacology [13], and machine learning [14,15].

Another major area impacted by quantum technology is cryptography [16,17]. Since Shor proposed a new algorithm using quantum information processing for efficient number factoring back in 1994 [18], his work proved the feasibility of a quantum-based algorithm for number factoring. By using modular exponentiation and Quantum Fourier Transform (QFT), previously conceived by Coopersmith [19], Shor’s algorithm successfully captured the period of a function $f\left(x\right)=a mod N$ given an initial superposition state. By leveraging these components, this algorithm performs on polynomial time $\mathrm{O} \left({\left(\log N\right)}^3\right)$, in opposition to the exponential time required by the classical procedures for RSA integer factorization [20,21].

Building upon this knowledge, several subsequent studies sought to improve Shor’s algorithm. In [22], the authors focused on speeding up the arithmetic operations by using improved adder designs, allowing to the parallel execution of quantum gates, while also optimizing the overall circuit’s structure. By doing so, they improved the modular exponentiation execution by up to seven hundred times compared to the available approaches. Building upon the knowledge developed by Meter and Itoh [22], the authors in [23] proposed a new reversible circuit for modular exponentiation using linear-size circuits, and working on register-transfer level instead of the commonly used qubit-transfer level. Their methodology's overall performance showed better scalability than the others previously available at the time, requiring four times less qubits.

The work by Ekerå [24] proposed changes on the QFT algorithm and the post-processing part alike. The author introduced a Shor’s discrete logarithm variant that is optimized when the discrete logarithm $\mathrm{d}$ is significantly smaller compared to the group order $\mathrm{q}$. The algorithm uses smaller QFTs whose sizes reduce the total qubit requirements in this setting. Furthermore, instead of the classical continued fractions method used in Shor’s post-processing, the author employed lattice-based techniques to recover the discrete logarithm from the quantum measurement outcomes. This work has been further expanded in the following work by Ekerå and Håstad [25], where the authors showed that the RSA factorization can be formulated as a short discrete logarithm, thus reducing the burden on quantum computers.

Chevignard et al. [26] optimized the number of required logical qubits for Shor’s algorithm by providing an alternative algorithm for the modular exponentiation part. By combining Ekerå–Håstad’s algorithm, compression techniques and residual arithmetic the authors could reduce the number of logical qubits required for RSA integer factoring. However, this simplification introduces a trade-off between the total number of qubits and the number of gates necessary for its implementation. In [27], the author proposed a novel methodology for number factorization using smaller circuit size by focusing on lattice-based sampling method. This change introduces a trade-off between circuit size and post-processing efficiency, since achieving a simpler classical post-processing demands more qubits and gates, reducing the practicality of Shor’s algorithm on the current quantum hardware.

Gidney [28] improves over his previous work on number factorization [29], developing circuit optimizations. By using approximated residue arithmetic, improved data allocation and reducing the number of magic states, the author managed to elaborate a methodology able to factor a large 2048-bit integer using less than 1 million noisy qubits. The author also showed that the total of quantum gates could be decreased compared with the work by Chevignard et al. His work set an important milestone to the feasibility of quantum number factorization in the current quantum machines.

As the literature mentioned, there are many efforts in different areas of Shor’s algorithm components, ranging from modular exponentiation to post-processing. However, a common feature among these works is the reliance on the QFT circuit, or its variants, for period extraction. Therefore, it is still necessary to investigate alternatives for the QFT structure itself. For example, alternative transforms may be more practical on quantum hardware for specific applications. One strong contender to this task is the Number Theoretic Transform (NTT), which is a specialized variation of the DFT but works over finite fields through modular arithmetic rather than complex numbers [30,31]. Classically, the NTT runs in $\mathrm{O}\left(nlogn\right)$ time and avoids floating-point precision issues, making it well-suited to cryptographic computations [32]. A quantum version of the NTT could, in principle, serve as a substitute for the QFT in algorithms involving integer or polynomial structures. Such an implementation might offer advantages in precision and potentially simpler gate constructions, since modular addition can be easier to realize than arbitrary quantum rotations.

In this context, incorporating a quantum version of the NTT within a quantum framework could lead to a modular design of QFT circuits. By breaking down the QFT into smaller components and selectively substituting them with specialized transforms, the overall circuit can be simplified and made more efficient for NISQ hardware. Such modularization not only streamlines the implementation of fundamental quantum algorithms but also improves their adaptability and performance [33]. Modular QFT architectures support more efficient Quantum Phase Estimation (QPE), a key subroutine in many quantum applications such as quantum chemistry, Hamiltonian learning, and Variational Quantum Eigensolver (VQE) [34]. Decomposing QFT into optimally connected building blocks helps to overcome limitations in qubit connectivity, mitigate gate errors, and reduce decoherence, thereby enabling algorithms to tackle larger instances and deeper circuits [35]. Additionally, this strategy allows for dynamic error mitigation and adaptive allocation of quantum resources, enhancing the reliability and scalability of computations on the available quantum devices.

To bridge this knowledge gap, we introduce a novel quantum factorization algorithm, named Jesse-Victor-Gharabaghi (JVG) algorithm, by incorporating a Quantum Number Theoretic Transform as an alternative to the usual QFT circuit, in the original Shor’s pipeline. It is important to emphasize that JVG’s novelty lies in advancing number theory period finding by extracting it from a finite ring rather than a complex field. The present work constitutes the first empirical validation of a QNTT-based approach through comprehensive benchmarking on both simulated and real quantum backends. This includes resource scaling projections under realistic NISQ constraints. This methodology offers a distinct and measurable contribution beyond previous QNTT formulations, which had not been integrated into or tested within a complete quantum factoring framework.

At the current phase of this study, the comparison will be restricted between the proposed QNTT-based circuit and the standard Shor’s algorithm using QFT. This is so we have a clear baseline for evaluating performance and scalability. By establishing a direct comparison, it becomes possible to quantify the resource savings and noise resilience provided by the QNTT circuit while maintaining the same algorithmic framework. This controlled assessment ensures that observed improvements can be attributed specifically to the substitution of QFT with QNTT, rather than to unrelated modifications in the algorithm. By doing so, we aim to provide a novel paradigm for number factorization, achieving superior scalability considering gate count and memory usage.

2. Methodology

2.1. Quantum Computing

Feynman first envisioned Quantum Computing in his groundbreaking paper “Simulating Nature with Computers” [36], where he proposed that classical computing machines could not capture the random nature of physical and natural phenomena. In fact, it would be more correct to apply quantum mechanic concepts to emulate the behaviour of physical world. Therefore, researchers have developed a completely new framework for information processing, based on the core principles of quantum mechanics, as suggested by Feynman. The most relevant principles used in the present study are presented and discussed as follows.

2.1.1. Qubits

Classical computers represent information using bits in binary form, where each one can take a binary value as input. The information is then computed through logical operations [37,38]. Its quantum counterpart is the quantum bit, usually called qubit. It is the basic unit of information processing in Quantum Computing (QC) and is defined mathematically as a vector containing the complex amplitudes defining the system’s quantum state. For example: a quantum state defined at ground state, is $\left|0\right.⟩={\left[1 0\right]}^T$. The excited state is represented as $\left|1\right.⟩={\left[0 1\right]}^T$. With qubits, we then can represent a complex quantum state in the form [39]:

$$\left|\mathsf{\Psi }\right.⟩= \sum _{j=0}^{n-1}{\alpha }_j{\left|j\right.⟩}_n$$

(1)

Equation 1 showcase a generic n-qubit quantum system $\left|\mathsf{\Psi }\right.⟩$, derives from a linear combination of all ${\left|j\right.⟩}_n$ states. Here, ${\alpha }_j$ represents the amplitude of the respective j-state, being a complex value. Physically, absolute value of the amplitude represents the likelihood of a specific j-state to occur. Finally, the amplitudes are normalized values such as:

$$\sum _{j=0}^{n-1}{\left|a_j\right|}^2=1$$

(2)

Qubits encode the characteristics of a quantum system, and are defined within a complex Hilbert space [40,41]. Being this an abstract idea, it is not trivial to visualize the behavior of the qubit while subjected to operations. However, it is possible understanding the quantum system behavior, and consequently the qubit itself, by using the Bloch sphere for a three-dimensional representation. The quantum system $\left|\mathsf{\Psi }\right.⟩$ then depends on the position of the qubit within this Hilbert space, that polar coordinates can represent. Given that the amplitudes are normalized to a unitary value as shown in Equation 2, it is possible to rewrite $\left|\mathsf{\Psi }\right.⟩$, for a one qubit system, state as:

$$\left|\mathsf{\Psi }\right.⟩=\cos {\displaystyle \frac{\theta }{2}}\left|0\right.⟩+e^{i\varphi }\sin {\displaystyle \frac{\theta }{2}}|1⟩$$

(3)

Where $\theta$ and $\varphi$ are real values representing the angles, in radians, of the qubit described within the Bloch sphere. Figure 1 depicts the Bloch sphere.

With these definitions, the qubits provide the framework for modeling the relevant quantum mechanical properties used in this study.

2.1.2. Superposition

The superposition principle in quantum mechanics states that a quantum system may exist as a linear combination of its possible states, as shown in Equation 1. This opposes the classical understanding of the classical bits, which are restricted to a single definite state at any given moment, while qubits can exist in a superposition of both cases [42,43]. In the QC framework, the superposition allows for processing an exponentially large state space, being one of the cornerstones which allows quantum algorithms to achieve significant speedups when compared to their classical counterparts [1,44,45].

2.1.3. Entanglement

Another important concept used in this study is entanglement [46]. It describes a single quantum system formed by two or more particles that cannot be expressed as their individual properties. In this scenario, these particles could share so much information between themselves that it would be possible to describe the full system by measuring only one of its particles [44,45]. In essence, entanglement means that for composite quantum systems, the state of each particle is inseparable from that of the others even when they are physically apart [15]. This conclusion is counterintuitive and not fully understood by the scientific community. However, it plays a significant role in the QC framework. It appears in quantum teleportation applications, quantum error correction, and number factorization, even appearing in Shor’s algorithm, being also responsible for enabling significant processing speed-ups by the quantum machines [47].

2.1.4. Interference

The third major quantum mechanical concept used in our study is interference. Like previously said, the quantum systems have wave-like behavior which can be modeled by Schrödinger’s equation. Therefore, the particles in such a system may interfere with each other in either a constructive or a destructive fashion [48,49]. This will affect the phase of each particle, which in part influences the likelihood of the outcome of a quantum state after measurement. The application of this property allows the QC to manipulate the probability of an outcome to a desired state. Examples of interference in QC framework are the Grover’s search algorithm [50], and QFT algorithm itself, both of which rely on interference to amplify the probability of the desired solution [44].

2.2. Quantum Gates

Quantum gates serve as helpers to model the quantum mechanical properties. They are unitary matrices that allow the application of linear operations on qubit state vectors. A matrix is defined as unitary when:

$$U^{-1}=U^{†}$$

(4)

Where $U^{†}$ represents the complex conjugate of a matrix $U$. By extension, unitary operators also have that $U{U}^{†}=U^{†}U=I$, being $I$ the identity matrix with the same order as $U$. An important property of unitary matrices is that they preserve the norm and the inner product of the vector which the operate upon, allowing for reversible operations without loss on information, which is one of the backbones of the QC framework [44].

Different fundamental quantum gates and operations were employed in this study, and it is important to introduce them before proceeding. The first unitary gate presented is the Hadamard gate, defined as follows:

$$H={\displaystyle \frac{1}{\surd 2 }}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]$$

(5)

This gate puts the qubit into a superposition state between $|0⟩$ and $|1⟩$. This is achieved by performing rotations around X and Z-axis as defined in the Bloch sphere (Figure 1). This matrix is fundamental in many quantum circuits. It ensures that the superposition is present, and, together with entanglement and interference, ensuring the that the quantum system explores multiple paths at once.

Pauli gates are also fundamental pieces of the quantum circuits. Specifically for this study, we present Pauli X and Pauli Z as they were used in our methodology.

$$X=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]$$

(6)

$$Z=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right]$$

(7)

The Pauli X gate changes the qubit orientation around X-axis, moving it from $\left|0\right.⟩$ to $|1⟩$ and vice-versa. The Pauli Z gate flips the phase of a given qubit. Considering a system in superposition, this operation does not alter the qubit state in $\left|0\right.⟩$, but maps the original $|1⟩$ to $-|1⟩$, fundamentally changing the qubit’s phase by a $\pi$ radians factor. The Pauli Z matrix can be generalized in terms of $\varphi$ angle, given in radians (Figure 1):

$$R_{\varphi }^Z=\left[\begin{array}{cc}1& 0\\ 0& e^{i\varphi }\end{array}\right]$$

(8)

In this general formulation, the term $e^{i\varphi }$ determines the phase change of the qubit.

Controlled operations are also paramount in QC. They allow that entanglement can be modeled into the QC framework, enhancing data processing done by quantum devices. Controlled quantum gates require at least two qubits, where one is the control and the other is the target. The operation is performed over the target qubit only if the control has the $|1⟩$ state. It is possible to have multi-controlled gates. , in which the unitary operation acts on the target qubit exclusively when all control qubits are in the $|1⟩$ state. The present work used CNOT (or CX) and Toffoli gates as controlled operations. The former is a two-qubit quantum gate implementing a controlled Pauli X matrix. The latter also implements a Pauli X operation, but it has two controlling qubit. The CNOT matrix is:

$$CNOT=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right]$$

(9)

The Toffoli matrix is an extension of the CNOT one. The matrix considering a two-qubit control scenario and one target is presented below:

$$Toffoli=\left[\begin{array}{cccccccc}1& 0& 0& 0& 0& 0& 0& 0\\ 0& 1& 0& 0& 0& 0& 0& 0\\ 0& 0& 1& 0& 0& 0& 0& 0\\ 0& 0& 0& 1& 0& 0& 0& 0\\ 0& 0& 0& 0& 1& 0& 0& 0\\ 0& 0& 0& 0& 0& 1& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 1\\ 0& 0& 0& 0& 0& 0& 1& 0\end{array}\right]$$

(10)

Finally, another important operation present in the developed circuits is the SWAP. As its name indicates, this operation changes the state between two qubits. Its matrix is:

$$SWAP=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right]$$

(11)

2.3. Quantum Fourier Transform

The Quantum Fourier Transform was conceived by Coppersmith [19]. It is the quantum counterpart of the classical Discrete Fourier Transform (DFT), mapping data from the time domain into the frequency one. Classically, DFT has complexity $O \left(n^2\right)$ with the following formulation [30,51]:

$$\widehat{f_k}={\displaystyle \frac{1}{\sqrt{N}}}\sum _{j=0}^{N-1}{x}_j{e}^{{\displaystyle \frac{2\pi ijk}{N}}}$$

(12)

Equation 12 shows the output vector $\widehat{f_k}$ as being a normalized linear combination of elements of the input vector $x_j$. The term $e^{{\displaystyle \frac{2\pi ijk}{N}}}$ is the kernel of the transform function, given in terms of indices $j$ and $k$, and by the vector length $N$ itself. Additionally, according to Euler’s equation, this term can be understood as a combination of the oscillatory influence of sine and cosine at different frequencies, as given by $2\pi i$. Additionally, by using advanced algorithm building techniques, it is possible to implement a faster variant of DFT with complexity $O (n\log n)$, being this version often referred to as Fast Fourier Transform (FFT) [52]. The QFT is mathematically defined as [1,44]:

$$\left|j\right.⟩\to {\displaystyle \frac{1}{\sqrt{N}}}\sum _{j=0}^{N-1}{e}^{{\displaystyle \frac{2\pi ijk}{N}}} |k⟩$$

(13)

The expression in Equation 13 is similar to the one presented in 4 but is fundamentally different. Here, the resulting quantum state $|j⟩$ is mapped into a superposition of states $|k⟩$. Additionally, being this a quantum transformation, it lies within a Hilbert space with dimension N. As a unitary operation over an N-dimensional Hilbert space, QFT performs a linear transformation that preserves inner products and vector norms, ensuring reversibility within the dynamics of a quantum computer [44]. The quantum circuit for a 4-qubit configuration for QFT is presented in Figure 2.

Figure 2 elucidates that the QFT circuit is a sequence of rotations applied over a superposition state. From left to right, the first quantum Hadamard gate puts the qubit into superposition. It is then followed by controlled gates $R_{\varphi }^Z$, which moves the qubit around the Z-axis given a $\varphi$ angle. From Equation 8, it is possible to see that the rotations implemented in the QFT circuit in Figure 2 can be generalized as $R_k^Z= R_{{\displaystyle \frac{2\pi }{2^k}}}^Z$. The last two operations are SWAPs, reversing the qubits orders to match the QFT’s definition [39,44].

The QFT, alike its classical counterpart, also has an inverse configuration which is used in Shor’s algorithm. Considering the quantum circuit configuration, the IQFT is the same as applying the forward circuit (Figure 2) but reversed. The IQFT circuit is:

Figure 3. Quantum circuit schematics for the inverse QFT.

Figure 3. Quantum circuit schematics for the inverse QFT.

2.4. Number Theoretic Transform

The Number Theoretic Transform (NTT) is a specialized version of DFT. While the latter operates over complex number, the former performs analogous computations over a real finite field or ring, often the integer modulus a prime [53]. Its formulation is [31]:

$$\widehat{f_k}=\sum _{j=0}^{N-1}{x}_j{\omega }^{jk} mod p$$

(14)

Where $mod$ indicates modular operations over a ring defined by a prime number $p$, as in ${\mathbb{Z}}_p=\{0, 1, \dots p-1\}$. Modular arithmetic operations then map the results into the defined ring by taking the remainder upon division by $q$. This makes the values wrap around $q$ whenever they exceed this prime number [54]. Still in Equation 8, the term $\omega$ represents the primitive root. In arithmetic, primitive roots generate the set of $N=p-1$ integer coprime values to the prime $q$ through successive exponentiations. Additionally, it is needed that $N\left|\right(p-1)$ and the primitive root must ensure that ${\omega }^j\equiv 1 mod p$ while ${\omega }^k\not\equiv 1 mod p$, $\forall 0<k<j$ [54].

Given its similar formulation to the DFT, NTT can be implemented in a classical fashion to reach complexity $O (n\log n)$ [55]. This is achieved by implementing the Gentleman-Sande algorithm [56]. Originally conceived as a variation of the Cooley-Tukey FFT algorithm [57], the Gentleman-Sande algorithm works in bit-reverse order, performing a decimation-in-frequency (DIF) factorization of the NTT. In this approach, the input sequence is processed orderly, but the outputs are produced in digit-reversed order. Each stage of the algorithm recursively breaks the problem into smaller parts, combining results with butterfly operations and twiddle factors, i.e. the unitary roots. The bit-reversal step must then be unscrambled at the end to recover the coefficients in the correct order. This variant, alongside Cooley-Tukey’s decimation-in-time (DIT) approach, forms one of the two standard recursive FFT factorizations, and is frequently adapted in NTT applications due to its memory efficiency and modular structure [52,56].

2.5. Quantum Number Theoretic Transform

Building upon the classical NTT, and the Gentleman-Sande algorithm, the Quantum Number Theoretic Transform (QNTT) was developed to be used in a quantum framework. The original QNTT implementation used in this study, was proposed by Lu et al. [58]. Their methodology combined quantum arithmetic operations together with quantum modular operations to implement a quantum version of the Gentleman-Sande butterfly operation for a configuration using 4 qubits as input and a modulus equals to 5. The authors implemented their QNTT circuit using NISQ friendly operations. For example, the adder and subtractor gates are composed by sequences of CNOT gates, which is more efficiently implemented than, for example, the QFT-based adder drapper [59,60,61,62]. By doing so, Lu et al. [58] developed an efficient quantum circuit able to perform QNTT operations in a quantum framework. Figure 4 depicts the QNTT circuit.

In Figure 4, the rectangular boxes represent the operations applied to the qubits. In this image, there is two input values represented by registers $|a_0⟩$ and $\omega \times |a_1⟩$, each one containing n-qubits, and $\omega$ being the twiddle factor. The register $|p⟩$ is the integer prime number determining the ring ${\mathbb{Z}}_p$, containing n-qubits. The remaining registers, $|u⟩$ and $|v⟩$ are ancilla qubits that will help to compute the necessary operations, containing n-qubits each [58].

It is possible to observe that the QNTT circuit uses quantum modulus, addition and subtraction operations to compute the transforms. It starts with a modulus operation computing $\left|a_0\right.⟩ mod |p⟩$, where the result is stored in a register $|u⟩$ using a CNOT gate. Following, the modular operation for the second input value is computed, and its result is stored in $|v⟩$. The next adder and modular operations then compute $\left|a_0+a_1\right.⟩ mod |p⟩$, which returns the transformed value for the register $|a_0⟩$. The last three operations compute $\left|a_1-a_0+p\right.⟩ mod |p⟩$, finally it returns the transformed value for the second input register.

Similarly to QFT, the QNTT circuit has an inverse form to compute the inverse QNTT operation, illustrated in Figure 5:

The IQNTT is present in the JVG algorithm developed in the present study.

2.6. Shor’s Algorithm

Shor’s algorithm was designed to factor a composite number formed by multiplying two prime integers. This is done by finding the order $r$ such as $x^r\equiv mod N$, being $N$ the composite number to be factored and $x$ a random initial value. The quantum circuit for the order finding used in Shor’s algorithm is represented in Figure 6.

Figure 6 can be split into three main structures. The first consists of putting the first register $|m⟩$, initialized in state $|0⟩$, into superposition. After that, the quantum modular exponentiation computation is applied to the circuit in the form of controlled rotations. Here, the controls are the qubits in register $m$ and the targets are the qubits in register $|n⟩$, initialized in state $|1⟩$. Note that the number of qubits in register $|m⟩$ determine the size of the superposition, which impacts on the phase estimation, while the number of qubits in $|n⟩$ needs to be sufficiently large to store integers up to $N$. The last part of the circuit is the inverse QFT in the $|m⟩$ register. At the end of this circuit, the register $|m⟩$ is measured, revealing information about the period of the function $f\left(r\right)=x^r mod N$ [18,39,44]. In the methodology here proposed, we substitute the IQFT circuit by the IQNTT. The novel quantum circuit for integer factorization in a quantum framework is presented in Figure 7.

Differently from QFT in Shor’s pipeline, the IQNTT retrieves the period of a given function $f\left(r\right)$ directly over a finite ring ${\mathbb{Z}}_p$. By changing spectral estimation from the complex domain to a ring-based spectrum, we extend the number-theoretic formulation of period finding offering a further understanding on its implementation.

Additionally, the QFT circuit requires extensive qubit interactions, which is hard to compute on present quantum hardware. Noisy Intermediate-Scale Quantum (NISQ) devices have limitations such as reduced coherent time per qubit, high error rates per gate, i.e. gate operation errors and gate fidelity, and restricted connectivity, al of which difficult feasibility of QFT circuits [63,64]. Contrariwise, the QNTT circuit (Figure 4) avoids rotations for input transformation, offering a simpler design. In this context, less complex implementations such as QNTT are preferable, as they offer a more efficient hardware-compatible framework for the current quantum devices [65].

3. Results

To evaluate the performance of the proposed methodology, we conducted experiments using two different approaches. The first one, we used Qiskit SDK to simulate the quantum circuit in a classical device. Table 1 has information about the hardware used for the quantum simulations in a Windows 11 operational system.

The second part consisted in implementing the same algorithms in an IBM’s quantum computer. For both cases, we considered the following composite numbers to be factored using QFT-based and QNTT-based algorithms: 15, 21, 143, 1363 and 67297. The selection of these values was because we need to assess the algorithms’ performance for composite values containing different number of digits. For each one of these values, the total number of qubits used in the circuit also changes. We also tried larger composite numbers, but due to hardware limitations, given that simulating quantum operations in classical devices is still very demanding [66,67], the algorithms failed to run. At this stage, it is relevant to note that both methodologies compared JVG against the Shor’s algorithm implemented by IBM [68].

It is important to emphasize that the purpose is to demonstrate and verify the underlying hypothesis, demonstrating that the proposed JVG algorithm consistently exhibits scalability trends, requiring fewer resources than the standard Shor’s algorithm, as problem size increases. While the present results do not target a large number of factorizations, i.e. RSA-2048, they establish a clear trajectory of improvement, indicating that the same principles could translate into significant resource savings in the given NISQ era.

Table 2 contains information about the composite numbers, their digits and the total amount of qubits in their respective circuits.

To maintain clarity between simulated and experimental outcomes, all performance metrics in this work are reported within their native execution contexts. The simulation-based results employ Qiskit’s gate model using the CX, U, and SWAP primitives, along with wall-clock execution time, memory consumption (RAM) and circuit depth as system-level metrics. These measurements capture algorithmic behavior independent of hardware-specific constraints. Conversely, the quantum computer evaluations are based on IBM Q backends that utilize a different native gate basis, primarily SX, CZ, RZ, and X, which include Qiskit Runtime (QR) execution time and circuit depth as indicators of resource demand. Because these gate sets are not directly equivalent, cross-domain comparisons are made in relative terms using normalized quantities such as circuit depth and runtime scaling rather than 1:1 gate count. This ensures that simulator results reflect algorithmic scaling properties, while hardware results capture physical implementation behavior under realistic noise and transpilation conditions. For each setup, each circuit was sampled 1024 times.

3.1. Results for Quantum Simulation

To account for stochastic effects in the simulation, each experiment was repeated 10 times. The mean and standard deviation were computed for every configuration across these runs. The average coefficient of variation is reported in Table 3 and Table 4, for both approaches.

Table 3 and Table 4 indicate that for the evaluated composite values, the QFT-based circuit yields better performance in terms of run time, RAM usage and gate count. It is possible to notice that the standard variation presents relatively small value compared to the mean. For both QFT and QNTT applications, the average coefficient of variation remained well below a 2% threshold. Considering run time and RAM, the JVG methodology reached an average of 1.08% and 0.89%, lower values than 1.17% and 1.21% calculated for the other methodology. The standard deviation for the gate count also revealed minimal, and both approaches reached very similar results. The same conclusion can be drawn for the circuit depth, where QFT-based technology reached 0.25% and the QNTT one 0.29%.

Figure 8 shows the plots for each metric using Log₁₀ scale for better visualization of the data points.

In Figure 8, the trendlines are of exponential form, indicating that both cases closely follow the exponential behavior. Figure 8 (a) shows a noticeable difference between the two approaches, where the QNTT-based model requires over 700 s to finish, when compared to the 170 s of its counterpart for N = 67297. However, for the same N, the QNTT alternative presents superior RAM usage values, needing on average 11.8 GB of memory, compared to 12.6 GB for the other quantum circuit. Additionally, Figure 8 (b) reveals that the trendline corresponding to the QFT-based approach surpasses the one representing the QNTT alternative.

A more careful analysis of the gate count also reveals that number factorization using QNTT circuit has superior scalability than the traditional Shor’s circuit. This becomes clear when evaluating the plots of each metric versus the number of qubits in the circuits depicted in Figure 9.

The trendlines in Figure 9 are also of exponential form. It reveals that JVG’s QNTT-based factorization scales better than Shor’s QFT. Examination of each panel shows that the gap seen at smaller composite values, like 15, 21 and 143, reduces as the number of qubits in the circuit grows. For the last considered point N = 67297, the gap becomes marginal, indicating that both methodologies achieve similar performance.

Additionally, a direct comparison between the increase of resource usage for each metric, also indicates improved scalability performance of the proposed methodology QNTT-based. Table 5 summarizes this information.

Table 5 refers to the increase in resources between the first composite number, N=15, and the last one evaluated, N = 67297, using the two methodologies. The data highlights that as circuit size increases, the QFT-based algorithm demands a substantially higher proportional growth in resources than the QNTT-based approach. For instance, the QFT circuit exhibited an increase of 17209% in runtime and 2881% in memory usage, whereas the QNTT circuit required reduced resources, 15007% and 2630% respectively.

The same pattern holds for gate counts and Circuit Depth. For gate count, the most significant difference is observed for CX gate, which increased by over 16155% for QFT, significantly more than 12401% for the same gate present in QNTT. The circuit depth of the traditional Shor’s algorithm also increased by 8749%, a considerably larger value compared to 6551% for the JVG methodology.

3.2. Results for Implementation on a Real Quantum Hardware

We also repeated the circuits ten times when implementing the circuits in a quantum device. However, due to the limitations of the processing time in quantum devices, the number of runs for N = 1363 was limited to six, as it demanded the largest amount of processing time. Different from the simulation methodology, we could not run the circuits for N = 67297. This was due to the current constraints of the NISQ devices, as previously discussed. They still offer limited coherence time and qubit connectivity, which prevent more profound and more complex quantum circuits from being implemented. At this phase, the quantum device used in our methodology was “ibm_torino”, which uses the Heron R1 quantum processor and has 133 qubits. We recommend addressing reference [69] for further information on this device and its processor.

Additionally, for every configuration, the mean and standard deviation were calculated across these runs, in the same fashion previously described. Table 6 and Table 7 contain the results for implementing the algorithms QFT and QNTT-based, respectively.

As presented in Table 6 and Table 7, both methodologies exhibited stable behavior across repeated runs, with relative standard deviations remaining within a few percentage points of the mean. On average, the JVG algorithm achieved a 2.64% average coefficient of variation in QR, about half of the reported value 5.15% for the QFT-based circuit. The JVG implementation maintained lower or comparable variability for the primary quantum gate metrics, reaching 0.22% for SX, 0.24% for CZ, and 0.24% for RZ gates. The QFT version reached 0.26%, 0.29%, and 0.33%, respectively. The X-gate variance followed a similar pattern, with 3.02% coefficient of variation for QNTT and 4.67% for QFT. Circuit Depth fluctuations also remained limited, averaging 0.39% and 0.53% for QNTT and QFT, respectively.

Table 6 and Table 7 also reveal that the QFT-based circuit yields better results in terms of runtime and gate count for an N = 1363, as observed from Table 3 and Table 4. At no evaluated condition did the QNTT surpass the performance of the traditional QFT implementation. This could be explained by the fact that limited composite numbers were investigated, as previously discussed. Still, it is interesting to observe that when the quantum circuit involves the highest number of qubits, the standard deviation for all the metrics regarding the QNTT approach is significantly less than its QFT alternative, which may indicate a more stable circuit.

Figure 10 presents the plot comparing QR versus the total amount of qubits in the circuit for each composite number.

The trendline in Figure 10 is of exponential form. The coefficient R² suggests good agreement of the data for Shor’s QFT and JVG’s QNTT approaches, being around 99% for both cases. Additionally, the trendline indicates that with the increase of qubits in the circuit, the difference between the two methodologies decreases substantially. This was not the case for the simulated results, where the two lines (Figure 8) were further apart, but with an indication to come closer together as the circuit increases. Finally, the trendline for QFT at last point is marginally surpassing the one for QNTT, reinforcing its superior scalability capacity.

Figure 11 summarizes the plots for gate count and Circuit Depth.

The trendlines in the plots in Figure 11 are also exponential, indicating good agreement with the plotted data. For all the experimental results, the JVG approach reduced the gap compared to the QFT, with the increasing number of qubits in the circuit, which complies with the observed trend for the simulated results. The most significant one was the number of X gates, where the gap between the points of both the approaches presented. The circuit depth also shows a substantial decrease in the gap between the two algorithms, revealing that they exhibit comparable performance in this metric.

Table 8 contains data comparing the increase in computational resources for QFT and QNTT-based circuits when implemented in a real quantum device.

Table 8 reveals the improved scalability of the QNTT model over the QFT counterpart. For each measured metric, as observed in Table 5, the increase in computational resources is significantly greater for the traditional QFT methodology. Notably, substantial differences are seen in the X gate count and circuit depth, where the JVG approach achieved considerably lower increases of 914% and 1922%, respectively, compared to 1321% and 2519% for the QFT-based algorithm.

3.3. Projections for Simulated and Experimental Results

We fitted the exponential models for both simulation and experimental results using the trendlines present in Figure 8, Figure 9, Figure 10 and Figure 11. These projections must be interpreted as indicative trends, rather than precise forecasts, since extrapolations beyond the measured range inherently carry uncertainty, since error accumulation and hardware-specific restrictions may alter scaling at larger qubit counts. Nevertheless, these results remain relevant, as they capture the underlying trend behavior and provide a qualitative description to anticipate the feasibility of future implementations.

3.3.1. Simulation

Although Shor’s QFT-based configuration still achieves lower absolute runtime, memory usage, gate count and circuit depth for the tested values, the relative growth rate of these indicators is consistently lower for the JVG algorithm. This means that, while both models experience exponential growth in resource requirements, the rate of increase for JVG’s QNTT is smaller, indicating that the additional computational cost rises more slowly than for QFT, providing strong evidence that the QNTT-based circuit manages resource growth more efficiently. To better visualize the scalability for the proposed JVG algorithm, we extrapolated the results for additional five points. In this extrapolation, we consider 100, 150, 200, 250 and 300 qubits using the trendline equations displayed in Figure 8 and Figure 9. The extrapolated results for run time and RAM usage are shown in Figure 12. The raw data is presented in Table 9.

The run time in Figure 12 (a) still shows the QFT model ahead of the QNTT-based one, considering the simulated results. However, the trendlines suggest that the performance gap between the two algorithms narrows as the number of qubits increases, even though the JVG methodology has not yet surpassed the QFT in this metric. Conversely, RAM usage becomes more discrepant with qubit number grow, as shown in Figure 12 (b). For the last point in the extrapolated plot, the projection indicates that the traditional Shor’s algorithm will require 38% more memory, representing a significant difference compared to the JVG methodology for the same configuration.

The same fashion is visualized considering the number of gates and circuit depth projections. Figure 13 compiles the extrapolated plots for each tracked metric.

Figure 13 reveals that considering the extrapolated data points, the JVG algorithm ultimately achieves superior results. This holds true for all the metrics. For the extreme case when 300 qubits are considered, the proposed algorithm can reduce the use of computational resources by 66%, 61%, 55% and 69% for CX, U, SWAP, and Circuit Depth, respectively. This is compelling evidence of the scalability achieved by JVG methodology over the traditional implementation of Shor’s algorithm.

3.3.2. Experimental

Similar approach was adopted for assessment of experimental results. Considering that the “ibm_torino” has a total amount of 133 qubits, we assumed 70, 85, 100, 115, and 130 qubits for the projections. The results for the projected outcomes for the QR are depicted in Figure 14, and the raw projected data from the trendline equations in Figure 10 and Figure 11 is given in Table 10.

From Figure 14, it is possible to observe that the processing time required to run both algorithms increases significantly, according to the projections. For an initial extrapolation of 70 qubits, it is still noticeable that the JVG approach already requires less time to compute the factors of a given composite number. This remains true for the following points in the projection, indicating that the proposed algorithm can already deliver tangible performance improvements in real-world scenarios for currently available quantum hardware.

Figure 15 presents the projections for the total amount of quantum gates and Circuit Depth considering the experimental results.

The projected values in Figure 15 confirm the superior scalability characteristic of the QNTT-based factorization. For all the metrics evaluated in the benchmark, the initial case considering a quantum circuit composed of 70 qubits is already sufficient to showcase the JVG’s superiority over the traditional Shor’s implementation. As previously mentioned, the growth in the number of qubits renders the difference between the two approaches, i.e. the gap between the plotted points, more compelling. These are strong findings, particularly considering that the projections are based on a real quantum computer. Finally, the sustained performance advantage observed at higher qubit counts indicates that the QNTT framework is well designed for future large-scale quantum architectures. It offers a realistic path toward efficient and hardware-compatible implementations of integer factorization on current NISQ devices.

3.3.3. RSA-Sized Circuits Projections for Experimental Results

Even though the scope of the present study does not include the factorization of large RSA encryption keys, it is essential to investigate the scalability trends implied by the proposed methodology. To this end, the results obtained from the experimental benchmarks were extrapolated to estimate the expected behavior for larger circuit sizes representing RSA-1024, RSA-2048 and RSA-4096. For such scenarios, the JVG quantum circuit would require approximately 4100, 8200, and 16400 qubits, respectively.

This approach is justified by the observed trend in the experimental data, which suggested that the implementation of the JVG algorithm on real quantum hardware would require approximately 70 qubits to outperform the QFT-based model, while the simulated configuration would demand around 100 qubits to achieve superiority.

The projections provide insight into how the JVG algorithm could scale under cryptographically relevant conditions, offering an evidence-based indication of its potential efficiency and resource advantage as quantum hardware continues to evolve. The focus is primarily on the gate count and circuit depth, as these are the most representative indicators of feasibility considering the present NISQ architectures. Figure 16 shows the projections, and Table 11 contains the raw data.

Figure 16 and Table 11 confirm the trend displayed for the previous projections. At RSA-1024, RSA-2048, and RSA-4096 configurations, the results reveal a significant difference in scaling behavior between the two approaches. For each gate type and circuit depth, the projected growth for the QFT-based circuit increases several orders of magnitude faster than for the QNTT-based JVG algorithm.

Considering the RSA-1024 projection (4100 qubits), the number of SX gates required by the QFT-based circuit requires approximately 13 orders of magnitude more resources than JVG. This pattern persists and even amplifies for larger configurations, being remarkably prominent for X gates, where for the extreme RSA-4096 configuration, the reduction on the resource even larger, representing a substantial reduction by the JVG methodology. Circuit depth is another metric significantly impacted, according to these projections. The expected results indicate a reduction of 15 orders of magnitude for RSA-1024 and larger orders of magnitude for RSA-2048 and RSA-4096.

These results demonstrate a consistent advantage for the JVG architecture. The slower growth observed for QNTT-based circuit indicates that the substitution of QFT with QNTT can effectively reduce circuit complexity and consequently reduce the cumulative error propagation. Although these values are not currently realizable on existing hardware, they provide a strong qualitative indication of the long-term scalability potential and hardware efficiency of the proposed algorithm in cryptographically relevant conditions.

4. Discussion

Before interpreting these findings, it is worth clarifying the conceptual boundary of our contribution. The JVG algorithm leverages the existing QNTT design of Lu et al. [58] but expands it through algorithm-level integration within number theory factorization framework and comprehensive empirical validation on simulated and real quantum backends. This places the JVG methodology as a validated architectural modification that improves the scaling behavior of the factoring algorithm, a must have characteristic in the current NISQ era.

The evidence supports a scalability advantage for JVG. Although QFT executes faster at the tested sizes, JVG’s rate of increase in runtime, gate counts, memory, and depth is lower, indicating asymptotic efficiency as the qubit number grows. This was observed to be true for both situations of simulated results and implementation on real quantum hardware.

4.1. Implications of Simulated Results for the QNTT-Based Algorithm

We can break down the analysis for Table 5 further and evaluate the increase in performance between the two methodologies under investigation. Table 12 summarizes the reduction in computational resource growth for the JVG methodology as the total amount of qubits increased from N=15 to N=67297 in the simulation backend, as presented in Table 5. Note that Table 12 does not consider the extrapolated values projected for the simulated results.

Table 12 showcases demonstrate that the proposed approach scales more efficiently, with a reduction of up to 33.5% in circuit depth relative to the initial configuration when compared to the QFT alternative. The second largest reduction was observed for CX gates, with 30.3%, followed by U gates, which reached a value of 26.2%. The SWAP gates also showed signs of reduction, reaching a value of 26.2%. Finally, run time and memory usage, which achieved 14.7% and 9.6% respectively, were also indicators of lower resource usage as the quantum circuit increased. Overall, the mean reduction in gate count was 22.%, confirming that the JVG methodology exhibits slower growth in computational requirements as circuit size increases.

Nevertheless, these values should be interpreted primarily as indicators of performance trends, since both the JVG and traditional Shor’s implementations would require more qubits than it is possible to currently test, as reflected in the projected outcomes shown in Figure 12 and Figure 13. Despite the experimental limitations previously stated, the conclusions derived from the simulated results and their extrapolated projections remain valid, reinforcing the reliability and significance of the proposed methodology.

Faster run time of quantum circuits is essential for the feasibility testing of the algorithm before moving to a real quantum device. Considering the RAM metric, it was observed that its improvement was enough for the QNTT circuit to reach better efficiency in terms of memory use, surpassing the QFT-based model. Again, this insight is of relevant interest given that currently, the simulation of quantum operations in classical devices is heavily constrained in memory usage [66,67]. Thus, more efficient algorithms could offer a superior option to model and simulate more complex circuits.

Considering number factorization using Shor’s algorithm, the high amount of gates and the circuit depth make it hard to implement on the current noisy machines [65]. The proposed JVG methodology was shown to have improved scaling for both the gate used and the quantum circuit depth metrics. The implementation of QNTT-based factorization opens the way for a more NISQ-friendly alternative, in which scalability is essential [70]. This was observed by assessing the CX, U, SWAP gates and Circuit Depth reductions, as described in Table 12. Additionally, it offers more efficient simulations on classical backends, which remain an essential step for validating quantum algorithms before moving to a real quantum machine [71,72]. Therefore, the improvements achieved with QNTT provide more tractable simulations of larger problem instances and a more realistic foundation for implementing integer factorization.

4.2. Implications of Experimental Quantum Results for the QNTT-Based Algorithm

From the data in Table 8, Table 13 summarizes the reduction in computational resource growth for the experimental quantum setup as the number of qubits increased from N = 15 to N = 1363. Again, we state that Table 13 does not incorporate the extrapolated values.

From Table 13, the QR showed a relevant reduction of 26%, indicating that for larger circuits, the proposed methodology requires less processing time and executes more efficiently, being more efficient and faster than its alternative as the number of qubits grows, demonstrating that the JVG algorithm can better manage resource growth when implemented on real quantum devices. This is important for current NISQ machines, since they still lack a larger coherence time, thus preventing long computations [65,70]. In this context, it would be possible to implement factorization algorithms more efficiently for more complex circuits [25,73].

A substantial reduction was also observed considering SX, RZ and X gates. This was especially true for X gates, which were reduced by 44.4%, followed by RZ gates with 29.7% and SX gates, achieving 23.5%. The overall reduction in the number of quantum gates was 30.50%, indicating a positive difference of 8.5% when compared to the simulated outcome. The Circuit Depth also presented reduction by over 31%, being slightly inferior to the one achieved by the simulations. Nevertheless, this outcome remains relevant, since reducing the total of gates in the circuit, consequently resulting in shallower depths, it is possible to reduce circuit depth and ultimately reduce cumulative error propagation [34,74,75].

A reduction of 24.21% over CZ gate count is also of relevance, as controlled gates are also a source of errors related to entanglement fidelity on quantum hardware when compared with single-qubit units [76,77]. By achieving this, it is possible to provide more reliable circuits in terms of both stability and noise resistance, which are desired properties. Combining X gates and CZ gates improvements, it will be possible to reach shallower and error resistant implementations for number factorization algorithms.

The values presented in Table 13, like the ones in Table 12, should be regarded as indicative of performance trends rather than absolute benchmarks, as the experimental setup remains constrained by the limited current NISQ hardware. Likewise, percentage-based improvements on small baselines may exaggerate significance. Thus, this discussion focuses on comparative growth rates and the consistency of CV values to assess true scalability and robustness.

Nevertheless, despite these hardware constraints, the experimental findings reinforce the robustness of the JVG methodology when implemented on real quantum devices, validating its projected trends observed in the experimental setup, further supporting the reliability and practical significance of the proposed approach for in NISQ computing applications.

4.3. Implications of the Projected Values for Simulated and Experimental Configurations

Despite the positive indicators in previous Table 12 and Table 13, the outcomes achieved by the proposed algorithm remained slightly below those yielded by the QFT-based methodology. Projections were developed to visualize this fashion considering both simulation and experimental setups. These plots represent model-based predictions from the exponential fits to the observed data.

For the simulation backend, the extrapolations revealed that the JVG algorithm was able to maintain consistent growth for memory usage, gate counts, and circuit depth when compared to the QFT approach. These metrics highlight the ability of the proposed methodology to manage computational resources more efficiently as the circuit size increases. In particular, the slower gate count and circuit depth growth rate indicates that the QNTT-based algorithm can scale to larger problem instances without a proportional rise in complexity. Among the assessed metrics, only the simulation run time presented negative results for the JVG methodology.

Considering the experimental setup, the projected results indicated the remarkable improved scalability of QNTT-based factorization. The proposed model was superior for all the metrics, including run time, unlike the behavior observed in the simulated results. The ability of the QNTT circuit to maintain exceptional performance when implemented on real hardware conditions, where noise, limited connectivity, and decoherence typically degrade results, indicates that the proposed approach is inherently more resilient than its counterpart. In this sense, the experimental results validate the robustness and adaptability of the methodology, demonstrating that it can leverage the available hardware resources more efficiently.

A similar conclusion is achieved considering the gate count and circuit depth metrics. They revealed substantial reductions in the QNTT implementation compared to the QFT one. The reduced number of two-qubit operations, such as CZ and CX gates, present in the JVG algorithm further minimizes entanglement-related errors. Additionally, the decrease in circuit depth highlights a more compact and optimized structure. These results reinforce that the QNTT-based approach is theoretically more efficient and more suitable for the current hardware. This behavior is crucial for NISQ-era quantum devices, where limited coherence time and gate fidelity impose strict constraints on circuit depth and the number of operations.

These empirical outcomes align with the theoretical projection values (Figure 12, Figure 13, Figure 14, Figure 15 and Figure 16) These projections are entirely data-oriented and derived from the experimentally observed relationships between gate count, circuit depth, and qubit number. They provide an evidence-based estimation of how both methodologies might behave under more complex circuit configurations, and for relevant scales considering the experimental setup. The projected results indicate that the JVG algorithm sustains a markedly slower resource-growth rate across all gate types and circuit-depth metrics when compared to Shor’s QFT-based framework. Specifically, they suggest that the JVG architecture preserves its scalability advantage even for RSA-size problems, reinforcing its potential as a more hardware-efficient and noise-resilient solution for future quantum cryptographic implementations.

Altogether, the results revealed that JVG is more hardware-compatible and scales better than Shor’s QFT variant. On the sizes we could run QFT is still faster, but trendlines and projections indicate JVG will overtake at larger qubit counts. JVG also appears less prone to error propagation inherent to the current NISQ devices, being of more practical implementation in these machines. In this context, JVG offers both a more efficient framework for validating algorithms on classical backends and a more suitable alternative for implementing integer factorization on current devices, where reducing computational cost is paramount [28,73].

4.4. Statistical Consistency and Implication on NISQ Devices

The statistical analysis for both simulated and experimental benchmarks provides essential insight into the stability and reliability of the obtained results. The consistently low coefficients of variation observed in both simulated and experimental environments reinforce the claim that the JVG architecture exhibits improved robustness to error and predictability. The smaller variability observed for QNTT circuits suggests that their gate structure interacts more favorably with NISQ noise characteristics.

It has been demonstrated empirically that the JVG circuit directly supports the scalability projections reported in Figure 12, Figure 13, Figure 14, Figure 15 and Figure 16, which estimates slower resource growth and enhanced performance for cryptographically relevant problem sizes. In this sense, the statistical analysis not only validates the repeatability of the experiments but also provides strong evidence that the JVG framework constitutes a more noise-resilient and hardware-efficient approach to quantum integer factorization.

4.5. Impact of QNTT Structure in Shor’s Algorithm Pipeline

The use of QNTT proved feasible inside Shor’s pipeline. It offered a novel methodology for number factorization by expanding QFT period finding from $\mathbb{C}$ to a finite ${\mathbb{Z}}_p$ ring. Thus, rather than sample phase estimations with complex roots of unit as in QFT (Figure 6), QNTT retrieves the period for number factorization by using $\omega$ mod $p$. This ring-based alternative expands number theory for factorization by implementing modular arithmetic. Empirically, this resulted to the JVG circuit’s slower growth in depth and gates and its lower variability on hardware, indicating that periodicity of ring structures can be directly leveraged to improve quantum integer factorization on NISQ devices.

While QFT relies on rotational gates (Figure 2 and Figure 3), the JVG is less dependent on these matrices. These gates require long qubit interactions, which could amplify not only errors in NISQ machines, but also offer worse scalability, as reported. Contrarywise, the inclusion of the QNTT structure, as described by Lu and colleagues [58], are NISQ friendly. The QNTT block relies on simpler operations dependent on sequences CX gates (Figure 4 and Figure 5) [60,62]. This architecture allows for a more regular and localized gate topology, reducing errors due to entanglement and other qubit interactions, as revealed by the reported benchmark results and projected values.

Overall, these characteristics make JVG more hardware-efficient and error-resistant under current device limitations. Therefore, the findings validate JVG as a promising and scalable alternative for quantum integer factorization, including RSA-scale security in the NISQ era, as projected.

5. Conclusions

This study leveraged the properties of the number theoretic transform into a quantum framework, combining the QNTT circuit into the number Shor’s pipeline to achieve a more efficient alternative for number factorization, while also expanding the number theory for number factorization. To verify the feasibility and performance of the proposed methodology, we investigated several composite numbers across quantum circuits of varying qubit sizes.

In the simulation results, JVG’s QNTT-based approach was consistently more scalable regarding run time, memory and gate count. Furthermore, performance gains became more relevant with growth of qubit number, potentially leading improved handling of larger problem sizes. This was observed by improvements of 30.2% for the number of CX gates, 14.7% for the run time, and 9.6% for memory usage, compared with the Shor’s algorithm. Experimental validation on a quantum device confirmed these trends. In this phase, the QNTT algorithm also provided superior resource growth in real quantum devices, surpassing the results observed during the simulations. A remarkable improvement of 44.46% on the number of X gates and 26% for the run time was observed by comparing QNTT and QFT models. While Shor’s algorithm remains faster for small circuits, JVG’s slower resource growth indicates potential superiority at larger circuits, as illustrated by the prediction graphs, showing to be a viable tool for cryptographically relevant applications.

These results are relevant because they provide evidence of a better alternative to QFT-based algorithms, being able to reduce resource overhead and mitigate noise-prone operations by quantum gates, including RSA-scale scenarios. These characteristics are desired in circuits to be implemented in near-term quantum machines.

Future research should investigate improvements in the proposed methodology. For example, the quantum modular exponentiation part could be further improved to remove the dependency of QFT presented here even further. Another possibility is to change the post-processing strategy, which could benefit from the proposed methodology.

Overall, this study establishes JVG’s QNTT-based circuit as a promising alternative toward implementing practical quantum integer factorization. The demonstrations of consistent improvements on run time, memory usage and gate counts during both simulated and experimental phases make the proposed methodology a more efficient and error-resilient approach for NISQ devices. These gains were achieved by replacing computationally heavy QFT with a more NISQ-friendly QNTT circuit, making quantum algorithms more tractable in the near-term hardware. Given the importance of number factorization with reduced quantum resources, it directly impacts fields like cryptography. Note that the results from the JVG algorithm is even more capable in the real quantum computer than in the simulated version, when compared against Shor’s algorithm. This indicated that JVG is more resilient to noise than Shor. The results presented here demonstrate a more efficient alternative for integer factorization and advance the practical utilization of current quantum computers.

The Jesse–Victor–Gharabaghi (JVG) algorithm presented in this study serves as a proof of concept to validate the proposed hypothesis. With the future advances on quantum hardware, the JVG framework is expected to undergo similar refinements and adaptations to those experienced by Shor’s algorithm. Such developments could ultimately lead to more practical and resource-efficient quantum factoring methods, leading to efficient cryptographic applications on quantum devices within the NISQ era.