FewBodyToolkit.jl: a Julia package for solving quantum few-body problems

This paper introduces FewBodyToolkit.jl, a Julia package based on the Gaussian expansion method that enables the simulation of bound and resonant states in general two- and three-body quantum systems with arbitrary pair-interactions across various spatial dimensions.

The Gist

Imagine the universe is built out of tiny, invisible LEGO bricks called particles. Sometimes, these bricks stick together in small groups of two or three to form tiny, stable structures. Physicists call this "few-body physics." It's like studying how two or three specific LEGO pieces snap together, which is different from studying a whole city made of millions of pieces (that's "many-body physics") or just looking at a single floating brick.

The paper introduces a new digital tool called FewBodyToolkit.jl. Think of this as a sophisticated, open-source "LEGO simulation kit" written in a computer language called Julia. Its job is to help scientists predict exactly how these small groups of particles will behave, what shapes they will form, and how much energy they hold, without having to build them in a real lab.

Here is how the toolkit works, explained through simple analogies:

1. The "Gaussian Expansion" Method: The Swiss Army Knife of Shapes

To figure out how particles move, the toolkit uses a method called the Gaussian Expansion Method.

• The Analogy: Imagine you are trying to draw a complex, wiggly curve (like the path a particle takes). Instead of trying to draw the whole thing in one go, you try to build it by stacking many smooth, bell-shaped curves (like a hill or a mound of sand) on top of each other.
• How it works: The toolkit stacks hundreds of these "bell curves" (called Gaussians) together. By adjusting the height and width of each bell curve, it can perfectly mimic the complex shape of a particle's behavior. If the particle is vibrating wildly (like a resonance), the toolkit can even use "wobbly" bell curves that wiggle back and forth to catch those movements.

2. The Three Main Tools in the Box

The package isn't just one big program; it's a toolbox with three specific drawers, each designed for a different job:

• Drawer 1 (GEM2B): For two-particle systems. It can handle particles moving in 1, 2, or 3 dimensions. It's great for finding stable pairs or pairs that are about to break apart.
• Drawer 2 (GEM3B1D): For three-particle systems, but only if they are stuck in a straight line (1D). This is useful for studying specific quantum wires or chains.
• Drawer 3 (ISGL): For three-particle systems in full 3D space. This is the heavy lifter for complex atoms and molecules.

3. Solving the "Three-Body Puzzle"

When you have three particles, things get tricky because there are three different ways to look at the group (Particle A with B, while C watches; or A with C, while B watches, etc.).

• The Analogy: Imagine three friends holding hands in a circle. To understand the group, you have to look at it from three different angles. The toolkit automatically splits the problem into these three "viewpoints" (called Faddeev components), solves the math for each angle, and then stitches the answers back together to get the full picture. It also knows how to handle identical particles (like two electrons) automatically, so the user doesn't have to do the math manually.

4. Catching the "Ghost" Particles (Resonances)

Sometimes, particles don't form a stable shape; they briefly stick together and then fly apart. These are called resonances. They are like ghosts—hard to catch because they don't stay still.

• The Analogy: The toolkit uses a trick called Complex Scaling. Imagine you are trying to photograph a fast-moving car. If you just take a normal picture, it's blurry. But if you rotate your camera slightly and change the lens settings (mathematically speaking), the blurry car suddenly snaps into focus, and you can see exactly where it is and how fast it's going. This allows the toolkit to calculate the "lifespan" and position of these fleeting particle groups.

5. Real-World Tests

The authors tested their toolkit on several known problems to prove it works:

• The Hydrogen Atom: They simulated a simple two-particle system (an electron and a proton) and got results that matched the exact math perfectly.
• The Positronium Ion: They simulated a weird atom made of an electron, another electron, and a positron (anti-electron). They calculated its energy and size, and the results matched what other scientists had found in high-precision studies.
• Mass-Imbalanced Systems: They simulated a system where one particle is heavy and two are light (like a big boulder with two pebbles), showing the tool works even when the particles are very different sizes.

Why This Matters

Before this toolkit, scientists often had to write their own custom code for every new few-body problem, which was slow and prone to errors. FewBodyToolkit.jl is like a pre-built, open-source engine that anyone can download. It comes with a manual and examples, making it easy for researchers, teachers, and students to simulate quantum systems without reinventing the wheel.

In short, this paper presents a versatile, user-friendly digital workshop that allows scientists to build, test, and understand the behavior of the smallest groups of particles in the universe, using a clever method of stacking mathematical "hills" to solve complex quantum puzzles.

Technical Summary

Technical Summary of "FewBodyToolkit.jl: a Julia package for solving quantum few-body problems"

Problem Statement
Quantum few-body physics investigates systems comprising a small number of particles (typically two to ten), serving as a bridge between single-particle and many-body regimes. While various software packages exist for simulating quantum systems, the authors identify a gap in the availability of a general, free-space solver that unifies the treatment of arbitrary interaction potentials for both two- and three-body systems within a single interface. Furthermore, there is a lack of accessible documentation and open-source implementations specifically tailored to the Julia programming language for these purposes.

