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:2111.02426 · Physical Review Research

No-go theorem and a universal decomposition strategy for quantum channel compilation

Weiyuan Gong, Si Jiang, Dong-Ling Deng

Published Jan 30, 2023• 2 citations
arXivHTMLPDF

Abstract

We rigorously prove a no-go theorem that, in sharp contrast to the case of compiling unitary gates, it is impossible to compile an arbitrary channel to arbitrary precision with any given finite elementary channel set, regardless of the length of the decomposition sequence. However, for a fixed error bound $\ensuremath{\epsilon}$, we find a general and systematic strategy to compile arbitrary quantum channels. We construct a universal set with a constant number of $\ensuremath{\epsilon}$-dependent elementary channels, such that an arbitrary quantum channel can be decomposed into a sequence of these elementary channels followed by a unitary gate, with the sequence length bounded by $O(\frac{1}{\ensuremath{\epsilon}}log\frac{1}{\ensuremath{\epsilon}})$ in the worst case. We further optimize this approach by exploiting proximal policy optimization---a powerful deep reinforcement learning algorithm for the gate compilation. We numerically evaluate the performance of our algorithm concerning topological compiling of Majorana fermions, and we show that our algorithm can conveniently and effectively reduce the use of expensive elementary operations.

DOI
10.1103/physrevresearch.5.013060

Related papers

Topological Quantum Compiling with Reinforcement Learning

Yuanhang Zhang, Pei-Lin Zheng, Yi Zhang +1 more

Quantum compiling, a process that decomposes the quantum algorithm into a series of hardware-compatible commands or elementary gates, is of fundamental importance for quantum computing. We introduce an efficient algorithm based on deep reinforcement learning that compiles an arbitrary single-qubit gate into a sequence of elementary gates from a finite universal set. It generates near-optimal gate sequences with given accuracy and is generally applicable to various scenarios, independent of the hardware-feasible universal set and free from using ancillary qubits. For concreteness, we apply this algorithm to the case of topological compiling of Fibonacci anyons and obtain near-optimal braiding sequences for arbitrary single-qubit unitaries. Our algorithm may carry over to other challenging quantum discrete problems, thus opening up a new avenue for intriguing applications of deep learning in quantum physics.

arXiv:2004.04743•Physical Review Letters•Oct 19, 2020•94 citations

Quantum compiling by deep reinforcement learning

Paris, M.G.A., Prati, E.

The general problem of quantum compiling is to approximate any unitary transformation that describes the quantum computation as a sequence of elements selected from a finite base of universal quantum gates.The Solovay-Kitaev theorem guarantees the existence of such an approximating sequence.Though, the solutions to the quantum compiling problem suffer from a tradeoff between the length of the sequences, the precompilation time, and the execution time.Traditional approaches are time-consuming, unsuitable to be employed during computation.Here, we propose a deep reinforcement learning method as an alternative strategy, which requires a single precompilation procedure to learn a general strategy to approximate single-qubit unitaries.We show that this approach reduces the overall execution time, improving the tradeoff between the length of the sequence and execution time, potentially allowing real-time operations.

•Jan 1, 2021•96 citations

Quantum circuit compilation with constant overhead

Chenyi Zhang, Xinyu Tan, Robin Kothari +2 more

Compiling a continuous gate set to a discrete universal gate set generally incurs an overhead. A circuit composed of $G$ arbitrary one- and two-qubit gates can be $ε$-approximated by a sequence of gates from $\{H,T,\mathrm{CNOT}\}$ by replacing each original gate by a sequence of $O(\log(G/ε))$ elementary gates. We show that this overhead can be avoided using adaptivity for polynomial-sized circuits with inverse-polynomial target error, which is optimal.

quant-pharXiv:2609.39092•Oct 1, 2026•0 citations

Quantum compiling by deep reinforcement learning

Lorenzo Del Moro, Matteo G. A. Paris, Marcello Restelli +1 more

