ZX-Calculus Cutting Stabiliser Decomposition

• Cutting stabiliser decomposition is a ZX-calculus method that exactly breaks non-Clifford quantum circuits into sums of stabiliser diagrams to lower simulation costs.
• It strategically cuts favorable non-stabiliser subdiagrams and interleaves each branch with aggressive ZX simplification to unlock T-count reductions.
• The method has been successfully applied to Clifford+T, hidden-shift, and magic-state circuits, achieving orders-of-magnitude reductions in stabiliser term counts.

Cutting stabiliser decomposition is a ZX-calculus-based method for exact classical simulation of non-Clifford quantum circuits in which one identifies small, favorable non-stabiliser subdiagrams, “cuts” them into a sum of simpler diagrams, and interleaves each cut with graphical simplification of the whole diagram. In the quantum-circuit literature, the method is used to reduce the number of stabiliser terms required to simulate Clifford+T circuits, hidden-shift circuits, and postselected magic-state-generation circuits, with the central objective of lowering the total term count $R$ or $K$ that governs strong-simulation cost (Kissinger et al., 2022, Kissinger et al., 2021). Later work generalized the approach to procedurally optimized vertex cuts and “dynamic” T-decompositions that exploit frequent ZX-diagram motifs, and applied it to magic state cultivation circuits where the final states were expressed as sums of $4$ and $8$ Clifford ZX-diagrams for the $d=3$ and $d=5$ variants respectively (Sutcliffe et al., 2024, Ahmad et al., 2024, Wan et al., 1 Sep 2025).

1. Formal basis and simulation objective

A stabiliser decomposition of a pure $n$-qubit state is an expansion

$$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$

where each $|\phi_i\rangle$ is a stabiliser state and $\alpha_i\in\mathbb{C}$; the stabiliser rank is the minimal $K$0 over all such decompositions (Kissinger et al., 2021). In the equivalent notation used in later work,

$K$1

with $K$2 the number of stabiliser terms and $K$3 the minimal such number (Kissinger et al., 2022).

The operational motivation is strong simulation. Because stabiliser states, Clifford circuits, and stabiliser measurements are simulable in polynomial time by Gottesman–Knill, a state written as a finite linear combination of stabiliser states can also be simulated provided the number of terms is not too large (Kissinger et al., 2021). For exact probabilities, one route is to compute

$K$4

with total cost $K$5, so $K$6 is the dominant complexity driver (Kissinger et al., 2021). In the cost model emphasized in the graphical literature, each stabiliser term costs $K$7 to simulate, giving overall cost roughly $K$8 (Kissinger et al., 2022).

The standard non-Clifford resource is the $K$9 gate,

$4$0

or its associated magic state

$4$1

equivalently denoted $4$2 in the 2021 treatment of magic-state injection (Kissinger et al., 2022, Kissinger et al., 2021). Naively,

$4$3

which yields $4$4 stabiliser terms and is generally impractical for strong simulation (Kissinger et al., 2022).

To compare decompositions, the literature uses an exponential rate $4$5. If a block reduction removes $4$6 non-Clifford spiders using $4$7 stabiliser terms, then

$4$8

(Kissinger et al., 2022). Equivalently, if a decomposition of a circuit with $4$9 non-Clifford spiders yields $8$0 Clifford terms, then

$8$1

(Ahmad et al., 2024). Lower $8$2 means fewer terms asymptotically.

A related quantity appears in Monte Carlo-style simulation. For

$8$3

the sum of magnitudes $8$4 governs sampling complexity: larger $8$5 implies larger variance and runtime (Wan et al., 1 Sep 2025). Cutting stabiliser decomposition is therefore relevant both to exact strong simulation and to sampling-based estimators.

2. ZX-calculus representation and the meaning of a cut

The method is formulated in the ZX-calculus, where circuits are represented as diagrams built from Z-spiders, X-spiders, Hadamards, and wires (Kissinger et al., 2022). Clifford+T circuits are translated into ZX-diagrams, reduced to graph-like form, and simplified by spider fusion, colour change, bialgebra/Hopf laws, local complementation, pivoting, and phase-gadget transformations (Kissinger et al., 2021). In reduced graph-like form, all spiders are Z-spiders connected by Hadamard edges, and simplification removes easy Clifford structure while exposing phase gadgets and other motifs (Kissinger et al., 2022, Kissinger et al., 2021).

In this setting, “cutting” means replacing a chosen spider or vertex by a small exact sum. A basic spider-cut identity is

$8$6

where

$8$7

