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:2509.01224

Cutting stabiliser decompositions of magic state cultivation with ZX-calculus

Kwok Ho Wan, Zhong, Zhenghao

Published Sep 1, 2025• 1 citation
arXivHTMLPDF

Abstract

We apply the cutting stabiliser decomposition techniques [arXiv:2403.10964] to the quantum states generated from magic state cultivation [arXiv:2409.17595], post-selected upon all $+1$ measured values for simplicity. The resultant states to the $d=3$ and $d=5$ variant magic state cultivation circuits can be expressed as a sum of $4$ and $8$ Clifford ZX-digrams respectively. Modifications to existing ZX-calculus stabiliser decomposition methods may enable better simulation of non-Clifford circuits containing a moderate number of $T$ gates in the context of quantum error correction.

DOI
10.48550/arxiv.2509.01224

Related papers

Simulating magic state cultivation with few Clifford terms

Kwok Ho Wan, Zhenghao Zhong, Ainhoa Zapirain

Building upon Wan, Zhong (2025) \cite{wan2025cuttingstabiliserdecompositionsmagic} we present a few methods on how to simulate the non-Clifford d = 5 magic state cultivation circuits\cite{gidney2024magicstatecultivationgrowing} with a sum of ≈ 8 Clifford ZX-diagrams on average, at 0.1 % noise. Compared to a magic cat state stabiliser decomposition of all 53 non-Clifford spiders ( 6,377,292 terms required), this is more than 7 × 10 5 times reduction in the number of terms. Our stabiliser decomposition has the advantage of representing the final non-Clifford state (in light of circuit errors) as a sum of Clifford ZX-diagrams. This will be useful in simulating the escape stage of magic state cultivation, where one needs to port the resultant state of cultivation into a larger Clifford circuit with many more qubits. Still, it's necessary to only track ≈ 8 Clifford terms. Our result sheds light on the simulability of operationally relevant, high T -count quantum circuits with some internal structure.Finally, we provide numerical results for full non-Clifford stabiliser rank simulation based on t s i m along with optimisations using our cutting decompositions. Nearly 4 × 10 6 shots per second can be obtained on a laptop for the smaller d = 3 circuits at uniform circuit level noise p = 0.0005 , making it only ∼ 1.1 times slower than its (circuit-unspecific and un-optimised) fully Clifford proxy simulation via s t i m using S gates.

arXiv:2509.08658•Quantum•Jun 12, 2026•0 citations

Constant-depth magic state cultivation with Clifford measurements by gauging

Bence Hetényi, Benjamin J. Brown, Dominic J. Williamson

Magic states are a scarce resource for two-dimensional qubit stabilizer codes. Magic state cultivation was recently proposed to reduce the cost of magic state preparation by measuring the transversal Clifford operator of the color code. Cultivation achieves $\sim 10^{-9}$ logical error rates for the $d=5$ color code, with substantially lower space-time overhead than magic state distillation. However, due to the $\mathcal{O}(d)$ depth of the Clifford measurement circuit, magic state cultivation becomes impractical for $d>5$. Here, we perform logical $XS^\dagger$ measurements on the color code by gauging a transversal Clifford gate, resulting in a constant-depth logical measurement circuit. We employ repeated gauging measurements with post-selection rather than performing error correction on the Clifford stabilizer code that emerges during the gauging protocol, thus gaining simplicity at the cost of scalability. Our protocol requires a regular square grid connectivity and yields logical error rates comparable to magic state cultivation. The $d=7$ version of our protocol gives access to the $10^{-12}$ logical error rate regime at $0.05\%$ physical error rate while retaining more than $1\%$ of the shots after the equivalent of the cultivation stage.

quant-pharXiv:2603.05429•Physical Review Letters•Mar 6, 2026•0 citations

Simulating quantum circuits with ZX-calculus reduced stabiliser decompositions

Aleks Kissinger, John van de Wetering

