⚛️ quantum physics

Scalable Simulation of Fermionic Encoding Performance on Noisy Quantum Computers

Using high-performance classical simulations with complex error models on large system sizes, this study evaluates the Derby-Klassen fermionic encoding against Jordan-Wigner and ternary tree encodings, finding that the high sampling costs of its postselection-based error mitigation limit its near-term applicability and highlight the need for encoding-specific circuit optimizations.

Original authors: Emiliia Dyrenkova, Raymond Laflamme, Michael Vasmer

Published 2026-02-27

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Emiliia Dyrenkova, Raymond Laflamme, Michael Vasmer

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

Imagine you are trying to simulate a complex dance party where the dancers are fermions (a type of subatomic particle like electrons). These dancers have a very strict rule: no two of them can ever stand in the exact same spot at the same time (the Pauli Exclusion Principle).

To simulate this dance on a quantum computer, we have to translate the dancers' moves into a language the computer understands: qubits (quantum bits). This translation process is called encoding.

This paper is essentially a "stress test" report. The authors asked: Which translation method works best when the quantum computer is noisy and prone to mistakes?

Here is the breakdown using everyday analogies:

1. The Problem: The "Noisy Room"

Imagine trying to have a serious conversation in a room where the walls are shaking, people are shouting, and the lights are flickering. This is what a current quantum computer is like. It's powerful, but it's noisy. Every time you try to do a calculation, there's a chance the "noise" will scramble your data.

To fix this, scientists use error mitigation. It's like having a friend in the room who checks your notes. If they see a mistake, they say, "Hey, that doesn't make sense, let's throw this attempt away and try again."

2. The Three Translators (Encodings)

The paper compares three different ways to translate the fermion dance into qubit language:

The Old School Translator (Jordan-Wigner):
- The Analogy: Imagine a long line of people passing a message down a chain. To tell the person at the end of the line what to do, you have to whisper to everyone in between.
- The Issue: It's efficient with space (uses few qubits), but the "message" gets very long and complicated. If one person in the middle sneezes (makes an error), the whole message gets garbled.
The Tree Translator (Ternary Tree):
- The Analogy: Instead of a line, imagine a family tree. Messages branch out.
- The Issue: It's a bit more organized, but it requires more people (qubits) to build the tree, and it's still hard to spot exactly where a mistake happened.
The Compact Translator (Derby-Klassen / DK):
- The Analogy: This is like a grid of neighbors. Every house (qubit) has a specific relationship with its immediate neighbors. Crucially, this method has local stabilizers.
- The Superpower: Think of these stabilizers as security cameras placed on every street corner. If a neighbor breaks a rule (an error occurs), the camera immediately flashes red. This allows the system to detect errors very locally and precisely.

3. The Experiment: The "Stress Test"

The authors didn't just guess; they built a super-fast computer simulation (a "digital twin") to run thousands of these dance simulations. They tested the three translators under different levels of "noise" (from a quiet room to a chaotic mosh pit).

They looked at two main things:

Accuracy: How close was the final result to the truth?
Sampling Cost: How many times did they have to throw away a failed attempt (due to the security cameras flashing red) before they got a good result?

4. The Surprising Results

Here is what they found, which might seem counterintuitive:

The "Perfect" Translator has a Catch: The Derby-Klassen (DK) encoding is the most sophisticated. It has the best security cameras (stabilizers) and can spot errors better than the others. However, because it is so strict, it rejects so many attempts that you have to run the simulation millions of times just to get a handful of valid results.
- The Metaphor: Imagine a bouncer at a club who is so strict that he kicks out 99% of the guests. Even though the people inside are perfect, you have to wait in line for hours just to get one person in.
The "Old School" Translator is Still Useful: The Jordan-Wigner method, while less precise at spotting errors, is much faster. It doesn't reject as many attempts. In the current "noisy" era of quantum computing, being fast and getting some data is often better than being perfect but getting no data.
The Verdict: For the quantum computers we have today (and in the near future), the high cost of checking the DK security cameras makes it impractical for large, complex simulations. The "Old School" method, combined with a simple global check (Global Parity Postselection), actually performed better in terms of getting usable results.

5. The Takeaway

The paper concludes that while the Derby-Klassen encoding is a brilliant idea with huge potential for the future (when quantum computers are quieter and more powerful), it is currently too "expensive" in terms of time and computing power to use for large-scale simulations.

The Bottom Line:
We found a Ferrari (DK encoding) that drives perfectly but gets terrible gas mileage. We also have a reliable Toyota (Jordan-Wigner) that gets great gas mileage but isn't as fast. Right now, for our long road trip, the Toyota is the better choice. But once we invent better fuel (better quantum hardware), we might be able to switch to the Ferrari.

The authors suggest that to make the Ferrari work, we need to either build better engines (hardware) or find a way to make the Ferrari more fuel-efficient (better circuit optimizations).

1. Problem Statement

Simulating fermionic systems (e.g., in quantum chemistry and materials science) is a primary target for quantum computers. However, mapping fermionic operators to qubit operators introduces significant challenges:

Locality vs. Efficiency: The standard Jordan-Wigner (JW) encoding is efficient in qubit count ( $n$ qubits for $n$ modes) but results in non-local, high-weight operators (requiring long strings of Pauli $Z$ gates), which increases circuit depth and error susceptibility.
Alternative Encodings: Local encodings like Ternary Tree (TT) and Derby-Klassen (DK) map local fermionic operators to local qubit operators but often require more qubits per mode or introduce complex stabilizer structures.
Error Mitigation: Encodings with local stabilizers (like DK) allow for error detection via postselection (discarding runs where stabilizer measurements fail). However, it is unclear if the accuracy gains from error detection outweigh the massive sampling overhead (postselection cost) on near-term noisy devices.
Simulation Limitations: Predicting performance for large systems (e.g., $18 \times 18$ lattices) is classically intractable for general quantum circuits, necessitating efficient simulation methods that can handle large scales while modeling realistic noise.