(Sutcliffe et al., 2024). Each cut doubles the number of terms, so applying it indiscriminately to every $8$8-spider produces $8$9 terms and $d=3$0 (Sutcliffe et al., 2024, Ahmad et al., 2024).

The point of the method is not the local cut by itself, but the simplification it unlocks. A strategically placed cut can separate neighborhoods, align target sets of phase gadgets, and allow $d=3$1 phases to fuse into Clifford phases or cancel outright (Kissinger et al., 2021, Ahmad et al., 2024). In the general vertex-cut formalism,

$d=3$2

and inserting this identity at a vertex splits the diagram into branches that are then reduced independently (Ahmad et al., 2024). The 2024 dynamic-decomposition paper makes this explicit by distinguishing the local efficiency of the decomposition from the post-simplification effective efficiency $d=3$3, with

$d=3$4

(Ahmad et al., 2024).

Several ZX substructures are especially important. A phase gadget is a central Z-spider of phase $d=3$5 connected by Hadamard edges to $d=3$6 neighbours; in reduced form, an $d=3$7-legged phase gadget corresponds to a cat state

$d=3$8

(Kissinger et al., 2022). Cat gadgets, pairs of overlapping phase gadgets, and “lone phase” hubs became standard cutting targets precisely because ZX simplification can turn their post-cut branches into Clifford diagrams or diagrams with very small residual T-count (Kissinger et al., 2022, Ahmad et al., 2024).

3. Major decomposition families

The development of cutting stabiliser decomposition proceeded by enlarging the class of admissible cuts while retaining exactness.

The 2021 reduced-stabiliser-decomposition method combined chunked magic-state decompositions with eager ZX simplification. It began from product decompositions such as the pairwise identity

$d=3$9

and from the Bravyi–Smith–Smolin $d=5$0-to-$d=5$1 decomposition for six magic states, giving $d=5$2 with $d=5$3 (Kissinger et al., 2021). The core advance was to interleave each chunk decomposition with ZX simplification so that the effective non-Clifford count $d=5$4 could be much smaller than the raw $d=5$5-count $d=5$6 (Kissinger et al., 2021).

The 2022 partial-and-graphical method made the cut itself structural. Instead of decomposing only $d=5$7 blocks, it cut favorable entangled subdiagrams detected in the ZX diagram. This included cat-state cuts and a partial $d=5$8-to-$d=5$9 reduction on a $n$0-qubit magic pack, which removes $n$1 $n$2-spiders at the cost of $n$3 stabiliser terms and therefore achieves

$n$4

for any circuit with $n$5 (Kissinger et al., 2022). The same paper gave best-structural-case rates of $n$6 for $n$7, $n$8 for $n$9, $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$0 for $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$1, and $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$2 for $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$3 (Kissinger et al., 2022).

The 2024 procedural-optimization work reframed the problem as choosing an optimal pattern of vertex cuts in a ZX-diagram to maximize T-count reduction at the cost of the fewest cuts (Sutcliffe et al., 2024). It assigned weights to vertices according to how many T-like gates they were blocking from fusing or cancelling, propagated those weights through higher tiers of blockers, and then cut the highest-weight candidates first (Sutcliffe et al., 2024). For circuits small enough to verify, this heuristic found the most optimal set of cuts possible $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$4 of the time (Sutcliffe et al., 2024).

The 2024 dynamic T-decomposition work then showed that even the most generalized T-decomposition, namely vertex cutting with baseline $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$5, can yield very strong $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$6 once paired with ZX simplification on appropriate motifs (Ahmad et al., 2024). It identified four dynamic motif families with efficiencies

$$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$7

for lone phase, multi-cat3, pair, and pair-phase decompositions respectively (Ahmad et al., 2024).

Family	Block or motif	Rate
Bravyi–Smith–Smolin chunking	$$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$8 magic states $$|\psi\rangle \;=\; \sum_{i=1}^{K} \alpha_i\,|\phi_i\rangle,$$9 terms	$|\phi_i\rangle$0
Partial reduction	$|\phi_i\rangle$1-to-$|\phi_i\rangle$2	$|\phi_i\rangle$3
Cat-state cut	$|\phi_i\rangle$4	$|\phi_i\rangle$5
Cat-state cut	$|\phi_i\rangle$6	$|\phi_i\rangle$7
Dynamic lone-phase motif	$|\phi_i\rangle$8 terms eliminate $|\phi_i\rangle$9 T-spiders	$\alpha_i\in\mathbb{C}$0

These families are exact rather than approximate. Their common logic is that one spends a small number of branches to unlock many ZX-calculus cancellations in each branch.

4. Algorithmic workflow and heuristics

