Fermi-Hubbard on a quantum computer, part 4: the 120-qubit quantum run

Now we reach the question that motivates this project: what happens when we run the Fermi-Hubbard simulation on real quantum hardware?

The large local run in this project line follows the Q-CTRL/IBM scenario at a concrete scale:

60 Hubbard sites;
120 fermionic modes, hence 120 qubits;
U/t_h = -2;
30 Trotter steps;
final model time t = 6;
IBM hardware through Fire Opal.

The time relation is simple

\[t=n_{\mathrm{step}}\Delta t\qquad \Delta t=0.2,\quad n_{\mathrm{step}}=30,\quad t=6\]

Each Trotter step approximates a small piece of digital time evolution. More steps move us closer to the continuous dynamics, but they also make the circuit deeper.

What was measured?

The hardware returns bitstrings. Those bitstrings must be converted into local observables. In this project, the important quantities are occupation, charge, spin, and double occupancy.

\[n_\uparrow(i)=\langle n_{i,\uparrow}\rangle,\quad n_\downarrow(i)=\langle n_{i,\downarrow}\rangle\\ \mathrm{charge}(i)=n_\uparrow(i)+n_\downarrow(i)\\ \mathrm{spin}(i)=n_\uparrow(i)-n_\downarrow(i)\\ D(i)=\langle n_{i,\uparrow}n_{i,\downarrow}\rangle\]

These observables let us read the quantum run as a material-like picture. The x-axis is the site position in the 1D chain. The y-axis is Trotter step or model time. The color can represent charge or spin.

Conceptually, this resembles quantum gas microscope measurements of 1D Fermi-Hubbard chains. It is not the same experiment. A cold-atom figure may show a symmetric local quench around the center, while our digital run shows a global evolution on a 60-site chain. But the language is similar: position, time, charge, and spin.

Timing

For the 120-qubit / 30-step Fire Opal run, the local estimated main+readout circuit execution time is approximately:

33.148928 seconds.

This is not the full human workflow time. It is also not the same as cloud wall time including queueing and service overhead. We therefore have to distinguish three times:

quantum execution proxy: estimated hardware circuit execution;
observed action wall time: the visible time taken by the cloud action;
end-to-end workflow time: preparation, validation, post-processing, and human decisions.

For a fair benchmark, we must state which time we mean. The 33 seconds are most interesting as an execution-time proxy for the quantum route.

Raw or readout corrected?

One unexpected lesson from the local comparison is that readout correction does not automatically improve every observable. For some global quantities, such as total charge, readout correction can help. For local RMSE against a chi256 reference, raw data can sometimes score better.

That is not a paradox. Error mitigation is not magic. It shifts errors. It may improve a global constraint while worsening some local observables. This is why we need multiple metrics.

Comparison with chi256

The local chi256 MPS reference had a wall time of 9033 seconds. Against that reference, the hardware was not perfect. But it did produce a useful full-instance estimate in a very short quantum execution time.

In the local scoring, the raw hardware route had a better overall score than the readout-corrected route against chi256. That is an important practical point: we should measure the data, not assume that the most corrected variant is always best.

What can we claim?

A cautious statement is

The quantum run quickly gives a useful local observable for a 120-qubit / 60-site Fermi-Hubbard instance. This does not prove that classical methods fail, but it is a concrete time-to-answer benchmark.

What we should not say

not that all classical computers are beaten;
not that the full wavefunction has been simulated;
not that noise no longer matters;
not that the local run fully reproduces the Q-CTRL paper claim.

What we can say

the circuit runs on real hardware;
the observables are material-like and interpretable;
the timing is interesting relative to local classical references;
the comparison becomes fair only when tensor networks and Majorana propagation are included.

This makes the quantum run the middle of the story, not the end. The next question is: how hard can classical methods fight back?

Sources and project links

Q-CTRL Fermi-Hubbard paper: https://arxiv.org/abs/2605.04025
Project repository: https://github.com/BramDo/fermi-hubbard-60q-tdvp
Fire Opal route in the repository: docs/fire_opal_route.md