⚛️ quantum physics

Simulating sparse SYK model with a randomized algorithm on a trapped-ion quantum computer

This paper demonstrates the successful real-time simulation of a 24-Majorana sparsified SYK model on a trapped-ion quantum processor using the TETRIS randomized algorithm and tailored error mitigation, enabling the observation of Loschmidt amplitude decay and providing a scalable benchmark for future large-scale quantum simulations.

Original authors: Etienne Granet, Yuta Kikuchi, Henrik Dreyer, Enrico Rinaldi

Published 2026-03-17

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Etienne Granet, Yuta Kikuchi, Henrik Dreyer, Enrico Rinaldi

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

The Big Picture: Simulating a "Quantum Chaos" Machine

Imagine you have a machine made of 24 tiny, invisible marbles (called Majorana fermions) that are constantly bumping into each other in a completely random, chaotic way. This is the SYK model.

In the real world, this model is famous for two reasons:

It's a mess: The marbles interact so wildly that it's impossible for a regular supercomputer to predict what they will do next. It's like trying to predict the exact path of every raindrop in a hurricane.
It's a secret code for Gravity: Physicists believe this chaotic system behaves mathematically like a black hole or a theory of quantum gravity. By simulating it, we are essentially building a "black hole in a lab" to understand how the universe works.

The Problem: To simulate this on a real quantum computer, the instructions (the code) are so long and complex that the computer makes mistakes before it even finishes the first sentence. The "noise" of the machine drowns out the signal.

The Solution: The authors of this paper built a new way to run this simulation on a trapped-ion quantum computer (a machine that holds atoms in place with lasers). They managed to run the simulation long enough to see the system "decay" (lose its initial energy), which is a key signature of chaos.

The Three Magic Tricks They Used

To make this work, they didn't just brute-force the problem. They used three clever tricks:

1. The "Sparse" Shortcut (Cutting the Cord)

Usually, in this model, every single marble interacts with every other marble. That's a lot of connections!

The Analogy: Imagine a party where everyone is shouting at everyone else. It's impossible to hear anything.
The Fix: They turned off most of the shouting. They created a "Sparse" version where marbles only talk to a few neighbors.
Why it works: It's like turning a chaotic crowd into a small group of friends chatting. It keeps the "chaotic flavor" (the physics) but removes the impossible complexity.

2. The "TETRIS" Algorithm (Rolling the Dice)

The standard way to simulate time is to take tiny, precise steps (like walking up a staircase). But on a noisy computer, taking too many steps leads to falling off.

The Analogy: Instead of walking up a staircase step-by-step, imagine you are playing TETRIS. You don't plan every move perfectly. Instead, you randomly drop blocks (operations) and let them settle.
The Magic: The TETRIS algorithm is a "randomized" method. It doesn't try to be perfect every time. Instead, it runs the simulation many times with slightly different random moves. When you average all those results together, the randomness cancels out, and the true answer emerges. It's like asking 1,000 people to guess the weight of a cow; no one is right, but the average of their guesses is very close.

3. The "Echo" and "Extrapolation" (Cleaning the Noise)

Even with the shortcuts, the quantum computer still makes mistakes (noise). The authors invented two ways to clean up the data:

Echo Verification (The Mirror Trick):
- The Analogy: Imagine you are trying to hear a whisper in a noisy room. You shout the whisper, wait for the echo, and then shout the exact opposite of the noise you heard. If the room is perfect, the noise cancels out, and you are left with just the whisper.
- In the paper: They ran the simulation and then ran a "mirror" version of it. By comparing the two, they could tell which parts were real physics and which parts were just machine errors.
LGAE (The "Volume Knob" Trick):
- The Analogy: Imagine you are trying to hear a song, but the radio is static. You can't turn off the static, but you can turn the volume up and down. If you know how the static changes as you change the volume, you can mathematically "extrapolate" (guess) what the song sounds like if the volume were zero (no static).
- In the paper: They changed a parameter called the "gate angle" (like turning a volume knob) to make the circuits "deeper" (more complex) or "shallower" (simpler). By comparing the results of the deep and shallow runs, they mathematically removed the noise to find the true answer.

