Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Scientific Reports

Reducing T-count and T-depth in approximate quantum Fourier transform circuits

Byeongyong Park, Doyeol Ahn

Published Oct 24, 2025• 1 citation
Publisher

Abstract

The quantum Fourier transform (QFT) is a fundamental component in various quantum algorithms, including Shor's factoring algorithm and the Harrow-Hassidim-Lloyd (HHL) algorithm for solving systems of linear equations. Efficient implementation of the QFT is essential for the practical realization of large-scale quantum algorithms, especially in fault-tolerant quantum computing. In fault-tolerant implementations, the Clifford + T gate library is the standard choice for building quantum circuits. As the most resource-intensive component within this framework, the T gate's associated cost poses a significant challenge to the efficient implementation of the QFT and its dependent algorithms. While approximate QFT (AQFT) circuits reduce this cost, state-of-the-art implementations still require a T-count of [Formula: see text] and a T-depth of [Formula: see text]. Although these results represent a notable achievement, the associated resource cost remains a primary bottleneck for practical, large-scale quantum algorithms, motivating further optimization. To address this bottleneck, this paper introduces two novel [Formula: see text]-qubit AQFT circuits with an approximation error of [Formula: see text]. Our first design, AQFT Circuit 1, halves the T-count to [Formula: see text] by constructing inverse phase gradient transformation (PGT) circuits without using additional non-Clifford gates and by implementing the inverse PGTs using quantum adders. Our second design, AQFT Circuit 2, reduces the T-depth to [Formula: see text] through parallelization of the inverse PGTs that add only [Formula: see text] additional T gates. For both AQFT circuits, the state-of-the-art linear-depth quantum adder is employed. We demonstrate that employing the linear-depth quantum adder provides advantages over the currently known logarithmic-depth quantum adder, not only in terms of T-count but also in T-depth optimization for the AQFT, particularly within the range [Formula: see text], which encompasses practical system sizes.

DOI
10.1038/s41598-025-21087-2

Related papers

T-count optimization of approximate quantum Fourier transform

Byeongyong Park, Doyeol Ahn

The quantum Fourier transform (QFT) is a ubiquitous quantum operation that is used in numerous quantum computing applications. The major obstacle to constructing a QFT circuit is that numerous elementary gates are required. Among the elementary gates, T gates dominate the cost of fault-tolerant implementation. Currently, the smallest-known T-count required to construct an n-qubit QFT circuit approximated to error O(\varepsilon) is ~8nlog_2(n/\varepsilon). Moreover, the depth of T gates (T-depth) in the approximate QFT circuit is ~2nlog_2(n/\varepsilon). This approximate QFT circuit was constructed using Toffoli gates and quantum adders. In this study, we present a new n-qubit QFT circuit approximated to error O(\varepsilon). Our approximate QFT circuit shows a T-count of ~4nlog_2(n/\varepsilon) and a T-depth of ~nlog_2(n/\varepsilon). Toffoli gates, which account for half of the T-count in the approximate QFT circuit reported in the previous study, are unnecessary in our construction. Quantum adders, which dominate the leading order term of T-depth in our approximate QFT circuit, are arranged in parallel to reduce T-depth.

arXiv:2203.07739•Mar 15, 2022•11 citations

Linear depth approximate QFT with zero ancilla

Laxmidhar Biswal, Anirban Bhattacharjee, Hafizur Rahaman

