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

In the noisy intermediate-scale quantum (NISQ) era [56] we have strict requirements on the programs that quantum computers are able to run (Fig. 1). Both currently dominant architectures of quantum computers, the superconducting architecture and the trapped-ion architecture, operate within a tight qubit and gate layer budget [3, 69, 39, 27, 13, 23, 2, 66, 4, 53, 15, 21, 57, 26]. This motivates flexibility in quantum algorithms to fit the available resources. Product-formula circuits for nuclear magnetic resonance (NMR) simulation illustrate the tension: they are deep and narrow, while current quantum computers favor shallower and wider circuits. In this work we show a way to convert narrow deep circuits into wide shallow circuits for the simulation of spin Hamiltonians, and we quantify the conversion with a fixed resource-comparison protocol across a set of NMR spin systems and two hardware architectures. In previous work we approached the same tension from the complementary side, executing deep sequential NMR circuits on present hardware with error suppression [9]; here we reshape the circuits themselves. As a demonstration we simulate the zero-field NMR spectrum of tetramethylsilane, a 13-spin system whose star-shaped interaction graph is the geometry in which the compression is largest. Zero- to ultralow-field NMR [45, 5] offers spectra with simple exact structure against which the simulation can be judged, and our reference spectra are verified with an independent classical computation [33]. A similar approach extends to solid-state NMR crystallography, where the problem size can scale into the classically intractable regime. Refs. [59, 22] study the simulation of different NMR experiments on quantum computers. Together with the ability to execute deep quantum circuits with reduced noise through error mitigation and error suppression [12, 9], logarithmic depth compression reduces the hardware cost of quantum utility for computational NMR [11].

The mechanism of copying qubits to parallelize commuting operations dates back to Moore and Nilsson [52] and underlies several recent constructions, from ancilla-parallelized simulation algorithms [68, 6] to parallelized fault-tolerant compilation [47, 60]. To the best of our knowledge the specific combination presented here is new for product-formula simulation of spin Hamiltonians, whose interaction terms decompose into two-local Pauli blocks of uniform type: the fan-out registers are sized by the interaction degree, a single parameter moves the schedule from the sequential circuit to the fully parallel one, and the construction is compiled and transpiled end to end to routed hardware; the extension to generic Pauli-sum Hamiltonians is left to future work. Our quantitative claim is a statistically controlled account of when this parallelization pays on hardware resources: with seed-controlled statistics on transpiled circuits we map, across a set of spin systems and two hardware architectures, where the two-qubit depth, gate count, and width-depth volume improve. The best resource tradeoff is reached at a partial fan-out, between the sequential circuit and the fully parallel one, and the gain grows with the degree inhomogeneity of the interaction graph, appearing only once a hub is sufficiently high-degree. The redundancy of the registers simultaneously provides error-detecting parity checks at no additional gate or measurement cost, recovering inside product-formula circuits the intrinsic-redundancy protection known from parity-encoded architectures for combinatorial optimization [44, 55]. Zero-field NMR spectra have been computed on quantum hardware for a four-spin system [59], and larger high-field systems were executed in our previous work [9]; the demonstration presented here makes no scale claim: its object is the comparison of compilation strategies under a device-noise model extrapolated to lower error rates.

We map the liquid-state NMR Hamiltonian of $N$ nuclear spins [46, 11] onto the following qubit Hamiltonian:

where $\omega_{k}$ is the offset frequency of spin $k$ in the rotating frame (determined by its chemical shift $\delta_{k}$, the static field strength $B_{0}$, and the gyromagnetic ratio $\gamma$ of the nucleus), $J_{kl}$ is the scalar coupling constant between spins $k$ and $l$, and $\vec{I}_{k}=(I_{k}^{X},I_{k}^{Y},I_{k}^{Z})$ is the spin-$\tfrac{1}{2}$ angular momentum operator. The Zeeman term is written along $X$ instead of the conventional $Z$: a global relabeling of the spin axes that leaves the spectrum unchanged and places the detected magnetization on the qubit measurement axis $Z$. Zero-field experiments, including the demonstration in Sec. Error detection and post-selection, correspond to the special case $\omega_{k}=0$, in which only the coupling terms remain; the parallelization introduced below acts on the coupling terms and therefore applies unchanged in both regimes. Here we propose a method for logarithmic compression of the depth of the product formula circuits required for the simulation of the Hamiltonian in Eq. 1, at the cost of an increase in the number of required qubits from $N$ to $\sum_{k}\max(1,d_{k})$, where $d_{k}$ is the degree of spin $k$ in the interaction graph. This overhead is quadratic for fully connected systems and linear for sparse topologies such as chains. As with similar depth compression methods described in other contexts [49, 25], compression is achieved by using the fact that the Z-basis repetition code has a logical Z operator of Hamming weight $d_{Z}=1$. This allows us to parallelize interactions that address the same qubit by copying that qubit via a binary CNOT tree. The depth of the binary tree scales logarithmically with the number of parallelized interactions. The qubits used for copying are freed upon executing the interactions and can be used for error detection and post-selection.

