NuLattice: Ab initio computations of atomic nuclei on lattices

NuLattice is a Python software package that enables ab initio computations of light atomic nuclei on lattices using methods like Hartree-Fock and coupled cluster theory with pion-less effective field theory interactions, allowing such calculations to be performed on standard laptops.

The Gist

Imagine the atomic nucleus as a tiny, chaotic dance floor where protons and neutrons (the dancers) are constantly interacting. Physicists have long tried to predict exactly how these dancers move and stick together using complex math. Usually, this requires massive supercomputers and years of work because the "dance floor" they use to calculate these movements is very crowded and messy.

This paper introduces a new tool called NuLattice, a software package that lets researchers run these complex nuclear calculations on a standard laptop. Here is how it works, explained simply:

1. The Problem: The "Harmonic Oscillator" Dance Floor

Traditionally, physicists use a mathematical grid called a "harmonic oscillator basis" to map out the nucleus. Think of this like trying to describe a crowded dance floor using a giant, swirling spiral pattern.

• The Issue: In this spiral pattern, a simple, short-range interaction (like two dancers bumping elbows) looks incredibly complicated and spread out across the whole room. To store all the math for just a few dancers, you would need terabytes of data—enough to fill a small server room. This forces scientists to use supercomputers and make heavy approximations.

2. The Solution: The "Lattice" Grid

The authors of this paper switched to a spatial lattice. Imagine replacing the swirling spiral with a simple, clean checkerboard.

• The Advantage: On a checkerboard, if two dancers interact, they are usually right next to each other. This keeps the math "sparse" (mostly empty space with just a few important numbers).
• The Result: Because the data is so sparse, the computer doesn't need to carry around a heavy backpack of information. It can fit the entire calculation for light nuclei (like Helium or Carbon) into the memory of a laptop.

3. The Tools in the Box

NuLattice comes with a set of "methods" (tools) to solve the dance floor puzzle, ranging from simple to complex:

• Hartree Fock: A quick, rough sketch of the dance. It assumes everyone dances independently in an average crowd.
• Coupled Cluster: A more detailed look that accounts for pairs of dancers interacting.
• Full Configuration Interaction (FCI): The "perfect" solution that tracks every possible move every dancer could make. This is the gold standard but usually too hard to calculate.
• IMSRG: A method that slowly smooths out the interactions to make them easier to solve.

4. What They Found

The team used NuLattice to simulate light nuclei (from Hydrogen-2 up to Oxygen-16) using a simplified version of nuclear physics called "pion-less effective field theory."

• Laptop Power: They successfully ran these simulations on a laptop, proving that you don't always need a supercomputer for these specific types of problems.
• The "Mean Field" Surprise: For the nuclei they studied, the simple "Hartree Fock" sketch (the rough average) actually captured most of the energy. The complex, detailed corrections (like the Coupled Cluster method) only added small tweaks. This suggests that for these specific, short-range interactions, the "average" behavior of the nucleus is very dominant.
• The Limitation: They found that their simplified physics model could not bind certain clusters of particles (like turning an Alpha particle into a larger nucleus) because the model treats interactions as having zero range (like touching points rather than fuzzy clouds). This is a known limitation of the specific theory they used, not necessarily a flaw in the software.

5. Why This Matters

The paper emphasizes that NuLattice is open-source (free for anyone to use) and written in Python (a popular, easy-to-read programming language).

• Education: Because it runs on laptops, teachers can use it to show students how nuclear physics works without needing a supercomputer lab.
• Research: It allows researchers to quickly test new ideas and "what-if" scenarios.

In short: NuLattice is a new, user-friendly software toolkit that turns the messy, supercomputer-heavy task of simulating atomic nuclei into a manageable project for a laptop, making nuclear physics more accessible to students and researchers alike.

Technical Summary

Technical Summary of "NuLattice: Ab initio computations of atomic nuclei on lattices"

Problem Statement
Ab initio computations of atomic nuclei, which utilize Hamiltonians derived from effective field theories (EFT) of quantum chromodynamics, traditionally rely on harmonic oscillator bases. While effective for many applications, this approach suffers from significant computational bottlenecks when dealing with large model spaces or three-nucleon forces. Specifically, the harmonic oscillator basis "scrambles" local, short-range nuclear interactions, transforming them into non-local operators with dense matrix representations. For three-nucleon forces, this results in the need to generate and store tens of terabytes of data, making the construction of the Hamiltonian more computationally expensive than the subsequent solution of the many-body problem. Consequently, these methods often require massive supercomputing resources and are inaccessible to many researchers and educators.

