SPARSE: Scattering Poles and Amplitudes from Radial Schrödinger Equations

This paper introduces the SPARSE algorithm, which employs the finite difference method to numerically solve radial Schrödinger equations for inelastic scattering of particles with spin, enabling the calculation of physical K-matrices, scattering poles, and amplitudes.

The Gist

Imagine you are a detective trying to figure out what happens when two tiny, spinning particles crash into each other. Sometimes they bounce off cleanly (elastic), but sometimes they smash together and turn into something else entirely (inelastic), like a car crash that turns a sedan into a motorcycle and a bicycle.

In the world of quantum physics, we use a famous rulebook called the Schrödinger equation to predict the outcome of these crashes. However, when you have many different ways the particles can change (many "channels"), solving this rulebook becomes a massive, messy math problem. Usually, physicists have to use complicated shortcuts or approximations to get an answer, which can sometimes hide the true details of the crash.

Enter SPARSE (Scattering Poles and Amplitudes from Radial Schrödinger Equations). Think of SPARSE as a super-efficient, no-nonsense calculator that solves the exact math without needing those messy shortcuts.

Here is how it works, broken down into simple concepts:

1. The Problem: A Tangled Web of Equations

Imagine you have a giant web of strings, where each string represents a possible state the particles could be in. When the particles collide, the strings tug on each other. To predict the crash, you need to solve the tension on every single string simultaneously.

• The Old Way: Physicists often used complex, slow methods to untangle this web, or they had to make guesses that might miss subtle details like "dips" or "cusps" in the data (weird bumps in the crash pattern).
• The SPARSE Way: SPARSE treats this web like a giant spreadsheet. It breaks the continuous space of the crash into tiny, discrete steps (like pixels on a screen). This turns the difficult, flowing math into a giant system of simple linear equations (like $Ax = B$).

2. The Secret Sauce: "Sparsity"

You might think a spreadsheet with millions of rows would crash your computer. But here is the magic trick: Sparsity.
In this giant spreadsheet, most of the cells are empty (zero). The tension in one string only affects its immediate neighbors, not the whole web.

• The Analogy: Imagine a massive library where 99% of the books are blank. If you tried to carry the whole library, it would be impossible. But if you only carry the few pages that actually have writing on them, it's easy.
• SPARSE is smart enough to only carry the "written pages." This allows it to solve systems with dozens of interacting channels (strings) on a regular laptop, something that used to require supercomputers.

3. The Boundary Conditions: The Walls of the Room

To solve the math, SPARSE needs to know what happens at the edges of the universe it's simulating.

• At the center (Origin): The particles can't be in two places at once, so the math forces the wave to be zero.
• At the edge (Far away): This is where the magic happens. SPARSE looks at how the particles behave far away from the crash site. It compares its numerical "guess" to the known, perfect mathematical behavior of free particles.
• The K-Matrix: By comparing its guess to the perfect math, SPARSE extracts a "scorecard" called the K-matrix. This scorecard tells us everything about the collision: how likely the particles are to bounce, how likely they are to change, and if they get stuck together for a moment.

4. Finding the Ghosts: Resonances and Poles

Sometimes, when particles crash, they form a temporary "ghost" state—a resonance. It's like a drum that rings for a split second after being hit. In physics, these show up as "poles" (mathematical singularities) in the K-matrix.

• SPARSE doesn't just look at the crash; it uses a clever interpolation technique (like connecting dots on a graph with a smooth curve) to find exactly where these "ghosts" live.
• It calculates the Mass (how heavy the ghost is), the Width (how fast it disappears), and the Coupling (how strongly it interacts with the particles).

5. The Real-World Demo

The paper shows off SPARSE with a simple example: two channels (two possible outcomes).

• One channel has a "well" (a trap) that holds a particle.
• The other channel has a similar trap but shifted up in energy.
• They are connected by a "bridge" (coupling).
• The Result: SPARSE predicts that a particle trapped in the second channel leaks out into the first channel, creating a sharp, narrow "resonance" (a loud ring) in the data. The algorithm found this perfectly, matching the theoretical prediction.

Why Should You Care?

If you are a physicist studying the building blocks of the universe (like protons and neutrons), you need to know exactly how they interact.

• No More Guessing: SPARSE removes the need for "approximate" methods. It gives you the raw truth of the Schrödinger equation.
• Speed: It's fast enough to run thousands of simulations to test different theories (like a "bootstrap" method) to see which one matches reality.
• Simplicity: It takes complex physics and turns it into simple CSV files (like Excel sheets) that anyone can feed into the program.

In a nutshell: SPARSE is a high-speed, memory-efficient engine that takes the messy, tangled math of particle collisions, simplifies it into a giant but sparse spreadsheet, and spits out the exact probabilities of what happens when the universe's smallest particles crash into each other. It's the ultimate tool for finding the "ghosts" (resonances) hiding in the noise.

Technical Summary

1. Problem Statement

The paper addresses the computational challenge of solving systems of coupled radial Schrödinger equations to describe the inelastic scattering of particles with spin in nonrelativistic quantum mechanics.

• Context: While the Schrödinger equation is the foundation for calculating scattering poles (resonances) and amplitudes, direct numerical solutions for complex systems (e.g., nucleon-nucleon scattering with multiple coupled channels like $NN \to N\Delta$) are often computationally expensive.
• Limitations of Existing Methods: Sophisticated methods like propagation algorithms or basis expansions can be computationally heavy. Conversely, standard finite-difference methods are often viewed as "crude" and inefficient for large systems due to the generation of massive, dense matrices that consume excessive memory.
• Goal: The author aims to develop an algorithm that is extremely efficient and capable of solving systems with dozens of coupled channels using modest computing resources, without requiring secondary approximations that might compromise the validity of resonant line shapes or threshold effects.