The paper is organized as follows. We first write the product-formula circuits for the liquid-state NMR Hamiltonian, then introduce the fan-out gadget and its rounds-parameterized schedule and report the resource comparison across spin systems and two hardware architectures (Sec. Parallelization/gadget). Section Error detection and post-selection develops the built-in error detection and demonstrates the full pipeline on the zero-field spectrum of tetramethylsilane under a device-noise model extrapolated to lower error rates. We close with an outlook toward fermionic and central-spin applications; the appendices collect the noise model, compilation and transpilation statistics, and the connectivity and star-scaling studies.

Eq. 2 shows the first-order, one-step product formula [48, 62] for the Hamiltonian in Eq. 1 without secular approximation. Higher-order formulas and multiple Trotter steps can be used to improve accuracy [16] at the cost of deeper circuits; the parallelization introduced in Sec. Parallelization/gadget applies identically regardless of the chosen order or step count, since it acts on each block of same-type Pauli terms independently.

When the Zeeman splittings $\omega_{k}$ are much larger than the couplings $J_{kl}$, as is the case in high-field liquid-state NMR, it is advantageous to work in the interaction picture, where the single-spin Zeeman rotations (the $X$ block in Eq. 2) are absorbed into the classical frame and only the bilinear coupling terms ($XX$, $YY$, $ZZ$) remain in the Trotterized circuit. This reduces the circuit depth per step [50, 10]. The numerical demonstration in Sec. Error detection and post-selection takes place at zero field, where no Zeeman terms are present, and uses a second-order product formula with $M=32$ Trotter steps.

As a concrete example, consider a $3$-spin molecule with chain connectivity. As depicted in Fig. 2, we map the 3 spins to qubits $\{q_{0},q_{1},q_{2}\}$ with respective Zeeman frequencies $\{\alpha,\beta,\gamma\}$ and spin-spin coupling parameters $\theta_{01}$ and $\theta_{12}$. The corresponding first-order, one-step product formula is then given in Eq. 3, which corresponds exactly to the circuit displayed in Fig. 3.

Generally in this circuit, the different contributions within the bilinear coupling terms ($XX$, $YY$, $ZZ$) cannot be executed in parallel and the circuit depth scales as $O(|E|)$, where $E$ is the edge set of the interaction graph (i.e. the set of spin pairs with non-zero $J_{kl}$), which gives $O(N^{2})$ for fully connected graphs.