Abstract We introduce an enhanced technique for strong classical simulation of quantum circuits which combines the ‘sum-of-stabilisers’ method with an automated simplification strategy based on the ZX-calculus. Recently it was shown that quantum circuits can be classically simulated by expressing the non-stabiliser gates in a circuit as magic state injections and decomposing them in chunks of 2–6 states at a time, obtaining sums of (efficiently-simulable) stabiliser states with many fewer terms than the naive approach. We adapt these techniques from the original setting of Clifford circuits with magic state injection to generic ZX-diagrams and show that, by interleaving this ‘chunked’ decomposition with a ZX-calculus-based simplification strategy, we can obtain stabiliser decompositions that are many orders of magnitude smaller than existing approaches. We illustrate this technique to perform exact norm calculations (and hence strong simulation) on the outputs of random 50- and 100-qubit Clifford + T circuits with up to 70 T-gates as well as a family of hidden shift circuits previously considered by Bravyi and Gosset with over 1000 T-gates.

arXiv:2109.01076•Quantum Science and Technology•Mar 11, 2022•45 citations

Polynomial-time simulation of non-Clifford quantum error correction

Serban Cercelescu, Mark Koch, Arthur Pesah

We show that every intermediate state of a broad class of non-Clifford quantum error-correction circuits is a third-order phase-polynomial state, even under stochastic Pauli noise. The class includes magic state distillation and cultivation, code switching and gauge fixing, transversal non-Clifford gates with syndrome extraction, and injection of diagonal magic states. Third-order phase-polynomial states strictly generalize stabilizer states, and we prove that they are exactly the stabilizer states of the diagonal-Clifford-and-Pauli (DCP) stabilizer formalism that we introduce. We characterize these states and show that their representations can be updated in polynomial time. This yields an exact polynomial-time simulation algorithm for these circuits and, more broadly, a framework for reasoning about their internal states and about magic states in general. We provide an open-source implementation, \texttt{merlin}, and benchmark it against existing non-Clifford simulators on distillation, cultivation, and code switching circuits. The benchmarks demonstrate improved runtime and memory scaling as the number of logical outputs grows in Bravyi-Haah distillation, and simulation of a code switching circuit beyond the reach of all other tested simulators.

quant-pharXiv:2610.06811•Oct 6, 2026•0 citations

Classical Simulation of Quantum Circuits with Partial and Graphical Stabiliser Decompositions

Aleks Kissinger, John van de Wetering, Renaud Vilmart

Recent developments in classical simulation of quantum circuits make use of clever decompositions of chunks of magic states into sums of efficiently simulable stabiliser states. We show here how, by considering certain non-stabiliser entangled states which have more favourable decompositions, we can speed up these simulations. This is made possible by using the ZX-calculus, which allows us to easily find instances of these entangled states in the simplified diagram representing the quantum circuit to be simulated. We additionally find a new technique of partial stabiliser decompositions that allow us to trade magic states for stabiliser terms. With this technique we require only $2^{αt}$ stabiliser terms, where $α\approx 0.396$, to simulate a circuit with T-count $t$. This matches the $α$ found by Qassim et al., but whereas they only get this scaling in the asymptotic limit, ours applies for a circuit of any size. Our method builds upon a recently proposed scheme for simulation combining stabiliser decompositions and optimisation strategies implemented in the software QuiZX. With our techniques we manage to reliably simulate 50-qubit 1400 T-count hidden shift circuits in a couple of minutes on a consumer laptop.

arXiv:2202.09202•Leibniz international proceedings in informatics•Jan 1, 2022•27 citations

Dynamic T-decomposition for classical simulation of quantum circuits

Wira Azmoon Ahmad, Matthew Sutcliffe

