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

Physical Review A

Quantum network optimization

Alexandre Blais

Published Jul 1, 2001• 23 citations
Publisher

Abstract

In many candidate designs of solid-state quantum computers, interactions between qubits are limited to a small number of neighboring qubits. Taking into account this limitation we describe how quantum algorithms can be executed efficiently on these designs. We illustrate our results with the quantum Fourier transform for which linear depth networks are obtained. The concepts presented in this work can be applied to all quantum algorithms to reduce considerably the coherence time needed for their execution.

DOI
10.1103/physreva.64.022312

Related papers

Quantum algorithm in quantum network systems

I. Sakamoto

Recently, the quantum computer (QC) using the nano‐devices have significantly attracted attention, because a large‐scale extention of the qubits could be easily realized in the nano‐devices. However, some problems for the realization of the QC with nano‐devices arise from the short decoherence time and the interaction of qubits only between nearest‐neighbor qubits. Therefore, we try to design the optimal quantum circuit of the quantum Fourier transform in various network system by means of the genetic algorithm (GA).

AIP conference proceedings•Jan 1, 2004•0 citations

Time-optimal Qubit mapping

Chi Zhang, Ari B. Hayes, Longfei Qiu +3 more

Rapid progress in the physical implementation of quantum computers gave birth to multiple recent quantum machines implemented with superconducting technology. In these NISQ machines, each qubit is physically connected to a bounded number of neighbors. This limitation prevents most quantum programs from being directly executed on quantum devices. A compiler is required for converting a quantum program to a hardware-compliant circuit, in particular, making each two-qubit gate executable by mapping the two logical qubits to two physical qubits with a link between them. To solve this problem, existing studies focus on inserting SWAP gates to dynamically remap logical qubits to physical qubits. However, most of the schemes lack the consideration of time-optimality of generated quantum circuits, or are achieving time-optimality with certain constraints. In this work, we propose a theoretically time-optimal SWAP insertion scheme for the qubit mapping problem. Our model can also be extended to practical heuristic algorithms. We present exact analysis results by using our model for quantum programs with recurring execution patterns. We have for the first time discovered an optimal qubit mapping pattern for quantum fourier transformation (QFT) on 2D nearest neighbor architecture. We also present a scalable extension of our theoretical model that can be used to solve qubit mapping for large quantum circuits.

International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS)•Apr 11, 2021•87 citations

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

The quantum Fourier transform on a linear nearest neighbor architecture

Yasuhiro Takahashi, Noboru Kunihiro, Kazuo Ohta

We show how to construct an efficient quantum circuit for computing a good approximation of the quantum Fourier transform on a linear nearest neighbor architecture. The constructed circuit uses no ancillary qubits and its depth and size are $O(n)$ and $O(n\log n)$, respectively, where $n$ is the length of the input. The circuit is useful for decreasing the size of Fowler et al.'s quantum circuit for Shor's factoring algorithm on a linear nearest neighbor architecture.

Quantum Information and Computation•May 1, 2007•36 citations

On the need for large Quantum depth

Nai-Hui Chia, Kai-Min Chung, Ching–Yi Lai

Near-term quantum computers are likely to have small depths due to short coherence time and noisy gates. A natural approach to leverage these quantum computers is interleaving them with classical computers. Understanding the capabilities and limits of this hybrid approach is an essential topic in quantum computation. Most notably, the quantum Fourier transform can be implemented by a hybrid of logarithmic-depth quantum circuits and a classical polynomial-time algorithm. Therefore, it seems possible that quantum polylogarithmic depth is as powerful as quantum polynomial depth in the presence of classical computation.

ACM Symposium on Theory of Computing (STOC)•Jun 7, 2020•24 citations

Reducing the Depth of Linear Reversible Quantum Circuits

Timothee Goubault de Brugiere, Marc Baboulin, Benoît Valiron +2 more