Depth compression by trading additional qubits, measurements, or nonlocal fan-out resources has been explored in several settings [52, 35, 61, 8], algebraic circuit identities give compression without added qubits [40], and logarithmic-depth improvements have been demonstrated with other quantum primitives such as the preparation of entangled states [18]. Ancilla-based parallelization has been developed for Hamiltonian-simulation algorithms at the asymptotic level [68], for commuting terms in the SELECT subroutine of linear-combination methods [6], and as serial-to-parallel tradeoffs in fault-tolerant compilation [47, 60]; the first two act within linear-combination-of-unitaries and quantum-walk algorithms, Zhang et al. compressing the dependence of the depth on the target precision and Boyd diagonalizing commuting terms in a block-encoding multiplexer, whereas the present construction parallelizes a product-formula circuit along the spatial dimension of the interaction graph and supplies an error-detecting register and end-to-end routed-hardware evaluation absent from that line of work. Tunable width-depth tradeoffs are also known for diagonal-unitary synthesis on planar grids [67], and a recent compiler for spin and fermionic Hamiltonian simulation reduces depth by gate synthesis and partial Trotterization within a fixed qubit count [20], complementary to the width-for-depth trade made here. The circuit fragment at the heart of our construction, a CNOT fan-out followed by parallel two-qubit rotations and the inverse fan-out, is a batched form of the phase gadgets of circuit synthesis [17]; we use the term gadget in this compilation sense, distinct from the perturbative Hamiltonian gadgets of complexity theory [38]. Here we consider a system of $N$ spins governed by a liquid-state NMR Hamiltonian as defined in Eq. 1. In a standard quantum simulation mapping, each logical spin $k$ is assigned to a single physical qubit $q_{k}$. The implementation of interaction terms $U_{kl}(\theta)=\exp(-i\frac{\theta}{2}P_{k}P_{l})$, where $P\in\{X,Y,Z\}$ denotes a Pauli operator (with $\theta$ absorbing the factor of $1/4$ from the spin-$\tfrac{1}{2}$ convention $I^{P}=\sigma^{P}/2$), is constrained by hardware topology. Specifically, two terms sharing a common logical spin, such as $U_{kl}$ and $U_{km}$, cannot be executed at the same time on a standard architecture because they require access to the same physical resource $q_{k}$.

The gadget compiler (detailed pseudocode in Fig. 5) uses a redundant register mapping where each logical spin $k$ is represented by a cluster of $n_{k}$ physical qubits $\mathcal{Q}_{k}$, with $d_{k}$ the degree of spin $k$ in the interaction graph. In the maximally parallel form (full fan-out) $n_{k}=\max(1,d_{k})$; the rounds parameter $R$ of Sec. 3.1 generalizes this to $n_{k}=\max(1,\lceil d_{k}/R\rceil)$, down to a single qubit per spin:

The set consists of a root qubit $q_{k,0}$ and $n_{k}-1$ ancillas. At full fan-out the total number of physical qubits is $\sum_{k}n_{k}=\sum_{k}\max(1,d_{k})$, which equals $2|E|$ when every spin participates in at least one coupling. For a fully connected interaction graph ($|E|=N(N-1)/2$) this yields $O(N^{2})$ qubits (see Fig. 4), whereas sparse graphs such as linear chains ($|E|=N-1$) require only $O(N)$; the scheduled gadget uses fewer, $\sum_{k}\max(1,\lceil d_{k}/R\rceil)$. The simulation is structured as a sequence of $M$ Trotter steps, each subdivided into interaction blocks $b\in\{1,\dots,B\}$ corresponding to different Pauli bases $\{XX,YY,ZZ\}$. An interaction block is defined by the unitary sequence:

where $W_{b}$ is the local basis transformation (e.g., $W=H^{\otimes N}$ for $XX$ terms), $F_{k}$ is the fan-out operator, and $U_{b,\text{parallel}}$ is the parallel interaction layer.

The operator $F_{k}$ is implemented as a binary tree of CNOT gates, as visualized in Fig. 4, which prepares the entangled logical state:

Each logical edge $\{k,l\}\in E$ is mapped to a unique pair of physical qubits $(q_{k,a},q_{l,b})$ from the allocated clusters. Because each physical qubit is involved in at most one interaction gate per time-bin, all terms of the same Pauli type can be executed in parallel. Mathematical equivalence is maintained because a $Z$-basis interaction applied to any member of the repetition-coded gadget is identical to an operation on the logical root. The block concludes with $F_{k}^{\dagger}$, which contracts the cluster to the root, followed by $W^{\dagger}$. This reduces the depth of the coupling layer from $O(|E|)$ to $O(\log\Delta)$, where $\Delta$ is the maximum degree of the graph.

This architecture detects errors without any algorithmic overhead. Redundancy introduced for a computational purpose that is simultaneously an error-detecting code is known from parity-encoded architectures for combinatorial optimization [44, 55]; here the same effect arises inside a product-formula simulation circuit, with the checks read from the terminal measurement. After the parallelized gate layer the ancilla qubits are released (Fig. 4): following the basis rotation $W_{b}$, all interactions in the parallel layer decompose as $ZZ$ rotations (regardless of whether the original Pauli type was $XX$, $YY$, or $ZZ$), and these preserve the code subspace of the repetition code: the logical states $\ket{0}^{\otimes n_{k}}$ and $\ket{1}^{\otimes n_{k}}$ are eigenstates of $Z_{i}Z_{j}$, so the GHZ-like entangled state produced by the fan-out $F_{k}$ remains within the code space throughout the interaction layer and can be cleanly uncomputed by the inverse CNOT fan-in $F_{k}^{\dagger}$.

