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:2410.18746 · Physical Review Applied

Practical implementation of Toffoli-based qubit rotation

Christoffer Hindlycke, Jakov Krnic, Jan-Åke Larsson

Published Dec 10, 2025• 0 citations
arXivHTMLPDF

Abstract

The Toffoli gate is an important universal quantum gate, and will alongside the Clifford gates be available in future fault-tolerant quantum computing hardware. Many quantum algorithms rely on performing arbitrarily small single-qubit rotations for their function, and these rotations may also be used to construct any unitary from a limited (but universal) gate set. How to carry out such rotations is then of significant interest. In this work, we evaluate the performance of a recently proposed single-qubit rotation algorithm using the Clifford plus Toffoli gate set by implementation of a one-shot version on both a real and a simulated quantum computer. We test the algorithm under various simulated noise levels using a per-qubit depolarizing error noise model and examine how the probabilities and process fidelities are affected. We then conduct live runs and find that the results reasonably match the simulated results. We also attempt to model the hardware noise by combining a number of noise models, matching the results to results of the live runs to approximate the hardware noise. Our results suggest that the algorithm will perform well for up to 1 % noise under the noise models we chose. We further posit the use of our algorithm as a benchmark for quantum processing units, given that it has a low complexity that is easy to fine-tune in small steps. We provide details for how to do this.

DOI
10.1103/29z2-15bm

Related papers

Single-qubit rotation algorithm with logarithmic Toffoli count and gate depth

Christoffer Hindlycke, Jan-Åke Larsson

Building generic gates from a restricted gate set is a difficult but important problem, especially in the noisy regime where only a limited set of noise-resistant gates are available, e.g., fault-tolerant Clifford gates (generated by Hadamard, phase, and gates) and fault-tolerant Toffoli gates. The Toffoli is also often used as a building block of many algorithms and will need to be constructed if not directly available. This makes Clifford + Toffoli an attractive gate set for building generic gates. In this Letter we give a simple and efficient algorithm for building an approximate single-qubit rotation using only Clifford + Toffoli , which in turn enables any generic single-qubit unitary. An important difference compared to earlier attempts is that the use of the Toffoli allows us to use simple rounding as opposed to a complicated approximation algorithm. The resulting gate array does not rely on repeatedly applying a fixed rotation, but immediately applies a rotation R θ * that is ε -close to the desired rotation R θ , with a success probability strictly greater than 1 / 2 . It can be rerun upon failure, giving an expected number of repetitions strictly less than 2, an expected Toffoli count strictly less than 4 ⌈ log 1 ε ⌉ , an expected gate depth strictly less than 4 ⌈ log 1 ε ⌉ + 6 , and uses 2 ⌈ log 1 ε ⌉ ancillas. The small circuit depth of our construction enables low-noise gates on existing quantum computational devices, and allows for arbitrary precision using a very modest number of ancillas. Published by the American Physical Society 2024

arXiv:2404.05618•Physical Review Research•Oct 28, 2024•4 citations

Cost-optimal single-qubit gate synthesis in the Clifford hierarchy

Gary J. Mooney, Charles D. Hill, Lloyd C. L. Hollenberg

For universal quantum computation, a major challenge to overcome for practical implementation is the large amount of resources required for fault-tolerant quantum information processing. An important aspect is implementing arbitrary unitary operators built from logical gates within the quantum error correction code. A synthesis algorithm can be used to approximate any unitary gate up to arbitrary precision by assembling sequences of logical gates chosen from a small set of universal gates that are fault-tolerantly performable while encoded in a quantum error-correction code. However, current procedures do not yet support individual assignment of base gate costs and many do not support extended sets of universal base gates. We analysed cost-optimal sequences using an exhaustive search based on Dijkstra’s pathfinding algorithm for the canonical Clifford+ T set of base gates and compared them to when additionally including Z -rotations from higher orders of the Clifford hierarchy. Two approaches of assigning base gate costs were used. First, costs were reduced to T -counts by recursively applying a Z -rotation catalyst circuit. Second, costs were assigned as the average numbers of raw (i.e. physical level) magic states required to directly distil and implement the gates fault-tolerantly. We found that the average sequence cost decreases by up to 54±3% when using the Z -rotation catalyst circuit approach and by up to 33±2% when using the magic state distillation approach. In addition, we investigated observed limitations of certain assignments of base gate costs by developing an analytic model to estimate the proportion of sets of Z -rotation gates from higher orders of the Clifford hierarchy that are found within sequences approximating random target gates.