The basic interleaved workflow is stable across the literature. A Clifford+T circuit $\alpha_i\in\mathbb{C}$1, together with chosen inputs and outputs or postselection effects, is first translated to a ZX-diagram; the diagram is then converted to graph-like form and simplified; a chunk, gadget, or vertex is selected; the selected region is decomposed into a small stabiliser sum; and each child diagram is immediately simplified before further cuts are chosen (Kissinger et al., 2021, Kissinger et al., 2022).

In the 2021 strong-simulation pipeline, the steps are: translate $\alpha_i\in\mathbb{C}$2 to a ZX-diagram, simplify to graph-like form, identify a chunk of $\alpha_i\in\mathbb{C}$3–$\alpha_i\in\mathbb{C}$4 non-Clifford spiders, unfuse a $\alpha_i\in\mathbb{C}$5 component on each selected spider, apply a chunked stabiliser decomposition such as the $\alpha_i\in\mathbb{C}$6-to-$\alpha_i\in\mathbb{C}$7 Bravyi–Smith–Smolin identity, re-simplify each child, and iterate until no non-Clifford spiders remain (Kissinger et al., 2021). The same paper emphasized that eager simplification improves the dominant term from $\alpha_i\in\mathbb{C}$8 to $\alpha_i\in\mathbb{C}$9 in amplitude computation, with an initial $K$00 graph-like simplification cost where $K$01 is the gate count (Kissinger et al., 2021).

In the cat-based 2022 method, the reduction loop scans internal Clifford spiders of phase $K$02 or $K$03 and arity $K$04, treating the corresponding star-shaped neighborhoods as cat gadgets when possible (Kissinger et al., 2022). The prescribed preference order is arity $K$05, then $K$06, then $K$07, then $K$08, matching the available $K$09 values $K$10, $K$11, $K$12, and $K$13 (Kissinger et al., 2022). If no cat gadget exists, the fallback is the partial $K$14-to-$K$15 reduction on a pack of $K$16 T-spiders (Kissinger et al., 2022).

The procedural-optimization heuristic of 2024 made cut selection explicit. Initial weights $K$17 are assigned to blocking CNOT endpoints by distributing $K$18 over the $K$19 blockers on minimal paths between T-like spiders that could fuse if those blockers were removed (Sutcliffe et al., 2024). Weights are then propagated across tiers using

$K$20

and a candidate vertex is cut only when its score suggests that the cut is likely to unlock at least two T cancellations across the two branches (Sutcliffe et al., 2024).

The dynamic-decomposition variant can be read as a higher-level policy layer on top of this interleaving. It first checks whether a standard cat-state or magic-$K$21 decomposition is best, then searches for dynamic motifs whose estimated $K$22 beats the best available static alternative, applies the relevant cut, and runs a full ZX rewrite pass before the next decision (Ahmad et al., 2024). This implies a simulator architecture in which motif detection, branch-local simplification, and adaptive cut selection are coupled rather than separated.

QuiZX is the principal implementation framework named in this literature, providing circuit-to-ZX translation and the reduction strategy used in the 2022 partial-and-graphical work (Kissinger et al., 2022). The 2025 cultivation study states that the input circuit is converted to a ZX-diagram “e.g., with PyZX,” then simplified and cut procedurally (Wan et al., 1 Sep 2025).

5. Empirical performance and applications

The 2021 reduced-stabiliser-decomposition paper reported exact norm calculations and strong simulation on random $K$23- and $K$24-qubit Clifford+T circuits with up to $K$25 T-gates and on hidden-shift circuits with over $K$26 T-gates (Kissinger et al., 2021). For random exponentiated-Pauli circuits under a $K$27-minute timeout on a $K$28-core Xeon, the success rates were $K$29 up to $K$30, $K$31 at $K$32, $K$33 at $K$34, and $K$35 above for $K$36 qubits; and $K$37 up to $K$38 with all but one failed at $K$39, $K$40 at $K$41, and $K$42 at $K$43 for $K$44 qubits (Kissinger et al., 2021). For $K$45 qubits and $K$46, naive strong simulation on doubled circuits required roughly $K$47 terms, whereas ZX-interleaved decomposition produced on average $K$48 terms, a $K$49-order reduction; at higher T-counts, the reduction reached up to $K$50 orders of magnitude (Kissinger et al., 2021).