The error detection uses a distance $d=2$ repetition code [28] defined for each spin register $\mathcal{Q}_{k}$ of size $n_{k}$, meaning that any single-qubit bit-flip error can be detected but not corrected. The code space $\mathcal{C}_{k}$ is the $+1$ eigenspace of the stabilizer group $\mathcal{S}_{k}$, generated by:

where $q_{k,0}$ is the root qubit and $\{q_{k,j}\}_{j=1}^{n_{k}-1}$ are the ancillas. The logical basis states are defined as $\ket{0}_{L}=\ket{0}^{\otimes n_{k}}$ and $\ket{1}_{L}=\ket{1}^{\otimes n_{k}}$.

The full simulation circuit is composed of $M\times B$ interaction blocks (see Fig. 5). Each block implements a cycle of expansion $F_{k}$, parallel interaction $U_{\text{parallel}}$, and compression $F_{k}^{\dagger}$. The detectability of stochastic Pauli noise depends on how these errors map to the syndrome register following the application of $F_{k}^{\dagger}$.

Bit-flip noise ($X$): Let $m\in\{0,1\}^{n_{k}}$ be a vector denoting the bit-flips accumulated on the physical qubits of register $\mathcal{Q}_{k}$. The unitary decoder $F_{k}^{\dagger}$ is an invertible $\mathbb{F}_{2}$-linear map, so the measured syndrome $s\in\{0,1\}^{n_{k}-1}$, read from the $n_{k}-1$ non-root copies after fan-in, is a fixed linear image of $m$. For a linear fan-in that XORs every copy directly against the root this image is $s_{j}=m_{j}\oplus m_{0}$; the binary CNOT tree actually compiled gives a different but equally invertible image. In either case the fan-in computes parities of the copies, so the syndrome vanishes exactly when every copy carries the same flip, and an error is undetected if and only if $m_{0}=m_{1}=\dots=m_{n_{k}-1}$. This condition is met only by the identity operation ($m=\vec{0}$) or the logical bit-flip $\bar{X}=X^{\otimes n_{k}}$ ($m=\vec{1}$).

During the parallel interaction layer, any weight-1 bit-flip on a single physical qubit $q_{k,j}$ (whether root or ancilla) produces a non-trivial syndrome and is therefore detectable. In particular, a flip on the root ($j=0$) yields $s_{i}=0\oplus 1=1$ for all $i$, while a flip on ancilla $j>0$ yields $s_{j}=1$ with all other syndrome bits zero. The interaction gates couple copies in different registers, so a control fault during an interaction propagates an additional bit-flip into the partner register; each register is checked by its own syndrome, so the fault is caught whenever a fanned-out register ($n_{k}>1$) is involved, which holds for every interaction of a fanned-out spin.

During the binary tree expansion $F_{k}$ (see Fig. 4), the situation differs because a bit-flip on a control qubit propagates through subsequent CNOT gates to its descendants. If a bit-flip occurs on the root qubit $q_{k,0}$ at the start of the expansion, it propagates to every qubit in the register, resulting in $m=\vec{1}$ and an undetected logical failure. In contrast, any bit-flip occurring on an internal node or target qubit that does not propagate to the entire cluster results in $s\neq\vec{0}$ and is detectable. Errors during the fan-in $F_{k}^{\dagger}$ are analogous: a bit-flip on a copy propagates only to qubits earlier in the reverse tree order and generally does not reach the root, producing a detectable syndrome.

Other errors: Phase-flip errors ($Z$) commute with the stabilizers $S_{k,j}$ and are not detectable by the syndrome register. Their effect depends on when they occur. Between interaction blocks the copies rest in $\ket{0}$, on which $Z$ acts trivially, and only the root qubit is vulnerable. During an interaction window, however, the register occupies the code space, where a $Z$ on any of the $n_{k}$ members acts as the logical $\bar{Z}$: the logical dephasing cross-section during the windows is $n_{k}$ times that of a single qubit, in exchange for the shorter schedule. In the NMR context these events contribute to $T_{2}$-like broadening. Leakage and readout errors are outside the scope of the $d=2$ stabilizer protection, though high-fidelity measurement limits their impact.

