⚛️ general relativity

An explicit and differentiable Wilson-Daubechies-Meyer transform for gravitational-wave data analysis

This paper introduces **wdm_transform**, an open-source Python package that provides a mathematically explicit, differentiable, and GPU-accelerated implementation of the Wilson-Daubechies-Meyer time-frequency transform for gravitational-wave data analysis, validated through numerical equivalence with frequency-domain methods and designed to support future optimization for non-stationary noise and complex detector challenges.

Original authors: Avi Vajpeyi, Giorgio Mentasti, Quentin Baghi, Ollie Burke, Lorenzo Speri

Published 2026-06-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Avi Vajpeyi, Giorgio Mentasti, Quentin Baghi, Ollie Burke, Lorenzo Speri

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

The Big Picture: Listening to the Universe with a Better Microphone

Imagine you are trying to listen to a specific bird singing in a very noisy forest.

The Time Domain is like listening to the forest with your ears closed. You know when a sound happened (a chirp at 2:00 PM), but you don't know exactly what pitch it was.
The Frequency Domain (like a standard Fourier Transform) is like looking at a frozen snapshot of the sound spectrum. You know exactly what pitches are present in the whole recording, but you don't know when the bird sang them.

Gravitational waves (ripples in space-time) are tricky. They aren't just a steady hum, and they aren't just a single sharp bang. They are often "chirps" that change pitch over time. To catch them, scientists need a tool that tells them both when and what pitch, simultaneously.

This paper introduces a new, open-source tool called wdm_transform that does exactly this. It uses a mathematical method called the Wilson–Daubechies–Meyer (WDM) transform to break down gravitational wave data into a grid of "time-frequency pixels."

The Problem: The Missing Manual

Scientists have been using the WDM method for years to find these cosmic signals. However, the "instruction manual" was scattered across old papers and complex code. It was hard for new researchers (especially those using modern Python tools) to figure out exactly how to build it without making mistakes.

Think of it like having a legendary, high-performance engine that everyone uses, but no one has a clear diagram of how the pistons fit together. If you try to rebuild it, you might get it wrong.

This paper provides the clear, step-by-step blueprint. It writes down the exact math, explains how to code it, and proves it works perfectly.

The Solution: A "Smart" Grid

The authors created a Python package (wdm_transform) that acts like a universal translator for this data.

The Grid (The Tiling): Imagine you have a giant photo of a sound. You want to cut it into small squares to analyze them.
- Standard methods (like Short-Time Fourier Transforms) often cut the photo into squares that overlap too much, wasting computer memory.
- The WDM method cuts the photo into perfect, non-overlapping tiles that fit together like a puzzle. It uses the absolute minimum number of pieces needed to describe the sound, saving memory and making calculations faster.
The "Magic" Window: To cut these tiles, the math uses a special "window" shape (called the Daubechies–Meyer window).
- Imagine trying to cut a cake. If you use a straight knife, the edges are sharp and messy.
- This method uses a knife with a soft, curved edge that blends perfectly into the next slice. This ensures that when you put all the slices back together, you get the exact original cake with no crumbs lost or added.
Speed and Power: The package is built to run on modern computer chips (GPUs).
- The authors tested it on massive streams of data (millions of points).
- The Result: On a standard computer chip, it takes a few seconds. On a powerful graphics card (GPU), it does the same job in milliseconds. This is like switching from a bicycle to a sports car.

The Proof: Does it Actually Work?

The authors didn't just build the tool; they tested it rigorously.

The "Round-Trip" Test: They took a signal, broke it down into the WDM grid, and then put it back together. The result was identical to the original signal down to the tiniest decimal point. This proves the math is exact and doesn't lose information.
The "LISA" Test: They simulated a specific type of gravitational wave source (a pair of stars orbiting each other in our galaxy) that the future LISA space telescope will look for.
- They analyzed this data using the old, standard frequency method.
- They analyzed the same data using their new WDM method.
- The Result: The answers were identical. The new method found the exact same location, speed, and mass of the stars as the old method. This confirms that the new tool is reliable and can be trusted to replace or supplement older methods.

Why This Matters

This paper doesn't claim to discover new stars or solve the mystery of the universe on its own. Instead, it paves the road for others to do so.

By providing a clear, open-source, and super-fast tool, the authors make it much easier for scientists to:

Handle messy data where the noise changes over time.
Deal with gaps in data (like when a telescope stops listening for a moment).
Run complex statistical analyses much faster using modern AI-style computing (JAX).

In short, they have handed the scientific community a better, faster, and easier-to-use wrench to tighten the bolts of gravitational wave discovery.

Technical Summary: An Explicit and Differentiable Wilson–Daubechies–Meyer Transform for Gravitational-Wave Data Analysis

