⚛️ quantum physics

Logarithmic depth compression of Heisenberg Hamiltonian simulation by fan-out parallelization, with built-in error detection

This paper introduces a fan-out-based gadget compiler that trades circuit width for logarithmic depth in Heisenberg Hamiltonian simulations, enabling parallel execution and built-in error detection that significantly reduces circuit depth and volume for high-degree interaction graphs on both superconducting and trapped-ion architectures, particularly when post-selection is applied.

Original authors: Artemiy Burov, Clément Javerzac

Published 2026-08-21

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Artemiy Burov, Clément Javerzac

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the quest to understand the invisible world of atoms and molecules, scientists have long relied on a technique called nuclear magnetic resonance, or NMR. By placing a sample in a magnetic field and listening to the radio signals emitted by its atomic nuclei, researchers can map out the structure of complex chemicals, from the proteins in our bodies to the materials in our phones. For decades, this has been done with classical computers, which simulate the behavior of these atoms by crunching numbers. However, as molecules grow larger and more intricate, the calculations become so vast that even the most powerful supercomputers struggle to keep up. This is where quantum computers enter the story. Unlike classical machines that process information in a linear fashion, quantum computers use the strange laws of physics to explore many possibilities at once, offering a potential shortcut for simulating nature. Yet, these machines are currently in a fragile, early stage of development. They are noisy, meaning their calculations are easily corrupted by tiny errors, and they are limited in how many steps they can take before the information fades away. The central challenge for scientists today is not just building these machines, but figuring out how to run complex simulations on them before the noise destroys the answer.

A team of researchers has now found a clever way to reshape these simulations to fit the limitations of today's quantum hardware. They focused on a specific type of calculation used to model the interactions between spins, the tiny magnetic properties of atomic nuclei. Traditionally, simulating these interactions requires a very deep, narrow circuit—a long sequence of steps performed one after another. On current quantum devices, which are prone to errors the longer they run, this depth is a fatal flaw. The researchers proposed a different approach: instead of making the circuit deeper, they made it wider. By using a technique called fan-out parallelization, they took a single logical spin and spread its information across a small group of physical qubits, or quantum bits. This allowed them to perform many interactions simultaneously rather than sequentially. The result is a circuit that is much shorter in time but requires more qubits to run. It is a trade-off, trading the scarcity of time for the relative abundance of available qubits.

The researchers tested this method on a molecule called tetramethylsilane, which consists of a central silicon atom surrounded by twelve hydrogen atoms. This specific arrangement creates a "star" shape in the interaction graph, where one central point connects to many others, a geometry that is particularly difficult to simulate efficiently. They compared their new, wider circuit against the traditional, deep one. In simulations based on the actual performance of a real quantum processor, the new method proved its worth. While the traditional circuit was twice as deep, the new circuit was significantly shallower. More importantly, the new method included a built-in safety mechanism. Because the information was spread across multiple qubits, the system could detect when an error occurred. If a mistake happened during the calculation, the extra qubits would reveal it, allowing the researchers to discard that specific run and keep only the clean data. This process, known as post-selection, acted like a filter, removing the noise that usually ruins these delicate experiments.

The findings suggest that this approach could be a practical bridge to useful quantum computing. In their simulations, the new method only outperformed the old one once the error rates of the hardware improved slightly, roughly by a factor of ten to fifteen. At the current level of noise found in today's machines, neither method could recover a clear signal. However, as hardware continues to improve, the shallower, wider circuits are expected to deliver accurate results sooner than their deeper counterparts. The study also highlighted that this advantage is not universal; it works best for molecules with uneven structures, like the star-shaped example, where one atom interacts with many others. For molecules where every atom interacts with every other atom in a uniform way, the benefits disappear, and the traditional method remains just as effective.

This work does not claim to have solved the problem of quantum simulation, but it offers a concrete strategy for navigating the noisy era of quantum computing. By rethinking how information is laid out on the chip, the researchers showed that it is possible to reduce the time a calculation takes, thereby reducing the chance of error. The built-in error detection adds a layer of reliability without requiring extra, complex steps in the algorithm. The study serves as a proof of concept, demonstrating that with the right compilation strategy, current and near-future quantum devices can begin to tackle problems that are currently out of reach for classical computers. The path forward involves refining these techniques for different types of molecules and waiting for hardware to catch up, but the direction is clear: making circuits wider and shallower is a viable path to unlocking the potential of quantum simulation.

Technical Summary: Logarithmic Depth Compression of Heisenberg Hamiltonian Simulation by Fan-out Parallelization

Problem Statement
Noisy intermediate-scale quantum (NISQ) computers are currently constrained by circuit depth, yet many Hamiltonian simulation methods, particularly product-formula simulations of spin systems (e.g., Nuclear Magnetic Resonance or NMR), generate circuits that are "narrow and deep." These deep circuits exceed the coherence times of current hardware, leading to significant errors. While current architectures (superconducting and trapped-ion) favor "wide and shallow" circuits, standard simulation approaches do not naturally align with these constraints. Previous work has addressed this by executing deep sequential circuits with error suppression; this paper proposes a complementary approach: reshaping the circuits themselves to trade circuit depth for circuit width.