Error propagation along blocks and post-selection: In the simplest case of a device without mid-circuit measurement the ancilla register is not reset between blocks, and any bit-flip error acquired in an early block preserves the parity mismatch relative to the root throughout the remaining unitary evolution: if a copy ends in $\ket{1}$ after one fan-in, subsequent fan-out cycles propagate this anti-correlation through the register, maintaining a non-trivial syndrome across all later blocks. This allows for a single measurement of all ancillas at the end of the Trotter sequence. The root qubits carry the measurement signal (the NMR observable), while the copy qubits are the syndrome register. The measurement counts are processed via a global post-selection filter defined by the projector $\Pi_{0}=\bigotimes_{k}\ket{\vec{0}}\bra{\vec{0}}_{anc,k}$. The expectation values are then computed over the null-syndrome shots alone.

To probe the regime where the depth compression matters, we simulate the zero-field NMR spectrum of tetramethylsilane (TMS, $\hphantom{{}^{\text{29}}_{\text{}}}{\vphantom{\text{X}}}{}^{\mathchoice{\hbox to0.0pt{\hss$\displaystyle\vphantom{\smash[t]{\text{2}}}\text{29}$}}{\hbox to0.0pt{\hss$\textstyle\vphantom{\smash[t]{\text{2}}}\text{29}$}}{\hbox to0.0pt{\hss$\scriptstyle\vphantom{\smash[t]{\text{2}}}\text{29}$}}{\hbox to0.0pt{\hss$\scriptscriptstyle\vphantom{\smash[t]{\text{2}}}\text{29}$}}}\kern 0.0pt\text{Si}\text{(}\text{CH}{\vphantom{\text{X}}}_{\smash[t]{\text{3}}}\text{)}\text{}{\vphantom{\text{X}}}_{\smash[t]{\text{4}}}$; Fig. 6), a star-shaped 13-spin system in which ²⁹Si couples identically to twelve protons (${}^{2}J_{\mathrm{SiH}}=6.6$ Hz [32]). At zero field the Hamiltonian contains only the scalar couplings, $H=2\pi J\sum_{k=1}^{12}\vec{I}_{\mathrm{Si}}\cdot\vec{I}_{k}$. We take the idealized $\mathrm{A}_{12}\mathrm{X}$ limit of twelve magnetically equivalent protons, in which the small proton–proton couplings commute with the Hamiltonian and the observable and leave the comb positions unchanged; they are omitted. The spectrum of such a system is a comb of lines at the frequencies $(K+\tfrac{1}{2})J$, where $K$ is the total proton angular momentum quantum number [45, 5]: six lines between 9.9 and 42.9 Hz (Appendix C). The hub degree of twelve maximizes the parallelization gain of the gadget on the heavy-hex architecture (Fig. 1), and because the circuits depend on the couplings only through the products $J\,dt$, the conclusions carry over to any star system with rescaled acquisition parameters. A four-spin zero-field spectrum has previously been computed on trapped-ion hardware [59].

The simulation prepares the computational basis state with the silicon spin and five protons pointing up and seven protons pointing down. A single basis state requires no state-preparation circuit, and this pattern populates every sector $K\geq 1$ of the total proton spin, producing all six comb lines, while avoiding the $K=0$ sector, which holds a single $F=\tfrac{1}{2}$ level and contributes no line; the sector weights are given in Appendix C. The observable is the $\gamma$-weighted total magnetization $\sum_{k}(\gamma_{k}/\gamma_{\mathrm{H}})(\langle I^{Z}_{k}\rangle-i\langle I^{Y}_{k}\rangle)$, the quantity to which a zero-field magnetometer signal is proportional [45, 5]. The Hamiltonian conserves every component of the total spin and the initial state is an eigenstate of the total $I^{Z}$, so the transverse expectation values vanish identically and the free induction decay is real; the measured imaginary quadrature is consistent with zero within shot noise and is discarded in the processing. Although not preparable in a magnetization-based experiment, this initial state is the natural state of the quantum simulation and shares with the physical zero-field experiment the complete comb of transition frequencies, which are set by the Hamiltonian alone. The dependence of the spectrum on the initial state is illustrated in Appendix C.

