A low-circuit-depth quantum computing approach to the nuclear shell model

This paper introduces a novel qubit mapping strategy for the Variational Quantum Eigensolver that assigns qubits to Slater determinants rather than single-particle states, enabling low-circuit-depth simulations of various nuclei on NISQ devices with errors mitigated by Zero-Noise Extrapolation to achieve less than 4% deviation from shell model predictions.

The Gist

The Big Picture: A New Way to Simulate the Atomic Nucleus

Imagine you are trying to simulate a complex dance troupe (the atomic nucleus) on a computer. The dancers are protons and neutrons, and they move according to strict rules (quantum mechanics).

For decades, scientists have used "classical" computers to predict how these dancers move. But as the troupe gets bigger, the number of possible dance formations explodes. It becomes like trying to count every grain of sand on a beach; the math gets too heavy for even the fastest supercomputers.

Quantum computers are the new hope. They are like super-powered calculators that can naturally handle these complex, entangled dances. However, current quantum computers are like "noisy" devices—they are prone to making mistakes (errors) and can't run very long, complex programs without falling apart.

This paper introduces a clever new strategy to run nuclear simulations on these imperfect, early-stage quantum computers.

---

The Problem: The "Single-Step" vs. The "Whole-Scene" Approach

To understand the authors' breakthrough, let's look at the two ways to map a nuclear problem onto a quantum computer.

1. The Old Way: The "Single-Step" Map (Single-Particle Basis)

Imagine you are directing a play. The traditional way to simulate the nucleus is to assign one "actor" (a qubit) to every single dancer (a single particle state).

• The Issue: If you have 12 dancers, you need 12 actors. But to make them dance together, you have to constantly tell them who to interact with. This requires a lot of complex instructions (gates) passed back and forth.
• The Result: The "script" (the quantum circuit) becomes incredibly long and complicated. On today's noisy computers, by the time the script finishes, the actors have forgotten their lines due to "noise" (errors).

2. The New Way: The "Whole-Scene" Map (Slater Determinant Basis)

The authors propose a different approach. Instead of assigning an actor to every single dancer, they assign an actor to represent a whole scene (a specific arrangement of all the dancers).

• The Analogy: Imagine you are filming a movie.
  • Old Way: You hire 100 extras and give each one a specific line. You have to direct every single interaction.
  • New Way: You hire 10 directors. Each director is responsible for one specific "scene" (a full configuration of the play).
• The Trade-off: You might need more directors (qubits) in total to cover all possible scenes. However, the instructions for each director are much simpler. They just need to know how to transition from one scene to another smoothly.
• The Benefit: The "script" becomes much shorter and simpler. Even though you have more directors, the instructions are so easy that the noisy computer can actually follow them without getting confused.

What Did They Do?

The team took this "Whole-Scene" strategy and tested it on seven different atomic nuclei, ranging from light ones (Lithium) to heavy ones (Polonium and Lead).

1. The Lightweights (Lithium): They simulated Lithium isotopes. They found that their new method produced results very close to the known "perfect" answers, with only a small error margin (about 2–7%).
2. The Heavyweights (Polonium & Lead): This was the big test. Simulating heavy nuclei usually breaks classical computers. They managed to simulate these heavy nuclei using 22 and 29 qubits. While the raw results were a bit off (due to hardware noise), the method proved it was possible to simulate these heavy systems on current hardware.

The Secret Sauce: Error Correction (Zero-Noise Extrapolation)

Since the quantum computers are "noisy," the results were initially a bit wobbly. To fix this, the authors used a technique called Zero-Noise Extrapolation (ZNE).

• The Analogy: Imagine you are trying to hear a whisper in a windy room.
  1. You listen once (the normal run).
  2. You turn up the wind volume to double the noise (adding extra "folds" to the circuit).
  3. You turn it up to triple the noise.
  4. You listen to the results at all three noise levels.
  5. You use math to draw a line back to "zero wind" (zero noise).

By running the simulation with increasing amounts of artificial noise and then mathematically "extrapolating" back to zero, they could guess what the perfect, noise-free answer would be.

The Result: After applying this trick, the errors dropped dramatically. For all seven nuclei, the final results were within 4% of the perfect theoretical answers. In some cases, like Lead-210, they went from being 85% off to less than 2% off!

Why Does This Matter?

This paper is a roadmap for the "near future" of quantum physics.

• Current Hardware is Limited: We don't have perfect quantum computers yet. They are small and noisy.
• The Trade-off: Usually, scientists think they need fewer qubits to be safe. This paper says, "Actually, if we use more qubits but make the instructions simpler, we can get better results on today's machines."
• The Future: As quantum computers get bigger (with hundreds or thousands of qubits), this "Whole-Scene" mapping will allow physicists to simulate heavy, complex nuclei that are currently impossible to study. It opens the door to understanding how stars explode, how elements are formed, and the fundamental forces of nature.

In a Nutshell

The authors found a way to simplify the "script" for quantum computers to simulate atomic nuclei. By grouping particles into "scenes" rather than tracking them individually, they created shorter, simpler programs that are more resistant to errors. Combined with a clever math trick to cancel out noise, they successfully simulated heavy atomic nuclei on today's imperfect quantum hardware, bringing us one step closer to unlocking the secrets of the universe.

Technical Summary

1. Problem Statement

