⚛️ nuclear theory

Fault-tolerant quantum algorithms for simulating atomic nuclei

This paper presents the first construction and compilation of fault-tolerant quantum algorithms for simulating atomic nuclei using shell-model and no-core-shell-model Hamiltonians, providing initial resource estimates that reveal comparable costs to chemical benchmarks for shell-model cases but significantly higher requirements for no-core models, thereby highlighting both the potential and current challenges of nuclear simulations on quantum computers.

Original authors: James Benstead, Michael Garn, Neil Gaspar, Sean Greenaway, Angus Kan, Lloyd La Ronde, Chandan Sarma, Paul Stevenson

Published 2026-07-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: James Benstead, Michael Garn, Neil Gaspar, Sean Greenaway, Angus Kan, Lloyd La Ronde, Chandan Sarma, Paul Stevenson

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 the universe as a giant, cosmic LEGO set. For decades, scientists have been incredibly good at figuring out how the tiny, colorful bricks that make up molecules (like the ones in your body or the air you breathe) snap together. They've built powerful computer programs to predict how these molecular LEGO sets behave, which helps us design new medicines and materials. But there's another, even stranger set of bricks hiding deep inside the center of every atom: the atomic nucleus. These are made of protons and neutrons, which are also tiny particles, but they play by a much wilder set of rules than their molecular cousins.

Understanding how these nuclear bricks stick together is like trying to solve a puzzle where the pieces change shape, push and pull on each other in mysterious ways, and sometimes even need three pieces to hold hands at once just to stay together. This is the "nuclear many-body problem," and it's one of the toughest challenges in physics. Why does it matter? Because if we can crack the code of the nucleus, we unlock secrets about how stars explode, how new elements are forged in the cosmos, and how we can use nuclear energy more safely and efficiently. For a long time, our regular computers have struggled to solve these puzzles because the math gets so complicated so fast that it would take longer than the age of the universe to finish. But now, a new kind of computer is on the horizon: the quantum computer. These machines don't just count; they dance with probability, making them potentially perfect for simulating these tiny, chaotic nuclear worlds.

The New Nuclear Map

In this paper, a team of researchers from the UK and the US has taken a giant step toward using these future quantum computers to simulate atomic nuclei. Think of them as cartographers drawing the first detailed maps for a quantum expedition into the heart of the atom. While the quantum community has been busy mapping out chemical molecules and solid materials, they've largely ignored the nucleus until now. These authors are saying, "Wait a minute, the nucleus is just as important, and it's actually very similar to the chemistry problems we've already solved, just with a few extra twists."

The team didn't just talk about it; they built the actual blueprints. They wrote down specific quantum algorithms—step-by-step instructions for a quantum computer—to calculate the energy and structure of atomic nuclei. They focused on two main ways to describe the nucleus: the "shell model," which treats the nucleus like a building with floors and rooms where protons and neutrons live, and the "no-core shell model," which is a more complex, ground-up approach that doesn't assume any part of the nucleus is just a solid, unchanging foundation.

The Blueprint and the Cost

To make sure these algorithms would actually work on a real machine, the team had to do some serious accounting. In the world of quantum computing, "cost" isn't measured in dollars, but in two things: how many "qubits" (the quantum bits of information) you need, and how many "Toffoli gates" (a specific type of complex logic switch) you have to flip to get the answer.

The researchers tested their blueprints on three specific nuclei: Magnesium-24, Magnesium-32, and Astatine-219. They found that for the shell-model versions of these nuclei, the cost is surprisingly manageable. In fact, the resources needed to simulate Magnesium-32 are comparable to what's needed to simulate a famous molecule called FeMoco (which is crucial for understanding how plants make fertilizer). This is a big deal because FeMoco is considered the "gold standard" benchmark for quantum chemistry. If we can simulate a nucleus as well as we can simulate this complex molecule, we're on the right track.

However, the story gets a bit trickier when they tried the "no-core" approach, which is necessary for lighter nuclei like Calcium-40. Here, the resource requirements skyrocketed. The team suggests that while it's possible in theory, the current methods are too expensive to be practical right now. It's like trying to build a skyscraper with a hammer instead of a crane; you can do it, but you'll need a much better tool or a smarter strategy to make it happen in a reasonable time.

What This Means

The paper doesn't claim to have solved the nuclear puzzle yet. Instead, it provides the first-ever "price tags" for solving these problems on a fault-tolerant quantum computer (a machine that can fix its own mistakes). The authors suggest that while we are close to being able to simulate some nuclei effectively, we need to keep inventing new, specialized strategies to handle the most complex cases.

Ultimately, this work is a bridge. It connects the world of nuclear physics with the world of quantum computing, showing that the two fields can learn from each other. By highlighting where the costs are low and where they are high, the team hopes to inspire a long-term collaboration between nuclear scientists and quantum engineers. Their goal is to one day see a quantum computer successfully simulate an atomic nucleus, giving us a clearer picture of the fundamental building blocks of our universe.

Technical Summary: Fault-Tolerant Quantum Algorithms for Simulating Atomic Nuclei

Problem Statement
While fault-tolerant quantum computing (FTQC) has seen significant progress in simulating electronic structure (chemistry) and condensed matter systems, the simulation of atomic nuclei has received comparatively little attention from the quantum computing community. Nuclear structure presents a distinct many-body fermionic problem involving protons and neutrons. Unlike electronic systems, nuclei lack an ionic background, are self-bound systems governed by the strong nuclear force, and require the inclusion of three-body (and potentially higher-order) interactions derived from chiral effective field theory (EFT). Furthermore, the nuclear interaction is less well-understood than the Coulomb interaction, and the exponential scaling of the Hilbert space with particle number poses severe classical computational challenges. Despite these similarities to electronic problems and the critical importance of nuclear data for astrophysics and industry, existing quantum algorithmic work has largely focused on noisy, near-term heuristics rather than scalable, fault-tolerant approaches.