Both compilations implement a second-order product formula with $M=32$ Trotter steps, converged at the acquisition grid used here; the residual Trotter error is the small difference between the two reference curves in Fig. 7. Commuting single-spin layers at the boundaries of consecutive Trotter steps are merged and adjacent inverse gate pairs cancel; all quoted depths and gate counts refer to these simplified circuits. The sequential compilation places the 13 spins on 13 qubits. The gadget compilation allocates a four-qubit register to the hub (schedule $R=3$) and executes the twelve hub couplings in three parallel rounds of four interactions, for 16 qubits in total. Every acquisition point uses the same step count, so all circuits of one compilation share the same depth. The demonstration pins the circuits to a fixed calibrated 16-qubit subgraph of the ibm_aachen coupling map, with the same basis and protocol as Table 1; each compilation uses its volume-optimal transpiler draw, the seed of least two-qubit volume $V_{2q}$ over 1024 seeds, with ties broken by the lowest two-qubit gate count, then seed order (Appendix B). Volume is independent of the noise level, so the same circuit serves every scaling, and the error-budget distributions of the two compilations do not overlap across the seed pool, so no draw selection could affect the direction of the comparison. The selected sequential circuits have a two-qubit depth of 4903 with 10554 two-qubit gates, against 2452 and 8123 for the gadget: a depth compression by a factor of 2.0 obtained together with a 23% reduction in two-qubit gate count for this draw, or 18% at the median of the volume-optimal draws. These absolute counts fall below the full-map medians of Table 1 because the demonstration fixes a favorable 16-qubit subgraph and uses the volume-minimizing draw instead of the median seed; the depth ratio near 2.0 is consistent across both.

The noise model is constructed from the published per-qubit calibration of the ibm_aachen device, a snapshot retrieved in July 2026 (Appendix A). Every gate carries thermal relaxation for its calibrated duration on the participating qubits, composed with a depolarizing residual chosen so that the total channel matches the calibrated gate error; readout errors are applied per qubit. At unit scale this parametric model reproduces the reference noise model that Qiskit constructs from the same calibration to within $3\times 10^{-7}$ in average gate fidelity. The circuits are scheduled as soon as possible and every idle period carries thermal relaxation for its scheduled duration. The rows of Fig. 7 divide all error rates by a common factor and multiply the coherence times by the same factor, so that each row is labeled by its median two-qubit error $p_{2q}$; the top row is the device as calibrated today. Each of the 45 acquisition points is sampled with 4096 shots per compilation by trajectory simulation [36].

The processing chain coincides with that of the SPINACH zero-field examples, mean subtraction, exponential apodization, and absorption-mode display, with the line broadening set to 1 Hz. Two independent checks anchor the simulation chain. The exact spectrum is recomputed with SPINACH from the same Hamiltonian, initial state, observable, and acquisition grid; the two exact free induction decays agree to $5.2\times 10^{-6}$ per point, a residual set by the underlying gyromagnetic-ratio tables. Separately, the full noisy pipeline run at zero error reproduces the noiseless reference within shot noise at every acquisition point.

Figure 7 shows the outcome. At the present-day calibration no compilation recovers any comb structure: the spectra are dominated by relaxation, and the post-selection acceptance of 0.14 sits at the random-parity floor of $2^{-3}$ expected from three fully scrambled ancilla bits. The comb begins to emerge near $p_{2q}=2\times 10^{-4}$ for all three traces, and from $p_{2q}=1\times 10^{-4}$ the post-selected gadget leads the shape recovery ($r=0.70$ against $0.63$ for the sequential compilation). In the lowest-noise row it reaches $r=0.94$ and retains $a=0.54$ of the exact comb amplitude, against $0.89$ and $0.39$ for the sequential compilation, while accepting 63% of the shots. The structure below 5 Hz is the windowed-transform signature of the slowly varying damping; the sequential spectra carry the larger low-frequency pedestal, in line with their larger idle budget, and the metric band excludes this region.

