Fault-tolerant quantum algorithms for simulating atomic nuclei

Researchers have developed new quantum algorithms to simulate the structure of atomic nuclei. They calculated how many qubits and operations a future quantum computer would need. They found that some nuclei are as challenging to simulate as complex molecules.

For decades, the quantum computing community has focused on the electronic structure problem in chemistry. This involves understanding how electrons interact within molecules. The math of electrons (fermions) is remarkably similar to the math of nucleons (protons and neutrons) inside an atomic nucleus. However, nuclear physics has remained a neglected frontier in quantum algorithm research. Most existing work targets near-term, noisy quantum devices. This leaves a gap in our understanding of what is required to simulate nuclei on large-scale, fault-tolerant quantum computers (FTQCs).

This paper bridges that gap by providing the first formal quantum resource estimates for fault-tolerant nuclear simulation. The authors navigate a tension between two modeling methods. "Phenomenological" shell models use simplified interactions to describe nucleons. "No-core" shell models derive forces from Chiral Effective Field Theory (EFT). These attempt to build the nuclear force from the ground up.

Beyond the electronic structure paradigm

The status quo in quantum simulation is biased toward electronic systems. In chemistry, the primary challenge is managing the Coulomb interaction between electrons. However, the authors note that nuclear physics introduces unique complexities. These break many of the shortcuts used in chemistry.

First, electrons move in the presence of a static ionic background. A nucleus is a self-bound system of nucleons with no external anchor. Second, nuclear interactions are not limited to two-body forces. Unlike electron-electron interactions in standard chemistry, the strong nuclear force requires three-body terms. These are interactions where three nucleons simultaneously influence one another.

Current approaches struggle with this dimensionality. The inclusion of these $n$-body terms ($n > 2$) leads to an exponential explosion in the complexity of the Hamiltonian (the mathematical description of the system's total energy). The authors argue that successes in electronic simulations may not translate directly to the nuclear regime. This is due to these specific structural differences.

Optimized selection via direct operator encoding

To tackle these Hamiltonians, the authors use a qubitization-based energy estimation algorithm. This approach relies on two primary components. A Prep oracle prepares a state representing the Hamiltonian's coefficients. A Sel (selection) oracle implements the Hamiltonian as a linear combination of unitaries (LCU).

The architectural pivot in this work is how they optimize the Sel circuit. Standard methods expand fermionic operators into a massive string of Pauli matrices (the standard language of qubits). The authors instead encode non-unitary $\sigma_{\pm}$ operators directly. In quantum computing, "non-unitary" means these operators do not preserve the total probability of the state, making them impossible to implement as simple quantum gates. The authors handle this by embedding them within a larger unitary structure through block-encoding.

Encoding them directly avoids the need to expand them into increasingly large sets of Pauli strings. This prevents the circuit size from ballooning as more-body terms are added.

The implementation follows a structured pipeline: 1. Jordan-Wigner Transformation: This maps fermionic operators (describing particles like protons) to spin-1/2 operators (the language of qubits). This allows the nuclear state to be represented in a qubit basis. 2. Phasing and Flipping: The Sel circuit is split into a phasing part and a flipping part. Phasing handles signs and weights. Flipping handles the creation or annihilation of particles. 3. Multiplexing and SwapUps: The authors use "SwapUp" operations to move particle indices within the register. This allows the circuit to address specific orbitals efficiently.

By integrating these steps into a single Sel circuit, the authors claim efficiency gains. They report a ~70% reduction in Toffoli gate counts (fundamental building blocks of fault-tolerant logic) for three-body terms. They also report a ~40% reduction for two-body terms compared to prior art [71].

Benchmarking against chemical standards

The paper’s results come from translating algorithmic optimizations into concrete hardware requirements. The authors report resource estimates in terms of Toffoli gates and logical qubits.

For phenomenological shell-model Hamiltonians, "M-scheme" partitioning is highly effective. This method breaks the Hamiltonian into smaller blocks based on angular momentum projection. By simulating these blocks separately, researchers can reduce the required qubit count. For $^{32}\text{Mg}$, the authors report this approach requires 746 logical qubits. They note these requirements are comparable to the resource estimates for simulating Femoco, a standard benchmark in quantum chemistry.

However, the landscape changes for no-core shell models. For these systems, resource requirements escalate sharply. For a light nucleus like $^{40}\text{Ca}$ (using Chiral EFT), the Toffoli gate counts reach $4.11 \times 10^{14}$ to $6.99 \times 10^{15}$. This suggests that the "brute force" approach used in chemistry may face difficulties in the more complex, multi-body reality of nuclear physics.

The scalability bottleneck of no-core models

The paper highlights several hurdles that prevent immediate practical application.

First, the effectiveness of symmetry-based partitioning depends on the Hamiltonian type. As shown in, partitioning works for phenomenological models.

However, it fails to provide meaningful relief for no-core shell models. The authors observe that two-body interactions remain the dominant terms in these models. They dominate both the 1-norm (the sum of absolute values of matrix elements) and the non-zero element count. Because these two-body terms must be duplicated across different symmetry sectors, the overhead outweighs the savings.

Second, there is the "initial state problem." An efficient energy estimation algorithm still requires an initial quantum state. This state must have a high overlap with the true ground state. The authors note that while the chemistry community has developed sophisticated methods for this, such as Matrix Product States (MPS), these are less mature in nuclear physics. This is especially true for systems involving three-body forces.

Finally, the authors caution regarding "long-range" nuclear interactions. Current chemistry-inspired optimization techniques, such as tensor factorization, may be ineffective. In chemistry, certain symmetries allow for massive Hamiltonian compression. In nuclei, the interaction may be too dense to benefit from these same methods.

Verdict: A roadmap, not a solution

This work is a vital piece of infrastructure for the field. It is not a "ready-to-run" manual.

If you seek a sign that quantum computers can simulate heavy nuclei, this paper provides it. The resource requirements for certain isotopes are in the same ballpark as the most challenging molecules in chemistry. However, existing toolkits from quantum chemistry cannot be ported wholesale to nuclear physics. The "no-core" models require fundamentally different, more bespoke algorithmic strategies. These must overcome the sheer density of three-body interactions.

The paper provides a clear signal. The path to useful nuclear simulation lies in developing new forms of tensor factorization and state-preparation protocols. These must be specifically tuned to the unique, multi-body, and long-range nature of the nuclear force. Code for generating these Hamiltonians is reportedly available via the NuHamil repository; see the paper for the canonical link.

Figures from the paper