We study a method of producing approximately diagonal 1-qubit gates. For each positive integer, the method provides a sequence of gates that are defined iteratively from a fixed diagonal gate and an arbitrary gate. These sequences are conjectured to converge to diagonal gates doubly exponentially fast and are verified for small integers. We systemically study this conjecture and prove several important partial results. Some techniques are developed to pave the way for a final resolution of the conjecture. The sequences provided here have applications in quantum search algorithms, quantum circuit compilation, generation of leakage-free entangled gates in topological quantum computing, etc.We study a method of producing approximately diagonal 1-qubit gates. For each positive integer, the method provides a sequence of gates that are defined iteratively from a fixed diagonal gate and an arbitrary gate. These sequences are conjectured to converge to diagonal gates doubly exponentially fast and are verified for small integers. We systemically study this conjecture and prove several important partial results. Some techniques are developed to pave the way for a final resolution of the conjecture. The sequences provided here have applications in quantum search algorithms, quantum circuit compilation, generation of leakage-free entangled gates in topological quantum computing, etc.

Sep 10, 20210 citations

Generating a statet-design by diagonal quantum circuits

Yoshifumi Nakata, Masato Koashi, Mio Murao

We investigate protocols for generating a state $t$ -design by using a fixed separable initial state and a diagonal-unitary $t$ -design in the computational basis, which is a $t$ -design of an ensemble of diagonal unitary matrices with random phases as their eigenvalues. We first show that a diagonal-unitary $t$ -design generates a $O(1/2^N)$ -approximate state $t$ -design, where $N$ is the number of qubits. We then discuss a way of improving the degree of approximation by exploiting non-diagonal gates after applying a diagonal-unitary $t$ -design. We also show that it is necessary and sufficient to use $O(\log_2 t)$ -qubit gates with random phases to generate a diagonal-unitary $t$ -design by diagonal quantum circuits, and that each multi-qubit diagonal gate can be replaced by a sequence of multi-qubit controlled-phase-type gates with discrete-valued random phases. Finally, we analyze the number of gates for implementing a diagonal-unitary $t$ -design by {\it non-diagonal} two- and one-qubit gates. Our results provide a concrete application of diagonal quantum circuits in quantum informational tasks.We investigate protocols for generating a state $t$-design by using a fixed separable initial state and a diagonal-unitary $t$-design in the computational basis, which is a $t$-design of an ensemble of diagonal unitary matrices with random phases as their eigenvalues. We first show that a diagonal-unitary $t$-design generates a $O(1/2^N)$-approximate state $t$-design, where $N$ is the number of qubits. We then discuss a way of improving the degree of approximation by exploiting non-diagonal gates after applying a diagonal-unitary $t$-design. We also show that it is necessary and sufficient to use $O(\log_2 t)$-qubit gates with random phases to generate a diagonal-unitary $t$-design by diagonal quantum circuits, and that each multi-qubit diagonal gate can be replaced by a sequence of multi-qubit controlled-phase-type gates with discrete-valued random phases. Finally, we analyze the number of gates for implementing a diagonal-unitary $t$-design by {\it non-diagonal} two- and one-qubit gates. Our results provide a concrete application of diagonal quantum circuits in quantum informational tasks.

arXiv:1311.1128New Journal of PhysicsMay 22, 201439 citations

On the Synthesis of Quantum Circuits for Diagonal Operators in Quantum Computation

Jonathan Welch

Diagonal unitary operators are commonly found in many quantum algorithms. They find application as analytical potential operators for quantum simulation, as well as for complex oracles used in quantum searches. However, in order to implement a quantum algorithm on a given quantum device, each operator must be decomposed into a sequence of fault-tolerant, device-level instructions. In general, to implement an $n$ -qubit diagonal unitary {\\em exactly} on a quantum computer generally requires $2^{n+1}-3$ one- and two-qubit gates. However, for most practical implementations of diagonal unitaries, some degree of approximation will be necessary if the circuit is to be efficient. In this thesis we develop two complementary methods for the approximate synthesis of quantum circuits for diagonal unitaries. We show how to apply these techniques to real-space quantum simulation and show how efficient high fidelity quantum simulations can be implemented with low-depth quantum circuits.Diagonal unitary operators are commonly found in many quantum algorithms. They find application as analytical potential operators for quantum simulation, as well as for complex oracles used in quantum searches. However, in order to implement a quantum algorithm on a given quantum device, each operator must be decomposed into a sequence of fault-tolerant, device-level instructions. In general, to implement an $n$-qubit diagonal unitary {\\em exactly} on a quantum computer generally requires $2^{n+1}-3$ one- and two-qubit gates. However, for most practical implementations of diagonal unitaries, some degree of approximation will be necessary if the circuit is to be efficient. In this thesis we develop two complementary methods for the approximate synthesis of quantum circuits for diagonal unitaries. We show how to apply these techniques to real-space quantum simulation and show how efficient high fidelity quantum simulations can be implemented with low-depth quantum circuits.