Methodology
The authors introduce a "fan-out gadget compiler" designed for Heisenberg-type NMR Hamiltonians. The core mechanism involves encoding each logical spin into a small repetition-code register, the size of which is determined by the spin's interaction degree ( $d_k$ ) in the interaction graph.

Fan-out Parallelization: Instead of executing pairwise interactions sequentially, the compiler uses a binary CNOT tree to copy the state of a logical spin (the "root") onto $n_k$ physical qubits (ancillas). This allows all pairwise interactions of a given Pauli type (XX, YY, or ZZ) involving that spin to execute in parallel.
Logarithmic Depth Scaling: The depth of the fan-out tree scales logarithmically with the number of parallelized interactions. Consequently, the depth of an interaction block scales as $O(\log \Delta)$ , where $\Delta$ is the maximum degree of the interaction graph, rather than the linear $O(\Delta)$ or $O(|E|)$ scaling of sequential circuits.
Scheduled Parallelization: The authors introduce a tunable parameter $R$ (rounds) that interpolates between the fully sequential circuit ( $R = \Delta$ ) and the fully parallel fan-out ( $R = 1$ ). This allows for an optimization of the width-depth trade-off (volume), finding a "sweet spot" where the overhead of the fan-out trees is balanced against the gains from parallelism.
Built-in Error Detection: The redundancy inherent in the repetition-code registers serves a dual purpose. After the parallel interaction layer, the registers are "uncomputed" (fan-in). The ancilla qubits are measured to perform parity checks. Because the interaction terms preserve the code subspace of the repetition code, any single-qubit bit-flip error (weight-1) during the interaction or fan-out/fan-in phases results in a detectable syndrome. This enables post-selection of error-free shots without additional algorithmic overhead or extra gate layers.

Key Contributions

Gadget Compiler: A novel compilation strategy that converts narrow, deep product-formula circuits into wide, shallow circuits by utilizing fan-out registers sized by interaction degree.
Resource Analysis: A rigorous comparison of the sequential baseline versus the gadget compilation across a set of NMR spin systems and two hardware architectures: a heavy-hex superconducting coupling map (IBM) and an all-to-all trapped-ion connectivity (Quantinuum/IonQ).
Theoretical Bounds: Formal proofs (Propositions 1 and 2) demonstrating that for degree-inhomogeneous graphs (like star graphs), the gadget reduces the two-qubit volume (width $\times$ depth) by a factor of $O(\log D / D)$ compared to sequential execution, where $D$ is the hub degree. The gain vanishes for dense, uniform graphs.
Error Detection Integration: The demonstration that the redundancy required for parallelization inherently provides distance-2 error detection, allowing for post-selection to recover signal quality in noisy simulations.

Results
The authors validated their method using a 13-spin star system (tetramethylsilane, TMS) and other synthetic and real-world spin systems.

Depth Reduction: On a heavy-hex superconducting topology, the optimal schedule ( $R=3$ ) reduced the two-qubit depth by a factor of approximately 2 (from ~4903 to ~2452) and reduced the two-qubit gate count by ~23% due to reduced routing overhead. On all-to-all connectivity, the depth was also halved, though the gate count increased due to the fan-out CNOTs.
Volume Optimization: The volume (qubits $\times$ depth) was reduced by a factor of 1.7 for the 13-spin demonstration (specifically 0.59 on heavy-hex and 0.62 on all-to-all) and up to 2.5-fold on all-to-all connectivity for high-degree systems.
Noise Performance: Under a noise model scaled from current IBM hardware calibrations:
- At present-day error rates ( $p_{2q} \approx 1.5 \times 10^{-3}$ ), neither compilation recovers the spectrum.
- As error rates improve to $10^{-4}$ , the post-selected gadget circuits begin to outperform the sequential compilation in spectral shape correlation ( $r=0.70$ vs $0.63$).
- At $p_{2q} = 5 \times 10^{-5}$ , the post-selected gadget achieves a correlation of $r=0.94$ and retains 54% of the exact amplitude, significantly outperforming the sequential baseline ( $r=0.89$ , 39% amplitude).
- The post-selection acceptance rate remains viable (e.g., 63% at $5 \times 10^{-5}$ ), offsetting the sampling cost.

Significance and Claims
The paper claims that this method provides a practical pathway to execute deeper quantum simulations on NISQ devices by leveraging available qubit width to reduce depth. The significance lies in:

Hardware Adaptability: It converts the "narrow and deep" nature of product-formula simulations into the "wide and shallow" regime favored by current and near-future hardware.
Error Mitigation: It integrates error detection directly into the simulation structure, allowing for post-selection that recovers spectral quality at error rates one to one-and-a-half orders of magnitude better than current hardware, without requiring full fault tolerance.
Scalability: The approach is particularly effective for systems with high-degree hubs (common in molecular NMR and central-spin physics), offering a route to simulate systems (e.g., the 34-spin phosphorus cluster) that are approaching the limits of classical Liouville-space simulation.

The authors explicitly state that the demonstration does not claim to run a classically intractable problem on current hardware but rather compares compilation strategies under extrapolated noise models to identify the error thresholds where quantum utility becomes achievable for computational NMR. The method is presented as a compiler-level optimization applicable to any product-formula simulation where a qubit participates in multiple terms of the same Pauli type.

Technical Summary: Logarithmic Depth Compression of Heisenberg Hamiltonian Simulation by Fan-out Parallelization

More like this