The inseparable coupling of a quantum system with its environment adds noise at resonant frequencies, causing energy fluctuations and losses entanglement of the fragile quantum state, informally known as decoherence. By truncating Fourier wiggles with the fault-tolerant features, a robust quantum Fourier transform (QFT) scheme can mitigate the decoherence effect. However, a low qubit-count and circuit-depth-based quantum circuit is desirable because of decoherence rate scale up linearly with qubit-count, shortening the coherence time of a fragile quantum state. Indeed, due to the high latency of 1-qubit phase-gates, phase-depth becomes a more dominant factor in circuit-depth and pays a high price for scalability. The above issues are addressed in this manuscript by implementing a fault-tolerant approximate quantum Fourier-transform (AQFT) in linear phase-depth with zero ancillary cost and \(\mathcal {O}(n\log n)\) phase-count using the Clifford+ \(Z_N\) -group. By truncating lower rotated phase operators, a robust fault-tolerant AQFT is achieved with linear phase-depth and zero ancillary cost, as well as 75%, 87.6%, 94.22%, and 26.99% average improvements in phase-depth, phase-count, CNOT-count, and ancillary cost respectively over the present-state-of-the-arts 1 . The proposed AQFT maintains polynomially small approximation error, achieving a strong balance between accuracy and efficiency that makes it practical for most algorithms and well suited for NISQ hardware.

Scientific Reports•Aug 15, 2026•0 citations

Approximate quantum Fourier transform with O(n log(n)) T gates

Yunseong Nam, Yuan Su, Dmitri A Maslov

Abstract The ability to implement the Quantum Fourier Transform (QFT) efficiently on a quantum computer facilitates the advantages offered by a variety of fundamental quantum algorithms, such as those for integer factoring, computing discrete logarithm over Abelian groups, solving systems of linear equations, and phase estimation, to name a few. The standard fault-tolerant implementation of an n-qubit unitary QFT approximates the desired transformation by removing small-angle controlled rotations and synthesizing the remaining ones into Clifford+T gates, incurring the T-count complexity of $$O(n\,{\mathrm{log}}^{2}\,(n))$$ O ( n log 2 ( n ) ) . In this paper, we show how to obtain approximate QFT with the T-count of $$O(n\,{\mathrm{log}}\,(n))$$ O ( n log ( n ) ) . For brevity, the above figures omit the dependence on the approximation error ε, assuming the error is fixed. Our approach relies on quantum circuits with measurements and feedforward, and on reusing a special quantum state that induces the phase gradient transformation. We report asymptotic analysis as well as concrete circuits, demonstrating significant advantages in both theory and practice.

arXiv:1803.04933•npj Quantum Information•Mar 13, 2020•122 citations

Truncated phase-based quantum arithmetic: Error propagation and resource reduction

Gregory A. L. White, Charles D. Hill, Lloyd C. L. Hollenberg

There are two important, and potentially interconnecting, avenues to the realization of large-scale quantum algorithms: improvement of the hardware, and reduction of resource requirements demanded by algorithm components. In focusing on the latter, one crucial subroutine to many sought-after applications is the quantum adder. A variety of different implementations exist with idiosyncratic pros and cons. One of these, the Draper quantum Fourier adder, offers the lowest qubit count of any adder, but requires a substantial number of gates as well as extremely fine rotations. In this work we present a modification of the Draper adder which eliminates small-angle rotations to highly coarse levels, matched with some strategic corrections. This reduces hardware requirements without sacrificing the qubit saving. We show that the inherited loss of fidelity is directly given by the rate of carry and borrow bits in the computation. We derive formulas to predict this, complemented by complete gate-level matrix product state simulations of the circuit. Moreover, we analytically describe the effects of possible stochastic control error. We present an in-depth analysis of this approach in the context of Shor's algorithm, focusing on the factoring of RSA-2048. Surprisingly, we find that each of the $7\ifmmode\times\else\texttimes\fi{}{10}^{7}$ quantum Fourier transforms may be truncated down to $\ensuremath{\pi}/64$, with additive rotations left only slightly finer. This result is much more efficient than previously realized. We quantify savings in terms of both logical resources and raw magic states, demonstrating that phase adders can be competitive with Toffoli-based constructions.

arXiv:2110.00217•Physical Review A•Nov 16, 2023•0 citations

The Art of Optimizing T-Depth for Quantum Error Correction in Large-Scale Quantum Computing

Avimita Chatterjee, Archisman Ghosh, Swaroop Ghosh