Abstract The general problem of quantum compiling is to approximate any unitary transformation that describes the quantum computation as a sequence of elements selected from a finite base of universal quantum gates. The Solovay-Kitaev theorem guarantees the existence of such an approximating sequence. Though, the solutions to the quantum compiling problem suffer from a tradeoff between the length of the sequences, the precompilation time, and the execution time. Traditional approaches are time-consuming, unsuitable to be employed during computation. Here, we propose a deep reinforcement learning method as an alternative strategy, which requires a single precompilation procedure to learn a general strategy to approximate single-qubit unitaries. We show that this approach reduces the overall execution time, improving the tradeoff between the length of the sequence and execution time, potentially allowing real-time operations.

arXiv:2105.15048•Communications Physics•Aug 6, 2021•2 citations

Quantum compiling problem without the inverses: an approach that reduces to multi-dimensional Knapsack problem

Yertay Zhiyenbayev, V. M. Akulin, Aikaterini Mandilara

Given a set of quantum gates and a target unitary operation, the most elementary task of quantum compiling is the identification of a sequence of the gates that approximates the target unitary to a determined precision $\varepsilon$. Solovay-Kitaev theorem provides an elegant solution which is based on the construction of successively tighter `nets' around the unity comprised by successively longer sequences of gates. The procedure for the construction of the nets, according to this theorem, requires accessibility to the inverse of the gates as well. In this work, we propose a method for constructing nets around unity without this requirement. The algorithmic procedure is applicable to sets of gates which are diffusive enough, in the sense that sequences of moderate length cover the space of unitary matrices in a uniform way. We prove that the number of gates sufficient for reaching a precision $\varepsilon$ scales as $ \log (1/\varepsilon )^{\log 3 / log 2} $ while the pre-compilation time is increased as compared to thatof the Solovay-Kitaev algorithm by the exponential factor 3/2.

•Aug 29, 2017•0 citations

Quantum compiling with diffusive sets of gates

Yertay Zhiyenbayev, V. M. Akulin, Aikaterini Mandilara

Given a set of quantum gates and a target unitary operation, the most elementary task of quantum compiling is the identification of a sequence of the gates that approximates the target unitary to a determined precision $\ensuremath{\varepsilon}$. The Solovay-Kitaev theorem provides an elegant solution which is based on the construction of successively tighter ``nets'' around unity comprised of successively longer sequences of gates. The procedure for the construction of the nets, according to this theorem, requires accessibility to the inverse of the gates as well. In this work, we propose a method for constructing nets around unity without this requirement. The algorithmic procedure is applicable to sets of gates which are diffusive enough, in the sense that sequences of moderate length cover the space of unitary matrices in a uniform way. We prove that the number of gates sufficient for reaching a precision $\ensuremath{\varepsilon}$ scales as $log{(1/\ensuremath{\varepsilon})}^{log3/log2}$ while the precompilation time is increased as compared to that of the Solovay-Kitaev algorithm by the exponential factor $3/2$.

arXiv:1708.08909•Physical Review A•Jul 24, 2018•13 citations
We rigorously prove a no-go theorem that, in sharp contrast to the case of compiling unitary gates, it is impossible to compile an arbitrary channel to arbitrary precision with any given finite elementary channel set, regardless of the length of the decomposition sequence. However, for a fixed error bound \ensuremathϵ\ensuremath{\epsilon}\ensuremathϵ, we find a general and systematic strategy to compile arbitrary quantum channels. We construct a universal set with a constant number of \ensuremathϵ\ensuremath{\epsilon}\ensuremathϵ-dependent elementary channels, such that an arbitrary quantum channel can be decomposed into a sequence of these elementary channels followed by a unitary gate, with the sequence length bounded by O(1\ensuremathϵlog1\ensuremathϵ)O(\frac{1}{\ensuremath{\epsilon}}log\frac{1}{\ensuremath{\epsilon}})O(\ensuremathϵ1​log\ensuremathϵ1​) in the worst case. We further optimize this approach by exploiting proximal policy optimization---a powerful deep reinforcement learning algorithm for the gate compilation. We numerically evaluate the performance of our algorithm concerning topological compiling of Majorana fermions, and we show that our algorithm can conveniently and effectively reduce the use of expensive elementary operations.
Quantum compiling, a process that decomposes the quantum algorithm into a series of hardware-compatible commands or elementary gates, is of fundamental importance for quantum computing. We introduce an efficient algorithm based on deep reinforcement learning that compiles an arbitrary single-qubit gate into a sequence of elementary gates from a finite universal set. It generates near-optimal gate sequences with given accuracy and is generally applicable to various scenarios, independent of the hardware-feasible universal set and free from using ancillary qubits. For concreteness, we apply this algorithm to the case of topological compiling of Fibonacci anyons and obtain near-optimal braiding sequences for arbitrary single-qubit unitaries. Our algorithm may carry over to other challenging quantum discrete problems, thus opening up a new avenue for intriguing applications of deep learning in quantum physics.
The general problem of quantum compiling is to approximate any unitary transformation that describes the quantum computation as a sequence of elements selected from a finite base of universal quantum gates.The Solovay-Kitaev theorem guarantees the existence of such an approximating sequence.Though, the solutions to the quantum compiling problem suffer from a tradeoff between the length of the sequences, the precompilation time, and the execution time.Traditional approaches are time-consuming, unsuitable to be employed during computation.Here, we propose a deep reinforcement learning method as an alternative strategy, which requires a single precompilation procedure to learn a general strategy to approximate single-qubit unitaries.We show that this approach reduces the overall execution time, improving the tradeoff between the length of the sequence and execution time, potentially allowing real-time operations.
Compiling a continuous gate set to a discrete universal gate set generally incurs an overhead. A circuit composed of GGG arbitrary one- and two-qubit gates can be εεε-approximated by a sequence of gates from {H,T,CNOT}\{H,T,\mathrm{CNOT}\}{H,T,CNOT} by replacing each original gate by a sequence of O(log⁡(G/ε))O(\log(G/ε))O(log(G/ε)) elementary gates. We show that this overhead can be avoided using adaptivity for polynomial-sized circuits with inverse-polynomial target error, which is optimal.
Abstract The general problem of quantum compiling is to approximate any unitary transformation that describes the quantum computation as a sequence of elements selected from a finite base of universal quantum gates. The Solovay-Kitaev theorem guarantees the existence of such an approximating sequence. Though, the solutions to the quantum compiling problem suffer from a tradeoff between the length of the sequences, the precompilation time, and the execution time. Traditional approaches are time-consuming, unsuitable to be employed during computation. Here, we propose a deep reinforcement learning method as an alternative strategy, which requires a single precompilation procedure to learn a general strategy to approximate single-qubit unitaries. We show that this approach reduces the overall execution time, improving the tradeoff between the length of the sequence and execution time, potentially allowing real-time operations.
Given a set of quantum gates and a target unitary operation, the most elementary task of quantum compiling is the identification of a sequence of the gates that approximates the target unitary to a determined precision ε\varepsilonε. Solovay-Kitaev theorem provides an elegant solution which is based on the construction of successively tighter `nets' around the unity comprised by successively longer sequences of gates. The procedure for the construction of the nets, according to this theorem, requires accessibility to the inverse of the gates as well. In this work, we propose a method for constructing nets around unity without this requirement. The algorithmic procedure is applicable to sets of gates which are diffusive enough, in the sense that sequences of moderate length cover the space of unitary matrices in a uniform way. We prove that the number of gates sufficient for reaching a precision ε\varepsilonε scales as $ \log (1/\varepsilon )^{\log 3 / log 2} $ while the pre-compilation time is increased as compared to thatof the Solovay-Kitaev algorithm by the exponential factor 3/2.
Given a set of quantum gates and a target unitary operation, the most elementary task of quantum compiling is the identification of a sequence of the gates that approximates the target unitary to a determined precision $\ensuremath{\varepsilon}$. The Solovay-Kitaev theorem provides an elegant solution which is based on the construction of successively tighter ``nets'' around unity comprised of successively longer sequences of gates. The procedure for the construction of the nets, according to this theorem, requires accessibility to the inverse of the gates as well. In this work, we propose a method for constructing nets around unity without this requirement. The algorithmic procedure is applicable to sets of gates which are diffusive enough, in the sense that sequences of moderate length cover the space of unitary matrices in a uniform way. We prove that the number of gates sufficient for reaching a precision $\ensuremath{\varepsilon}$ scales as $log{(1/\ensuremath{\varepsilon})}^{log3/log2}$ while the precompilation time is increased as compared to that of the Solovay-Kitaev algorithm by the exponential factor 3/23/23/2.