Sep 29, 20152 citations

The Solovay-Kitaev algorithm

Christopher M. Dawson, Michael A. Nielsen

This pedagogical review presents the proof of the Solovay-Kitaev theorem in the form of an efficient classical algorithm for compiling an arbitrary single-qubit gate into a sequence of gates from a fixed and finite set. The algorithm can be used, for example, to compile Shor's algorithm, which uses rotations of $π/ 2^k$ , into an efficient fault-tolerant form using only Hadamard, controlled-{\sc not}, and $π/ 8$ gates. The algorithm runs in $O(\log^{2.71}(1/ε))$ time, and produces as output a sequence of $O(\log^{3.97}(1/ε))$ quantum gates which is guaranteed to approximate the desired quantum gate to an accuracy within $ε> 0$ . We also explain how the algorithm can be generalized to apply to multi-qubit gates and to gates from $SU(d)$ .This pedagogical review presents the proof of the Solovay-Kitaev theorem in the form of an efficient classical algorithm for compiling an arbitrary single-qubit gate into a sequence of gates from a fixed and finite set. The algorithm can be used, for example, to compile Shor's algorithm, which uses rotations of $π/ 2^k$, into an efficient fault-tolerant form using only Hadamard, controlled-{\sc not}, and $π/ 8$ gates. The algorithm runs in $O(\log^{2.71}(1/ε))$ time, and produces as output a sequence of $O(\log^{3.97}(1/ε))$ quantum gates which is guaranteed to approximate the desired quantum gate to an accuracy within $ε> 0$. We also explain how the algorithm can be generalized to apply to multi-qubit gates and to gates from $SU(d)$.

arXiv:quant-ph/0505030May 6, 20058 citations

Constructing arbitrary single-qubit fault-tolerant gates

Austin G. Fowler

We present a method for constructing optimal fault-tolerant approximations of arbitrary unitary gates using an arbtrary discrete universal gate set. The method presented is numerical and scales exponentially with the number of gates used in the approximation, however, for the specific case of arbitrary single-qubit gates and the fault-tolerant gates permitted by the 7-qubit Steane code, it is shown that the longest practical gates sequences can be found. We also analyse the practicality of the fault-tolerant approximations of the phase rotation gates used in Shor’s algorithm and find that simple non-fault-tolerant phase rotations are more robust for realistic error rates. A general scaling law of how rapidly these fault-tolerant approximations converge to arbitrary single-qubit gates is also determined. In large-scale quantum computation, every qubit of data is encoded across multiple physical qubits to form a logical qubit permitting quantum error correctionWe present a method for constructing optimal fault-tolerant approximations of arbitrary unitary gates using an arbtrary discrete universal gate set. The method presented is numerical and scales exponentially with the number of gates used in the approximation, however, for the specific case of arbitrary single-qubit gates and the fault-tolerant gates permitted by the 7-qubit Steane code, it is shown that the longest practical gates sequences can be found. We also analyse the practicality of the fault-tolerant approximations of the phase rotation gates used in Shor’s algorithm and find that simple non-fault-tolerant phase rotations are more robust for realistic error rates. A general scaling law of how rapidly these fault-tolerant approximations converge to arbitrary single-qubit gates is also determined. In large-scale quantum computation, every qubit of data is encoded across multiple physical qubits to form a logical qubit permitting quantum error correction

arXiv:quant-ph/0411206Nov 30, 20046 citations

Qutrit-Based Orthogonal Approximations with Inverse-Free Quantum Gate Sets

