Factoring using 2n+2 qubits with Toffoli based modular multiplication (1611.07995v2)

Abstract: We describe an implementation of Shor's quantum algorithm to factor n-bit integers using only 2n+2 qubits. In contrast to previous space-optimized implementations, ours features a purely Toffoli based modular multiplication circuit. The circuit depth and the overall gate count are in O(n^3) and O(n^3 log(n)), respectively. We thus achieve the same space and time costs as Takahashi et al., while using a purely classical modular multiplication circuit. As a consequence, our approach evades most of the cost overheads originating from rotation synthesis and enables testing and localization of faults in both, the logical level circuit and an actual quantum hardware implementation. Our new (in-place) constant-adder, which is used to construct the modular multiplication circuit, uses only dirty ancilla qubits and features a circuit size and depth in O(n log(n)) and O(n), respectively.

• The paper presents a Toffoli-based modular multiplication scheme that reduces the qubit requirement in Shor’s algorithm.
• It introduces a novel constant-adder using borrowed dirty ancillas to optimize circuit depth without the overhead of rotation synthesis.
• Numerical analyses confirm space efficiency with a Toffoli count scaling as 32n²log₂n for controlled multiplications and 64n³log₂n overall.

Factoring Using $2n+2$ Qubits with Toffoli-Based Modular Multiplication: Insights and Implications

The paper "Factoring Using $2n+2$ Qubits with Toffoli-Based Modular Multiplication" by H\"aner, Roetteler, and Svore presents an advanced implementation of Shor's quantum algorithm for integer factorization. The proposed method reduces the qubit requirement while maintaining computational efficiency. Unlike other implementations, this approach leverages a purely Toffoli-based modular multiplication circuit that circumvents the overheads associated with rotation synthesis.

Shor's algorithm is renowned for its capability to factor large integers in polynomial time, fundamentally challenging classical cryptographic protocols like RSA. The efficient realization of Shor's algorithm on quantum devices, however, poses significant resource optimization challenges, particularly concerning the number of qubits and gate operations.

Technical Contributions

This paper introduces a modular multiplier that utilizes Toffoli gates, which are purely classical, thereby avoiding complexity introduced by quantum-specific operations such as quantum Fourier transforms (QFT). The authors achieve a gate count and circuit depth of $\mathcal O(n^3\log n)$ and $\mathcal O(n^3)$, respectively, aligning with existing space-optimized methods but without requiring rotation synthesis.

Their approach uses a novel constant-adder that operates with dirty ancillas, allowing for resource sharing by leveraging qubits in arbitrary states. This use of borrowed dirty ancillas offers substantial space savings and optimization of circuit depth.

Numerical Results and Bold Claims

Through rigorous simulation, the paper dissects the scaling behavior of the Toffoli count in their modular multiplier circuit, confirming its expected growth of $32n^2\log_2 n$ for controlled modular multiplications. Such detailed numerical analyses support the claim that their implementation is space-efficient, with an overall Toffoli count for Shor's algorithm at $64n^3\log_2 n$.

The absence of overhead from rotation synthesis implies that practical quantum error correction (QEC) can be more straightforwardly implemented. This reduction can significantly enhance the viability and accessibility of quantum computations designed for factorization tasks.

Implications and Future Work

The implications of employing Toffoli-based designs lie in not only the quantum computing field's practical aspects but also in enhancing theoretical understanding of quantum efficiency. This implementation facilitates debugging and testability, allowing classical reversible simulators to efficiently check Toffoli network-based circuits. Given that fault localization can be efficiently executed, it enhances the prospects of scalable quantum computing.

While this work presents meaningful advancements, it also opens pathways for further research. Investigating whether a linear-time constant-adder without the current ancilla requirements is possible, or exploring the effects of geometrical constraints alongside dirty ancillas, could yield even more resource-preserving techniques.

Conclusion

The paper illustrates a significant advancement in the field of quantum computational algorithm implementation. By optimizing classical gate approaches within quantum algorithms, it serves as a blueprint for future endeavors that aim to construct efficient quantum circuits with a delicate balance between qubit count and computational depth. This paper contributes meaningfully to a deeper understanding of how classical and quantum elements can be synergized to push the boundaries of computational capabilities.