Quantum Error Correction (QEC), combined with magic state distillation, ensures fault tolerance in large-scale quantum computation. To apply QEC, a circuit must first be transformed into a non-Clifford (or T) gate set. T-depth, the number of sequential T-gate layers, determines the magic state cost, impacting both spatial and temporal overhead. Minimizing T-depth is crucial for optimizing resource efficiency in fault-tolerant quantum computing. While QEC scalability has been widely studied, T-depth reduction remains an overlooked challenge. It is established that T-depth reduction is an NP-hard problem and we systematically evaluate multiple approximation techniques: greedy, divide-and-conquer, Lookahead-based brute force, and graph-based. The Lookahead-based brute-force algorithm (partition size 4) performs best, optimizing $90 \%$ of reducible cases (i.e., circuits where at least one algorithm achieved optimization) with an average T-depth reduction of around $51 \%$. Additionally, we introduce an expansion factor-based identity gate insertion strategy, leveraging controlled redundancy to achieve deeper reductions in circuits initially classified as non-reducible. With this approach, we successfully convert up to ${2 5 \%}$ of non-reducible circuits into reducible ones, while achieving an additional average reduction of up to $11.8 \%$. Furthermore, we analyze the impact of different expansion factor values and explore how varying the partition size in the Lookahead-based brute-force algorithm influences the quality of T-depth reduction.

arXiv:2503.06045•International Symposium on Quality Electronic Design (ISQED)•Apr 8, 2026•1 citation

Efficient T-Count Fault-tolerant Quantum Clifford+T Multiplexer

Negin Mashayekhi, Shekoofeh Moghimi, Mohammad Reza Reshadinezhad

Reversible logic is essential in quantum computing due to its ability to preserve information and establish a one-to-one mapping between inputs and outputs. The Clifford+T gate set, known for supporting fault-tolerant quantum circuits, offers resilience against decoherence but introduces high implementation costs, particularly due to the T gate's resource intensity. In this work, we propose a new and efficient quantum multiplexer design, the Quantum Clifford T-MUX, designed entirely within the Clifford+T framework. This multiplexer minimizes T-count and avoids the use of ancillary qubits, both critical factors for practical, fault-tolerant quantum computing. As part of this architecture, we present a newly designed fault-tolerant Peres gate using only Clifford+T gates, which serves as a fundamental building block in the T-MUX construction. The proposed T-MUX achieves reduced T-count, no garbage output, and improved efficiency compared to traditional designs. These improvements position it as a valuable component for building scalable quantum Arithmetic Logic Units (ALUs), data buses, and memory systems. Overall, this work contributes toward the development of low-overhead, modular quantum control structures suited for near-term and long-term quantum computing architectures. The proposed circuit is simulated using the Quirk online tool, and the result confirms the accuracy of the design. This design achieves an average 35% improvement in T-Count without any constant input, compared to its counterpart, respectively.