Although the gadget circuit is twice as shallow and holds 23% fewer two-qubit gates, its raw spectra trail the sequential ones in shape correlation at $p_{2q}=10^{-4}$ (0.56 against 0.63). The unfiltered average retains the flagged shots, more than half of which carry a detected fault at $p_{2q}=10^{-4}$ and contribute distorted spectra. A phase flip on any member of the encoded register during an interaction window also acts as the logical $\bar{Z}$, so the logical dephasing cross-section during the windows grows with the register size, and the shorter schedule repays this only in part. The depth advantage acts through the idle channel, visible as the smaller low-frequency relaxation pedestal of the gadget spectra, but at these error rates the gate channel dominates. Post-selection changes the balance: the same redundancy that raises the dephasing cross-section makes a large fraction of the faults detectable, and discarding the flagged shots makes the post-selected gadget the most accurate of the three traces at this noise level. At the lowest noise level the difference between the sequential and unfiltered-gadget correlations is within the shot noise of 4096 shots, whereas the improvement from post-selection is evaluated on the same shots. A bootstrap over the comb-band frequency points resolves it: at $p_{2q}=5\times 10^{-5}$ the paired gains $r_{\mathrm{PS}}-r_{\mathrm{seq}}=+0.05$ [95% CI $+0.04,\,+0.06$] and $a_{\mathrm{PS}}-a_{\mathrm{seq}}=+0.14$ [$+0.13,\,+0.15$] both exclude zero, as do $+0.07$ [$+0.05,\,+0.10$] and $+0.05$ [$+0.04,\,+0.07$] at the $10^{-4}$ crossover.

Post-selection carries a sampling cost. Keeping a fraction $p_{\mathrm{acc}}$ of the shots, matching the accepted-shot count of an unfiltered run takes $1/p_{\mathrm{acc}}$ times its wall-clock. The correlations above hold the budget fixed at 4096 shots per circuit and charge the discarded gadget shots against its own total, so this penalty is already reflected in them: the gadget accepts $p_{\mathrm{acc}}=0.63$ at $p_{2q}=5\times 10^{-5}$ and $0.43$ at the $10^{-4}$ crossover, overheads of $1.6$ and $2.3$, and still leads. Since the gadget circuit is half as deep, each of its shots would also run in proportionally less gate time on hardware, which offsets part of this overhead where the per-shot runtime is dominated by gate depth. At the present-day $1.5\times 10^{-3}$ the acceptance falls to near the $2^{-3}$ random-parity floor ($p_{\mathrm{acc}}=0.14$, a sevenfold overhead), but no compilation recovers the spectrum there, so the sampling cost is not the limiting factor.

We have presented a logarithmic-depth compression method for product-formula simulation of Heisenberg-type spin Hamiltonians based on fan-out parallelization. The method replaces a narrow, deep sequential implementation of pairwise spin interactions with a wider and shallower circuit in which each logical spin is represented by a degree-dependent register. A binary CNOT tree distributes the logical state across this register, allowing all interactions of the same Pauli type to be applied in parallel before the register is uncomputed. As a result, the depth of an interaction block scales logarithmically with the maximum degree of the interaction graph, rather than with the number of edges. The required qubit overhead is quadratic for fully connected systems but remains linear for sparse spin topologies such as chains.

The logarithmic depth gain demonstrated here is enabled by the binary CNOT fan-out tree, a primitive whose efficient preparation has been studied in the context of GHZ-state generation [18] and whose computational power and circuit-depth advantages have been established in several theoretical and experimental settings [52, 35, 61, 8]. Our work shows that this primitive translates directly into a practical compiler-level optimization for Hamiltonian simulation.

Beyond depth reduction, the method enables post-selection against detectable errors without adding extra algorithmic layers. In noisy simulations of the 13-spin TMS system at zero field, under noise models anchored to the published calibration of a present-day quantum processing unit (QPU), the demonstration locates the error rates at which the spectrum of this example is recovered. At the current median two-qubit error of $1.5\times 10^{-3}$ no compilation recovers the spectrum; recognizable combs appear near $2\times 10^{-4}$; and from $10^{-4}$ the post-selected gadget circuits, at half the two-qubit depth, lead the sequential baseline in spectral quality ($r=0.70$ against $0.63$ at $10^{-4}$, and $r=0.94$ with $a=0.54$ against $0.89$ and $0.39$ at $5\times 10^{-5}$). The register redundancy that enlarges the logical dephasing cross-section during the interaction windows is the same structure that flags a large fraction of the faults for discarding; post-selection turns the cost of the encoding into a net benefit.

