A modern Fortran library for SU(3) coupling and recoupling coefficients

This paper introduces a modern Fortran library that calculates SU(3) coupling and recoupling coefficients for specific group chains using established algorithms, demonstrating improved accuracy and a broader range of applicable quantum numbers compared to existing implementations.

The Gist

Imagine the universe is built out of a giant, complex LEGO set. Physicists use a specific set of rules, called SU(3) symmetry, to figure out how these LEGO bricks snap together to form atoms, nuclei, and particles.

To do the math for these connections, scientists need special "glue" numbers. These numbers tell them exactly how likely it is for two specific pieces to join, or how to rearrange a pile of three or four pieces that were glued in a different order. In the scientific world, these are called coupling and recoupling coefficients.

For decades, physicists have been using a specific set of instructions (an algorithm) to calculate these numbers. However, the old instructions had two big problems:

1. They broke with big numbers: If the LEGO structures got too huge (large quantum numbers), the math would get messy, lose precision, and give the wrong answer.
2. They were old-fashioned: The code was written in an older style of computer language that didn't take advantage of modern, super-fast computers.

This paper introduces a new tool called ndsu3lib. Think of it as a brand-new, high-tech calculator app that replaces the old, clunky manual.

The New Tool: ndsu3lib

Here is what makes this new library special, explained through simple analogies:

1. The "Super-Strong" Glue (Precision)
Imagine trying to balance a tower of 100 Jenga blocks. The old calculator was like a shaky hand; by the time you got to block 60, the tower would wobble and fall (the math became inaccurate).
The new library, ndsu3lib, is like a robotic arm with perfect stability. It uses a technique called multiprecision arithmetic. Think of this as switching from a ruler with millimeter marks to a laser measure that can see down to the width of a single atom. This allows physicists to calculate the glue for massive, complex structures that the old tool simply couldn't handle.

2. The "Smart Path" (Efficiency)
The old method was like trying to find your way out of a maze by walking every single dead end. The new library uses a "building-up" strategy. It starts with the simplest, most stable LEGO connections and builds up to the complex ones, ensuring it never takes a wrong turn. It also has a "smart switch" that automatically decides whether to use a standard calculator or the super-precise laser measure, depending on how hard the math is. This saves time and battery life.

3. The "Universal Translator" (Compatibility)
Old software was often written in a language that only old computers spoke. This new library is written in modern Fortran, which is like speaking the native language of today's supercomputers. It also comes with "adapter cables" (wrappers) so that scientists who write their programs in C or C++ can still use it easily. It's like giving your old DVD player a USB port so it can play modern files.

4. The "Team Player" (Speed)
Modern computers have many cores (like a team of workers). The old library was like a single worker trying to do everything alone. The new library is designed to let the whole team work at once (OpenMP multithreading), making the calculations happen much faster.

Why Does This Matter?

You might ask, "Who cares about LEGO math?"

This is crucial for Nuclear Physics. Scientists are trying to simulate the inside of atomic nuclei to understand how stars burn, how elements are formed, and how to create new materials.

• The Old Way: They could only simulate small nuclei because the math broke down for bigger ones.
• The New Way: With ndsu3lib, they can simulate much larger, more complex nuclei with high accuracy. This helps them predict the properties of matter in extreme environments, like inside neutron stars or during nuclear reactions.

The Bottom Line

The authors of this paper didn't just invent a new way to do the math; they rebuilt the entire engine. They took the same fundamental rules (the Draayer-Akiyama algorithm) but rewrote the code to be:

• More Accurate: It doesn't break when the numbers get big.
• Faster: It uses modern computers efficiently.
• More Flexible: It works with different types of modern software.

It's the difference between using a slide rule and using a smartphone calculator: the math is the same, but the new tool lets you solve problems that were previously impossible.

Technical Summary

1. Problem Statement

The group $SU(3)$ is fundamental in various branches of physics, particularly nuclear physics (e.g., the Elliott model and symplectic no-core configuration interaction frameworks), particle physics, and quantum optics. Calculations in these fields rely heavily on $SU(3)$ coupling coefficients (analogous to Clebsch-Gordan coefficients) and recoupling coefficients (analogous to $6j$ and $9j$ symbols).

Existing computational tools, specifically the widely used Akiyama-Draayer (AD) library and the newer SU3lib (C++), face significant limitations:

• Numerical Instability: They lose precision and produce incorrect results (errors on the order of unity) when dealing with large quantum numbers ($\lambda, \mu$), which restricts the model spaces available for modern nuclear structure calculations.
• Legacy Code: The AD library is written in older Fortran, limiting optimization for modern computer architectures and preventing efficient use of modern features like dynamic memory allocation and multithreading.
• Precision Constraints: Standard double-precision arithmetic is often insufficient for large quantum numbers, and existing libraries lack robust, automated mechanisms to switch to higher precision only when necessary.

2. Methodology

The authors developed ndsu3lib, a modern Fortran 2003 library that implements and refines the algorithms of Draayer, Akiyama, and Millener.

