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

Performing the Quantum Fourier Transform in Linear Parallel Time

Cristopher Moore

Published Jan 1, 1998• 0 citations
OpenAlex

Abstract

We exhibit a quantum circuit that performs the Quantum Fourier Transform on $n$ qubits in $ (n)$ depth. Thus, a parallel quantum computer can carry out the QFT in linear time. We conjecture that this can, in fact, be reduced to $ ({\rm log} n)$ depth, which would place the QFT in the class {\bf QNC} of problems solvable in logarithmic parallel time.

Related papers

Another Way to Perform the Quantum Fourier Transform in Linear Parallel Time

Cristopher Moore

. We exhibit a quantum circuit that performs the Quantum Fourier Transform on n qubits in O(n) depth. Thus, a parallel quantum computer can carry out the QFT in linear time. Griffiths and Niu have already shown this, so this paper is little more than an exercise in quantum circuit design; but perhaps it illustrates a worthwhile idea. We also speculate as to whether the QFT might be in the class QNC 1 of problems solvable in logarithmic parallel time. Shor's factoring algorithm [6] suggests that quantum computers can do things in polynomial time that classical computers cannot. However, since decoherence due to storage errors is a function of time, we should also ask to what extent we can parallelize quantum algorithms; if we can do many quantum operations at once, rather than serially, we can solve larger problems before our computer decoheres. Consider a quantum circuit operating on a set of qubits, containing onequbit gates (2 \\Theta 2 unitary matrices) and the two-qubit controlled...

arXiv:quant-ph/9801038•Jan 19, 1998•1 citation

Some Notes on Parallel Quantum Computation

Cristopher Moore, Martin Nilsson

We exhibit some simple gadgets useful in designing shallow parallel circuits for quantum algorithms. We prove that any quantum circuit composed entirely of controlled-not gates or of diagonal gates can be parallelized to logarithmic depth, while circuits composed of both cannot. Finally, while we note the Quantum Fourier Transform can be parallelized to linear depth, we exhibit a simple quantum circuit related to it that we believe cannot be parallelized to less than linear depth, and therefore might be used to prove that QNC < QP.

arXiv:quant-ph/9804034•Apr 14, 1998•14 citations

Parallel Quantum Computation and Quantum Codes

Cristopher Moore, Martin Nilsson

We study the class QNC of efficient parallel quantum circuits, the quantum analog of NC. We exhibit several useful gadgets and prove that various classes of circuits can be parallelized to logarithmic depth, including circuits for encoding and decoding standard quantum error-correcting codes, or, more generally, any circuit consisting of controlled-not gates, controlled $\pi$-shifts, and Hadamard gates. Finally, while we note the exact quantum Fourier transform can be parallelized to linear depth, we conjecture that neither itnor a simpler "staircase" circuit can be parallelized to less than this.

arXiv:quant-ph/9808027•SIAM Journal on Computing•Jan 1, 2001•219 citations

Fast parallel circuits for the quantum Fourier transform

Richard Cleve, John Watrous

