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

arXiv:quant-ph/0405050 · Physical Review A

Demonstrating quantum algorithm acceleration with NMR quantum computer

Mikio Nakahara, Yasushi Kondo, Kazuya Hata, Shogo Tanimura

Published Nov 19, 2004• 8 citations
arXivHTMLPDF

Abstract

In general, a quantum circuit is constructed with elementary gates, such as one-qubit gates and CNOT gates. It is possible, however, to speed up the execution time of a given circuit by merging those elementary gates together into larger modules, such that the desired unitary matrix expressing the algorithm is directly implemented. We demonstrate this experimentally by taking the two-qubit Grover's algorithm implemented in NMR quantum computations, whose pseudopure state is generated by cyclic permutations of the state populations. This is the first exact time-optimal solution, to our knowledge, obtained for a self-contained quantum algorithm.

DOI
10.1103/physreva.70.052319

Related papers

Warp-Drive Quantum Computation

Mikio Nakahara, Juha J. Vartiainen, Yasushi Kondo +2 more

Recently it has been shown that time-optimal quantum computation is attained by using the Cartan decomposition of a unitary matrix. We extend this approach by noting that the unitary group is compact. This allows us to reduce the execution time of a quantum algorithm $U_{\rm alg}$ further by adding an extra gate $W$ to it. This gate $W$ sends $U_{\rm alg}$ to another algorithm $WU_{\rm alg}$ which is executable in a shorter time than $U_{\rm alg}$. We call this technique warp-drive. Here we show both theoretically and experimentally that the execution time of Grover's algorithm is reduced in two-qubit NMR quantum computer. Warp-drive is potentially a powerful tool in accelerating algorithms and reducing the errors in any realization. of a quantum computer

arXiv:quant-ph/0411153•Nov 20, 2004•1 citation

Modelling of Grover’s quantum search algorithms: implementations of Simple quantum simulators on classical computers

Sergey Victorovich Ulyanov, Andrey G. Reshetnikov, Olga Tyatyushkina

Models of Grover’s search algorithm is reviewed to build the foundation for the other algorithms. Thereafter, some preliminary modifications of the original algorithms by others are stated, that increases the applicability of the search procedure. A general quantum computation on an isolated system can be represented by a unitary matrix. In order to execute such a computation on a quantum computer, it is common to decompose the unitary into a quantum circuit, i.e., a sequence of quantum gates that can be physically implemented on a given architecture. There are different universal gate sets for quantum computation. Here we choose the universal gate set consisting of CNOT and single-qubit gates. We measure the cost of a circuit by the number of CNOT gates as they are usually more difficult to implement than single qubit gates and since the number of single-qubit gates is bounded by about twice the number of CNOT’s.

System Analysis in Science and Education•Sep 30, 2020•4 citations

Unitary transformations for quantum computing

Juha J. Vartiainen

The last two decades have seen an enormous increase in the computational power of digital computers. This was due to the rapid technical development in manufacturing processes and controlling semiconducting structures on submicron scale. Concurrently, the electric circuits have encountered the first signs of the realm of quantum mechanics. Those effects may induce noise and thus they are typically considered harmful. However, the manipulation of the coherent quantum states might turn out be the basis of powerful computers – quantum computers. There, the computation is encoded into the unitary time evolution of a quantum mechanical state vector. Eventually, quantum mechanics could enable one, for example, to read secret electronic messages which are encrypted by the widely employed RSA cryptosystem – a task which is extremely laborious for the current digital computers. This thesis presents a theoretical study of the coherent manipulations of pure quantum states in a quantum register, that is, quantum algorithms. An implementation of a quantum algorithm involves the initialization of the input state and its manipulation with quantum gates followed by the measurements. The physical implementation of each gate requires that it is decomposed into low-level gates whose physical realizations are explicitly known. Here, the problem is examined from two directions. Firstly, the numerical optimization scheme for controlling time-evolution of a closed quantum system is discussed. This yields a method for implementing quantum gates acting on up to three quantum bits, qubits. The approach is independent of the physical realization of the quantum computer, but it is considered explicitly for a proposed inductively coupled Josephson charge qubit register. Secondly, the techniques of numerical matrix computation are utilized to find a general method for decomposing an arbitrary n-qubit gate into a sequence of elementary gates, which act on one or two qubits. The results of this thesis help to improve the implementation of quantum algorithms. The quantum circuit construction developed in the thesis is the first one to achieve the asymptotically minimal complexity in the number of elementary gates. In context of acceleration of quantum algorithms we present a gate-level study of Shor's algorithm and show how to accelerate the algorithm by merging several elementary gates into multiqubit gates. Finally, the requirements set by the resulting gate array are compared to the properties of superconducting qubits. This allows us to discuss the feasibility of the Josephson charge qubit register, for instance, as hardware for breaking the RSA cryptosystem.