Problem Statement
Time-frequency analysis is essential in gravitational-wave (GW) astronomy for characterizing transient signals, instrumental artifacts, and non-stationary noise. While the Wilson–Daubechies–Meyer (WDM) wavelet-packet transform has been utilized in GW pipelines (e.g., for burst searches and LISA source analysis), a self-contained, mathematically explicit reference for practitioners remains lacking. This gap hinders the adoption of WDM in modern, differentiable inference workflows (such as those using JAX) and complicates the reproduction of results. Furthermore, while the theoretical foundations exist, the specific implementation details regarding coefficient layout, boundary conditions (DC and Nyquist channels), and normalization conventions have not been unified in a single, reproducible package.

Methodology
The authors present wdm_transform, an open-source Python package that implements the WDM transform with a focus on mathematical explicitness and differentiability. The methodology involves:

Mathematical Formulation: The paper provides a complete derivation of the forward and inverse transforms. It defines the WDM basis using a uniform rectangular tiling of the time-frequency plane (unlike the dyadic decomposition of standard wavelets). The basis functions are constructed by combining Wilson-basis pairing (positive and negative frequency atoms) with a smooth Daubechies–Meyer frequency window.
- The transform maps $N$ time-domain samples to a packed coefficient grid of size $(N_t, N_f + 1)$ , where $N = N_t N_f$ .
- Special handling is provided for three distinct channel types: DC ( $m=0$ ), interior ( $0 < m < N_f$ ), and Nyquist ( $m=N_f$ ). The interior channels utilize an alternating phase factor $C_{nm}$ to ensure real-valued, orthogonal coefficients, while edge channels are treated as unpaired real coefficients.
- The Daubechies–Meyer window is defined with a cosine taper ( $d=1$ ), controlled by a parameter $A \in (0, 1/2)$ , ensuring exact partition-of-unity reconstruction.
Statistical Properties: The paper derives the WDM likelihood function. Under the assumption of locally stationary noise, the noise covariance matrix in the WDM domain is approximately diagonal. This allows for the construction of a "WDM Whittle likelihood," which is the time-frequency analogue of the standard frequency-domain Whittle likelihood. The authors explicitly address the rank deficiency of the full covariance matrix (due to the redundancy of edge channels) and define the Moore-Penrose pseudo-inverse to handle this in the likelihood calculation.
Implementation: The package supports NumPy, CuPy, and JAX backends. The JAX backend enables GPU acceleration and automatic differentiation. The implementation validates the forward and inverse transforms through exact round-trip reconstruction tests, ensuring floating-point precision.

Key Contributions

Explicit Reference: The paper serves as a pedagogical and self-contained reference for the sampled WDM construction, clarifying conventions for normalization, phase, indexing, and the treatment of DC/Nyquist channels that were previously scattered across various works.
Open-Source Package: The release of wdm_transform provides a unified interface for WDM transforms with CPU and GPU capabilities, facilitating integration into modern Python-based GW inference pipelines.
Differentiability: By leveraging JAX, the transform is fully differentiable, enabling gradient-based samplers (e.g., HMC, NUTS) and variational inference to operate directly on WDM-domain data without manual derivative derivation.
Validation: The authors perform rigorous numerical validation, demonstrating that the forward-inverse round trip recovers data to machine precision ( $\epsilon_{rt} \lesssim 10^{-16}$ ) and that the coefficients are empirically decorrelated as expected for stationary noise.

Results

Performance Benchmarks: The package achieves $O(N \log N)$ scaling. Benchmarks on a T4 GPU show that for large data streams ( $N=10^6$ ), the JAX backend is approximately 23 times faster than the NumPy CPU implementation (16 ms vs. 370 ms).
Inference Equivalence: As a worked example, the authors compared Bayesian parameter estimation for a resolved LISA galactic binary using both frequency-domain and WDM-domain likelihoods. Under a shared stationary noise model, the WDM-domain likelihood reproduced the frequency-domain posteriors to numerical precision. The Jensen–Shannon divergence between the two posteriors was negligible (median $5 \times 10^{-6}$ bits), and the posterior medians aligned closely.
Orthogonality: Empirical checks confirmed that the basis functions form an orthogonal set, with the forward-then-inverse transform acting as an identity map on the signal space, while the reverse map (inverse-then-forward) correctly projects arbitrary packed arrays onto the valid signal subspace.

Significance and Claims
The authors explicitly state that this work does not introduce the WDM transform itself, nor does it claim to outperform existing pipeline-specific implementations in terms of raw speed or novel algorithmic discovery. Instead, the significance of the work lies in:

Reproducibility and Accessibility: Making the WDM transform "easy to adopt and reproduce" in modern workflows by providing a mathematically explicit, self-contained derivation and implementation.
Enabling Future Optimization: Paving the way for systematic optimization of WDM tilings, which is particularly promising for handling non-stationary noise, stochastic backgrounds, and data gaps anticipated in future detectors like LISA.
Differentiable Inference: Providing the necessary infrastructure to use WDM representations in differentiable inference pipelines, allowing for direct comparisons with alternative time-frequency representations and facilitating the use of gradient-based methods.

The paper concludes that while the current implementation uses a specific window ( $d=1$ ) and assumes stationary noise for the validation example, the framework is designed to support future extensions, including higher-order windows and direct waveform generation in the WDM domain.