In quantum computing the decoherence time of the qubits determines the computation time available, and this time is very limited when using current hardware. In this article, we minimize the execution time (the depth) for a class of circuits referred to as linear reversible circuits, which has many applications in quantum computing (e.g., stabilizer circuits, “CNOT+T” circuits, etc.). We propose a practical formulation of a divide-and-conquer algorithm that produces quantum circuits that are twice as shallow as those produced by existing algorithms. We improve the theoretical upper bound of the depth in the worst case for some range of qubits. We also propose greedy algorithms based on cost minimization to find more optimal circuits for small or simple operators. Overall, we manage to consistently reduce the total depth of a class of reversible functions, with up to 92% savings in an ancilla-free case and up to 99% when ancillary qubits are available.

arXiv:2201.06380•IEEE Transactions on Quantum Engineering•Jan 1, 2021•38 citations
In many candidate designs of solid-state quantum computers, interactions between qubits are limited to a small number of neighboring qubits. Taking into account this limitation we describe how quantum algorithms can be executed efficiently on these designs. We illustrate our results with the quantum Fourier transform for which linear depth networks are obtained. The concepts presented in this work can be applied to all quantum algorithms to reduce considerably the coherence time needed for their execution.
Recently, the quantum computer (QC) using the nano‐devices have significantly attracted attention, because a large‐scale extention of the qubits could be easily realized in the nano‐devices. However, some problems for the realization of the QC with nano‐devices arise from the short decoherence time and the interaction of qubits only between nearest‐neighbor qubits. Therefore, we try to design the optimal quantum circuit of the quantum Fourier transform in various network system by means of the genetic algorithm (GA).
Rapid progress in the physical implementation of quantum computers gave birth to multiple recent quantum machines implemented with superconducting technology. In these NISQ machines, each qubit is physically connected to a bounded number of neighbors. This limitation prevents most quantum programs from being directly executed on quantum devices. A compiler is required for converting a quantum program to a hardware-compliant circuit, in particular, making each two-qubit gate executable by mapping the two logical qubits to two physical qubits with a link between them. To solve this problem, existing studies focus on inserting SWAP gates to dynamically remap logical qubits to physical qubits. However, most of the schemes lack the consideration of time-optimality of generated quantum circuits, or are achieving time-optimality with certain constraints. In this work, we propose a theoretically time-optimal SWAP insertion scheme for the qubit mapping problem. Our model can also be extended to practical heuristic algorithms. We present exact analysis results by using our model for quantum programs with recurring execution patterns. We have for the first time discovered an optimal qubit mapping pattern for quantum fourier transformation (QFT) on 2D nearest neighbor architecture. We also present a scalable extension of our theoretical model that can be used to solve qubit mapping for large quantum circuits.
. 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 show how to construct an efficient quantum circuit for computing a good approximation of the quantum Fourier transform on a linear nearest neighbor architecture. The constructed circuit uses no ancillary qubits and its depth and size are O(n)O(n)O(n) and O(nlog⁡n)O(n\log n)O(nlogn), respectively, where nnn is the length of the input. The circuit is useful for decreasing the size of Fowler et al.'s quantum circuit for Shor's factoring algorithm on a linear nearest neighbor architecture.
Near-term quantum computers are likely to have small depths due to short coherence time and noisy gates. A natural approach to leverage these quantum computers is interleaving them with classical computers. Understanding the capabilities and limits of this hybrid approach is an essential topic in quantum computation. Most notably, the quantum Fourier transform can be implemented by a hybrid of logarithmic-depth quantum circuits and a classical polynomial-time algorithm. Therefore, it seems possible that quantum polylogarithmic depth is as powerful as quantum polynomial depth in the presence of classical computation.
In quantum computing the decoherence time of the qubits determines the computation time available, and this time is very limited when using current hardware. In this article, we minimize the execution time (the depth) for a class of circuits referred to as linear reversible circuits, which has many applications in quantum computing (e.g., stabilizer circuits, “CNOT+T” circuits, etc.). We propose a practical formulation of a divide-and-conquer algorithm that produces quantum circuits that are twice as shallow as those produced by existing algorithms. We improve the theoretical upper bound of the depth in the worst case for some range of qubits. We also propose greedy algorithms based on cost minimization to find more optimal circuits for small or simple operators. Overall, we manage to consistently reduce the total depth of a class of reversible functions, with up to 92% savings in an ancilla-free case and up to 99% when ancillary qubits are available.