The gadget compiler thus suits QPUs with spare qubits but a bounded depth budget, converting the register overhead into shallower interaction blocks and detectable-error post-selection. The fan-out parallelization principle extends to any product-formula simulation in which a qubit participates in multiple terms of the same Pauli type. This includes fermionic Hamiltonians under the Jordan-Wigner mapping [37], where hopping terms decompose into blocks of uniform Pauli type that are individually parallelizable. The same degree criterion carries over (Proposition 2): the compression is largest where a mode couples to many others in the Pauli-type-resolved interaction graph, as in molecular electronic-structure Hamiltonians or higher-coordination lattice models, and it is absent for a degree-two one-dimensional chain such as the 120-qubit Fermi-Hubbard model recently simulated [31], which sits at the $O(\log 2)=O(1)$ no-compression end. For Hamiltonians with higher-locality or mixed-Pauli terms, the parallelization applies within each same-type block; the overhead analysis then depends on the Pauli-type-resolved degree of each qubit rather than the total interaction degree.

A natural next target is the central-spin physics of color-center registers. The NV^- electron spin in diamond couples to tens of resolved ¹³C nuclear spins through individually measured hyperfine tensors, forming the high-degree star geometry in which the gadget compression is largest; the 27-nuclear-spin register of Ref. [1] is a named physical system of this kind. Every term of the free evolution commutes with the electron $Z$ operator, so the evolution between microwave pulses forms a single fan-out window and pulsed sequences arrive naturally partitioned for the gadget. Simulating polarization-transfer protocols such as PulsePol [58] at these register sizes is demanding for classical methods and experimentally verifiable, which makes it a suitable first application. The construction itself also generalizes from the compiler presented here to a problem-agnostic compiler pass acting on any circuit in which many two-qubit interactions share a qubit; a systematic account is left to future work.

Classical NMR simulation packages typically operate in Liouville space to accommodate mixed states and relaxation, where unrestricted density-matrix evolution incurs $O(2^{2N})$ scaling with the number of coupled spins $N$ and becomes impractical around twenty spins [33, 42, 19, 9]; tensor network methods such as matrix product states (MPS) extend this reach to approximately 32 spins, the Liouville limit, where the broadly distributed entanglement of long-range-coupled NMR spins makes even accurate MPS evolution costly [22]. Quantum simulation of the coherent time evolution operates natively in Hilbert space ($2^{N}$), sidestepping the quadratic overhead in the exponent. In the near term, depth compression via the gadget compiler, combined with error suppression techniques [9], may enable NISQ devices to push into this classically intractable regime. For instance, the 34-spin phosphorus cluster lies beyond the Liouville limit of density-matrix NMR packages, although the coherent zero-field evolution simulated here is a Hilbert-space ($2^{N}$) problem whose exploitable symmetry can lower the classical cost further, so the following is a comparison of compiled circuit sizes, not a demonstrated advantage. Its maximally parallel (full fan-out) schedule compiles to a two-qubit depth of 50 (one Trotter step) to 1290 (32 steps) at a width of 96 qubits, against 164 to 5124 at 34 qubits for the sequential compilation, a three- to fourfold depth reduction traded for width in the routing-free circuit. On all-to-all connectivity this depth reduction is also a volume reduction (0.63, Table 2); on the routed heavy-hex device the densely coupled phosphorus core cannot embed as a single localized register, so the volume-optimal schedule falls back to the sequential circuit, and the cluster illustrates that a width-for-depth volume gain need not appear on every architecture. As Fig. 1 illustrates for the demonstration, whose transpiled circuit sizes are computed classically rather than executed on hardware, the trade shifts the requirement toward the wide-and-shallow regime where current superconducting QPUs offer sufficient qubit counts, and trapped-ion devices come close in both qubit number and demonstrated depth. The noisy demonstration of Sec. Error detection and post-selection quantifies the remaining gap for the 13-spin system: median two-qubit error rates near $10^{-4}$, an order of magnitude below present calibrations, together with correspondingly longer coherence times, suffice to recover the spectrum of this 13-spin example.