Anuradha Mahasinghe, Dulmi Fernando, Kaushika De Silva

The efficient compiling of arbitrary single-qubit gates into a sequence of gates from a finite gate set is of fundamental importance in quantum computation. The exact bounds of this compilation are given by the Solovay–Kitaev theorem, which serves as a powerful tool in compiling quantum algorithms that require many qubits. However, the inverse closure condition it imposes on the gate set adds a certain complexity to the experimental compilation, making the process less efficient. This was recently resolved by a version of the Solovay–Kitaev theorem for inverse-free gate sets, yielding a significant gain. Considering the recent progress in the field of three-level quantum systems, in which qubits are replaced by qutrits, it is possible to achieve the quantum speedup guaranteed by the Solovay–Kitaev theorem simply from orthogonal gates. Nevertheless, it has not been investigated previously whether the condition of inverse closure can be relaxed for these qutrit-based orthogonal compilations as well. In this work, we answer this positively, by obtaining improved Solovay–Kitaev approximations to an arbitrary orthogonal qutrit gate, with an accuracy ε from a sequence of O(log8.62(1/ε)) orthogonal gates taken from an inverse-free set.The efficient compiling of arbitrary single-qubit gates into a sequence of gates from a finite gate set is of fundamental importance in quantum computation. The exact bounds of this compilation are given by the Solovay–Kitaev theorem, which serves as a powerful tool in compiling quantum algorithms that require many qubits. However, the inverse closure condition it imposes on the gate set adds a certain complexity to the experimental compilation, making the process less efficient. This was recently resolved by a version of the Solovay–Kitaev theorem for inverse-free gate sets, yielding a significant gain. Considering the recent progress in the field of three-level quantum systems, in which qubits are replaced by qutrits, it is possible to achieve the quantum speedup guaranteed by the Solovay–Kitaev theorem simply from orthogonal gates. Nevertheless, it has not been investigated previously whether the condition of inverse closure can be relaxed for these qutrit-based orthogonal compilations as well. In this work, we answer this positively, by obtaining improved Solovay–Kitaev approximations to an arbitrary orthogonal qutrit gate, with an accuracy ε from a sequence of O(log8.62(1/ε)) orthogonal gates taken from an inverse-free set.

International Online Conference on Mathematics and Applications (IOCMA)Jun 13, 20230 citations

We investigate protocols for generating a state

t

-design by using a fixed separable initial state and a diagonal-unitary

t

-design in the computational basis, which is a

t

-design of an ensemble of diagonal unitary matrices with random phases as their eigenvalues. We first show that a diagonal-unitary

t

-design generates a

O(1/2^N)

-approximate state

t

-design, where

N

is the number of qubits. We then discuss a way of improving the degree of approximation by exploiting non-diagonal gates after applying a diagonal-unitary

t

-design. We also show that it is necessary and sufficient to use

O(\log_2 t)

-qubit gates with random phases to generate a diagonal-unitary

t

-design by diagonal quantum circuits, and that each multi-qubit diagonal gate can be replaced by a sequence of multi-qubit controlled-phase-type gates with discrete-valued random phases. Finally, we analyze the number of gates for implementing a diagonal-unitary

t

-design by {\it non-diagonal} two- and one-qubit gates. Our results provide a concrete application of diagonal quantum circuits in quantum informational tasks.

n

-qubit diagonal unitary {\\em exactly} on a quantum computer generally requires

2^{n+1}-3

one- and two-qubit gates. However, for most practical implementations of diagonal unitaries, some degree of approximation will be necessary if the circuit is to be efficient. In this thesis we develop two complementary methods for the approximate synthesis of quantum circuits for diagonal unitaries. We show how to apply these techniques to real-space quantum simulation and show how efficient high fidelity quantum simulations can be implemented with low-depth quantum circuits.

π/ 2^k

, into an efficient fault-tolerant form using only Hadamard, controlled-{\sc not}, and

π/ 8

gates. The algorithm runs in

O(\log^{2.71}(1/ε))

time, and produces as output a sequence of

O(\log^{3.97}(1/ε))

quantum gates which is guaranteed to approximate the desired quantum gate to an accuracy within

ε> 0

. We also explain how the algorithm can be generalized to apply to multi-qubit gates and to gates from

SU(d)