⚛️ quantum physics

Quantum Utility in Simulating the Real-time Dynamics of the Fermi-Hubbard Model using Superconducting Quantum Computers

This paper demonstrates quantum utility by successfully simulating the real-time relaxation dynamics of a 100+ qubit one-dimensional Fermi-Hubbard model on IBM's superconducting quantum computers using optimized Trotterization schemes, achieving results that surpass conventional classical approximation methods.

Original authors: Talal Ahmed Chowdhury, Vladimir Korepin, Vincent R. Pascuzzi, Kwangmin Yu

Published 2026-03-26

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Talal Ahmed Chowdhury, Vladimir Korepin, Vincent R. Pascuzzi, Kwangmin Yu

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 City

Imagine you are trying to understand how a massive, chaotic city behaves. In this city, the "citizens" are electrons, and they are incredibly social but also very picky. They like to move around (hop between houses), but if two citizens try to live in the exact same house at the same time, they get into a huge fight (this is the "repulsion").

This is the Fermi-Hubbard Model. It's a famous mathematical recipe used by physicists to describe how electrons behave in materials like superconductors or magnets.

The Problem:
For decades, supercomputers (the biggest, fastest classical computers we have) have tried to simulate this city. But as the city gets bigger, the math gets so complicated that the computer runs out of memory and crashes. It's like trying to calculate the traffic patterns of every car in the world simultaneously; the numbers just get too huge.

The Solution:
The authors of this paper decided to use a Quantum Computer instead. Think of a quantum computer not as a calculator, but as a "nature simulator." Instead of doing math about the electrons, it builds a tiny, artificial version of the electron city using light and electricity, letting the laws of physics do the work for it.

The Challenge: The "Heavy Hex" Maze

The researchers used IBM's superconducting quantum computers. These machines are built like a specific type of city grid called a "heavy-hexagonal lattice."

The Constraint: In this city, a house (qubit) can only talk directly to its immediate neighbors. It cannot shout across the street to a house three blocks away.
The Physics Problem: In the real electron world, an electron at one end of the chain needs to interact with an electron at the other end.
The Analogy: Imagine you are in a line of people holding hands. You need to pass a message to the person at the very end of the line, but you can only whisper to the person next to you. To get the message across, you have to pass it down the line, one by one. In a quantum computer, doing this "passing" requires extra operations called SWAP gates, which are slow and prone to errors (like a game of "telephone" where the message gets garbled).

The Innovation: The "Scalable" Blueprint

The team's biggest breakthrough was designing a new way to organize the simulation so that the "message passing" didn't slow down as the city got bigger.

The Map (Qubit Encoding): They arranged the electrons on the quantum chip in a very specific pattern. Instead of placing them randomly, they paired them up so that the "neighbors" in the electron world were also "neighbors" on the chip. This minimized the need for long-distance shouting.
The Time Machine (Trotterization): To simulate time moving forward, they broke the simulation into tiny steps (like frames in a movie).
- First-Order Step: They took a simple step forward.
- Second-Order Step: They refined this to take a "half-step forward, look back, half-step forward" approach, which is more accurate.
- The Optimization: They realized that by merging certain steps together, they could make the "movie" smoother without making the film reel longer.

The Magic Trick:
Usually, if you double the size of the city (add more electrons), the complexity of the simulation doubles or triples. But the authors proved that their method is scalable.

Analogy: Imagine building a tower of blocks. Usually, if you make the tower twice as wide, you need four times as many blocks to keep it stable. But their method is like a special Lego set where, no matter how wide you make the tower, the height of the structure needed to keep it stable stays the same. This means they could simulate a city with 104 qubits (over 100 electrons) without the computer getting overwhelmed.

The Race Against Time: Noise vs. Reality

Quantum computers are currently "noisy." They are like a radio station with a lot of static. The "static" (errors) gets worse the longer you run the simulation.

To fix this, the team used a toolkit of Error Mitigation techniques (their "noise-canceling headphones"):