Methodology
The paper introduces NuLattice, a Python software package designed to perform ab initio computations using a spatial lattice as the single-particle basis. This approach leverages the short-range nature of nuclear forces (specifically within pion-less effective field theory at leading order) to maintain sparse data structures.

• Lattice Formulation: The single-particle basis is defined on a cubic lattice with $L^3$ sites. The Hamiltonian consists of kinetic energy (coupling neighboring sites), two-body contact interactions, and three-body contact interactions. Because the interactions are local (on-site or nearest-neighbor), the number of non-zero matrix elements scales linearly with the number of lattice sites ($O(D)$), in stark contrast to the $O(D^3)$ or $O(D^5)$ scaling found in harmonic oscillator bases for two- and three-body terms.
• Algorithms: NuLattice implements four primary computational methods:
  1. Full Configuration Interaction (FCI): Used for light nuclei ($A=2,3,4$), utilizing scipy.sparse for efficient storage and eigenvalue computation.
  2. Hartree-Fock (HF): Implemented using sparse data operations to compute the density matrix and energy.
  3. Coupled-Cluster (CCSD): The package employs a reference state based on the lattice basis rather than a Hartree-Fock basis to preserve sparsity. It utilizes a normal-ordered two-body approximation. The solver uses inexact Newton's method with Direct Inversion of the Iterative Subspace (DIIS) for convergence. The implementation mixes sparse-dense and dense-dense tensor contractions, using opt_einsum for optimization.
  4. In-Medium Similarity Renormalization Group (IMSRG): Implemented at the IMSRG(2) level. Due to the evolving structure of the Hamiltonian during the flow, which complicates sparse approaches, the current implementation uses dense tensors for small lattice sizes ($L=2,3$).
• Interactions: The code currently employs leading-order pion-less EFT with two-body and three-body contact terms. Parameters are calibrated to the ground-state energies of $^2$H and $^4$He.

Key Contributions

• Software Release: The authors release NuLattice as an open-source (BSD-3-clause) Python package, making ab initio nuclear structure calculations accessible on standard laptops and desktops.
• Sparse Implementation: By exploiting the locality of lattice interactions, the package avoids the storage and generation bottlenecks associated with three-nucleon forces in harmonic oscillator bases.
• Educational Utility: The package is designed with pure functions and extensive documentation (via Sphinx) to facilitate use in research and education, including its use in recent summer schools for teaching convergence patterns and renormalization.

Results
The paper presents results for light nuclei ($^2$H, $^3$He, $^4$He, $^8$Be, $^{12}$C, and $^{16}$O) on lattices with spacing $a \approx 1.7\text{--}2.5$ fm.

• Light Nuclei ($A=2,3,4$): For $^2$H, CCSD yields the exact solution, while Hartree-Fock fails to converge. For $^3$He and $^4$He, the results show that Hartree-Fock and Coupled-Cluster with Singles (CCS) capture the bulk of the ground-state energy. CCSD provides only marginal improvements over CCS, suggesting that for these compact nuclei with zero-range interactions, single-particle excitations dominate.
• Convergence: The energy converges rapidly with lattice size $L$. For $^{16}$O, the energy changes by less than 0.2 MeV between $L=4$ and $L=5$.
• IMSRG vs. CCSD: IMSRG(2) and CCSD results are consistent with each other and close to Hartree-Fock, indicating that higher-order correlations (beyond singles and doubles) contribute little to the binding energy in this specific zero-range framework.
• Limitations: The study confirms that pion-less EFT at leading order with zero-range interactions fails to bind $\alpha$ particles into larger nuclei like $^8$Be, $^{12}$C, and $^{16}$O against $\alpha$-decay. This is attributed to the zero-range nature of the potential, which cannot bind systems beyond the $\alpha$ particle. Additionally, for weakly bound systems like $^3$He, finite-size effects and three-particle–three-hole correlations are significant, leading to larger discrepancies between approximate methods (CCSD/IMSRG) and FCI benchmarks on smaller lattices.

Significance and Claims
The authors claim that NuLattice represents a significant step toward democratizing ab initio nuclear physics. By reducing the computational cost through sparse lattice techniques, the package allows non-trivial computations to be performed on laptops, thereby making these methods accessible to a broader group of researchers and educators. The paper emphasizes that while the current implementation is limited to leading-order pion-less EFT and zero-range interactions, the framework successfully demonstrates that complex many-body solvers (CCSD, IMSRG, FCI) can be implemented efficiently in Python. The authors invite the community to contribute to the package, noting that future work will focus on finite-range interactions, chiral EFT, higher-precision solvers, and the calculation of excited states and observables beyond ground-state energies.