Memory in Waveform Models

Scrollable formula. Use Left and Right arrow keys to reveal hidden content.

Scrollable table. Use Left and Right arrow keys to reveal additional columns.

Scrollable figure. Use Left and Right arrow keys to inspect hidden content.

Adding memory to a finite waveform is not equivalent to appending an arbitrary step. A reliable model must specify which memory source is included, the early-cut integration constant, angular modes and frame, the waveform’s missing prehistory, and every filter or taper that can alter a low-frequency offset. This page gives a deterministic benchmark for endpoint recovery and a workflow for analytic or numerical waveforms. It models the radiative product, not a detector pipeline or a present observational claim.

Helpful background. Einstein Equations supplies the flux constraints that generate physical memory. Waves, Green Functions, and Geometric Optics supplies Fourier leakage, integration constants, and retarded boundary conditions. Gravitational Radiation and Waveforms supplies strain, news, curvature, modes, and frames. Causality and Global Structure supplies early/late cuts and the Bondi frame in which an offset is defined.

What a memory waveform must contain

At future null infinity,

\Delta H(x^A) =\int_{u_i}^{u_f}\mathcal N(u,x^A)\,du,

where $H=\lim r(h_+-i h_\times)$ and $\mathcal N=\partial_uH$ . This endpoint difference is displacement memory. Spin and center-of-mass memory instead involve additional time integrals of particular parity components; they are not additional strain steps to substitute for $\Delta H$ . A model can constrain its nonoscillatory radiation using:

a matter or Coulombic endpoint formula for ordinary memory;
an angular energy-flux integral for nonlinear displacement memory;
an angular-momentum-flux relation for spin memory;
a center-of-mass charge/flux relation for center-of-mass memory;
an extracted Bondi news series that already contains some or all of these pieces.

Those inputs must not be summed without checking overlap. For example, adding a flux-reconstructed nonlinear memory to a numerical strain that already retains its nonoscillatory component double counts it.

Favata constructs displacement memory from radiative moments and discusses its finite waveform behavior in Favata 2010, §§5–6, pp. 6–9, PDF. Numerical extraction, curvature-to-strain integration, extrapolation, and characteristic methods have distinct integration and gauge systematics Bishop and Rezzolla 2016, §3.3.2, pp. 25–27, §§6.4–6.5, pp. 58–62, and §7.8.2, p. 74, PDF.

A deterministic endpoint benchmark

Use a synthetic waveform with a known smooth memory offset,

h(t)=A\sin(2\pi ft)e^{-(t/\tau_o)^8} +\frac{\Delta h}{2}\left[1+\tanh(t/\tau_m)\right].

The first term is a tapered oscillatory control. The second has the exact endpoint change $\Delta h$ . The estimator averages over two quiet endpoint windows and subtracts the early mean from the late mean. This is deliberately simpler than a production flux calculation: it tests whether sampling, duration, and endpoint selection can recover a known nonoscillatory component before a physical waveform is trusted.

The reference environment is CPython 3.12.7 with NumPy==2.1.3. Save the following complete driver as memory_offset.py. The script must produce the resolution and duration tables used below.

import numpy as np

DELTA = 2.0e-22
FREQ = 1.37
TAU_MEMORY = 0.35
TAU_OSC = 4.5
OSC_AMPLITUDE = 6.0e-22

def waveform(t, delta=DELTA):
    oscillatory = (
        OSC_AMPLITUDE
        * np.sin(2.0 * np.pi * FREQ * t)
        * np.exp(-(t / TAU_OSC) ** 8)
    )
    memory = 0.5 * delta * (1.0 + np.tanh(t / TAU_MEMORY))
    return oscillatory + memory

def endpoint_offset(n, duration, delta=DELTA):
    t = np.linspace(-duration / 2.0, duration / 2.0, n)
    h = waveform(t, delta)
    early = t <= -duration / 2.0 + 2.0
    late = t >= duration / 2.0 - 2.0
    h_early = np.trapezoid(h[early], t[early]) / (
        t[early][-1] - t[early][0]
    )
    h_late = np.trapezoid(h[late], t[late]) / (
        t[late][-1] - t[late][0]
    )
    return h_late - h_early

print("resolution study: N, offset, relative_error, zero_control")
for n in (2049, 4097, 8193):
    result = endpoint_offset(n, 16.0)
    zero = endpoint_offset(n, 16.0, delta=0.0)
    print(n, result, abs(result - DELTA) / DELTA, zero)

print("duration study: duration, N, offset, relative_error")
for duration in (12.0, 16.0, 24.0, 32.0):
    n = int(duration * 512) + 1
    result = endpoint_offset(n, duration)
    print(duration, n, result, abs(result - DELTA) / DELTA)

Create an isolated environment and rerun exactly with:

python3.12 -m venv .memory-offset-venv
.memory-offset-venv/bin/python -m pip install numpy==2.1.3
.memory-offset-venv/bin/python memory_offset.py

No random numbers or external data enter, so the printed values should agree to ordinary floating-point rounding.

Resolution and duration convergence

For duration $T=16\,\mathrm{s}$ and fixed two-second endpoint windows, the reference output is:

Grid resolution $N$	Recovered result $\Delta h$	Relative error	Zero-memory difference
2049	$2.0000159474\times10^{-22}$	$7.9737\times10^{-6}$	$1.5947\times10^{-27}$
4097	$2.0000159353\times10^{-22}$	$7.9677\times10^{-6}$	$1.5935\times10^{-27}$
8193	$2.0000159323\times10^{-22}$	$7.9661\times10^{-6}$	$1.5932\times10^{-27}$

Refinement changes the result by progressively smaller amounts, but the error approaches a nonzero plateau. The zero-memory control has the same plateau. This diagnoses finite-window contamination from the tapered oscillatory term rather than time-step error.

Holding the sample rate near $512\,\mathrm{Hz}$ and changing the duration gives:

Window duration $T$ (s)	Grid resolution $N$	Recovered result $\Delta h$	Relative error
12	6145	$1.5319125685\times10^{-22}$	$2.3404\times10^{-1}$
16	8193	$2.0000159323\times10^{-22}$	$7.9661\times10^{-6}$
24	12289	$2.0000000000\times10^{-22}$	$2.35\times10^{-16}$
32	16385	$2.0000000000\times10^{-22}$	$2.35\times10^{-16}$

The twelve-second record fails despite fine sampling because its endpoint windows still contain the oscillatory transient. Duration convergence, not grid refinement, fixes the result. A production study should vary at least time step, total duration, taper width, endpoint-window width, integration prescription, and angular-mode cutoff.

From the benchmark to a physical model

A source-backed displacement-memory workflow is:

transform all input modes into one inertial/Bondi frame and the common $h_+-i h_\times$ harmonic convention;
obtain news from a directly supplied series or a controlled derivative of strain;
form the energy flux with explicit $1/(16\pi G)$ normalization and angular couplings;
project away the $\ell=0,1$ kernel before solving the memory sphere equation;
integrate from a declared early cut and record the integration constant;
add only components absent from the original waveform;
rerun with increased duration, sampling, and $\ell_{\max}$ and compare independent extraction or flux methods.

If starting from $\Psi_4$ , two time integrations are required. Low-frequency numerical errors are then amplified by $1/\omega^2$ . Fixed-frequency integration, polynomial drift subtraction, or high-pass filtering can stabilize an oscillatory waveform while erasing or biasing memory. Such a processed strain cannot be used as a memory reference unless the filter transfer function and lost integration constants are restored independently.

Failure modes and diagnostics

Insufficient stationarity: early or late windows contain oscillations, as the $T=12\,\mathrm{s}$ benchmark exposes.
Spectral leakage: a finite record spreads an offset and low-frequency power across Fourier bins; taper choice changes the result.
Integration drift: small curvature or news biases become secular strain trends.
Arbitrary constants: setting the mean strain to zero silently chooses a memory baseline.
High-pass removal: conditioning can suppress the very nonoscillatory component being modeled.
Mode truncation: the flux is quadratic, so omitted oscillatory modes can source retained memory modes.
Frame mismatch: a translation, boost, or supertranslation changes mode content and endpoint cuts.
Double counting: flux-reconstructed memory is added to an input already containing it.

A claimed offset should be accompanied by a zero-memory control, an injected-known-offset benchmark, a convergence table, and at least one independent construction such as Bondi-news integration versus flux reconstruction.

Scope and observation boundary

This workflow produces and validates a waveform component. Detector response, calibration, search statistics, and present event evidence belong to Gravitational-Wave Astronomy and dated Research records. A waveform offset that survives numerical convergence is necessary but not sufficient for an observational conclusion.

Exercise

The grid-refinement table appears converged to a relative error near $8\times10^{-6}$ , while the duration study reaches machine precision. Which numerical control should be changed first for this benchmark, and why?

Solution

Increase the duration or move the endpoint windows farther into quiet data before refining the grid again. The error and zero-memory control plateau together under factor-of-two grid refinement, so discretization is no longer dominant. Extending the record from 16 to 24 seconds removes the tapered oscillatory contamination and reduces the error by roughly ten orders of magnitude. Further resolution without duration control would only reproduce the same biased endpoint average more precisely.

References

Bishop, Nigel T., and Luciano Rezzolla. “Extraction of Gravitational Waves in Numerical Relativity.” Living Reviews in Relativity 19 (2016): 2. DOI. Open PDF.
Favata, Marc. “The Gravitational-Wave Memory Effect.” Classical and Quantum Gravity 27 (2010): 084036. DOI. Open PDF.