2. Methodology

The authors employed high-performance stabilizer circuit simulation using the Stim library to benchmark fermionic encodings at scales far beyond previous studies (up to $18 \times 18$ lattices and 40 Trotter steps).

Encodings Compared:
- Jordan-Wigner (JW): Standard encoding with fermionic swap networks for optimization.
- Ternary Tree (TT): An asymptotically optimal one-to-one encoding minimizing average operator weight.
- Derby-Klassen (DK): A compact encoding optimized for 2D square lattices (Fermi-Hubbard model) featuring local stabilizers.
Error Models:
- Standard Depolarizing (SD): Uniform noise on gates.
- Superconducting Inspired (SI): A more realistic model with lower single-qubit error rates and higher measurement errors, mimicking superconducting hardware.
Circuit Construction:
- Simulated mirror circuits ( $U U^\dagger$ ) to ensure deterministic logical outcomes for benchmarking.
- Implemented Trotterized time evolution for the Fermi-Hubbard Hamiltonian.
- Tested various Error Mitigation (EM) strategies for DK:
  - Global Parity (GP): Discarding runs with odd total parity.
  - Stabilizer Reconstruction (SR): Measuring stabilizers to detect errors and postselecting.
  - Flag Qubits: Detecting high-weight error propagation during stabilizer measurement.
  - Virtual Quantum Error Detection (VQED): A technique using random stabilizer measurements to estimate expectation values.
Metrics:
- Observable Error Rate ( $R_{obs}$ ): The probability of measuring an incorrect observable.
- Error Detection Rate ( $R_{det}$ ): The fraction of runs discarded due to detected errors.
- Sampling Overhead: The inverse of the survival rate after postselection.

3. Key Contributions

Scalable Simulation Framework: Demonstrated the ability to simulate fermionic encodings on lattices up to $18 \times 18$ (324+ qubits) using stabilizer formalism, a scale previously inaccessible for detailed noise analysis.
Comprehensive Benchmarking: Provided a direct comparison of JW, TT, and DK encodings under realistic noise models, moving beyond theoretical operator weight analysis to actual circuit performance.
Quantification of Postselection Costs: Systematically analyzed the trade-off between accuracy improvements from error detection (specifically in DK) and the exponential increase in sampling requirements.
Circuit Optimization Insights: Validated that specialized circuit optimizations (like fermionic swap networks for JW and parallelized Trotter steps for DK) are critical for performance, often outweighing the benefits of lower operator weight in TT.

4. Key Results

JW vs. DK vs. TT:
- TT Encoding: Despite having optimal average operator weight, TT performed poorly compared to optimized JW and DK circuits. The lack of specialized circuit optimizations and higher gate counts negated the theoretical locality advantage.
- JW Encoding: With fermionic swap networks and global parity postselection, JW provided robust, low-error results, particularly in the "near-future" error regime ( $p=0.1\%$ ).
- DK Encoding: Showed the best potential accuracy in the "aspirational" regime ( $p=0.01\%$ ) when using Stabilizer Reconstruction (SR). SR significantly reduced observable error rates compared to JW and TT.
The Sampling Bottleneck:
- The primary limitation of the DK encoding is the sampling overhead. As circuit depth (Trotter steps) and lattice size increase, the error detection rate rises, causing the survival rate of samples to drop exponentially.
- For a $16 \times 16$ lattice at $p=0.01\%$ , the DK encoding exhausted the simulation budget ($100,000$ shots) after only 6 Trotter steps, whereas JW could simulate deeper circuits with acceptable error rates.
- The "diminishing returns" of DK are evident: beyond a certain point, the cost of acquiring enough valid samples outweighs the accuracy gain.
Error Mitigation Techniques:
- Stabilizer Reconstruction (SR) was superior to Global Parity (GP) for DK, offering finer-grained error detection.
- Flag Qubits and VQED did not provide significant improvements over standard stabilizer measurement in terms of accuracy or sampling efficiency for the tested scenarios.
Error Models: The Superconducting Inspired (SI) model showed similar trends to the Standard Depolarizing model, though slightly favoring DK due to lower single-qubit gate errors.

5. Significance and Conclusion

Practicality for Near-Term Devices: The study concludes that while the DK encoding offers theoretical advantages in error detection, its high sampling requirements make it impractical for near-term devices unless physical error rates are extremely low (aspirational regime) or specialized circuit optimizations are applied.
Role of Circuit Optimization: The results emphasize that circuit structure and optimization (e.g., swap networks, parallelization) are currently more impactful for performance than the choice of encoding alone.
Future Directions:
- The authors suggest that for DK to be viable, it may need to be concatenated with a Quantum Error Correction (QEC) code (like the surface code) to suppress logical errors before postselection is applied.
- Further work is needed to develop encoding-specific circuit optimizations to reduce the depth and sampling cost of DK-based simulations.
- Experimental validation on hardware is recommended to test the validity of the stabilizer simulation predictions against real-world noise (e.g., leakage, coherent errors).

In summary, the paper provides a critical reality check on fermionic encodings: while local encodings with error detection (DK) are promising for future fault-tolerant regimes, their high sampling costs currently limit their utility on noisy intermediate-scale quantum (NISQ) devices compared to optimized standard encodings like Jordan-Wigner.