Methodology
The paper presents FewBodyToolkit.jl, an open-source Julia package designed to solve the Schrödinger equation for few-body systems. The core implementation relies on the Gaussian Expansion Method (GEM), a well-established technique in hadronic, nuclear, and atomic physics.

• Coordinate Systems: The package handles two-body systems using a single relative coordinate and three-body systems using Jacobi coordinates. For three-body problems, the wave function is decomposed into a sum of Faddeev components (rearrangement channels), with the code automatically managing reductions for identical particles.
• Basis Functions: The method expands unknown states into coherent superpositions of Gaussian basis functions. These functions are defined with radial parts $r^l e^{-\nu r^2}$ and angular parts appropriate for 1D, 2D, or 3D dimensions.
• Resonances and Oscillatory States: To address resonant states and highly excited states, the package supports Complex Scaling Method (CSM). This involves a complex rotation of the radial coordinate ($r \to r e^{i\theta}$), which exposes resonances as discrete complex eigenvalues. Additionally, the package supports complex-valued Gaussian ranges to better represent oscillatory wave functions.
• Implementation Details: The package is modular, consisting of three solvers:
  • GEM2B: For two-body systems in 1D, 2D, and 3D.
  • GEM3B1D: For three-body systems in 1D.
  • ISGL: For three-body systems in 3D, utilizing Infinitesimally Shifted Gaussian lobe basis functions to handle angular momentum algebra.
    The workflow involves input validation, basis size estimation, memory preallocation, precomputation of constants (e.g., Clebsch-Gordan coefficients), and, crucially, an interpolation technique for three-body systems. Since numerical integration of interaction matrix elements can be computationally expensive, the package evaluates integrals on a logarithmic grid of Gaussian parameters and applies cubic spline interpolation, significantly reducing costs for large basis sets.

Key Contributions

1. Unified Interface: The package provides a unified API for solving general few-body problems with arbitrary pair-interactions, supporting both bound and resonant states across different spatial dimensions.
2. Automatic Symmetry Handling: It automatically handles angular momentum coupling and (anti-)symmetrization for identical particles, reducing the number of Faddeev components where applicable.
3. Accessibility and Documentation: Unlike many specialized codes, FewBodyToolkit.jl is designed with a simple API, comprehensive documentation, and runnable example scripts to lower the barrier for new users, researchers from other communities, and educators.
4. Optimization Tools: The package includes helper functions for optimizing Gaussian basis parameters (ranges and counts) to minimize energy for target states, utilizing the Nelder-Mead algorithm.
5. Observable Calculation: The ISGL module allows for the on-the-fly calculation of physical observables, such as mean-square radii and expectation values of central operators.

Results and Benchmarks
The authors validate the package through several examples and benchmarks:

• Two-Body Systems: The package successfully reproduces exact analytical solutions for the Coulomb potential in 3D. Using optimized parameters and complex-ranged Gaussians, it achieves high accuracy for highly excited states (up to $n=40$) and accurately calculates resonance positions and widths for nuclear potentials using complex scaling.
• Three-Body Systems (1D): The GEM3B1D module reproduces results for mass-imbalanced 2+1 systems (bosonic and fermionic) interacting via Gaussian and contact potentials, matching reference values from literature with high precision. Convergence studies show sub-percent differences with increasing basis size.
• Three-Body Systems (3D): The ISGL module is tested on the positronium negative ion ($Ps^-$). The calculated binding energy and various observables (mean radii, inverse radii) agree with high-precision literature values within a relative difference of less than 0.5%.
• Performance: Benchmarks indicate that both runtime and memory usage scale polynomially with the number of basis functions. The use of analytical expressions for matrix elements significantly reduces computational cost for smaller basis sizes, while the interpolation scheme keeps costs manageable for larger systems. The package can treat realistic three-body problems with modest computational resources (e.g., solving a 3D system with ~1000 basis functions in seconds on a standard laptop).

Significance and Claims
The authors position FewBodyToolkit.jl as a tool to fill a specific gap in the computational landscape: a general, free-space solver for few-body problems that combines arbitrary interactions, unified interfaces for 2- and 3-body systems, and accessible documentation within the Julia ecosystem.

The paper claims the package is motivated by recent research needs in low-dimensional systems and few-body resonances. It highlights that the package has already been applied in recent studies of three-body resonances in ultracold atomic systems and in hadron physics (investigating potentials from lattice QCD). The authors modestly state that while the current implementation focuses on research, it is also intended as an entry point for teaching, a basis for new method development, and a benchmarking tool. They acknowledge limitations, noting that the method may face challenges with wave functions having pronounced nodes at the origin or requiring large-amplitude oscillations over extended ranges, where other methods might be more suitable. Future extensions are envisioned to include additional interaction types (spin-dependent, tensor, three-body forces) and potentially other numerical methods like momentum-space Faddeev equations or machine learning techniques.