Methodology
The authors develop and compile specific quantum algorithms designed for fault-tolerant hardware to simulate nuclear structure. The core methodology involves:

Target Hamiltonians: The study utilizes two classes of nuclear Hamiltonians:
- Phenomenological Shell-Model Hamiltonians: These include empirical and phenomenological interactions for specific nuclei ( $^{24}\text{Mg}$ , $^{32}\text{Mg}$ , and $^{219}\text{At}$ ). These models typically assume an inert core (e.g., $^{16}\text{O}$ or $^{208}\text{Pb}$ ) and generally contain one- and two-body terms.
- No-Core Shell-Model Hamiltonians: Derived from Chiral EFT, these models do not assume an inert core and are constructed from first principles. They explicitly include one-, two-, and three-body interaction terms. The authors use the NuHamil software to generate these Hamiltonians, suitable for light nuclei up to approximately $^{40}\text{Ca}$ .
Algorithmic Framework: The authors employ qubitization-based quantum phase estimation (QPE). This approach requires encoding the Hamiltonian $H$ as a linear combination of unitaries (LCU) using two primary oracles:
- Preparation (Prep): Prepares a superposition state weighted by the coefficients of the Hamiltonian terms.
- Selection (Sel): A walk operator that selects the specific unitary terms based on the state prepared by Prep.
Circuit Optimization: A significant portion of the work focuses on optimizing the Sel and Prep circuits for nuclear Hamiltonians, specifically addressing the Jordan-Wigner transformation of fermionic operators.
- The authors introduce optimized circuits for one-, two-, and three-body terms that directly encode non-unitary $\sigma^{\pm}$ operators without expanding them into Pauli strings, a departure from prior art [71, 85].
- They utilize SwapUp operations and CNOT ladders to handle Jordan-Wigner Z-strings efficiently.
- For the three-body terms, they construct a unified Sel circuit that block-encodes one-, two-, and three-body terms simultaneously, rather than treating them as separate LCU components.
- The authors also explore a strategy for M-scheme Hamiltonians (where two-body terms are block-diagonal by total angular momentum projection $M$ ), allowing for the simulation of individual $M$ -blocks rather than the full Hamiltonian to reduce resource requirements.

Key Contributions

First Resource Estimates: The paper provides the first known quantum resource estimates (in terms of Toffoli gate counts and logical qubit counts) for fault-tolerant quantum simulation of atomic nuclei.
Algorithm Construction: The construction of qubitization-based energy estimation algorithms tailored specifically for nuclear Hamiltonians, including those with three-body interactions.
Circuit Improvements: The authors demonstrate that their circuit constructions achieve significant reductions in resource costs compared to prior art. Specifically, their Sel circuits achieve approximately a 50% reduction in Toffoli counts for one-body terms, ~40% for two-body terms, and an overall ~70% reduction when combining one-, two-, and three-body terms compared to the approach in [71].
Strategic Analysis: The work compares two simulation strategies: direct simulation of the full Hamiltonian versus simulating individual $M$ -blocks. The analysis shows that the $M$ -block approach is more resource-efficient regarding qubit counts and the physical size requirements of the error-corrected quantum computer.

Results
The authors compiled the algorithms for specific nuclear cases and reported the following resource estimates (assuming a target simulation error $\epsilon = 0.01$ MeV):

Shell-Model Nuclei ( $^{32}\text{Mg}$ and $^{219}\text{At}$ ): The resource estimates for the shell-model Hamiltonians of $^{32}\text{Mg}$ $^{32} Mg$ and $^{219}\text{At}$ $^{219} At$ are comparable to recent estimates for the simulation of the FeMoco active site (a standard benchmark in chemistry).
- For $^{32}\text{Mg}$ , the largest coherent QPE circuit requires roughly half the number of qubits but an order of magnitude more Toffoli gates than the best algorithms for FeMoco.
- For $^{219}\text{At}$ , the qubit count is similar to FeMoco, but the Toffoli count is again an order of magnitude higher.
No-Core Shell-Model ( $^{40}\text{Ca}$ ): For light nuclei using Chiral EFT Hamiltonians (up to $\sim^{40}\text{Ca}$ ), the resource requirements are significantly higher than for the shell-model cases. The authors note that the density of the Hamiltonian and the inclusion of three-body terms make these simulations currently impractical without more bespoke strategies.

Significance and Claims
The paper claims that these results represent a foundational step toward realizing useful nuclear simulations on quantum computers. By drawing parallels between nuclear and electronic structure problems while highlighting specific nuclear challenges (such as three-body forces and self-binding), the authors aim to spur long-term collaboration between the nuclear physics and quantum computing communities.

The authors modestly frame the work as a tool for generating resource estimates and demonstrating algorithmic feasibility rather than solving specific nuclear physics questions immediately. They emphasize that while the shell-model results are promising and comparable to chemical benchmarks, the no-core shell-model results indicate that further algorithmic innovation is required before such simulations become practicable on near-future fault-tolerant hardware. The ultimate goal stated is to enable the study of nuclear stability limits, nuclear shapes, and other open questions in nuclear structure that are currently inaccessible to classical computation.

More like this