What Did They Actually See?

They ran the simulation for 24 particles (which is a lot for this type of experiment). They watched a specific number called the Loschmidt Amplitude.

The Metaphor: Imagine you drop a pebble into a still pond. The ripples spread out. The "Loschmidt amplitude" measures how much of the original "stillness" is left after the ripples hit the edges.
The Result: In a perfect world, the ripples would fade away in a specific pattern. On a noisy computer, the ripples usually disappear too fast or get distorted.
The Victory: Using their "Sparse" model, "TETRIS" algorithm, and "Noise Cleaning" tricks, they successfully saw the ripples fade away exactly as the theory predicted. They proved that even with a noisy machine, we can simulate complex quantum chaos.

Why Does This Matter?

This is a "proof of concept." It shows that we don't need a perfect, error-free quantum computer to do useful science. We can use "noisy" computers today if we are smart about how we write the code and how we clean up the results.

The Future:
The authors estimate that to simulate a truly large system (like a real black hole model), we might need a quantum computer with about 50 to 100 qubits (particles). They calculated that with their current methods, it would take about 30 hours to run one simulation on such a machine. While that sounds long, it's a massive leap forward from "impossible."

In short: They took a chaotic, impossible-to-solve physics problem, simplified it, used a dice-rolling strategy to run it, and used clever math to filter out the computer's mistakes. The result? A working simulation of a "black hole in a box."

1. Problem Statement

The Sachdev-Ye-Kitaev (SYK) model is a paradigmatic model for strongly correlated quantum systems, exhibiting quantum chaos and holographic duality to 2D gravity. However, simulating its real-time dynamics on classical computers is intractable due to the exponential scaling of the Hilbert space and the chaotic nature of the system.

Simulating the SYK model on current Noisy Intermediate-Scale Quantum (NISQ) devices faces two primary hurdles:

Hamiltonian Complexity: The standard SYK model involves $O(N^4)$ interaction terms with all-to-all connectivity, leading to extremely deep circuits when using standard Trotterization.
Noise: The depth required for accurate simulation exceeds the coherence times of current hardware, causing results to be dominated by noise rather than physical dynamics.

2. Methodology

The authors propose a hybrid approach combining model sparsification, a randomized simulation algorithm, and tailored error mitigation techniques.

A. Model: Sparse SYK

Instead of the dense SYK model, the authors simulate a sparsified version where interaction terms are randomly sampled with probability $p$ .

Hamiltonian: $H = \sum p_{ijkl} J_{ijkl} \psi_i \psi_j \psi_k \psi_l$ .
Sparsity Parameter: They set $p = kN / \binom{N}{4}$ to maintain extensive energy while reducing the number of terms to $O(N)$ , making the model compatible with the chaotic properties of the dense model but significantly cheaper to simulate.
Encoding: For $N=24$ Majorana fermions, they use the Jordan-Wigner transformation to map fermions to 12 qubits ( $L=12$ ), plus 1 ancilla qubit.

B. Algorithm: TETRIS (Time Evolution Through Random Independent Sampling)

They employ TETRIS, a randomized Hamiltonian simulation algorithm.

Mechanism: Instead of discretizing time (Trotterization), TETRIS samples random unitary operators $U$ from a distribution such that $\mathbb{E}[U] = \lambda e^{iHt}$ .
Advantage: It eliminates Trotter discretization error. The gate cost scales as $O(t^2)$ , which is superior to Trotterization ( $O(t)$ but with high constant factors and discretization errors) for short-to-medium times and sparse Hamiltonians.
Gate Angle ( $\tau$ ): A tunable parameter controlling the number of gates. Smaller $\tau$ means more gates but less attenuation; larger $\tau$ means fewer gates but higher signal attenuation ( $\lambda$ ).

C. Error Mitigation Techniques

To combat hardware noise, two specific techniques were developed:

Echo Verification:
- Utilizes the ancilla qubit to measure the Loschmidt amplitude.
- Instead of discarding shots where the system register is not in the $|0\dots0\rangle$ state, the authors count single-bit-flip errors (Hamming weight 1) as valid contributions to the $|0\dots0\rangle$ projector. This leverages the conservation of fermionic parity to distinguish noise from physical dynamics, reducing variance.
Large Gate Angle Extrapolation (LGAE):
- A variant of Zero Noise Extrapolation (ZNE).
- By varying the gate angle $\tau$ , the number of gates in the circuit changes without altering the theoretical expectation value.
- The authors run circuits at a "shallow" angle ( $\tau_0$ ) and a "deep" angle ( $\tau_\alpha = \alpha \tau_0$ ). They extrapolate the results to the zero-noise limit (effectively $\tau \to \infty$ or gate count $\to 0$ ) using linear or exponential fits.

D. Benchmarking: Mirror-on-Average

The authors propose a new benchmark protocol using TETRIS.

Concept: Instead of a standard mirror circuit ( $U^\dagger U = I$ ), they use two independently sampled TETRIS circuits ( $U$ and $U'$ ).
Result: $U'^\dagger U$ is only proportional to the identity on average.
Benefit: This provides a scalable estimate of noise specifically for local observables, arguing that standard mirror circuits overestimate noise for local measurements.

3. Key Results

The experiment was conducted on the Quantinuum System Model H1 (trapped-ion, 20 qubits, all-to-all connectivity).

System Size: $N=24$ Majorana fermions (12 qubits + 1 ancilla).
Observable: Real part of the Loschmidt amplitude (vacuum survival probability) $\mathcal{L}(t) = \text{Re}\langle 0 | e^{iHt} | 0 \rangle$ .
Performance:
- The team successfully simulated dynamics up to $Jt \approx 1.0$ , observing the characteristic decay of the Loschmidt amplitude.
- LGAE Efficacy: Using LGAE with the "Echo Verification" observable ( $O = |0\dots0\rangle_{mit}$ ), the mitigated results recovered the exact theoretical values within one standard deviation.
- Noise Analysis: Theoretical modeling of the noise (global depolarizing channel) revealed that for certain observables ( $O=I$ ), noise can cause an upward bias in the signal, a counter-intuitive effect captured by their model.
Benchmarking: The "Mirror-on-Average" benchmark showed a decay rate for local observables that was significantly lower than standard mirror circuits, suggesting standard benchmarks are too pessimistic for local physics.

4. Resource Estimation & Scalability

The authors extrapolated the results to estimate resources for larger systems (e.g., $N=50, 100$ ) required to extract the quantum Lyapunov exponent (via OTOCs).

Gate Count: Using TETRIS with ternary tree encoding, the estimated two-qubit gate count for $L=50$ is $\sim 4 \times 10^6$ .
Runtime: Assuming 30ms per circuit depth, a single run would take ~30 hours. With parallelization, this could be reduced to ~2 hours.
Conclusion: While feasible, larger-scale simulations require further algorithmic improvements (e.g., sum-of-squares spectral amplification) or simplified Hamiltonians to remain within the capabilities of near-term hardware.

5. Significance

First Experimental Demonstration: This is a successful experimental simulation of the real-time dynamics of a sparse SYK model on a quantum processor, pushing the boundary of what is possible with current NISQ hardware.
Algorithmic Validation: It validates TETRIS as a superior alternative to Trotterization for sparse, chaotic Hamiltonians, particularly for short-time dynamics where it avoids discretization errors.
Error Mitigation Innovation: The combination of Echo Verification and LGAE demonstrates that tailored mitigation strategies can recover physical signals from noisy data where standard methods fail.
New Benchmarking Paradigm: The "Mirror-on-Average" protocol offers a more realistic assessment of noise for local observables, addressing a known limitation of standard benchmarking.
Path to Quantum Gravity: By successfully simulating the chaotic dynamics of the SYK model, this work moves closer to "Quantum Gravity in the Lab," providing a testbed for studying holographic duality and quantum chaos phenomena that are inaccessible to classical computation.