ZX-Diagram Optimization Techniques

• ZX-diagram optimizations are systematic transformations of graphical quantum representations that simplify circuit structures using algebraic and combinatorial techniques.
• These techniques employ local rewrite rules, metaheuristic search, and machine learning to reduce gate counts, qubit usage, and simulation complexity.
• The optimization methods enhance quantum circuit synthesis and simulation efficiency by leveraging graph-theoretic strategies and formal verification tools.

ZX-diagram optimization refers to the systematic transformation and simplification of ZX-diagrams—graphical representations of quantum processes—via local and global rewrite rules, metaheuristic search, and formal graph-theoretic reasoning. These optimizations target diverse objectives: reduction in two-qubit and non-Clifford gate counts, minimization of qubit width, reduction of contraction complexity in simulation, maximization of strong simulation efficiency, and algorithmic circuit synthesis subject to hardware or logical constraints. The ZX-calculus provides both the algebraic and combinatorial groundwork for these transformations, allowing quantum circuit structures to be manipulated at the level of their diagrammatic tensor networks. Recent work on arXiv demonstrates algorithmic, machine-learned, and graph-theoretic paths for realizing such optimizations across compilation, simulation, and architecture design.

1. Structural Principles and Rewrite Rules

ZX-diagrams encode quantum circuits as multigraphs with Z-spiders (green), X-spiders (red), phases, and Hadamard edges. The key rewrite rules include color-dual spider fusion, identity removal (phase-0 degree-2 spiders), Hadamard-mediated color change, π-commutation, bialgebraic rewrites, and local complementation/pivoting (Duncan et al., 2019, Kissinger et al., 2019, Stollenwerk et al., 2022, Holker, 2023). For parameterized circuits, linear combination rules enable diagrammatic expansion over non-Clifford gates, and causal cone reductions prune diagrams to relevant subgraphs (Stollenwerk et al., 2022).

Tables summarizing foundational ZX rewrite rules:

Rule Name	Diagrammatic Action	Algebraic Effect
Spider Fusion	Merge same-color spiders	Phase addition
Identity Removal	Remove degree-2, phase-0	Acts as identity
Local Complementation	Toggle edges among neighbors	Graph-state equivalence
Pivoting	complementation sequence	Pauli-pair elimination

Global rewrites such as local complementation and pivoting alter overall connectivity and enable the elimination, duplication, or redistribution of quantum gates—modulating extracted circuit size, depth, and parallelism (Duncan et al., 2019, Holker, 2023). Generalized neighbor unfusion splits spiders along arbitrary neighbor subsets, widening the search space for structural optimization (Holker, 2023).

2. Metaheuristics and Graph-Theoretic Search

Metaheuristic techniques such as simulated annealing and genetic algorithms leverage ZX congruences (non-simplification rewrites: local complementation, pivoting) to traverse the space of equivalent diagrams, focusing on the cost reduction of extracted circuits—typically defined as a weighted sum of two-qubit and single-qubit gates (Krueger, 2022). These approaches circumvent local-optimization traps intrinsic to greedy simplification and allow the discovery of minimized representations (e.g., circuits with ∼46% fewer two-qubit gates for n ≤ 14 qubits) (Krueger, 2022).

