Pushing Fermi-Hubbard Simulation with Pauli-Propagation and QuEPP
In today’s era of quantum computing, hardware noise is the elephant in the room. Even the most elegant algorithms fall apart when qubits decohere or gates misfire, turning crisp theoretical results into unusable static. If we want to extract real value from quantum computers before fault-tolerance arrives, mitigating this noise isn’t just a “nice-to-have”—it’s an absolute necessity.
Quantum Enhanced Pauli Propagation (QuEPP) offers a practical workaround. Instead of trying to fix the hardware, QuEPP uses a statistical approach. By generating and executing a massive batch of modified circuits, it analyzes the spread of the results to mathematically trace back and extract a clean, mitigated expectation value. But writing the plumbing for QuEPP from scratch is a massive headache.
You end up writing hundreds of lines of boilerplate just to handle circuit branching, track different truncation orders, and manage parameter sweeps. It quickly turns a physics experiment into a software engineering chore. That’s exactly why we built QuEPP directly into Divi.
Instead of managing job parallelization and manual circuit generation yourself, Divi handles the routing behind the scenes. On top of that, QuEPP’s overhead grows with the size of the circuit, so blindly mitigating every qubit on the lattice is wasteful.
When it comes to the Fermi-Hubbard model, we’ve been seeing recently activity back and forth between Q-CTRL and Algorithmiq, debating whether there is a quantum advantage in the latest simulation of the Fermi-Hubbard model or not. We at Qoro are not algorithm developers, we simply provide the tools researchers need to get the best results for the experiments they want to try!
Nonetheless, the Fermi-Hubbard model is a great case for running on quantum computers, and even if there is no advantage today, there is still promise in the future. To get to that answer as fast as possible, we’ve shown in our previous blog that we can use a combination of simulation techniques to identify interesting regions of the full system to minimize the subsystem that has to be analyzed. There we used a cheap Clifford Pauli-Propagator pre-pass that identifies, via the Lieb-Robinson light cone, which sites actually develop non-trivial dynamics in the time window of interest.
In this blog, we follow up on this work. We again use the “Scout and Snipe” approach, but where in our last post we benchmarked GPU execution time, this time we run on IBM quantum hardware.
The Experiment: Revisiting the Fermi-Hubbard model
Despite its simplicity, the Fermi-Hubbard can describe phenomena such as phase transitions in solid-state physics, Mott insulation and high-temperature superconductivity.
It consists of a grid with two fermions per site to account for up and down spins. Interaction is restricted to spins on the same site, as well as to same-sign neighbouring spins. Because no analytical solution exists for two or more dimensions, simulation is the only way to understand these dynamics. And, since quantum simulation is one of the most promising avenues for near-term quantum advantage, testing these algorithms on real QPUs is of great interest.
For this benchmark, we modeled a 2D grid of 20 qubits which can hold an up and a down spin at each site. In the simulation, half of the grid is initialized at full occupation, while the other half starts out completely empty. Then, the domain wall is removed and the spins are allowed to interact for some time T. To solve the time evolution problem, we implement Trotterization with N steps, each evolving the system for dt = T/N timesteps.
The scout locates 12 qubits that have activity and should be analyzed. We prepare the circuits for those sites and apply error mitigation and compare against a raw execution on IBM quantum hardware. We show an improvement of 29% in accuracy, simply by turning on error mitigation in Divi. One setting.
From Simulation to Hardware, skipping the boilerplate
Using Divi, we can abstract the entire workflow. The framework handles translating the time evolution problem into quantum circuits in batch, executing the error mitigation protocol, and routing jobs to Qoro’s cloud execution service Solo, automating QPU access.
Instead of writing custom execution loops, we only define the Hamiltonian and the rest is handled by Divi’s TimeEvolution workflow. This abstracts away the hardware-specific routing so you can iterate on the physics:
For our Fermi-Hubbard experiment, we first run the scout to determine the active sites of the lattice. After that, we feed that reduced sub-lattice into a three-stage analysis:
- First, we run a standard, mitigation-free run on the QPU, using only optimized transpiling.
- Second, we turned on QuEPP to mitigate errors.
- We used Solo to run batch simulations to verify the result.
Before we sent off the first experiment, to fully understand the payload we were about to send to the IBM quantum computers, we could use Divi’s dry run feature to get the exact number of circuits that would be sent ahead of time, ensuring we don’t blow the budget.
The Results: 29% Improvement in Accuracy
In a setting with high interaction strength (U=5.0), difficult for QPUs due to decoherence pushing the “sharp” profile towards a mixed state, QuEPP manages to cut error down significantly.
We aren’t in the fault-tolerant era yet, but there are plenty of methods we can use today to boost the results we can obtain. Using these already known methods is currently up to the researcher to figure out how to make work. Divi provides the tools needed to explore quantum computing.
As our IBM hardware run showed, QuEPP managed to cut the mean absolute error by 29%, with up to 60% improvement on some sites. In high-interaction settings where quantum hardware usually struggles, error mitigation techniques—especially when paired with tools that handle the heavy lifting—are a massive step toward getting actual, useful mileage out of today’s QPUs.
The Impact
29% higher accuracy for fewer total circuits. While QuEPP requires 10x more circuits to mitigate errors, Divi automatically applies observable grouping behind the scenes, reducing the total required circuits by 12x. You get production-grade error mitigation without blowing your QPU budget.
At Qoro, we aren’t on the hunt for quantum advantage ourselves, but our mission is build the platform that helps you find it. The time your team wastes building the same old pipelines and managing infrastructure only delays your actual R&D breakthroughs.
It shouldn’t take weeks to get access basic infrastructure to run experiments and it shouldn’t be up to the scientists to understand every method of executing quantum algorithms.
With Solo, we handle it for you. Researchers focus on the algorithm, we handle the execution.