TREX: Randomly flipping bits to cancel out measurement errors.
Dynamical Decoupling: Shaking the system gently while it's waiting to keep it from getting "drowsy" (decoherence).
Zero-Noise Extrapolation: Running the simulation with more noise on purpose, then mathematically guessing what the result would be if there were no noise at all.

The Results: Beating the Classical Giants

They ran the simulation on two IBM computers:

Small Scale (20 qubits): They compared their results to a perfect classical calculation. The quantum computer matched the perfect math almost exactly, proving their method works.
Large Scale (104 qubits): This is where the magic happened.
- Classical Computers: Even the best supercomputers using "Matrix Product States" (a clever approximation method) started to fail after a certain time. Why? Because as time passes, the electrons get "entangled" (their fates become linked across the whole city). To simulate this, the classical computer needs exponentially more memory, eventually running out of RAM.
- The Quantum Computer: Because the quantum computer is the system, it didn't need extra memory to store the entanglement. It handled the complexity naturally.

The Verdict:
The quantum computer successfully simulated the relaxation of the "Néel state" (a specific magnetic pattern) for a system of 104 qubits over a significant period. This is a task that is currently impossible for classical supercomputers to do accurately.

Why This Matters

This paper is a milestone because it moves quantum computing from "theoretical potential" to practical utility.

Before: We could only simulate tiny, simple systems on quantum computers.
Now: We have a blueprint to simulate large, complex systems that classical computers simply cannot touch.

The Takeaway:
Think of this as the first time a human successfully built a working model of a hurricane in a wind tunnel that was larger than the hurricane itself. We didn't just calculate the wind speed; we actually created the wind. This proves that quantum computers are ready to help us discover new materials, better batteries, and perhaps even room-temperature superconductors, by simulating the complex dance of electrons in ways we never could before.

1. Problem Statement

The Fermi-Hubbard model is a cornerstone of condensed matter physics, describing strongly correlated electron systems. While the one-dimensional (1D) version is integrable and solvable, simulating its real-time dynamics for large systems remains a significant challenge for classical computers.