The nuclear shell model is a fundamental paradigm for understanding atomic nucleus structure, typically solved using Configuration Interaction (CI) methods. However, classical simulations face the "curse of dimensionality," where the Hilbert space size grows combinatorially with the number of valence nucleons, rendering calculations for many exotic or heavy nuclei intractable.

While quantum computing offers a natural solution via exponential scaling of the multi-qubit Hilbert space, current Noisy Intermediate-Scale Quantum (NISQ) devices are limited by noise and decoherence. Standard approaches map individual single-particle states to qubits. While this minimizes qubit count, it often results in complex quantum circuits with high depth (requiring many two-qubit gates) to represent the necessary excitations (specifically double excitations in the $m$-scheme). These deep circuits are prone to error accumulation on current hardware, making accurate ground-state energy calculations difficult.

2. Methodology

The authors propose a novel Slater Determinant (SD) based qubit mapping strategy designed to prioritize circuit simplicity over qubit economy.

• Qubit Mapping Strategy:

  • Standard Approach: Maps each single-particle orbital to a qubit. Excitations between orbitals require complex multi-qubit operations (double Givens rotations).
  • Proposed SD Approach: Maps each valid Slater Determinant (a many-body configuration) to a single qubit.
  • Hamiltonian Reformulation: The shell model Hamiltonian is rewritten in the basis of SD configurations ($H = \sum H_{mn} \hat{A}^\dagger_m \hat{A}_n$). In this basis, transitions between configurations correspond to single excitations rather than double excitations.

• Ansatz Construction:

  • The variational quantum eigensolver (VQE) ansatz is constructed using a ladder of single-excitation Givens rotations.
  • This significantly reduces the circuit depth compared to the double-excitation ansatz required in single-particle mappings.
  • The Hamiltonian in the SD basis requires fewer Pauli terms to measure, further reducing overhead.

• Error Mitigation:

  • The authors employ Zero-Noise Extrapolation (ZNE) using two-qubit gate folding.
  • Specifically, they insert pairs of CZ gates (acting as identity) to artificially increase noise levels (scale factors $\lambda = 1, 3, 5$).
  • Results are extrapolated to the zero-noise limit using linear, polynomial, and exponential models.

• Systems Studied:

  • Light Nuclei: Four lithium isotopes ($^6$Li, $^7$Li, $^8$Li, $^9$Li) in the $p$-shell.
  • Medium Nucleus: $^{18}$F in the $sd$-shell.
  • Heavy Nuclei: $^{210}$Po and $^{210}$Pb (beyond the $^{208}$Pb core).
  • Hardware/Simulators: Simulations on IBM's FakeFez (noise model) and execution on real hardware ibm_pittsburgh.

3. Key Contributions

1. Novel Encoding: Introduction of an SD-to-qubit mapping that trades increased qubit count for drastically reduced circuit depth and gate complexity.
2. Feasibility for Heavy Nuclei: Demonstration that heavy nuclei like $^{210}$Po and $^{210}$Pb can be simulated as 22-qubit and 29-qubit systems, respectively, by restricting the basis to time-reversed pairs (a physically motivated truncation for ground states).
3. Hardware Validation: Successful execution of these circuits on real quantum hardware, showing that the simplified ansatz is robust against current noise levels.
4. Error Mitigation Success: Demonstration that ZNE can recover high-accuracy results even from raw hardware data that initially showed large deviations (e.g., 85% error in raw $^{210}$Pb data).

4. Results

• Resource Comparison (6Li & 18F):
  • For $^6$Li, the SD mapping required 8 qubits (vs. 12 for single-particle) but reduced the circuit depth from 132 to 36 (optimized) and significantly lowered the number of two-qubit gates.
  • For $^{18}$F, the SD mapping used 25 qubits vs. 24 for single-particle, but the circuit depth was reduced from 2055 to 213 (optimized), and Pauli terms were reduced from 2112 to 618.
• Accuracy (Noisy Simulation & Hardware):
  • Raw Results: Without mitigation, noisy simulations showed ~7% underbinding for lighter nuclei, while heavy nuclei showed significant deviations (up to 85% for $^{210}$Pb on hardware).
  • Post-Mitigation: After applying ZNE, the binding energies for all seven nuclei converged to within 4% of the exact shell model predictions.
  • Specific Case ($^{210}$Pb): Raw hardware results were 85% off; after linear ZNE, the error dropped to 1.19%.
• Optimizer Performance: The COBYLA optimizer demonstrated faster convergence compared to SLSQP and SPSA in the simulation phase.

5. Significance and Conclusion

This work establishes that circuit depth reduction is a more critical resource than qubit count for near-term nuclear physics simulations on NISQ devices.

• Trade-off: While the SD mapping increases the number of qubits required (which is becoming less of a bottleneck as hardware scales to 100+ qubits), it drastically simplifies the circuit topology. This makes the algorithm compatible with current hardware connectivity and noise profiles.
• Scalability: The approach is particularly effective for lighter nuclei and two-nucleon systems. For heavier systems, the method allows for feasible simulation by focusing on the most relevant SD configurations.
• Future Outlook: The authors suggest that as quantum hardware advances, this strategy of trading qubit count for reduced gate complexity offers a promising pathway for scalable, high-fidelity quantum simulations of nuclear structure, potentially extending to include three-nucleon forces within the same circuit design.

In summary, the paper provides a practical roadmap for applying VQE to nuclear shell models on current quantum hardware, proving that with the right encoding and error mitigation, accurate nuclear binding energies can be extracted despite hardware limitations.