GadIR: A Spatial-Topology Preserving Compiler for Quantum Many-Body Systems Simulation

AI summary

Overview

• Research area: Quantum compiler design and quantum architecture, specifically compilation of quantum many-body simulation workloads onto real quantum hardware. Published at the 58th IEEE/ACM International Symposium on Microarchitecture (MICRO), Athens, Greece, 2026 (arXiv:2609.01771v1 [quant-ph]).
• Technical level: Advanced. The paper builds on ZX-calculus, Pauli gadgets, Suzuki-Trotter decomposition and hardware-specific synthesis, so it assumes comfort with quantum circuit models and compiler pipelines. The explanation below translates the core ideas into plain language.
• Scope, in one sentence: The paper introduces GadIR, a Pauli-gadget-based intermediate representation that keeps the spatial topology of a physical many-body model intact through compilation, and shows it reduces dominant compilation overheads across superconducting, neutral-atom, photonic MBQC and fault-tolerant architectures.

What This Paper Is About

Simulating quantum many-body systems starts from a Hamiltonian that describes particles arranged on a lattice and interacting only with their neighbors, and a compiler must turn that Hamiltonian into native instructions for a specific quantum machine. Existing compilers (Paulihedral, 2QAN, Tetris, QuCLEAR) represent the Hamiltonian as a flat list of Pauli strings, which discards the lattice geometry of the original physical model, and their optimizations are largely tuned to superconducting hardware. GadIR's goal is to keep that lost geometric information alive throughout the compilation pipeline and to perform optimization steps that are independent of any one hardware technology.

Key Contributions

1. A topology-preserving intermediate representation. GadIR represents Hamiltonian terms as Pauli gadgets (a special graph structure inside a ZX-diagram) anchored on a graph that mirrors the original physical model's lattice, rather than flattening them into a linear sequence of Pauli strings. The authors state this is, to their knowledge, the first quantum compiler that preserves Hamiltonian topology.
2. Pauli gadget group reduction in the frontend. Instead of cancelling gates pairwise between two Pauli strings, the frontend eliminates patterns across a large set of gadgets simultaneously, which the authors argue extends the available optimization space compared with gate cancellation and Clifford extraction.
3. Hardware-independent backend with topology-guided synthesis. Trotterization and scheduling are performed directly on GadIR in ZX-diagram form, reducing circuit depth without hardware assumptions; the preserved topology then guides qubit initial placement when synthesizing hardware-native programs, with hardware-specific optimizations applied at the synthesis stage.
4. Broad evaluation across models and architectures. The compiler is evaluated on all canonical many-body model classes (spin, bosonic, fermionic, lattice-gauge) and on four architecture families, reporting lower overhead than the state-of-the-art QuCLEAR.

Main Findings

• Reduction versus QuCLEAR on superconducting hardware: GadIR reduces the two-qubit gate count to 0.56× that of QuCLEAR on average.
• Reduction versus QuCLEAR on neutral-atom hardware: infidelity is reduced to 0.87× of QuCLEAR on average, on a zoned neutral-atom architecture.
• Reduction versus QuCLEAR in the fault-tolerant regime: the number of non-Clifford operations is reduced to 0.85× of QuCLEAR on average, under a lattice-surgery scheme.
• Reduction versus QuCLEAR on photonic MBQC: the number of emitter entanglements is reduced to 0.75× of QuCLEAR on average, for measurement-based quantum computation on silicon quantum dots.
• Coverage of model classes: benchmarks span spin, bosonic, fermionic and lattice-gauge models, which the authors describe as all canonical many-body models.
• Coverage of hardware targets: evaluations use superconducting devices from IBM and Google, zoned-architecture neutral atoms, photonic MBQC, and FTQC with lattice surgery.
• Topology survives encoding: the paper illustrates that a 2×3 bosonic lattice model, under bosonic linear encoding, maps to a 2×3×2 lattice of qubits, and this induced structure is what GadIR retains.
• Beyond many-body simulation: results indicate the compiler also performs well on other quantum simulation problems such as quantum chemistry, and it is described as orthogonal to particle-to-qubit encoding techniques such as Fermihedral and HATT.

Methodology in Plain English

The pipeline follows the physical model from lattice to hardware instruction:

1. Start from the physical model. Particles sit on lattice sites and interact with neighbors, giving a Hamiltonian whose structure is inherently geometric.
2. Encode particles to qubits. Fermionic or bosonic operators are mapped to qubit operators using encodings such as Jordan-Wigner, Bravyi-Kitaev, Fermihedral or HATT. Crucially, the geometry is not destroyed by this step — it is remapped (for example, a Fenwick tree for Bravyi-Kitaev, or a lattice with one extra dimension for bosonic linear encoding).
3. Represent terms as Pauli gadgets on a graph. Each Hamiltonian term becomes a Pauli gadget, a compact ZX-diagram pattern of Z- and X-spiders that encodes a multi-qubit Pauli exponential. Gadgets are hung on a graph whose shape matches the encoded model, so spatial position is preserved rather than erased.
4. Reduce groups of gadgets (frontend). The compiler finds and eliminates reducible patterns across many gadgets at once, shrinking the Hamiltonian before any hardware details enter the picture.
5. Trotterize and schedule (backend). The time-evolution operator is approximated with a second-order Suzuki-Trotter product over r steps, applied directly in diagram form, and gadgets are scheduled to shorten circuit depth — all without committing to a hardware target.
6. Synthesize with topology-aware placement. Gadgets are lowered to native operations for the chosen architecture, and the retained lattice structure tells the compiler where to place qubits initially, which is where hardware-specific optimizations are applied.

The paper's framing contrasts this with prior flows that produce a flattened Pauli-string representation, optimize only circuit-level metrics, and generate a gate-based logical circuit tailored to superconducting devices.

Why This Matters

Compilation overhead is the practical bottleneck between a physically meaningful Hamiltonian and something a quantum machine can actually execute. By keeping model geometry in the IR, GadIR opens optimization opportunities that string-based representations simply cannot see, and by keeping the middle of the pipeline hardware-agnostic, one representation can serve superconducting, neutral-atom, photonic and fault-tolerant targets. This matters increasingly as architectures diversify beyond superconducting qubits.

Real-world applications:

• Condensed matter and materials modeling: spin and fermionic lattice models such as Hubbard-type systems, where the lattice geometry is the physics.
• Quantum chemistry: the authors report the compiler also works on chemistry simulation workloads outside many-body lattice models.
• Lattice gauge theory and high-energy physics: the lattice-gauge benchmark class targets simulation of gauge fields on a lattice.
• Cross-platform quantum software toolchains: a single hardware-agnostic IR that can be retargeted to neutral atoms, photonic MBQC or lattice-surgery FTQC.

Industry relevance: compiler infrastructure of this kind is directly relevant to quantum hardware vendors and cloud providers who need to map simulation workloads onto heterogeneous backends, and to toolchain developers who currently maintain separate, hardware-specific optimization passes.

Future Directions

• Generalizing topology extraction. GadIR relies on the Hamiltonian having an identifiable spatial structure; how it handles models whose encoded qubit Hamiltonian has no clean lattice-like geometry is not addressed in the paper content.
• Deeper integration with encoding methods. Since the compiler is described as orthogonal to Fermihedral and HATT, combining topology-preserving compilation with encoding-level co-optimization is a natural next step.
• Scaling and workload breadth. The excerpt reports averages over canonical model classes but not individual benchmark sizes or per-model results; extending evaluation to larger and more application-specific Hamiltonians would test generality.
• Noise-aware and architecture-specific tuning. The backend currently keeps scheduling hardware-independent and applies hardware specifics only at synthesis; folding device noise characteristics and connectivity constraints earlier into the topology-aware passes is an open opportunity.

Target Audience

Quantum compiler and quantum architecture researchers will get the most from this paper, particularly those working on intermediate representations, ZX-calculus-based optimization, and hardware mapping. It is also valuable for graduate students in quantum information who want a concrete example of how physical-model structure can be exploited in compilation, and for practitioners building simulation workloads who need to target multiple hardware backends. Readers without background in ZX-diagrams or Trotterization will need to consult the background section, since the contribution is defined in those terms.

Authors’ abstract

Simulating quantum many-body systems has been one of the most important applications of quantum computation. For simulation, the Hamiltonian of a physical system is compiled into quantum programs with native instructions for quantum hardware. In previous works, the Hamiltonian is represented as Pauli strings, then compiled and optimized based on the quantum circuit model. Such representation paradigm neglects the spatial topology of original physical models, which is vital information to reducing the overhead of compiling many-body systems Hamiltonians. To address such neglect, we introduce a spatial-topology preserving compiler for quantum many-body simulation. Using Pauli gadgets as the representations of the Hamiltonian, we introduce our intermediate representation -- GadIR, to preserve the spatial-topology information of original physical models. Our compiler frontend performs the group reduction algorithm based on Pauli gadget model, which is a hardware-independent optimization. Our compiler backend performs trotterization and scheduling on Pauli gadgets, then synthesizes the Pauli gadgets into hardware-native quantum programs. We evaluate our compiler on all the canonical quantum many-body system models, while achieving a significant reduction on compilation overhead regarding four major quantum architectures. Overall, our spatial-topology preserving IR exploits the compilation optimization space for quantum many-body systems Hamiltonian.