Classical Limitations: Exact diagonalization is limited to small system sizes ( $N \lesssim 40$ qubits) due to the exponential growth of the Hilbert space. Classical approximation methods, such as Matrix Product States (MPS), struggle with time evolution because quantum states not in eigenstates develop long-range correlations and volume-law entanglement, requiring exponentially large bond dimensions that exceed current computational resources.
Quantum Hardware Constraints: Realizing large-scale quantum simulations on superconducting processors (like IBM's) is hindered by limited qubit connectivity (heavy-hexagonal lattice), finite coherence times, and high error rates, particularly for two-qubit gates.

2. Methodology

The authors propose a scalable quantum simulation framework tailored for IBM's superconducting quantum processors, utilizing over 100 qubits.

A. Model and Qubit Encoding

Model: 1D Fermi-Hubbard model with open boundary conditions, $L$ lattice sites, hopping parameter $t=1$ , on-site interaction $U=1$ , and zero chemical potential.
Qubit Mapping: To accommodate the heavy-hexagonal topology of IBM devices, the authors map each fermionic site $j$ $j$ to two neighboring qubits ( $2j$ $2 j$ and $2j+1$ $2 j + 1$ ).
- This encoding ensures that hopping terms (nearest-neighbor in fermions) map to next-nearest-neighbor interactions in the qubit register, and on-site interactions map to nearest-neighbor qubit interactions.
- This specific mapping avoids the need for long-range SWAP chains, keeping the circuit depth independent of system size.

B. Trotterization Schemes

The time evolution operator $U(\tau) = e^{-iH\tau}$ is decomposed using Trotter-Suzuki decomposition.

First-Order Trotterization: A standard decomposition of the Hamiltonian into hopping, interaction, and chemical potential terms.
Optimized Second-Order Trotterization:
- The authors introduce a symmetric splitting (Strang splitting) for higher accuracy.
- Key Optimization: They merge adjacent unitary layers between consecutive Trotter steps. For example, two interaction layers $\hat{U}_U(\theta_U/2)$ from adjacent steps are combined into a single $\hat{U}_U(\theta_U)$ .
- Scalability: Crucially, the circuit depth per Trotter step remains constant regardless of the number of qubits ( $N=2L$ ). This is achieved by parallelizing operations and utilizing the specific qubit connectivity, avoiding the $O(N)$ depth penalty often seen in periodic boundary condition simulations.

C. Error Mitigation

To combat noise on real hardware, the study employs a suite of Quantum Error Mitigation (QEM) techniques:

Twirled Readout Error Extinction (TREX): Randomizes measurement errors to make them uniform and correctable.
Dynamical Decoupling (DD): Applies pulse sequences to idle qubits to suppress decoherence.
Pauli Twirling (PT): Converts coherent errors in two-qubit gates (CZ) into stochastic noise.
Zero-Noise Extrapolation (ZNE): Scales noise levels (via gate folding) and extrapolates to the zero-noise limit.

3. Key Contributions

Scalable Circuit Architecture: The development of Trotter circuits where the depth is independent of system size ( $L$ ). This allows simulations on 104 qubits ( $L=52$ ) with the same circuit depth complexity as 20 qubits ( $L=10$ ).
Optimized Second-Order Scheme: The introduction of a merged-layer second-order Trotterization that reduces circuit depth while maintaining higher accuracy than first-order methods.
Large-Scale Demonstration: Successful simulation of the 1D Fermi-Hubbard model on 104 qubits (IBM Marrakesh and Kingston processors), a scale beyond the reach of classical exact methods.
Quantum Utility Validation: Demonstration that superconducting quantum computers can outperform classical tensor network methods (MPS) in the regime of high entanglement and long-time evolution, where MPS fails due to bond dimension truncation.

4. Results

The study simulated the relaxation dynamics of the Néel observable (staggered magnetization) starting from a Néel product state.

Small System Validation ( $L=10, N=20$ ):
- Results from IBM Kingston (using QEM) showed excellent agreement with exact classical diagonalization and noiseless Qiskit simulations.
- The optimized second-order Trotterization provided higher accuracy than the first-order approach.
- Low standard deviation across multiple runs confirmed the reliability of the error mitigation strategy.
Large System Simulation ( $L=52, N=104$ ):
- Simulations were run on IBM Marrakesh (First-order) and Kingston (Optimized Second-order).
- Comparison with Classical Methods: The quantum results agreed well with the MPS-TDVP (Matrix Product State - Time Dependent Variational Principle) classical method up to simulation time $\tau \leq 4$ .
- Divergence at Long Times:
  - Classical Failure: For $\tau > 4$ , the MPS method failed because the entanglement entropy grew exponentially, requiring a bond dimension ( $\chi$ ) that exceeded the memory capacity of the 40GB NVIDIA A100 GPU.
  - Quantum Performance: The quantum computer continued to provide results, though noise accumulation (specifically from CZ gates) began to degrade accuracy at longer times. However, the quantum approach successfully accessed a time regime where the classical approximation broke down.
Circuit Metrics:
- For $L=52$ and 10 Trotter steps, the total circuit depth was $\approx 515$ (First-order) and $\approx 860$ (Optimized Second-order).
- Critically, these depths were nearly identical to those for $L=10$ , confirming the size-independence of the circuit depth.

5. Significance

This work establishes a clear milestone in Quantum Utility:

Beyond Classical Reach: It demonstrates that current noisy intermediate-scale quantum (NISQ) devices can simulate quantum many-body dynamics in regimes (large system size + long time + high entanglement) where classical tensor network methods fail.
Scalability Proof: The constant-depth circuit design proves that superconducting quantum architectures can scale to larger systems without a linear penalty in circuit depth, provided the connectivity constraints are respected.
Future Directions: The methodology paves the way for studying more complex phenomena in the Fermi-Hubbard model, such as spin-charge separation, entanglement entropy dynamics, and information scrambling, which are currently intractable for classical computers.

In conclusion, the paper validates that with optimized circuit design and robust error mitigation, superconducting quantum computers can serve as powerful tools for exploring the real-time dynamics of strongly correlated systems, offering a distinct advantage over classical approximation methods in highly entangled regimes.