Dynamic Induction of Lattice Gauge Theories on a Quantum Computer

AI summary

Overview

Research area: Digital quantum simulation of lattice gauge theories (LGTs) — specifically the 1+1D spin-1/2 U(1) quantum link formulation of the Schwinger model — using superconducting quantum hardware.

Technical level: Intermediate. The paper assumes familiarity with gauge symmetry, Trotterization, and qubit encodings, but its central idea (using symmetry generators as a dynamical resource) is stated plainly enough for non-specialists in lattice gauge theory.

Scope: The paper proposes and experimentally demonstrates a scheme in which Gauss's law is used not to constrain or post-select an existing gauge theory, but to dynamically generate the gauge theory from a simpler, hardware-friendly three-body XXX Hamiltonian.

What This Paper Is About

Simulating lattice gauge theories on quantum computers is hard because Gauss's law must be enforced at every site, and direct implementations of gauge-matter interactions require deep, expensive circuits. Existing approaches either penalize gauge-violating processes energetically (analog) or discard gauge-violating measurement outcomes after the fact (digital), treating Gauss's law purely as a constraint. This paper asks whether Gauss's law can instead be used as an engineering tool: starting from a Hamiltonian that does not have the target gauge symmetry and adding cheap single-qubit terms proportional to the Gauss-law generators, so that the desired LGT emerges dynamically in the protected subspace.

Key Contributions

1. A third paradigm for gauge theories on quantum computers. The authors introduce "dynamic induction," in which Gauss's law generates the gauge theory rather than merely suppressing or detecting violations. The mechanism is repurposed from a gauge-protection scheme originally developed to stabilize an intended gauge theory against errors.

2. A concrete, resource-efficient protocol for the 1+1D spin-1/2 U(1) quantum link model. The target three-body QLM interaction is replaced by a three-body XXX term, and the gauge protection Hamiltonian is a linear combination of the Gauss-law generators, implemented entirely with single-qubit rotations rather than entangling gates.

3. An experimental demonstration on 101 qubits. The dynamically induced LGT was run on a chain of 101 qubits (50 matter sites plus 51 gauge links) of IBM's 156-qubit ibm_basquecountry processor, and compared against matrix-product-state benchmarks and against a pure-gauge PXP implementation using 51 qubits.

4. A fivefold reduction in entangling-gate depth. The two-qubit gate depth per Trotter step drops from 35 (direct QLM implementation) to 7 (dynamically induced LGT), compared with 8 for the PXP implementation. Because the XXX blocks mutually commute, the XXX evolution carries no internal Trotter error and adds no further two-qubit depth in second-order Trotter evolution — an advantage the QLM and PXP schemes do not have.

Main Findings

• Gauge violations suppressed by more than an order of magnitude. Matrix-product-state simulations show that without protection ($V=0$) the gauge-violating three-body interaction rapidly drives the system out of the physical Hilbert space, while with $V=4.5$ and $c_j = (-1)^{j+1}$ the growth of the normalized average gauge violation $\langle\varepsilon_G\rangle = \sum_j \langle G_j\rangle^2 / N_g$ is suppressed by more than one order of magnitude throughout the evolution, consistent with a continuous quantum Zeno picture.

• Hardware matches theory over the experimentally accessible window. For both the fully filled and bare vacuum initial states and all three masses ($m=0$, $0.5$, $1$), the ibm_basquecountry data closely tracks the corresponding MPS benchmarks across 8 Trotter steps of size $\Delta t = 0.25$. Deviations appear only after several Trotter steps due to hardware errors.

• The dynamically induced scheme outperformed the PXP scheme. Despite using nearly twice as many qubits (101 versus 51) and a slightly shorter circuit (depth 7 versus 8), the dynamically induced LGT matched the target QLM trajectory better than PXP. The authors attribute this to the large redundancy of the encoding, which provides a more powerful error-detection and post-selection strategy.

• The direct QLM implementation was too noisy to use. The authors report that the 35-deep circuit for the direct QLM implementation "severely limits" the number of Trotter steps that can be implemented with high fidelity, and it was excluded from the quench comparison.

• Gauge protection does not suppress incoherent noise. Adding the gauge-protection layer to the full QLM circuit produced no significant improvement in data quality, consistent with the picture that protection makes coherent transitions to unphysical states off-resonant but does not affect transitions caused by incoherent noise.

• Post-selection is restrictive but results remain reproducible. For the dynamically induced LGT, outcomes with more than 2 gauge violations were discarded; less than 1% of shots were retained at the longest evolution times. Across all measurements the largest standard deviation was 0.021, computed as the spread over three independent runs on different days.

• Encoding and observables. Physical configurations satisfy $G_j|\Psi\rangle = 0$ with $G_j = \frac{(-1)^j}{2}(\sigma_j^z - \tau_{j-1,j}^z - \tau_{j,j+1}^z - 1)$. The global observable is the mean electric field $\langle E\rangle = \langle \sum_j \tau_{j,j+1}^z\rangle / N_f$, which is 0 for the bare vacuum and $-1$ for the fully filled state; increasing mass suppresses kinetic processes, giving smaller oscillation amplitudes and shorter oscillation periods.

Methodology in Plain English

The team targeted the spin-1/2 U(1) quantum link model in 1+1 dimensions, where matter sits on even sites and gauge fields on the links between them, all mapped onto qubits. They compared three circuit constructions for a single Trotter step:

1. Direct QLM: implement the target three-body interaction exactly. This requires three-body terms between $|000\rangle$ and $|111\rangle$ and decomposes into a two-qubit depth of 35.
2. PXP: use Gauss's law to integrate out the matter fields, leaving a pure-gauge theory. This brings the depth down to 8.
3. Dynamically induced LGT: replace the target interaction with a three-body XXX term, which flips three neighboring qubits regardless of their alignment, and add single-qubit energy penalties proportional to the Gauss-law generators. This brings the depth to 7. Each XXX three-body evolution decomposes into just four CNOT gates and a single RX rotation.