arXiv:2005.05581•Quantum•Feb 15, 2021•7 citations

Efficient Fault-Tolerant Single Qubit Gate Approximation And Universal Quantum Computation Without Using The Solovay-Kitaev Theorem

H. F. Chau

Arbitrarily accurate fault-tolerant (FT) universal quantum computation can be carried out using the Clifford gates Z, S, CNOT plus the non-Clifford T gate. Moreover, a recent improvement of the Solovay-Kitaev theorem by Kuperberg implies that to approximate any single-qubit gate to an accuracy of $ε> 0$ requires $\text{O}(\log^c[1/ε])$ quantum gates with $c > 1.44042$. Can one do better? That was the question asked by Nielsen and Chuang in their quantum computation textbook. Specifically, they posted a challenge to efficiently approximate single-qubit gate, fault-tolerantly or otherwise, using $Ω(\log[1/ε])$ gates chosen from a finite set. Here I give a partial answer to this question by showing that this is possible using $\text{O}(\log[1/ε] \log\log[1/ε] \log\log\log[1/ε] \cdots)$ FT gates chosen from a finite set depending on the value of $ε$. The key idea is to construct an approximation of any phase gate in a FT way by recursion to any given accuracy $ε> 0$. This method is straightforward to implement, easy to understand, and interestingly does not involve the Solovay-Kitaev theorem.

arXiv:2406.04846•Jun 7, 2024•0 citations

Implementation of Toffoli gates with a single asymmetric Heisenberg XY interaction

Shi-Biao Zheng

The Toffoli gate, which has practical applications in the implementation of practical quantum algorithms and quantum error correction, is usually constructed from concatenated two-qubit or qubit-qutrit gates. Here we show that the Toffoli gate for three qubits can be implemented through a single $\mathit{XY}$ interaction plus two single-qubit rotations. This method greatly simplifies the experimental implementation of the Toffoli gate and promises a much higher fidelity compared to those based on elementary gate decomposition. We present an example for the implementation of the required $\mathit{XY}$ interaction in cavity QED.

Physical Review A•Apr 15, 2013•37 citations

Pseudorandom circuits from Clifford-plus- T gates

Yaakov S. Weinstein

We explore the implementation of pseudorandom single-qubit rotations and multiqubit pseudorandom circuits constructed only from Clifford gates and the $T$ gate, a phase rotation of $\ensuremath{\pi}/4$. Such a gate set would be appropriate for computations performed in a fault tolerant setting. For single-qubit rotations the distribution of parameters found for unitaries constructed from Clifford plus $T$ quickly approaches that of random rotations and requires significantly fewer gates than the construction of arbitrary single-qubit rotations. For Clifford-plus-$T$ pseudorandom circuits we find an exponential convergence to a random matrix element distribution and a Gaussian convergence to the higher-order moments of the matrix element distribution. In addition, the nearest-neighbor eigenangle statistics distribution almost immediately converges to that of random unitary matrices. All of these convergence rates are found to be insensitive to the number of qubits.

arXiv:1309.3943•Physical Review A•Dec 2, 2013•4 citations

CS-count-optimal quantum circuits for arbitrary multi-qubit unitaries

Priyanka Mukhopadhyay

Abstract In quantum computing there are quite a few universal gate sets, each having their own characteristics. In this paper we study the Clifford+CS universal fault-tolerant gate set. The CS gate is used is many applications and this gate set is an important alternative to Clifford+T. We introduce a generating set in order to represent any unitary implementable by this gate set and with this we derive a bound on the CS-count of arbitrary multi-qubit unitaries. Analysing the channel representation of the generating set elements, we infer $${\mathcal {J}}_n^{CS}\subset {\mathcal {J}}_n^T$$ J n CS ⊂ J n T , where $${\mathcal {J}}_n^{CS}$$ J n CS and $${\mathcal {J}}_n^T$$ J n T are the set of unitaries exactly implementable by the Clifford+CS and Clifford+T gate sets, respectively. We develop CS-count optimal synthesis algorithms for both approximately and exactly implementable multi-qubit unitaries. With the help of these we derive a CS-count-optimal circuit for Toffoli, implying $${\mathcal {J}}_n^{Tof}={\mathcal {J}}_n^{CS}$$ J n Tof = J n CS , where $${\mathcal {J}}_n^{Tof}$$ J n Tof is the set of unitaries exactly implementable by the Clifford+Toffoli gate set. Such conclusions can have an important impact on resource estimates of quantum algorithms.