For quantum simulation, graph-theoretic approaches target contraction complexity (e.g., treewidth of the ZX diagram's line graph). Strategic pivots and graph-like unfusions routinely reduce the overall simulation FLOP count by 1–4 orders of magnitude for Sycamore-type circuits of depth 20 (Cam et al., 2023). This demonstrates the immense leverage of non-local diagram rewrites when paired with cost proxies and contraction order heuristics.

3. Machine Learning for Optimization Sequence Discovery

Recent innovations deploy reinforcement learning (RL), graph neural networks (GNNs), and tree search to discover effective sequences of ZX-diagram rewrites that minimize metrics such as CNOT count or spider count (Nägele et al., 2023, Mattick et al., 4 Apr 2025). The RL agent treats diagram rewriting as a Markov Decision Process, learning policies that generalize to diagrams ≈10× larger than seen during training, and outperforming hand-crafted heuristics, greedy, and simulated annealing methods for both circuit abstraction and tensor network contraction (Nägele et al., 2023, Mattick et al., 4 Apr 2025).

A typical RL+GNN optimization pipeline:

Stage	Input	Output	Action/Reward
State encoding	ZX-diagram graph	Feature matrix	Admissible rewrites
Policy inference	GNN	Action logits	Spider reduction
Environment	Diagram state	New diagram	Reward Δ(node count)

Empirically, RL agents achieve up to 38% further node reduction than simulated annealing on large diagrams, and inference wall-clock times 10× faster than traditional metaheuristics (Nägele et al., 2023).

4. Strong Simulation and T-Decomposition Optimization

The ZX-calculus provides a foundation for strong classical simulation of quantum circuits via stabilizer decompositions, particularly for Clifford+T circuits. Traditional fixed T-decomposition routines exhibit exponential scaling in T-count, with the number of stabilizer terms governed by $2^{\alpha t}$ ($\alpha \approx 0.47$, Bravyi-Smith-Smolin) (Sutcliffe et al., 2024). Recent work introduces a procedurally optimized cutting method: a vertex-weighting and greedy cutting heuristic yields maximal T-count reductions for minimal cut cost, systematically exposing hidden fusion possibilities. This achieves the most optimal cut set 71% of the time for small circuits and empirical reductions in $\alpha_{\rm eff}$ to $0.1 \lesssim \alpha \lesssim 0.2$ for larger, structured circuits (Sutcliffe et al., 2024).

A procedural cutting pipeline:

• Assign spider weights $W_v$ by their "blocking" potential for T-fusion.
• Iteratively cut spiders with highest $W_v$, update the diagram locally, and recompute weights.
• Fuse unlocked T-spiders post-cut via Clifford rules.
• Finish with standard T-gate decomposition if ≤2 T-spiders remain.

This enables simulation of circuits with twice as many T-gates as classical methods for equivalent runtime budget (Sutcliffe et al., 2024).

5. Partitioning, Pathwidth, and Qubit Optimization

Optimizing ZX-diagrams for resource usage extends beyond gate count to quantum memory (qubit) minimization. Partitioning techniques aim to divide diagrams into k sparsely-connected subdiagrams, admitting independent reduction and efficient cross-referencing. The "smarter k-partitioning" workflow integrates hypergraph partitioning, Boolean parameter cuts, and pairwise table aggregation, reducing computational resources exponentially in subproblem size rather than global size (Sutcliffe, 2024).

Separately, minimization of active qubits during circuit execution is governed by cutwidth and pathwidth of the ZX-diagram's signature graph. Algorithms employ feedback vertex set solving (NP-hard for Hadamard degadgetization) and greedy pathwidth minimization to achieve up to 65% reduction in qubit count (Vandaele, 2024). The methods apply directly in lattice surgery and Pauli Fusion contexts, directly connecting the diagrammatic structure to logical resource footprints.

Optimization	Graph-theoretic Problem	Result
Hadamard degadgetization	Directed FVS	NP-hard; FPT feasible
Qubit minimization	Fixed-end pathwidth	NP-hard; greedy O(V·E)
Modular circuit partition	KaHyPar hypergraph k-cut	O(k·2^{α t/k}) scaling

6. Advanced Algebraic Constructs and Model-Checking Platforms

Beyond classical graph rewriting, declarative languages such as LMNtal/QLMNtal support encoding quantified ZX rewrite rules (spider fusion, bialgebra, color change) with cardinality quantifiers and labels, including nondeterministic state exploration and linear temporal logic (LTL) model checking (Tei et al., 19 Nov 2025). This enables formal verification of rule sequences, exhaustive state space analysis, and interactive strategy testing well beyond the capabilities of high-throughput compilers like PyZX or proof assistants such as Quantomatic.

Case studies demonstrate handling hundreds of thousands of distinct diagrammatic states, systematic rule-token control, and model-checking of normal form reachability properties. These platforms facilitate laboratory-grade investigation of optimization heuristics and the debugging of rule completeness, confluent strategies, and proof tactics (Tei et al., 19 Nov 2025).

7. Specialized Optimizations: Triangles, Parameterized Circuits, and Hybrid Models

In simulation, the triangle generator (Δ or star-edge) introduced in ZX-diagrams for multi-controlled gate representation leads to dramatic reductions in stabilizer decomposition complexity. Specialized decompositions (D₁–D₆) lower the stabilizer rank exponent for triangles to β ≈ 0.774 per triangle vs the naive β ≈ 1.58 via 4 T-spiders, accelerating simulation by orders of magnitude and enabling single-shot exact evaluation of gradient variances in barren plateau analysis for QML ansätze (Koch et al., 2023).

Parameterized circuits benefit from ZX rewriting rules for diagrammatic linear combinations, causal cone pruning, and commutation, with direct translation of gate expansions (e.g., $e^{i\gamma Z}$ to cosine/sine-weighted diagrammatic sums). This facilitates symbolic simplification and analytic expectation formula generation with substantial reduction in diagram size and evaluation complexity (Stollenwerk et al., 2022).

Hybrid quantum-classical circuits employ the ZX-ground extension, adding special ground generators to model classical logic and discard operations. Optimization rules preserve focused gFlow (for extractability), and Gaussian-elimination–guided rewriting prunes classical segments before circuit extraction, followed by label-propagation for classical gate detection (Borgna et al., 2021).

8. Empirical Impact and Limitations

Across benchmarks, ZX-diagram optimization achieves notable empirically validated results:

• Two-qubit gate reductions of 19.8% on benchmark suite circuits, surpassing prior ZX and non-ZX strategies (Holker, 2023).
• T-count improvements (up to 50% reduction vs prior methods) in ancilla-free regimes (Kissinger et al., 2019).
• Qubit count reductions up to 65% via pathwidth-based rewriting (Vandaele, 2024).
• Simulation speedups up to 4 200× on deep Sycamore circuits (Cam et al., 2023).
• Pareto-optimal trade-offs in quantum architecture search for depth, CNOT count, and accuracy, consistently dominating gate-level genetic programming (Ewen et al., 2024).

Limitations include NP-hardness of certain graph decompositions, extraction overhead during metaheuristic search, rule-set incompleteness for some non-standard circuit motifs, and scalability to very large or shallow circuits (search-space growth). Hybrid approaches integrating RL-guided search, formal verification, and partition-aware rewriting offer promising avenues for future progress.

• Graph-rewriting via LMNtal: (Tei et al., 19 Nov 2025)
• ML-driven ZX-optimization: (Nägele et al., 2023, Mattick et al., 4 Apr 2025)
• Procedural T-cutting: (Sutcliffe et al., 2024)
• Partitioning and pathwidth: (Sutcliffe, 2024, Vandaele, 2024)
• Non-simplification metaheuristics: (Krueger, 2022)
• Graph-theoretic simplification: (Duncan et al., 2019)
• Hybrid ZX-ground optimization: (Borgna et al., 2021)
• Parameterized-circuit rules: (Stollenwerk et al., 2022)
• Triangle generator decompositions: (Koch et al., 2023)
• Simulation speedup via graph-like form: (Cam et al., 2023)
• Reinforcement learning for circuit minimization: (Mattick et al., 4 Apr 2025)
• T-count reduction, phase teleportation: (Kissinger et al., 2019)
• Causal flow preserving optimization: (Holker, 2023)
• Architecture search with ZX-mutations: (Ewen et al., 2024)

ZX-diagram optimization is a rapidly developing field exploiting the intersection of algebraic, combinatorial, and computational models to deliver scalable, effective reductions in key quantum resource metrics. The arXiv corpus demonstrates a wide range of algorithmic, machine-learned, and declarative methods that continue to extend the power and flexibility of the ZX-calculus in quantum science and engineering.