The 2022 cat-state paper reported that the new partial-and-graphical method could reliably simulate $K$51-qubit $K$52 T-count hidden shift circuits in a couple of minutes on a consumer laptop (Kissinger et al., 2022). More specifically, $K$53 of random hidden-shift instances completed within $K$54 minutes on an Intel Core i5-10400H, $K$55 GHz, and the remaining $K$56 finished within $K$57 minutes (Kissinger et al., 2022). On hidden-shift circuits with $K$58 qubits and T-count $K$59, the variance of runtimes on a log scale dropped from approximately $K$60 for the previous method to approximately $K$61 for the cat-based method (Kissinger et al., 2022). On random $K$62-qubit Clifford+T circuits up to $K$63, average runtimes were about an order of magnitude better with cat-based cutting (Kissinger et al., 2022).

The 2024 procedural-optimization paper focused on pseudo-structured circuits produced from CNOTs, phase gates, and Toffolis. It reported “consistent improvements of orders of magnitude,” with effective efficiency $K$64, and stated that there is no upper bound for the efficiency achieved by the method, allowing in principle $K$65 for highly structured circuits (Sutcliffe et al., 2024).

The 2025 cultivation application demonstrated the relevance of cutting beyond generic circuit benchmarks. For the $K$66 magic state cultivation variant, the initial circuit has T-count $K$67; after two cuts and ZX simplification, each branch has a single $K$68 or $K$69 spider, and the final expansion yields a $K$70-term stabiliser decomposition (Wan et al., 1 Sep 2025). For the $K$71 variant, the initial circuit has T-count $K$72; reusing the $K$73 decomposition inside the larger circuit and applying further cuts yields an $K$74-term stabiliser decomposition (Wan et al., 1 Sep 2025). In both cases, the paper attributes the reduction to cut placement aligned with the postselected measurement structure.

6. Limits, related methods, and terminological scope

The method is exact. The cuts are exact stabiliser decompositions, not sampling approximations, and the 2021 framework notes exact amplitudes and marginals with exact numbers in $K$75; probabilities take the form

$K$76

(Kissinger et al., 2021). This distinguishes cutting stabiliser decomposition from quasiprobability sampling, Monte Carlo stabiliser-extent methods, and other approximate techniques whose costs depend on negativity or on the number of samples required for a target error (Kissinger et al., 2021, Wan et al., 1 Sep 2025).

A common misconception is that the method amounts to decomposing every $K$77 gate independently. In the ZX-based literature, the opposite is emphasized: one cuts only those vertices, spiders, or subdiagrams whose removal is expected to trigger substantial fusion, cancellation, gadget merging, or elimination of Clifford substructure (Kissinger et al., 2022, Sutcliffe et al., 2024). Another misconception is that the best available asymptotic $K$78 always dominates practical performance. The dynamic-decomposition results were introduced precisely to show that apparently weaker local decompositions can yield better overall efficiency once post-cut ZX simplification is taken into account (Ahmad et al., 2024).

The main limitation is that exponential dependence remains. The 2021 paper states that worst-case circuits with dense, “incompressible” non-Clifford interactions still scale poorly, and the 2022 paper gives $K$79 as the worst-case guarantee when one repeatedly applies the partial $K$80-to-$K$81 cut in diagrams with few or no usable cat gadgets (Kissinger et al., 2021, Kissinger et al., 2022). The best gains occur when ZX reduction exposes phase gadgets, especially arity $K$82 or $K$83, when repeated neighborhoods permit gadget merging, or when doubled diagrams create cancellations between $K$84 and $K$85 (Kissinger et al., 2021, Kissinger et al., 2022).

The method sits alongside several other classical-simulation paradigms. The literature contrasts it with quasiprobability sampling, tensor-network contraction, and path-sum or ZH-calculus methods (Kissinger et al., 2021). Tensor networks can excel on low-depth or low-connectivity circuits, but exact contraction can remain exponential and may perform poorly on global highly entangling circuits (Kissinger et al., 2021). Path-sum and ZH-calculus methods are described as powerful for Toffoli- or CCZ-heavy circuits, though hyperedge growth can be problematic if not carefully managed (Kissinger et al., 2021). Cutting stabiliser decomposition is therefore best understood as a structure-sensitive exact alternative rather than a universal replacement.

The phrase also has a distinct terminological scope outside this quantum-simulation setting. In an unrelated optimisation paper, “Cutting Stabiliser Decomposition” is used for a stabilised cutting-plane scheme based on Benders decomposition with adaptive oracles for multi-horizon stochastic programming in power-system investment planning (Zhang et al., 2022). In adjacent quantum-error-correction work, “cutting” refers instead to distance-preserving rewrites that decompose high-weight stabiliser measurements into single- and two-qubit operations while preserving distance and logical count (Rodatz et al., 2024). Within quantum-circuit simulation, however, the term denotes the ZX-calculus program of targeted cuts plus aggressive graphical simplification to minimise stabiliser-term growth.