2. Methodology

The SPARSE algorithm employs a first-order finite-difference method optimized for memory and speed. The workflow is as follows:

A. Mathematical Formulation

1. System Reduction: The starting point is a system of coupled Schrödinger equations for two-body scattering. By separating the center-of-mass motion and assuming the nonrelativistic limit (where mass differences between channels are small), the system is reduced to a set of radial equations for a specific partial wave (defined by total angular momentum $J$).
2. Radial Equation: The system is transformed into a set of differential equations for the reduced radial wavefunction $u(r) = r\psi(r)$:
   $$\left[ -\frac{1}{2\mu}\frac{d^2}{dr^2} + \frac{L(L+1)}{2\mu r^2} + V(r) - E \right] u(r) = 0$$
   where $V(r)$ is a matrix coupling different spin-orbital channels.

B. Numerical Discretization

1. Finite Difference: The coordinate space $r$ is discretized into a grid from $0$ to a large radius $R$. The second derivative is approximated using the standard central difference formula.
2. Boundary Conditions:
   • Origin ($r=0$): Dirichlet condition $u(0) = 0$.
   • Infinity ($r=R$): For open channels ($E > V_{threshold}$), a real constant boundary condition is imposed. For closed channels, $u(R)=0$.
3. Matrix Construction: The discretized system forms a linear non-homogeneous system $(H - E)u = B$.
   • Sparsity Optimization: The resulting Hamiltonian matrix is sparse. SPARSE utilizes a banded matrix storage format (storing only the $2N+1$ non-zero diagonals) rather than a full dense matrix. This reduces memory usage from terabytes (for large grids) to megabytes, enabling the solution of systems with $N \approx 4$ channels and $M \approx 10^6$ grid points on standard hardware.

C. Extraction of Physical Observables

1. K-Matrix Calculation:
   • The numerical wavefunctions are solved for a given energy $E$.
   • In the asymptotic region (large $r$), the numerical solutions are matched to analytical solutions involving Riccati-Bessel functions ($S_l$ and $C_l$).
   • By integrating the numerical wavefunctions against sine and cosine basis functions, the algorithm extracts the Reactance Matrix (K-matrix) elements using the relation $K = YX^{-1}$.
2. Scattering Poles and Amplitudes:
   • Interpolation: The K-matrix is calculated at discrete energy points. The AAA algorithm (Adaptive Antoulas-Anderson) is used to perform rational polynomial interpolation of the K-matrix elements.
   • Pole Identification: Poles of the K-matrix on the real axis are identified.
   • Resonance Characterization: The residues of these poles are analyzed to determine the resonance mass ($M$), width ($\Gamma$), and coupling constants ($g_i$) to various channels.
   • T-Matrix: The scattering amplitude ($T$) and cross-sections are derived from the K-matrix via the Cayley transform ($S = (I+iK)(I-iK)^{-1}$).

3. Key Contributions

• Efficiency via Sparsity: The primary innovation is the efficient handling of the finite-difference method. By recognizing the banded structure of the Hamiltonian and using diagonal-ordered storage, SPARSE makes high-resolution numerical solutions feasible for complex, multi-channel systems on standard hardware.
• Direct Calculation without Approximations: The method calculates scattering poles and amplitudes directly from the Schrödinger equation, avoiding phenomenological approximations often needed to handle overlapping resonances or threshold cusps.
• Automated Pole Extraction: The integration of the AAA rational approximation algorithm allows for the automatic and robust identification of scattering poles and the extraction of physical parameters (mass, width, couplings) from numerical data.
• User Accessibility: The algorithm is implemented in Python, accepting inputs via simple CSV files (channels.csv and potential.csv), making it accessible to researchers with minimal coding expertise.

4. Results

The paper validates the algorithm using a showcase example involving two coupled channels:

• Setup: A system with a P-wave channel (threshold 0) and an S-wave channel (threshold 100 MeV). The potentials were engineered to create a bound state in the first channel and a narrow resonance in the first channel arising from a "would-be" bound state in the second channel.
• Performance:
  • The algorithm successfully calculated the K-matrix over an energy range of 0–80 MeV.
  • It correctly identified a narrow resonance at $M = 67.09$ MeV with a width $\Gamma = 0.66$ MeV.
  • The scattering amplitude ($|T|^2$) clearly displayed the interference between the bound state enhancement and the resonance peak.
• Verification: The extracted parameters matched the theoretical expectations of the engineered potential, demonstrating the code's ability to resolve complex line shapes and overlapping structures.

5. Significance

• Phenomenological Utility: SPARSE is particularly valuable for fitting potential models to experimental data (e.g., in hadron physics) where parameters must be varied thousands of times (e.g., in bootstrap error analysis). Its speed makes such intensive fitting procedures practical.
• Handling Complex Structures: The method naturally handles "esoteric" structures in scattering amplitudes, such as dips and cusps near energy thresholds, without requiring special ad-hoc treatments, as these emerge naturally from the Schrödinger equation.
• Scalability: The memory optimization allows the study of systems with dozens of coupled channels (relevant for strongly interacting systems in the Born-Oppenheimer approximation), which were previously computationally prohibitive for direct finite-difference solutions.
• Open Source: By providing a GitHub repository with a Python API and tutorials, the author lowers the barrier to entry for high-precision scattering calculations in nonrelativistic quantum mechanics.