International Conference on Computer and Knowledge Engineering•Oct 28, 2025•0 citations
The quantum Fourier transform (QFT) is a fundamental component in various quantum algorithms, including Shor's factoring algorithm and the Harrow-Hassidim-Lloyd (HHL) algorithm for solving systems of linear equations. Efficient implementation of the QFT is essential for the practical realization of large-scale quantum algorithms, especially in fault-tolerant quantum computing. In fault-tolerant implementations, the Clifford + T gate library is the standard choice for building quantum circuits. As the most resource-intensive component within this framework, the T gate's associated cost poses a significant challenge to the efficient implementation of the QFT and its dependent algorithms. While approximate QFT (AQFT) circuits reduce this cost, state-of-the-art implementations still require a T-count of [Formula: see text] and a T-depth of [Formula: see text]. Although these results represent a notable achievement, the associated resource cost remains a primary bottleneck for practical, large-scale quantum algorithms, motivating further optimization. To address this bottleneck, this paper introduces two novel [Formula: see text]-qubit AQFT circuits with an approximation error of [Formula: see text]. Our first design, AQFT Circuit 1, halves the T-count to [Formula: see text] by constructing inverse phase gradient transformation (PGT) circuits without using additional non-Clifford gates and by implementing the inverse PGTs using quantum adders. Our second design, AQFT Circuit 2, reduces the T-depth to [Formula: see text] through parallelization of the inverse PGTs that add only [Formula: see text] additional T gates. For both AQFT circuits, the state-of-the-art linear-depth quantum adder is employed. We demonstrate that employing the linear-depth quantum adder provides advantages over the currently known logarithmic-depth quantum adder, not only in terms of T-count but also in T-depth optimization for the AQFT, particularly within the range [Formula: see text], which encompasses practical system sizes.
The quantum Fourier transform (QFT) is a ubiquitous quantum operation that is used in numerous quantum computing applications. The major obstacle to constructing a QFT circuit is that numerous elementary gates are required. Among the elementary gates, T gates dominate the cost of fault-tolerant implementation. Currently, the smallest-known T-count required to construct an n-qubit QFT circuit approximated to error O(\varepsilon) is ~8nlog_2(n/\varepsilon). Moreover, the depth of T gates (T-depth) in the approximate QFT circuit is ~2nlog_2(n/\varepsilon). This approximate QFT circuit was constructed using Toffoli gates and quantum adders. In this study, we present a new n-qubit QFT circuit approximated to error O(\varepsilon). Our approximate QFT circuit shows a T-count of ~4nlog_2(n/\varepsilon) and a T-depth of ~nlog_2(n/\varepsilon). Toffoli gates, which account for half of the T-count in the approximate QFT circuit reported in the previous study, are unnecessary in our construction. Quantum adders, which dominate the leading order term of T-depth in our approximate QFT circuit, are arranged in parallel to reduce T-depth.
The inseparable coupling of a quantum system with its environment adds noise at resonant frequencies, causing energy fluctuations and losses entanglement of the fragile quantum state, informally known as decoherence. By truncating Fourier wiggles with the fault-tolerant features, a robust quantum Fourier transform (QFT) scheme can mitigate the decoherence effect. However, a low qubit-count and circuit-depth-based quantum circuit is desirable because of decoherence rate scale up linearly with qubit-count, shortening the coherence time of a fragile quantum state. Indeed, due to the high latency of 1-qubit phase-gates, phase-depth becomes a more dominant factor in circuit-depth and pays a high price for scalability. The above issues are addressed in this manuscript by implementing a fault-tolerant approximate quantum Fourier-transform (AQFT) in linear phase-depth with zero ancillary cost and O(nlog⁡n)\mathcal {O}(n\log n)O(nlogn) phase-count using the Clifford+ ZNZ_NZN​ -group. By truncating lower rotated phase operators, a robust fault-tolerant AQFT is achieved with linear phase-depth and zero ancillary cost, as well as 75%, 87.6%, 94.22%, and 26.99% average improvements in phase-depth, phase-count, CNOT-count, and ancillary cost respectively over the present-state-of-the-arts 1 . The proposed AQFT maintains polynomially small approximation error, achieving a strong balance between accuracy and efficiency that makes it practical for most algorithms and well suited for NISQ hardware.
Abstract The ability to implement the Quantum Fourier Transform (QFT) efficiently on a quantum computer facilitates the advantages offered by a variety of fundamental quantum algorithms, such as those for integer factoring, computing discrete logarithm over Abelian groups, solving systems of linear equations, and phase estimation, to name a few. The standard fault-tolerant implementation of an n-qubit unitary QFT approximates the desired transformation by removing small-angle controlled rotations and synthesizing the remaining ones into Clifford+T gates, incurring the T-count complexity of O(n log2 (n))O(n\,{\mathrm{log}}^{2}\,(n))O(nlog2(n)) O ( n log 2 ( n ) ) . In this paper, we show how to obtain approximate QFT with the T-count of O(n log (n))O(n\,{\mathrm{log}}\,(n))O(nlog(n)) O ( n log ( n ) ) . For brevity, the above figures omit the dependence on the approximation error ε, assuming the error is fixed. Our approach relies on quantum circuits with measurements and feedforward, and on reusing a special quantum state that induces the phase gradient transformation. We report asymptotic analysis as well as concrete circuits, demonstrating significant advantages in both theory and practice.
There are two important, and potentially interconnecting, avenues to the realization of large-scale quantum algorithms: improvement of the hardware, and reduction of resource requirements demanded by algorithm components. In focusing on the latter, one crucial subroutine to many sought-after applications is the quantum adder. A variety of different implementations exist with idiosyncratic pros and cons. One of these, the Draper quantum Fourier adder, offers the lowest qubit count of any adder, but requires a substantial number of gates as well as extremely fine rotations. In this work we present a modification of the Draper adder which eliminates small-angle rotations to highly coarse levels, matched with some strategic corrections. This reduces hardware requirements without sacrificing the qubit saving. We show that the inherited loss of fidelity is directly given by the rate of carry and borrow bits in the computation. We derive formulas to predict this, complemented by complete gate-level matrix product state simulations of the circuit. Moreover, we analytically describe the effects of possible stochastic control error. We present an in-depth analysis of this approach in the context of Shor's algorithm, focusing on the factoring of RSA-2048. Surprisingly, we find that each of the $7\ifmmode\times\else\texttimes\fi{}{10}^{7}$ quantum Fourier transforms may be truncated down to $\ensuremath{\pi}/64$, with additive rotations left only slightly finer. This result is much more efficient than previously realized. We quantify savings in terms of both logical resources and raw magic states, demonstrating that phase adders can be competitive with Toffoli-based constructions.
Quantum Error Correction (QEC), combined with magic state distillation, ensures fault tolerance in large-scale quantum computation. To apply QEC, a circuit must first be transformed into a non-Clifford (or T) gate set. T-depth, the number of sequential T-gate layers, determines the magic state cost, impacting both spatial and temporal overhead. Minimizing T-depth is crucial for optimizing resource efficiency in fault-tolerant quantum computing. While QEC scalability has been widely studied, T-depth reduction remains an overlooked challenge. It is established that T-depth reduction is an NP-hard problem and we systematically evaluate multiple approximation techniques: greedy, divide-and-conquer, Lookahead-based brute force, and graph-based. The Lookahead-based brute-force algorithm (partition size 4) performs best, optimizing 90%90 \%90% of reducible cases (i.e., circuits where at least one algorithm achieved optimization) with an average T-depth reduction of around 51%51 \%51%. Additionally, we introduce an expansion factor-based identity gate insertion strategy, leveraging controlled redundancy to achieve deeper reductions in circuits initially classified as non-reducible. With this approach, we successfully convert up to 25%{2 5 \%}25% of non-reducible circuits into reducible ones, while achieving an additional average reduction of up to 11.8%11.8 \%11.8%. Furthermore, we analyze the impact of different expansion factor values and explore how varying the partition size in the Lookahead-based brute-force algorithm influences the quality of T-depth reduction.
Reversible logic is essential in quantum computing due to its ability to preserve information and establish a one-to-one mapping between inputs and outputs. The Clifford+T gate set, known for supporting fault-tolerant quantum circuits, offers resilience against decoherence but introduces high implementation costs, particularly due to the T gate's resource intensity. In this work, we propose a new and efficient quantum multiplexer design, the Quantum Clifford T-MUX, designed entirely within the Clifford+T framework. This multiplexer minimizes T-count and avoids the use of ancillary qubits, both critical factors for practical, fault-tolerant quantum computing. As part of this architecture, we present a newly designed fault-tolerant Peres gate using only Clifford+T gates, which serves as a fundamental building block in the T-MUX construction. The proposed T-MUX achieves reduced T-count, no garbage output, and improved efficiency compared to traditional designs. These improvements position it as a valuable component for building scalable quantum Arithmetic Logic Units (ALUs), data buses, and memory systems. Overall, this work contributes toward the development of low-overhead, modular quantum control structures suited for near-term and long-term quantum computing architectures. The proposed circuit is simulated using the Quirk online tool, and the result confirms the accuracy of the design. This design achieves an average 35% improvement in T-Count without any constant input, compared to its counterpart, respectively.