The XXX term by itself also produces processes that violate Gauss's law. The protection term $V H_G = V\sum_j c_j G_j$ makes those unwanted transitions off-resonant, freezing the dynamics into the physical sector. The authors chose $V = 4.5$ with $\Delta t = 0.25$ and $c_j = (-1)^{j+1}$.

Experimentally, they quenched from two initial states (fully filled and bare vacuum) at three masses, running 8 Trotter steps. Classical reference data came from Qiskit's MPS simulator: a high-resolution target QLM trajectory with $\Delta t = 0.05$ over 40 first-order Trotter steps (total time $t=2$), plus circuit-level simulations of the exact experimental circuits. The MPS truncation threshold was $10^{-12}$, checked against $10^{-8}$ and $10^{-10}$. For the hardware runs, the AerSimulator's qubit limit was raised from 63 to 156.

On the hardware side: logical qubits were mapped to a connected physical chain chosen by maximizing estimated layer fidelity from reported two-qubit gate errors; circuits were transpiled with Qiskit's preset pass manager at optimization level 3, run ten times, and the shallowest result selected. Gate twirling used 500 randomizations, dynamical decoupling used the XpXm sequence, and a 500 μs repetition delay separated circuit executions. Each data point came from $3\times10^5$ shots collected over three independent runs of $10^5$ shots on different days, with post-selection applied per day.

Why This Matters

Impact on research: The work reframes gauge protection from a symmetry-preservation tool into a Hamiltonian-engineering resource. It also shows that symmetry constraints embedded in single-qubit terms can substitute for explicitly encoding those symmetries in entangling circuits, which is a broadly applicable circuit-compilation idea, not just a lattice-gauge-theory trick. The comparison against PXP is notable: the "simpler" pure-gauge reduction lost to the dynamically induced scheme despite using half the qubits.

Real-world applications (as motivated by the paper):

• High-energy physics: digital simulation of confining gauge theories and string breaking, where lattice gauge theory is the standard nonperturbative tool.
• Condensed matter: quantum simulation of emergent gauge fields and constrained many-body dynamics.
• Quantum error mitigation: using Gauss's law and the redundancy of the encoding as an error-detection and post-selection strategy, which the authors explicitly identify as key to their results.
• Hamiltonian engineering on near-term hardware: realizing complex many-body models from simpler, experimentally accessible interactions when direct implementations are prohibitively deep.

Industry relevance: The experiments were run on IBM superconducting hardware using Qiskit's transpiler, SamplerV2 primitive, and Aer MPS simulator, so the resource estimates (depth 7 versus 35 per Trotter step) translate directly into practical guidance for what near-term cloud-accessible quantum processors can do. A fivefold reduction in two-qubit depth is the difference between a circuit that is too noisy to use and one that reproduces quantitative dynamics.

Future Directions

• Extension to higher spatial dimensions. The authors argue this is the scheme's main advantage: in a $d$-dimensional U(1) QLM the protection Hamiltonian remains a linear combination of Gauss-law operators $H_G = \sum_{\vec{n}} c_{\vec{n}} G_{\vec{n}}$, requiring only single-qubit rotations. Raising dimensionality adds local terms to each generator without adding entangling gates. By contrast, eliminating matter fields becomes rapidly worse — in 2+1D each matter occupation depends on 4 gauge links, and the elementary gauge-matter interaction maps onto an effective interaction involving 7 qubits.

• Finding the optimal gauge-violating starting Hamiltonian. The paper states that determining which unprotected Hamiltonian, under protection, best reproduces the target theory in higher dimensions remains an important open direction.

• Separating coherent from incoherent error. Since adding protection to the full QLM circuit did not help, a natural question is how to combine dynamic induction with strategies that address incoherent noise, which the Zeno-type mechanism does not touch.

• Applying the paradigm beyond gauge theories. The broader claim — that single-qubit terms can enforce symmetries without encoding them in circuits — invites testing on other constrained many-body models where direct circuit constructions are too deep.

Target Audience

Quantum simulation researchers working on lattice gauge theories and constrained many-body dynamics; quantum algorithm and circuit-compilation specialists interested in symmetry-based resource reduction; experimentalists on superconducting platforms evaluating what near-term devices can achieve; and high-energy and condensed-matter theorists interested in which gauge-theory phenomena are within reach of digital quantum hardware. Readers purely interested in applications of quantum computing outside physics simulation will find less of direct use.

Authors’ abstract

Gauge invariance is central to modern physics and underpins quantum simulations of lattice gauge theories (LGTs). Existing quantum simulation approaches employ Gauss's law either to energetically suppress gauge-violating processes in analog platforms or to detect and discard gauge-violating outcomes in digital devices. Here we introduce a third paradigm, in which Gauss's law is used to dynamically generate the gauge theory itself from a substantially simpler Hamiltonian. Starting from a readily programmable three-body XXX model, we employ experimentally efficient single-qubit U(1) gauge symmetry-generator terms that induce the dynamics of a U(1) LGT. We implement this approach using 101 qubits on a 156-qubit IBM quantum processor and observe real-time dynamics in quantitative agreement with the target LGT while reducing the entangling-gate depth per Trotter step by a factor of five compared with a direct implementation. Our results establish gauge protection as a resource for Hamiltonian engineering rather than merely symmetry preservation, opening a scalable resource-efficient route towards digital quantum simulations of increasingly complex gauge theories in higher spatial dimensions.