It is known that a quantum circuit may be simulated with classical hardware via stabilizer state (T-)decomposition in [Formula: see text] time, given t non-Clifford gates and a decomposition efficiency [Formula: see text]. The past years have seen a number of papers presenting new decompositions of lower [Formula: see text] to reduce this runtime and enable simulation of ever larger circuits. More recently, it has been demonstrated that well-placed applications of apparently weaker (higher [Formula: see text]) decompositions can in fact result in better overall efficiency when paired with the circuit simplification strategies of ZX-calculus. In this work, we take the most generalized T-decomposition (namely vertex cutting), which achieves a poor efficiency of [Formula: see text] and identify common structures to which applying this can, after simplification via ZX-calculus rewriting, yield very strong effective efficiencies [Formula: see text]. By taking into account this broader scope of the ZX-diagram and incorporating the simplification facilitated by the well-motivated cuts, we derive a handful of efficient T-decompositions whose applicabilities are relatively frequent. In benchmarking these new ‘dynamic’ decompositions against the existing alternatives, we observe a significant reduction in overall [Formula: see text] and hence overall runtime for classical simulation, particularly for certain common circuit classes.

arXiv:2412.17182•International Journal of Modern Physics C•Jun 13, 2025•1 citation
We apply the cutting stabiliser decomposition techniques [arXiv:2403.10964] to the quantum states generated from magic state cultivation [arXiv:2409.17595], post-selected upon all +1+1+1 measured values for simplicity. The resultant states to the d=3d=3d=3 and d=5d=5d=5 variant magic state cultivation circuits can be expressed as a sum of 444 and 888 Clifford ZX-digrams respectively. Modifications to existing ZX-calculus stabiliser decomposition methods may enable better simulation of non-Clifford circuits containing a moderate number of TTT gates in the context of quantum error correction.
Building upon Wan, Zhong (2025) \cite{wan2025cuttingstabiliserdecompositionsmagic} we present a few methods on how to simulate the non-Clifford d = 5 magic state cultivation circuits\cite{gidney2024magicstatecultivationgrowing} with a sum of ≈ 8 Clifford ZX-diagrams on average, at 0.1 % noise. Compared to a magic cat state stabiliser decomposition of all 53 non-Clifford spiders ( 6,377,292 terms required), this is more than 7 × 10 5 times reduction in the number of terms. Our stabiliser decomposition has the advantage of representing the final non-Clifford state (in light of circuit errors) as a sum of Clifford ZX-diagrams. This will be useful in simulating the escape stage of magic state cultivation, where one needs to port the resultant state of cultivation into a larger Clifford circuit with many more qubits. Still, it's necessary to only track ≈ 8 Clifford terms. Our result sheds light on the simulability of operationally relevant, high T -count quantum circuits with some internal structure.Finally, we provide numerical results for full non-Clifford stabiliser rank simulation based on t s i m along with optimisations using our cutting decompositions. Nearly 4 × 10 6 shots per second can be obtained on a laptop for the smaller d = 3 circuits at uniform circuit level noise p = 0.0005 , making it only ∼ 1.1 times slower than its (circuit-unspecific and un-optimised) fully Clifford proxy simulation via s t i m using S gates.
Magic states are a scarce resource for two-dimensional qubit stabilizer codes. Magic state cultivation was recently proposed to reduce the cost of magic state preparation by measuring the transversal Clifford operator of the color code. Cultivation achieves ∼10−9\sim 10^{-9}∼10−9 logical error rates for the d=5d=5d=5 color code, with substantially lower space-time overhead than magic state distillation. However, due to the O(d)\mathcal{O}(d)O(d) depth of the Clifford measurement circuit, magic state cultivation becomes impractical for d>5d>5d>5. Here, we perform logical XS†XS^\daggerXS† measurements on the color code by gauging a transversal Clifford gate, resulting in a constant-depth logical measurement circuit. We employ repeated gauging measurements with post-selection rather than performing error correction on the Clifford stabilizer code that emerges during the gauging protocol, thus gaining simplicity at the cost of scalability. Our protocol requires a regular square grid connectivity and yields logical error rates comparable to magic state cultivation. The d=7d=7d=7 version of our protocol gives access to the 10−1210^{-12}10−12 logical error rate regime at 0.05%0.05\%0.05% physical error rate while retaining more than 1%1\%1% of the shots after the equivalent of the cultivation stage.
Abstract We introduce an enhanced technique for strong classical simulation of quantum circuits which combines the ‘sum-of-stabilisers’ method with an automated simplification strategy based on the ZX-calculus. Recently it was shown that quantum circuits can be classically simulated by expressing the non-stabiliser gates in a circuit as magic state injections and decomposing them in chunks of 2–6 states at a time, obtaining sums of (efficiently-simulable) stabiliser states with many fewer terms than the naive approach. We adapt these techniques from the original setting of Clifford circuits with magic state injection to generic ZX-diagrams and show that, by interleaving this ‘chunked’ decomposition with a ZX-calculus-based simplification strategy, we can obtain stabiliser decompositions that are many orders of magnitude smaller than existing approaches. We illustrate this technique to perform exact norm calculations (and hence strong simulation) on the outputs of random 50- and 100-qubit Clifford + T circuits with up to 70 T-gates as well as a family of hidden shift circuits previously considered by Bravyi and Gosset with over 1000 T-gates.
We show that every intermediate state of a broad class of non-Clifford quantum error-correction circuits is a third-order phase-polynomial state, even under stochastic Pauli noise. The class includes magic state distillation and cultivation, code switching and gauge fixing, transversal non-Clifford gates with syndrome extraction, and injection of diagonal magic states. Third-order phase-polynomial states strictly generalize stabilizer states, and we prove that they are exactly the stabilizer states of the diagonal-Clifford-and-Pauli (DCP) stabilizer formalism that we introduce. We characterize these states and show that their representations can be updated in polynomial time. This yields an exact polynomial-time simulation algorithm for these circuits and, more broadly, a framework for reasoning about their internal states and about magic states in general. We provide an open-source implementation, \texttt{merlin}, and benchmark it against existing non-Clifford simulators on distillation, cultivation, and code switching circuits. The benchmarks demonstrate improved runtime and memory scaling as the number of logical outputs grows in Bravyi-Haah distillation, and simulation of a code switching circuit beyond the reach of all other tested simulators.
Recent developments in classical simulation of quantum circuits make use of clever decompositions of chunks of magic states into sums of efficiently simulable stabiliser states. We show here how, by considering certain non-stabiliser entangled states which have more favourable decompositions, we can speed up these simulations. This is made possible by using the ZX-calculus, which allows us to easily find instances of these entangled states in the simplified diagram representing the quantum circuit to be simulated. We additionally find a new technique of partial stabiliser decompositions that allow us to trade magic states for stabiliser terms. With this technique we require only 2αt2^{αt}2αt stabiliser terms, where α≈0.396α\approx 0.396α≈0.396, to simulate a circuit with T-count ttt. This matches the ααα found by Qassim et al., but whereas they only get this scaling in the asymptotic limit, ours applies for a circuit of any size. Our method builds upon a recently proposed scheme for simulation combining stabiliser decompositions and optimisation strategies implemented in the software QuiZX. With our techniques we manage to reliably simulate 50-qubit 1400 T-count hidden shift circuits in a couple of minutes on a consumer laptop.
It is known that a quantum circuit may be simulated with classical hardware via stabilizer state (T-)decomposition in [Formula: see text] time, given t non-Clifford gates and a decomposition efficiency [Formula: see text]. The past years have seen a number of papers presenting new decompositions of lower [Formula: see text] to reduce this runtime and enable simulation of ever larger circuits. More recently, it has been demonstrated that well-placed applications of apparently weaker (higher [Formula: see text]) decompositions can in fact result in better overall efficiency when paired with the circuit simplification strategies of ZX-calculus. In this work, we take the most generalized T-decomposition (namely vertex cutting), which achieves a poor efficiency of [Formula: see text] and identify common structures to which applying this can, after simplification via ZX-calculus rewriting, yield very strong effective efficiencies [Formula: see text]. By taking into account this broader scope of the ZX-diagram and incorporating the simplification facilitated by the well-motivated cuts, we derive a handful of efficient T-decompositions whose applicabilities are relatively frequent. In benchmarking these new ‘dynamic’ decompositions against the existing alternatives, we observe a significant reduction in overall [Formula: see text] and hence overall runtime for classical simulation, particularly for certain common circuit classes.