•Apr 8, 2005•2 citations

Efficient Decomposition of Unitary Matrices in Quantum Circuit Compilers

Anna M. Krol, Aritra Sarkar, Imran Ashraf +2 more

Unitary decomposition is a widely used method to map quantum algorithms to an arbitrary set of quantum gates. Efficient implementation of this decomposition allows for the translation of bigger unitary gates into elementary quantum operations, which is key to executing these algorithms on existing quantum computers. The decomposition can be used as an aggressive optimization method for the whole circuit, as well as to test part of an algorithm on a quantum accelerator. For the selection and implementation of the decomposition algorithm, perfect qubits are assumed. We base our decomposition technique on Quantum Shannon Decomposition, which generates O(344n) controlled-not gates for an n-qubit input gate. In addition, we implement optimizations to take advantage of the potential underlying structure in the input or intermediate matrices, as well as to minimize the execution time of the decomposition. Comparing our implementation to Qubiter and the UniversalQCompiler (UQC), we show that our implementation generates circuits that are much shorter than those of Qubiter and not much longer than the UQC. At the same time, it is also up to 10 times as fast as Qubiter and about 500 times as fast as the UQC.

arXiv:2101.02993•Applied Sciences•Jan 12, 2022•54 citations

An arbitrary two-qubit computation in 23 elementary gates or less

Stephen S. Bullock, Igor L. Markov

Quantum circuits currently constitute a dominant model for quantum computation according to M. Nielsen and I. Chuang (2000). Our work addresses the problem of constructing quantum circuits to implement an arbitrary given quantum computation, in the special case of two qubits. We pursue circuits without ancilla qubits and a small number of elementary quantum gates by A. Barenco et al. (1995) and G. Song and A. Klappenecker (2003) as possible. Our lower bound for worst-case optimal two-qubit circuits calls for at least 17 gates: 15 one-qubit rotations and 2 CNOTs. To this end, we constructively prove a worst-case upper bound to 23 elementary gates, of which at most 4 (CNOTs) entail multi-qubit interactions. Our analysis shows that previous known synthesis algorithms, although more general, entail much larger quantum circuits than ours in the special case of two qubits. One such algorithm according to G. Cybenko (2001) has a worst case of 61 gates of which 18 may be CNOTs. Our technique rely on the KAK decomposition from Lie theory as well as the polar and spectral (symmetric Shur) matrix decompositions from numerical analysis. They are related to the canonical decomposition of two-qubit gate with respect to the "magic basis" of phase-shifted Bell states by N. Khaneja et al. (2001) and M. Lewenstein et al. (2001). We extend this decomposition in terms of elementary gates for quantum computation.

ACM/IEEE Design Automation Conference (DAC)•Mar 1, 2004•5 citations

Optimization and experimental realization of the quantum permutation algorithm

İ. Yalçınkaya, Z. Gedik