We give new bounds on the circuit complexity of the quantum Fourier transform (QFT). We give an upper bound of O(log n+log log(1//spl epsiv/)) on the circuit depth for computing an approximation of the QFT with respect to the modulus 2/sup n/ with error bounded by /spl epsiv/. Thus, even for exponentially small error, our circuits have depth O(log n). The best previous depth bound was O(n), even for approximations with constant error. Moreover, our circuits have size O(n log(n//spl epsiv/)). As an application of this depth bound, we show that P. Shor's (1997) factoring algorithm may be based on quantum circuits with depth only O(log n) and polynomial size, in combination with classical polynomial-time pre- and postprocessing. Next, we prove an /spl Omega/(log n) lower bound on the depth complexity of approximations of the QFT with constant error. This implies that the above upper bound is asymptotically tight (for a reasonable range of values of /spl epsiv/). We also give an upper bound of O(n(log n)/sup 2/ log log n) on the circuit size of the exact QFT modulo 2/sup n/, for which the best previous bound was O(n/sup 2/). Finally, based on our circuits for the QFT with power-of-2 moduli, we show that the QFT with respect to an arbitrary modulus m can be approximated with accuracy /spl epsiv/ with circuits of depth O((log log m)(log log 1//spl epsiv/)) and size polynomial in log m+log(1//spl epsiv/).

arXiv:quant-ph/0006004•Annual Symposium on Foundations of Computer Science•Nov 7, 2002•271 citations

Improved Exact and Approximate Quantum Fourier Transforms from Multiplication

Chandrima Kayal, Rajat Mittal, Manaswi Paraashar +1 more

In the world of quantum computing, quantum Fourier transform (QFT) has been one of the most important subroutines for quantum algorithms, as exemplified by Shor's factoring algorithms and phase estimation (which in itself has been used as a primitive in various quantum algorithms). In fact most of the well known quantum algorithms can be divided into two classes, QFT based algorithms and search based algorithms. The usual circuit for QFT (covered in almost every basic quantum algorithms course) needs $O(q^2)$ gates (and $O(q)$ qubits) to perform the exact Fourier transform over $\mathbb{F}_{2^q}$. Cleve and Watrous (FOCS 2000) improved this gate count to $O(q (\log q)^2 (\log \log q))$ using the integer multiplication algorithm in $O(n (\log n) (\log \log n))$ time for two $n$-bit integers (best known at that time). Our first main result shows that this gate count can be improved to $O(q (\log q))$. In fact, if there is a multiplication circuit, to multiply two $n$-bit integers, with $O(n (\log n)^α)$ gates; we get a QFT circuit with $O(q (\log q)^α)$ gates (improving upon $O(q (\log q)^{α+ 1})$) gates from the construction of Cleve and Watrous). Given the recent claim by OpenAI about integer multiplication, this opens up the possibility of having a QFT circuit with $o \left( q (\log q)\right)$ gates. On approximating the QFT over $\ZZ/(2^q \ZZ)$, the result of Ahokas, Cleve and Hales (ERATO 2003) showed that an approximating circuit can be built with $O \left( q (\log \log(q/\varepsilon))^{α+1} \right)$ gates, where $ε$ is the approximating parameter. Our second main result again improves this to $O \left( q (\log \log(q/\varepsilon))^α \right)$ gates.

arXiv:2611.06341•Nov 4, 2026•0 citations

A review on quantum Fourier transform

Tomás Barros, Pablo Álvarez, Bárbara Vidal +1 more

This survey presents a comprehensive analysis of the quantum Fourier transform (QFT), a fundamental tool in quantum computing, in comparison to its classical counterpart, the fast Fourier transform (FFT). The study begins with an introduction to the classical Fourier transform, which is widely used in different disciplines such as signal and image processing. The article introduces the QFT as a quantum version of the Fourier transform, detailing how it leverages quantum parallelism and superposition to reduce the time complexity of the operation, and highlighting its crucial role in quantum algorithms like Shor’s algorithm for integer factorization. The analysis also addresses the mathematical foundations of the QFT, its implementation in quantum circuits, and the key advantages and challenges associated with its use, such as measurement precision and quantum decoherence. Finally, it concludes with an exploration of the current and potential applications of QFT in quantum computing.

Quantum Information Processing•Jan 27, 2026•2 citations
We exhibit a quantum circuit that performs the Quantum Fourier Transform on nnn qubits in (n) (n)(n) depth. Thus, a parallel quantum computer can carry out the QFT in linear time. We conjecture that this can, in fact, be reduced to (logn) ({\rm log} n)(logn) depth, which would place the QFT in the class {\bf QNC} of problems solvable in logarithmic parallel time.
. We exhibit a quantum circuit that performs the Quantum Fourier Transform on n qubits in O(n) depth. Thus, a parallel quantum computer can carry out the QFT in linear time. Griffiths and Niu have already shown this, so this paper is little more than an exercise in quantum circuit design; but perhaps it illustrates a worthwhile idea. We also speculate as to whether the QFT might be in the class QNC 1 of problems solvable in logarithmic parallel time. Shor's factoring algorithm [6] suggests that quantum computers can do things in polynomial time that classical computers cannot. However, since decoherence due to storage errors is a function of time, we should also ask to what extent we can parallelize quantum algorithms; if we can do many quantum operations at once, rather than serially, we can solve larger problems before our computer decoheres. Consider a quantum circuit operating on a set of qubits, containing onequbit gates (2 \\Theta 2 unitary matrices) and the two-qubit controlled...
We exhibit some simple gadgets useful in designing shallow parallel circuits for quantum algorithms. We prove that any quantum circuit composed entirely of controlled-not gates or of diagonal gates can be parallelized to logarithmic depth, while circuits composed of both cannot. Finally, while we note the Quantum Fourier Transform can be parallelized to linear depth, we exhibit a simple quantum circuit related to it that we believe cannot be parallelized to less than linear depth, and therefore might be used to prove that QNC < QP.
We study the class QNC of efficient parallel quantum circuits, the quantum analog of NC. We exhibit several useful gadgets and prove that various classes of circuits can be parallelized to logarithmic depth, including circuits for encoding and decoding standard quantum error-correcting codes, or, more generally, any circuit consisting of controlled-not gates, controlled π\piπ-shifts, and Hadamard gates. Finally, while we note the exact quantum Fourier transform can be parallelized to linear depth, we conjecture that neither itnor a simpler "staircase" circuit can be parallelized to less than this.
We give new bounds on the circuit complexity of the quantum Fourier transform (QFT). We give an upper bound of O(log n+log log(1//spl epsiv/)) on the circuit depth for computing an approximation of the QFT with respect to the modulus 2/sup n/ with error bounded by /spl epsiv/. Thus, even for exponentially small error, our circuits have depth O(log n). The best previous depth bound was O(n), even for approximations with constant error. Moreover, our circuits have size O(n log(n//spl epsiv/)). As an application of this depth bound, we show that P. Shor's (1997) factoring algorithm may be based on quantum circuits with depth only O(log n) and polynomial size, in combination with classical polynomial-time pre- and postprocessing. Next, we prove an /spl Omega/(log n) lower bound on the depth complexity of approximations of the QFT with constant error. This implies that the above upper bound is asymptotically tight (for a reasonable range of values of /spl epsiv/). We also give an upper bound of O(n(log n)/sup 2/ log log n) on the circuit size of the exact QFT modulo 2/sup n/, for which the best previous bound was O(n/sup 2/). Finally, based on our circuits for the QFT with power-of-2 moduli, we show that the QFT with respect to an arbitrary modulus m can be approximated with accuracy /spl epsiv/ with circuits of depth O((log log m)(log log 1//spl epsiv/)) and size polynomial in log m+log(1//spl epsiv/).
In the world of quantum computing, quantum Fourier transform (QFT) has been one of the most important subroutines for quantum algorithms, as exemplified by Shor's factoring algorithms and phase estimation (which in itself has been used as a primitive in various quantum algorithms). In fact most of the well known quantum algorithms can be divided into two classes, QFT based algorithms and search based algorithms. The usual circuit for QFT (covered in almost every basic quantum algorithms course) needs O(q2)O(q^2)O(q2) gates (and O(q)O(q)O(q) qubits) to perform the exact Fourier transform over F2q\mathbb{F}_{2^q}F2q​. Cleve and Watrous (FOCS 2000) improved this gate count to O(q(log⁡q)2(log⁡log⁡q))O(q (\log q)^2 (\log \log q))O(q(logq)2(loglogq)) using the integer multiplication algorithm in O(n(log⁡n)(log⁡log⁡n))O(n (\log n) (\log \log n))O(n(logn)(loglogn)) time for two nnn-bit integers (best known at that time). Our first main result shows that this gate count can be improved to O(q(log⁡q))O(q (\log q))O(q(logq)). In fact, if there is a multiplication circuit, to multiply two nnn-bit integers, with O(n(log⁡n)α)O(n (\log n)^α)O(n(logn)α) gates; we get a QFT circuit with O(q(log⁡q)α)O(q (\log q)^α)O(q(logq)α) gates (improving upon O(q(log⁡q)α+1)O(q (\log q)^{α+ 1})O(q(logq)α+1)) gates from the construction of Cleve and Watrous). Given the recent claim by OpenAI about integer multiplication, this opens up the possibility of having a QFT circuit with o(q(log⁡q))o \left( q (\log q)\right)o(q(logq)) gates. On approximating the QFT over $\ZZ/(2^q \ZZ)$, the result of Ahokas, Cleve and Hales (ERATO 2003) showed that an approximating circuit can be built with O(q(log⁡log⁡(q/ε))α+1)O \left( q (\log \log(q/\varepsilon))^{α+1} \right)O(q(loglog(q/ε))α+1) gates, where εεε is the approximating parameter. Our second main result again improves this to O(q(log⁡log⁡(q/ε))α)O \left( q (\log \log(q/\varepsilon))^α \right)O(q(loglog(q/ε))α) gates.
This survey presents a comprehensive analysis of the quantum Fourier transform (QFT), a fundamental tool in quantum computing, in comparison to its classical counterpart, the fast Fourier transform (FFT). The study begins with an introduction to the classical Fourier transform, which is widely used in different disciplines such as signal and image processing. The article introduces the QFT as a quantum version of the Fourier transform, detailing how it leverages quantum parallelism and superposition to reduce the time complexity of the operation, and highlighting its crucial role in quantum algorithms like Shor’s algorithm for integer factorization. The analysis also addresses the mathematical foundations of the QFT, its implementation in quantum circuits, and the key advantages and challenges associated with its use, such as measurement precision and quantum decoherence. Finally, it concludes with an exploration of the current and potential applications of QFT in quantum computing.