🔭 astrophysics

cosmo-numba: B-modes and COSEBIs computations accelerated by Numba

The paper introduces "cosmo-numba," a high-performance Python package that leverages Numba to accelerate the precise computation of E-/B-mode decompositions and COSEBIs for weak gravitational lensing analyses, effectively addressing computational bottlenecks in the era of large-scale cosmological surveys.

Original authors: Axel Guinot, Rachel Mandelbaum

Published 2026-03-20

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Axel Guinot, Rachel Mandelbaum

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to listen to a faint, beautiful melody (the story of the Universe) played in a crowded, noisy room. In cosmology, this "melody" is the Weak Gravitational Lensing—the subtle bending of light from distant galaxies caused by invisible dark matter. By studying this bending, scientists can map out the invisible architecture of the cosmos.

However, there's a problem. The room is full of noise (systematic errors from our telescopes and atmosphere). To hear the true melody, we need to separate the "good notes" (E-modes) from the "bad noise" (B-modes). If we mix them up, our understanding of the Universe gets distorted.

This is where the new software cosmo-numba comes in. Think of it as a super-powered, high-speed audio engineer that can instantly separate the good notes from the noise with perfect clarity.

Here is a breakdown of how it works, using simple analogies:

1. The Challenge: The "Mathematical Tightrope"

To separate these cosmic notes, scientists use complex math called COSEBIs (Complete Orthogonal Sets of E-/B-mode Integrals).

The Problem: Doing this math is like trying to balance a stack of 80 plates on a wobbly table. If you use standard computer math (like a regular calculator), the stack wobbles and falls over after a few plates because the numbers aren't precise enough. You need 80 decimal places of precision to keep the stack standing.
The Old Way: Previously, scientists used a powerful but slow tool called Mathematica to do this. It was accurate, but it was like using a heavy, slow-moving steam engine to run a race. It was too slow to be used in modern, fast-paced experiments where you need to run the calculation millions of times.

2. The Solution: The "Numba" Rocket

The authors, Axel Guinot and Rachel Mandelbaum, built a new tool called cosmo-numba.

The Magic Trick: They used a technology called Numba. Imagine Numba as a "speed-boosting jetpack" for Python code. It takes the slow, careful instructions and translates them into a super-fast language that the computer's brain (CPU) can execute instantly.
The Hybrid Approach: The software is smart. It knows when to be a "precision surgeon" and when to be a "speedster."
- For the parts of the math that need extreme accuracy (the 80 decimal places), it uses special tools (like mpmath) to ensure the stack of plates never falls.
- For the parts that just need to be fast, it puts on the Numba jetpack, making the calculations 100 times faster than previous methods.

3. Two Ways to Listen to the Music

The software offers two different ways to separate the cosmic melody:

Method A: The COSEBIs (The High-Precision Filter)
This is the heavy-duty method. It integrates (adds up) the data over a huge range. The paper shows that if you try to do this with standard computer precision, you get a 3-4% error—like hearing the melody slightly out of tune. But with their high-precision Numba method, it matches the "gold standard" perfectly, just much faster.
Method B: Pure-Mode Correlation (The Clean Sweep)
This is a newer method to separate the signals. It's mathematically more stable (easier to balance), but it still requires running the calculation thousands of times.
- The Speed Test: The authors compared their tool against standard Python tools (SciPy). Their tool was 50 times faster when running on multiple computer cores. It's the difference between walking to the store versus taking a bullet train.

4. Why Does This Matter?

In the past, scientists could only check for errors (the "noise") once or twice because the math took too long.

The New Era: With cosmo-numba, scientists can run these checks millions of times during their analysis. This allows them to catch tiny errors that would have been missed before.
Real-World Use: This software is already being used by major projects like UNIONS and the upcoming Roman Space Telescope mission. It ensures that when we finally map the dark matter of the Universe, the map is accurate and the "melody" is clear.

Summary

cosmo-numba is a software package that solves a major bottleneck in astronomy. It combines extreme mathematical precision (to avoid errors) with blazing speed (to handle massive data). It's like upgrading from a hand-cranked calculator to a quantum computer, allowing astronomers to listen to the Universe's secrets with crystal-clear clarity.

1. Problem Statement

Weak gravitational lensing is a critical tool for understanding the universe's content and evolution. However, modern cosmological analysis is shifting from being limited by data volume to being limited by systematic uncertainties. A major computational bottleneck in this field is the decomposition of cosmic shear into E-modes (signal) and B-modes (systematics/noise).

The specific challenges addressed are:

High Precision Requirements: Calculating E/B-mode decompositions, particularly using Complete Orthogonal Sets of E-/B-mode Integrals (COSEBIs), requires integrating oscillatory functions over large ranges. Standard floating-point precision (float64, ~15 decimal places) is insufficient, leading to significant errors. Previous implementations (e.g., in Mathematica) achieve the necessary precision (>80 decimal places) but are difficult to integrate into modern, Python-based cosmological inference pipelines.
Computational Speed: While pure-mode correlation functions are numerically stable, their integration into likelihood-based inference pipelines requires thousands of calls. Standard Python libraries (like scipy) are too slow for this iterative process, making them untractable for large-scale cosmological inference.

2. Methodology

The authors present cosmo-numba, a Python-based software package designed to balance extreme numerical precision with high computational speed. The methodology relies on a hybrid architecture:

Hybrid Precision/Speed Architecture:
- High-Precision Components: Parts of the code requiring extreme accuracy (specifically the computation of COSEBI weight functions) utilize Python libraries sympy and mpmath. This allows for arbitrary precision arithmetic (defaulting to 80 decimal places) to match the original Mathematica implementations.
- High-Speed Components: Parts of the code that do not require arbitrary precision leverage Numba (Just-In-Time compilation). This accelerates loops and numerical operations significantly compared to standard Python.
COSEBI Implementation:
- Computes weight functions ( $T_{n,\pm}$ ) on a logarithmic scale using Bessel functions.
- Computes filter functions ( $W_n(\ell)$ ) via a Hankel transform (order 0) using the FFTLog algorithm, implemented in Numba.
- Supports calculation from both shear correlation functions ( $\xi_\pm$ ) and power spectra ( $P_{E/B}$ ).
Pure-Mode Correlation Functions:
- Implements the pure E/B-mode correlation functions defined by Schneider et al. (2022).
- Uses the qags method from QUADPACK with 5th-order spline interpolation for integration, ensuring stability while maintaining speed via Numba acceleration.
Testing Framework:
- The package includes robust unit tests. To handle the difficulty of testing Numba-compiled code, the authors implemented a feature to disable compilation during coverage tests, ensuring full code coverage and mathematical validation.
- Validation is performed against fiducial models from the Core Cosmology Library (CCL) and LSST Year 10 covariance parameters.

3. Key Contributions

First Public Pure-Mode Implementation: While COSEBIs have other implementations (e.g., CosmoPipe), this is the first publicly available implementation for pure-mode correlation functions, enabling their use in cosmological inference rather than just as one-time null tests.
Python-Native High-Precision Integration: The package bridges the gap between high-precision mathematical requirements (traditionally handled by Mathematica) and modern Python-based inference pipelines.
Performance Optimization: By combining mpmath for precision-critical steps and Numba for speed-critical steps, the package achieves a unique balance of accuracy and efficiency.
Comprehensive Validation: The software provides rigorous unit tests that validate both the implementation logic and the mathematical accuracy against established benchmarks.

4. Results

The authors present quantitative comparisons demonstrating the efficacy of cosmo-numba:

Precision Validation (COSEBIs):
- Using standard float64 (15 decimal places) results in several percent errors in COSEBI calculations compared to the reference Mathematica implementation.
- Using 80 decimal places (via mpmath) recovers the Mathematica results exactly.
- The difference between COSEBIs computed from $\xi_\pm$ and those computed from power spectra $P_{E/B}$ is negligible (at most $0.3\sigma$ relative to LSST Y10 covariance), confirming internal consistency.
Speed Comparisons:
- vs. CosmoPipe: When computing filter functions, the Numba-based implementation is approximately 100 times faster than CosmoPipe (which uses Levin integration) for equivalent precision.
- vs. Scipy: For pure-mode correlation functions, the serial Numba version is >8x faster than scipy (using CubicSpline and quad), and the parallel version is >50x faster.
Error Propagation: The study confirms that using lower precision than the default setting introduces significant errors, validating the necessity of the high-precision approach for scientific analysis.

5. Significance and Impact

Enabling Next-Generation Surveys: The software is already being utilized by the UNIONS (Ultraviolet Near Infrared Optical Northern Survey) to validate catalogs for cosmological analysis and is planned for use in the Roman High Latitude Imaging Survey (HLIS).
Facilitating Systematic Checks: By making pure-mode decomposition fast enough for iterative likelihood calculations, the tool allows researchers to move beyond using E/B-mode decomposition solely as a "one-time" null test. It can now be integrated directly into cosmological inference pipelines to constrain systematics during parameter estimation.
Accessibility: Providing a high-precision, high-speed, Python-native tool lowers the barrier for cosmologists to perform rigorous systematic checks without relying on external, non-Python software or sacrificing computational efficiency.

In summary, cosmo-numba solves the "precision vs. speed" trade-off in weak lensing analysis, enabling the next generation of cosmological surveys to rigorously control systematic uncertainties through fast, accurate E/B-mode decomposition.