Algorithmic Approach:

• Draayer-Akiyama (DA) Algorithm: The library calculates Reduced Coupling Coefficients (RCCs) using recurrence relations derived from the method of infinitesimal generators.
• Biedenharn-Louck-Hecht (BLH) Prescription: To resolve the "outer multiplicity problem" (ambiguity in basis choice when multiple irreps appear), the library enforces the BLH prescription. This is achieved via a "building-up process" where RCCs for a coupling $(\lambda_1, \mu_1) \times (\lambda_2, \mu_2) \to (\lambda_3, \mu_3)$ are derived recursively from simpler couplings with lower outer multiplicity, ensuring specific coefficients vanish according to defined conditions.
• Group Chains: The library supports two primary group chains:
  1. Canonical: $SU(3) \supset U(1) \times SU(2)$ (flavor degrees of freedom).
  2. Angular Momentum: $SU(3) \supset SO(3)$ (nuclear physics applications).
• Recoupling: It computes $U$ and $Z$ coefficients (for 3 irreps) and $9-(\lambda, \mu)$ coefficients (for 4 irreps) by solving systems of linear equations involving the RCCs.

Implementation Improvements:

• Hybrid Precision: To handle large quantum numbers without excessive computational cost, the library employs an adaptive precision strategy. It uses double, quadruple, or multiprecision (via the MPFUN2020 library) arithmetic based on empirical tests of unitarity.
• Optimized Recursion: For non-extremal RCCs, the library iteratively calculates from the lowest-weight state if the target state is closer to the bottom of the weight diagram, reducing the number of iterations and minimizing error accumulation.
• Modern Architecture: The code uses allocatable arrays (removing hard-coded limits), OpenMP for multithreading, and interfaces with LAPACK (for linear algebra) and WIGXJPF or GSL (for $SU(2)$ coefficients).

3. Key Contributions

• ndsu3lib Library: A complete, open-source (MIT license) Fortran 2003 library with C/C++ wrappers, providing a modern, maintainable alternative to legacy codes.
• Extended Range of Validity: The library successfully computes coefficients for significantly larger quantum numbers than the AD library. While the AD library fails completely for $\Sigma_w \ge 66$ (where $\Sigma_w$ is the sum of quantum numbers), ndsu3lib remains valid and precise up to $\Sigma_w = 81$.
• Enhanced Precision:
  • For $SU(3) \supset SO(3)$ (critical for nuclear physics), ndsu3lib achieves errors $\approx 10^{-15}$ with multiprecision, whereas AD and SU3lib degrade significantly for large quantum numbers.
  • It demonstrates that using the WIGXJPF library for $SU(2)$ coefficients yields orders of magnitude better precision than GSL for large angular momenta.
• Documentation and Derivation: The paper provides a self-contained derivation of the DA building-up process and documents the specific formulae and phase conventions used, including corrections to previous literature.

4. Results

The authors conducted extensive validation tests comparing ndsu3lib against the AD library and SU3lib:

• Precision Tests:

  • $SU(3) \supset U(1) \times SU(2)$: ndsu3lib maintains mean errors around $10^{-15}$ and maximal errors around $10^{-9}$ for $\Sigma_w = 81$. In contrast, AD and SU3lib show rapid precision loss and outright failure (errors $\ge 1$) for $\Sigma_w \ge 66$.
  • $SU(3) \supset SO(3)$: With quadruple precision enabled, ndsu3lib keeps errors below $10^{-12}$ across the tested range. For extreme cases (e.g., coupling $(7, 39) \times (41, 2) \to (3, 8)$), multiprecision reduces errors from $10^{-9}$ (quadruple) to $10^{-15}$.
  • Recoupling Coefficients ($U, Z, 9-(\lambda, \mu)$): All three libraries show comparable precision for recoupling coefficients, though ndsu3lib remains stable at higher quantum numbers where AD fails.

• Performance (Speed):

  • The speed of ndsu3lib is comparable to SU3lib and AD.
  • For $SU(3) \supset U(1) \times SU(2)$, ndsu3lib is slightly faster (up to 2x) than the others for large $\Sigma_w$.
  • For $SU(3) \supset SO(3)$, ndsu3lib is slower than AD for small $\Sigma_w$ (<20) but becomes significantly faster (up to 3x) for $\Sigma_w > 46$, largely due to the efficiency of its modern implementation and optimized recursion paths.

5. Significance

The ndsu3lib library addresses a critical bottleneck in modern ab initio nuclear structure calculations. By enabling the accurate computation of $SU(3)$ coupling and recoupling coefficients for large quantum numbers, it allows physicists to expand model spaces in symmetry-guided frameworks (such as the symplectic no-core configuration interaction). This capability is essential for describing collective nuclear phenomena and heavy nuclei where large deformation and high angular momentum are present. The library's modern architecture ensures it is optimized for current and future high-performance computing environments, making it a robust tool for the next generation of nuclear physics research.