Scientific Reports•Jun 17, 2024•3 citations
The Toffoli gate is an important universal quantum gate, and will alongside the Clifford gates be available in future fault-tolerant quantum computing hardware. Many quantum algorithms rely on performing arbitrarily small single-qubit rotations for their function, and these rotations may also be used to construct any unitary from a limited (but universal) gate set. How to carry out such rotations is then of significant interest. In this work, we evaluate the performance of a recently proposed single-qubit rotation algorithm using the Clifford plus Toffoli gate set by implementation of a one-shot version on both a real and a simulated quantum computer. We test the algorithm under various simulated noise levels using a per-qubit depolarizing error noise model and examine how the probabilities and process fidelities are affected. We then conduct live runs and find that the results reasonably match the simulated results. We also attempt to model the hardware noise by combining a number of noise models, matching the results to results of the live runs to approximate the hardware noise. Our results suggest that the algorithm will perform well for up to 1 % noise under the noise models we chose. We further posit the use of our algorithm as a benchmark for quantum processing units, given that it has a low complexity that is easy to fine-tune in small steps. We provide details for how to do this.
Building generic gates from a restricted gate set is a difficult but important problem, especially in the noisy regime where only a limited set of noise-resistant gates are available, e.g., fault-tolerant Clifford gates (generated by Hadamard, phase, and gates) and fault-tolerant Toffoli gates. The Toffoli is also often used as a building block of many algorithms and will need to be constructed if not directly available. This makes Clifford + Toffoli an attractive gate set for building generic gates. In this Letter we give a simple and efficient algorithm for building an approximate single-qubit rotation using only Clifford + Toffoli , which in turn enables any generic single-qubit unitary. An important difference compared to earlier attempts is that the use of the Toffoli allows us to use simple rounding as opposed to a complicated approximation algorithm. The resulting gate array does not rely on repeatedly applying a fixed rotation, but immediately applies a rotation R θ * that is ε -close to the desired rotation R θ , with a success probability strictly greater than 1 / 2 . It can be rerun upon failure, giving an expected number of repetitions strictly less than 2, an expected Toffoli count strictly less than 4 ⌈ log 1 ε ⌉ , an expected gate depth strictly less than 4 ⌈ log 1 ε ⌉ + 6 , and uses 2 ⌈ log 1 ε ⌉ ancillas. The small circuit depth of our construction enables low-noise gates on existing quantum computational devices, and allows for arbitrary precision using a very modest number of ancillas. Published by the American Physical Society 2024
For universal quantum computation, a major challenge to overcome for practical implementation is the large amount of resources required for fault-tolerant quantum information processing. An important aspect is implementing arbitrary unitary operators built from logical gates within the quantum error correction code. A synthesis algorithm can be used to approximate any unitary gate up to arbitrary precision by assembling sequences of logical gates chosen from a small set of universal gates that are fault-tolerantly performable while encoded in a quantum error-correction code. However, current procedures do not yet support individual assignment of base gate costs and many do not support extended sets of universal base gates. We analysed cost-optimal sequences using an exhaustive search based on Dijkstra’s pathfinding algorithm for the canonical Clifford+ T set of base gates and compared them to when additionally including Z -rotations from higher orders of the Clifford hierarchy. Two approaches of assigning base gate costs were used. First, costs were reduced to T -counts by recursively applying a Z -rotation catalyst circuit. Second, costs were assigned as the average numbers of raw (i.e. physical level) magic states required to directly distil and implement the gates fault-tolerantly. We found that the average sequence cost decreases by up to 54±3% when using the Z -rotation catalyst circuit approach and by up to 33±2% when using the magic state distillation approach. In addition, we investigated observed limitations of certain assignments of base gate costs by developing an analytic model to estimate the proportion of sets of Z -rotation gates from higher orders of the Clifford hierarchy that are found within sequences approximating random target gates.
Arbitrarily accurate fault-tolerant (FT) universal quantum computation can be carried out using the Clifford gates Z, S, CNOT plus the non-Clifford T gate. Moreover, a recent improvement of the Solovay-Kitaev theorem by Kuperberg implies that to approximate any single-qubit gate to an accuracy of ε>0ε> 0ε>0 requires O(log⁡c[1/ε])\text{O}(\log^c[1/ε])O(logc[1/ε]) quantum gates with c>1.44042c > 1.44042c>1.44042. Can one do better? That was the question asked by Nielsen and Chuang in their quantum computation textbook. Specifically, they posted a challenge to efficiently approximate single-qubit gate, fault-tolerantly or otherwise, using Ω(log⁡[1/ε])Ω(\log[1/ε])Ω(log[1/ε]) gates chosen from a finite set. Here I give a partial answer to this question by showing that this is possible using O(log⁡[1/ε]log⁡log⁡[1/ε]log⁡log⁡log⁡[1/ε]⋯ )\text{O}(\log[1/ε] \log\log[1/ε] \log\log\log[1/ε] \cdots)O(log[1/ε]loglog[1/ε]logloglog[1/ε]⋯) FT gates chosen from a finite set depending on the value of εεε. The key idea is to construct an approximation of any phase gate in a FT way by recursion to any given accuracy ε>0ε> 0ε>0. This method is straightforward to implement, easy to understand, and interestingly does not involve the Solovay-Kitaev theorem.
The Toffoli gate, which has practical applications in the implementation of practical quantum algorithms and quantum error correction, is usually constructed from concatenated two-qubit or qubit-qutrit gates. Here we show that the Toffoli gate for three qubits can be implemented through a single XY\mathit{XY}XY interaction plus two single-qubit rotations. This method greatly simplifies the experimental implementation of the Toffoli gate and promises a much higher fidelity compared to those based on elementary gate decomposition. We present an example for the implementation of the required XY\mathit{XY}XY interaction in cavity QED.
We explore the implementation of pseudorandom single-qubit rotations and multiqubit pseudorandom circuits constructed only from Clifford gates and the TTT gate, a phase rotation of $\ensuremath{\pi}/4$. Such a gate set would be appropriate for computations performed in a fault tolerant setting. For single-qubit rotations the distribution of parameters found for unitaries constructed from Clifford plus TTT quickly approaches that of random rotations and requires significantly fewer gates than the construction of arbitrary single-qubit rotations. For Clifford-plus-TTT pseudorandom circuits we find an exponential convergence to a random matrix element distribution and a Gaussian convergence to the higher-order moments of the matrix element distribution. In addition, the nearest-neighbor eigenangle statistics distribution almost immediately converges to that of random unitary matrices. All of these convergence rates are found to be insensitive to the number of qubits.
Abstract In quantum computing there are quite a few universal gate sets, each having their own characteristics. In this paper we study the Clifford+CS universal fault-tolerant gate set. The CS gate is used is many applications and this gate set is an important alternative to Clifford+T. We introduce a generating set in order to represent any unitary implementable by this gate set and with this we derive a bound on the CS-count of arbitrary multi-qubit unitaries. Analysing the channel representation of the generating set elements, we infer JnCS⊂JnT{\mathcal {J}}_n^{CS}\subset {\mathcal {J}}_n^TJnCS​⊂JnT​ J n CS ⊂ J n T , where JnCS{\mathcal {J}}_n^{CS}JnCS​ J n CS and JnT{\mathcal {J}}_n^TJnT​ J n T are the set of unitaries exactly implementable by the Clifford+CS and Clifford+T gate sets, respectively. We develop CS-count optimal synthesis algorithms for both approximately and exactly implementable multi-qubit unitaries. With the help of these we derive a CS-count-optimal circuit for Toffoli, implying JnTof=JnCS{\mathcal {J}}_n^{Tof}={\mathcal {J}}_n^{CS}JnTof​=JnCS​ J n Tof = J n CS , where JnTof{\mathcal {J}}_n^{Tof}JnTof​ J n Tof is the set of unitaries exactly implementable by the Clifford+Toffoli gate set. Such conclusions can have an important impact on resource estimates of quantum algorithms.