The quantum permutation algorithm provides computational speed-up over classical algorithms for determining the parity of a given cyclic permutation. For its $n$-qubit implementations, the number of required quantum gates scales quadratically with $n$ due to the quantum Fourier transforms included. We show here for the $n$-qubit case that the algorithm can be simplified so that it requires only $O(n)$ quantum gates, which theoretically reduces the complexity of the implementation. To test our results experimentally, we utilize IBM's 5-qubit quantum processor to realize the algorithm by using the original and simplified recipes for the 2-qubit case. It turns out that the latter results in a significantly higher success probability which allows us to verify the algorithm more precisely than the previous experimental realizations. We also verify the algorithm for the first time for the 3-qubit case with a considerable success probability by taking the advantage of our simplified scheme.

arXiv:1708.07900•Physical Review A•Dec 29, 2017•30 citations
In general, a quantum circuit is constructed with elementary gates, such as one-qubit gates and CNOT gates. It is possible, however, to speed up the execution time of a given circuit by merging those elementary gates together into larger modules, such that the desired unitary matrix expressing the algorithm is directly implemented. We demonstrate this experimentally by taking the two-qubit Grover's algorithm implemented in NMR quantum computations, whose pseudopure state is generated by cyclic permutations of the state populations. This is the first exact time-optimal solution, to our knowledge, obtained for a self-contained quantum algorithm.
Recently it has been shown that time-optimal quantum computation is attained by using the Cartan decomposition of a unitary matrix. We extend this approach by noting that the unitary group is compact. This allows us to reduce the execution time of a quantum algorithm UalgU_{\rm alg}Ualg​ further by adding an extra gate WWW to it. This gate WWW sends UalgU_{\rm alg}Ualg​ to another algorithm WUalgWU_{\rm alg}WUalg​ which is executable in a shorter time than UalgU_{\rm alg}Ualg​. We call this technique warp-drive. Here we show both theoretically and experimentally that the execution time of Grover's algorithm is reduced in two-qubit NMR quantum computer. Warp-drive is potentially a powerful tool in accelerating algorithms and reducing the errors in any realization. of a quantum computer
Models of Grover’s search algorithm is reviewed to build the foundation for the other algorithms. Thereafter, some preliminary modifications of the original algorithms by others are stated, that increases the applicability of the search procedure. A general quantum computation on an isolated system can be represented by a unitary matrix. In order to execute such a computation on a quantum computer, it is common to decompose the unitary into a quantum circuit, i.e., a sequence of quantum gates that can be physically implemented on a given architecture. There are different universal gate sets for quantum computation. Here we choose the universal gate set consisting of CNOT and single-qubit gates. We measure the cost of a circuit by the number of CNOT gates as they are usually more difficult to implement than single qubit gates and since the number of single-qubit gates is bounded by about twice the number of CNOT’s.
The last two decades have seen an enormous increase in the computational power of digital computers. This was due to the rapid technical development in manufacturing processes and controlling semiconducting structures on submicron scale. Concurrently, the electric circuits have encountered the first signs of the realm of quantum mechanics. Those effects may induce noise and thus they are typically considered harmful. However, the manipulation of the coherent quantum states might turn out be the basis of powerful computers – quantum computers. There, the computation is encoded into the unitary time evolution of a quantum mechanical state vector. Eventually, quantum mechanics could enable one, for example, to read secret electronic messages which are encrypted by the widely employed RSA cryptosystem – a task which is extremely laborious for the current digital computers. This thesis presents a theoretical study of the coherent manipulations of pure quantum states in a quantum register, that is, quantum algorithms. An implementation of a quantum algorithm involves the initialization of the input state and its manipulation with quantum gates followed by the measurements. The physical implementation of each gate requires that it is decomposed into low-level gates whose physical realizations are explicitly known. Here, the problem is examined from two directions. Firstly, the numerical optimization scheme for controlling time-evolution of a closed quantum system is discussed. This yields a method for implementing quantum gates acting on up to three quantum bits, qubits. The approach is independent of the physical realization of the quantum computer, but it is considered explicitly for a proposed inductively coupled Josephson charge qubit register. Secondly, the techniques of numerical matrix computation are utilized to find a general method for decomposing an arbitrary n-qubit gate into a sequence of elementary gates, which act on one or two qubits. The results of this thesis help to improve the implementation of quantum algorithms. The quantum circuit construction developed in the thesis is the first one to achieve the asymptotically minimal complexity in the number of elementary gates. In context of acceleration of quantum algorithms we present a gate-level study of Shor's algorithm and show how to accelerate the algorithm by merging several elementary gates into multiqubit gates. Finally, the requirements set by the resulting gate array are compared to the properties of superconducting qubits. This allows us to discuss the feasibility of the Josephson charge qubit register, for instance, as hardware for breaking the RSA cryptosystem.
Unitary decomposition is a widely used method to map quantum algorithms to an arbitrary set of quantum gates. Efficient implementation of this decomposition allows for the translation of bigger unitary gates into elementary quantum operations, which is key to executing these algorithms on existing quantum computers. The decomposition can be used as an aggressive optimization method for the whole circuit, as well as to test part of an algorithm on a quantum accelerator. For the selection and implementation of the decomposition algorithm, perfect qubits are assumed. We base our decomposition technique on Quantum Shannon Decomposition, which generates O(344n) controlled-not gates for an n-qubit input gate. In addition, we implement optimizations to take advantage of the potential underlying structure in the input or intermediate matrices, as well as to minimize the execution time of the decomposition. Comparing our implementation to Qubiter and the UniversalQCompiler (UQC), we show that our implementation generates circuits that are much shorter than those of Qubiter and not much longer than the UQC. At the same time, it is also up to 10 times as fast as Qubiter and about 500 times as fast as the UQC.
Quantum circuits currently constitute a dominant model for quantum computation according to M. Nielsen and I. Chuang (2000). Our work addresses the problem of constructing quantum circuits to implement an arbitrary given quantum computation, in the special case of two qubits. We pursue circuits without ancilla qubits and a small number of elementary quantum gates by A. Barenco et al. (1995) and G. Song and A. Klappenecker (2003) as possible. Our lower bound for worst-case optimal two-qubit circuits calls for at least 17 gates: 15 one-qubit rotations and 2 CNOTs. To this end, we constructively prove a worst-case upper bound to 23 elementary gates, of which at most 4 (CNOTs) entail multi-qubit interactions. Our analysis shows that previous known synthesis algorithms, although more general, entail much larger quantum circuits than ours in the special case of two qubits. One such algorithm according to G. Cybenko (2001) has a worst case of 61 gates of which 18 may be CNOTs. Our technique rely on the KAK decomposition from Lie theory as well as the polar and spectral (symmetric Shur) matrix decompositions from numerical analysis. They are related to the canonical decomposition of two-qubit gate with respect to the "magic basis" of phase-shifted Bell states by N. Khaneja et al. (2001) and M. Lewenstein et al. (2001). We extend this decomposition in terms of elementary gates for quantum computation.
The quantum permutation algorithm provides computational speed-up over classical algorithms for determining the parity of a given cyclic permutation. For its nnn-qubit implementations, the number of required quantum gates scales quadratically with nnn due to the quantum Fourier transforms included. We show here for the nnn-qubit case that the algorithm can be simplified so that it requires only O(n)O(n)O(n) quantum gates, which theoretically reduces the complexity of the implementation. To test our results experimentally, we utilize IBM's 5-qubit quantum processor to realize the algorithm by using the original and simplified recipes for the 2-qubit case. It turns out that the latter results in a significantly higher success probability which allows us to verify the algorithm more precisely than the previous experimental realizations. We also verify the algorithm for the first time for the 3-qubit case with a considerable success probability by taking the advantage of our simplified scheme.