← Back to Part VI: Gravitational Wave Memory & BMS Symmetries

Observational Prospects

Detecting spin memory across the gravitational wave spectrum

1. Measurement Strategy: Extracting B-mode Memory

The spin memory produces a permanent offset in the magnetic-parity component of the gravitational wave strain. Define the accumulated spin observable:

$$\Sigma(u_f) = \int_{-\infty}^{u_f} h_B(u)\,du$$

where $h_B$ is the B-mode (odd-parity) component of the strain. To extract$h_B$ from detector data, decompose the strain into spin-weighted spherical harmonics$\,_{-2}Y_{lm}(\theta, \phi)$:

$$h_+(u) - ih_\times(u) = \sum_{l,m} \left(a_{lm}^E(u) - i\,a_{lm}^B(u)\right)\,\,_{-2}Y_{lm}(\theta,\phi)$$

The E-mode coefficients $a_{lm}^E$ carry displacement memory, while $a_{lm}^B$carry spin memory. After the wave train passes ($u_f \to +\infty$):

$$\Sigma(+\infty) = \int_{-\infty}^{+\infty} h_B(u)\,du = \text{const} \neq 0 \qquad \text{(spin memory)}$$

For a single detector, the E/B decomposition requires either a network of detectors (to reconstruct the sky pattern) or a waveform model that predicts the B-mode content from the source parameters. With three or more detectors, one can directly measure$h_+$ and $h_\times$ independently and perform the decomposition.

2. Matched Filtering: Deriving the SNR Formula

Start from optimal filter theory. The signal-to-noise ratio for a known template$h(t)$ in Gaussian noise with power spectral density $S_n(f)$ is:

$$\mathrm{SNR}^2 = 4\int_0^\infty \frac{|\tilde{h}(f)|^2}{S_n(f)}\,df$$

The spin memory signal is a step function in the time domain: $h_B(t) = \Delta h_B \cdot \Theta(t - t_{\rm merger})$. Its Fourier transform is:

$$\tilde{h}_B(f) = \frac{\Delta h_B}{2\pi i f} + \frac{\Delta h_B}{2}\,\delta(f)$$

Dropping the delta function (which contributes at $f = 0$) and noting that the memory builds up over a timescale $\sim 1/f_{\rm ISCO}$ (not instantaneously), the spectral amplitude is:

$$|\tilde{h}_B(f)|^2 \approx \frac{(\Delta h_B)^2}{4\pi^2 f^2}\,e^{-2f/f_{\rm ISCO}}$$

Substituting into the SNR formula:

$$\mathrm{SNR}^2 = \frac{(\Delta h_B)^2}{\pi^2}\int_{f_{\rm low}}^{f_{\rm ISCO}} \frac{df}{f^2\,S_n(f)}$$

The $1/f^2$ weighting is critical: it means the SNR is dominated by the lowest accessible frequencies. This is why low-frequency sensitivity is paramount for memory detection, and why LISA and next-generation ground-based detectors (with lower seismic walls) are so important.

3. Detector-by-Detector SNR Estimates

For each detector, we compute the spin memory SNR using the actual noise curve $S_n(f)$:

LIGO O4/A+ ($f_{\rm low} \sim 10\,\text{Hz}$): For a GW150914-like source, $\Delta h_B \sim 3 \times 10^{-23}$ at 410 Mpc. The integral gives:

$$\mathrm{SNR}_{\rm LIGO} \sim 3 \times 10^{-3} \quad \text{(single event, far below threshold)}$$

Einstein Telescope ($f_{\rm low} \sim 2\,\text{Hz}$): The improved low-frequency sensitivity boosts the $\int df/(f^2 S_n)$ integral by a factor $\sim 100$:

$$\mathrm{SNR}_{\rm ET} \sim 0.05 \text{ (single BBH)}, \quad \sim 0.3 \text{ (single IMBH at 1 Gpc)}$$

LISA ($f_{\rm low} \sim 10^{-4}\,\text{Hz}$): For SMBH mergers ($M \sim 10^7\,M_\odot$), the enormous mass gives large memory strain:

$$\mathrm{SNR}_{\rm LISA} \sim 5\text{--}50 \quad \text{(SMBH merger at 3 Gpc, potentially detectable!)}$$

Pulsar Timing Arrays ($f \sim \text{nHz}$): The stochastic background of SMBH mergers produces cumulative memory that contributes to the Hellings-Downs correlation at the $\sim 1\%$ level.

4. Stacking Analysis

For $N$ independent events, each with individual spin memory SNR $\rho_i$, the combined SNR from coherent stacking is:

$$\rho_{\rm stack}^2 = \sum_{i=1}^N \rho_i^2$$

For events with similar parameters (same $\rho_1$), this simplifies to:

$$\rho_{\rm stack} = \rho_1 \sqrt{N}$$

Setting $\rho_{\rm stack} = 3$ as the detection threshold, the number of events needed is:

$$N_{\rm detect} = \left(\frac{3}{\rho_1}\right)^2$$

Estimates: LIGO A+ with $\rho_1 \sim 0.003$ needs$N \sim 10^6$ events (impractical). ET with $\rho_1 \sim 0.05$ needs$N \sim 3600$ events (achievable in a few years of operation). CE with$\rho_1 \sim 0.08$ needs $N \sim 1400$ events.

5. Optimal Sources for Spin Memory Detection

Supermassive BBH mergers (LISA): For $M \sim 10^7\,M_\odot$ at $z \sim 1$ ($D_L \approx 6.7\,\text{Gpc}$), the spin memory strain is $\Delta h_B \sim (G M/(c^2 D_L)) \cdot \eta \cdot v/c \sim 5 \times 10^{-17}$. With LISA's extraordinary low-frequency sensitivity, this yields SNR $\sim 5$--$50$, making SMBH mergers the most promising single-event targets.

EMRIs (LISA): Extreme mass-ratio inspirals complete $\sim 10^5$ orbits in the LISA band. Each orbit deposits a small increment of spin memory. The cumulative B-mode signal builds coherently:$\Delta h_B^{\rm total} \sim N_{\rm orbits} \times \Delta h_B^{\rm per\,orbit}$. For a $10\,M_\odot$ object spiraling into a $10^6\,M_\odot$ SMBH, the accumulated spin memory SNR can reach $\sim 1$--$5$.

Precessing stellar-mass BBH (ET/CE): Systems with significant spin-orbit misalignment (e.g., dynamical captures in dense clusters) have enhanced B-mode emission. The 1.5PN spin-orbit contribution to spin memory scales as$\chi_{\rm eff} \sin\iota$, boosting $\rho_1$ by a factor $\sim 2$--$5$relative to non-spinning systems.

Core-collapse supernovae (ET/CE): Asymmetric neutrino emission carries angular momentum, producing spin memory with$\Delta h_B \sim G\,\Delta J_\nu/(c^3 D_L)$. For a Galactic CCSN ($D_L \sim 10\,\text{kpc}$) with $\Delta J_\nu \sim 10^{47}\,\text{g\,cm}^2/\text{s}$, this gives$\Delta h_B \sim 10^{-23}$, potentially detectable by ET.

6. Systematic Errors and Disentangling Signals

Confusion with displacement memory: The E-mode displacement memory is $\sim c/v$ times larger. Any leakage of E-mode into the B-mode channel (due to imperfect sky localization or incomplete detector networks) can mimic spin memory. The contamination scales as:

$$\Delta h_B^{\rm leak} \sim \delta\psi \cdot \Delta h_E \sim \delta\psi \cdot \frac{c}{v}\cdot \Delta h_B^{\rm true}$$

where $\delta\psi$ is the polarization angle uncertainty. For LIGO networks, $\delta\psi \sim 10^\circ$, giving contamination at the $\sim 30\%$ level. A five-detector network reduces this to $\sim 5\%$.

Frame-dragging effects: For EMRIs, the geodetic and Lense-Thirring precession of the small body also produces B-mode emission. Separating this from genuine spin memory requires waveform models accurate to $\sim 0.1$ rad in orbital phase over the full inspiral.

Current upper limits (2025): LIGO O3 stacking analyses with$\sim 90$ BBH events place an upper limit on the average spin memory of$\langle\Delta h_B\rangle < 5 \times 10^{-22}$ at 90% confidence. The O4/O5 runs are expected to improve this by a factor $\sim 3$--$5$.

7. Future Projections

The timeline for spin memory detection depends critically on the detector landscape:

2030s (ET/CE era): With $\sim 10^4$--$10^5$ BBH detections per year, stacking should yield a $3\sigma$ detection of displacement memory within months and a $3\sigma$ spin memory detection within $\sim 2$--$5$ years.

2035+ (LISA era): A single SMBH merger could provide a definitive spin memory detection. LISA is expected to observe $\sim 10$--$100$ SMBH mergers over its mission lifetime.

Fundamental physics payoff: Detection of spin memory would directly confirm the super-rotation symmetry of asymptotically flat spacetimes, validate the infrared triangle connecting soft gravitons to BMS symmetries to memory, and constrain the B-mode sector of the gravitational wave landscape for the first time.

Full Detectability Analysis: Noise Curves, SNR, Stacking, and Horizons

Python

script.py240 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# Full detectability analysis for spin memory
G = 6.674e-11
c = 3e8
Msun = 1.989e30
Mpc = 3.086e22
yr = 3.156e7

# --- Detector noise curves (analytic fits) ---
def ligo_aplus(f):
    """LIGO A+ design sensitivity"""
    f0 = 25.0
    x = f / f0
    S = 1.3e-48 * (x**(-4.14) - 5*x**(-2) + 111*(1 - x**2 + 0.5*x**4)/(1+0.5*x**2))
    return np.where(f > 8, np.maximum(np.abs(S), 1e-52), np.inf)

def einstein_telescope(f):
    """Einstein Telescope (ET-D) sensitivity"""
    f0 = 10.0
    x = f / f0
    S_low = 2.4e-52 * x**(-15.64) + 3.2e-49 * x**(-2.145)
    S_high = 7.6e-49 * (1 + 0.7*x**2)
    S = np.where(f < 100, S_low + S_high, S_high)
    return np.where(f > 1, np.maximum(np.abs(S), 1e-52), np.inf)

def cosmic_explorer(f):
    """Cosmic Explorer (40km) sensitivity"""
    return ligo_aplus(f) * 0.01  # ~10x better strain -> 100x better PSD

def lisa_noise(f):
    """LISA noise curve (SciRD 2017)"""
    L = 2.5e9  # arm length
    f_star = c / (2 * np.pi * L)
    P_oms = (1.5e-11)**2 * (1 + (2e-3/f)**4)  # optical metrology
    P_acc = (3e-15)**2 * (1 + (0.4e-3/f)**2) * (1 + (f/8e-3)**4)  # acceleration
    S = (P_oms + 2*(1+np.cos(f/f_star)**2)*P_acc/(2*np.pi*f)**4) / L**2
    # Transfer function
    R = 3./20. / (1 + 0.6*(f/f_star)**2)
    return np.where((f > 1e-5) & (f < 1), S/R, np.inf)

def pta_noise(f):
    """PTA noise (rough model for SKA era)"""
    T_obs = 20 * yr
    sigma_t = 100e-9  # 100ns timing precision
    N_pulsars = 200
    S = sigma_t**2 / (T_obs * N_pulsars) * (1 + (f*T_obs)**(-2))
    return np.where((f > 1e-9) & (f < 1e-6), S, np.inf)

# --- Spin memory strain amplitude ---
def h_spin_memory(M_total, eta, DL, v_final=0.5):
    """Peak spin memory strain"""
    return 0.02 * (G * M_total / (c**2 * DL)) * eta * v_final

def memory_spectrum(h0, f, f_char):
    """Memory frequency-domain amplitude: step function -> 1/f spectrum"""
    return h0 / (2 * np.pi * f) * np.exp(-f/f_char) * np.sqrt(f_char)

# --- Compute SNR ---
def compute_snr(h0, f_char, noise_func, f_low, f_high, N_points=5000):
    f = np.logspace(np.log10(f_low), np.log10(f_high), N_points)
    Sn = noise_func(f)
    h_tilde = memory_spectrum(h0, f, f_char)
    valid = np.isfinite(Sn) & (Sn > 0) & np.isfinite(h_tilde)
    if np.sum(valid) < 10:
        return 0.0
    integrand = np.zeros_like(f)
    integrand[valid] = h_tilde[valid]**2 / Sn[valid]
    snr_sq = 4 * np.trapezoid(integrand[valid], f[valid])
    return np.sqrt(max(snr_sq, 0))

# --- Figure 1: Noise curves ---
fig, axes = plt.subplots(2, 2, figsize=(15, 12))
fig.patch.set_facecolor('#0a0a1a')

ax = axes[0, 0]
ax.set_facecolor('#0a0a1a')

f_ground = np.logspace(0, 4, 2000)
f_space = np.logspace(-5, 0, 2000)
f_pta = np.logspace(-9.5, -6, 500)

# Plot noise amplitude spectral densities
mask = ligo_aplus(f_ground) < 1e-40
ax.loglog(f_ground[mask], np.sqrt(ligo_aplus(f_ground[mask])), 'c-', lw=2, label='LIGO A+')
mask = einstein_telescope(f_ground) < 1e-40
ax.loglog(f_ground[mask], np.sqrt(einstein_telescope(f_ground[mask])), 'lime', lw=2, label='Einstein Telescope')
mask = cosmic_explorer(f_ground) < 1e-40
ax.loglog(f_ground[mask], np.sqrt(cosmic_explorer(f_ground[mask])), 'orange', lw=2, label='Cosmic Explorer')
mask = lisa_noise(f_space) < 1e-30
ax.loglog(f_space[mask], np.sqrt(lisa_noise(f_space[mask])), 'yellow', lw=2, label='LISA')

ax.set_xlabel('Frequency (Hz)', color='white', fontsize=12)
ax.set_ylabel('Strain noise ASD $\\sqrt{S_n(f)}$ (1/Hz$^{1/2}$)', color='white', fontsize=12)
ax.set_title('Detector Noise Curves', color='cyan', fontsize=14, fontweight='bold')
ax.legend(fontsize=10, facecolor='#1a1a2e')
ax.set_ylim(1e-25, 1e-17)
ax.set_xlim(1e-5, 1e4)
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)
for s in ax.spines.values(): s.set_color('#333')

# --- Figure 2: SNR vs distance for each source type ---
ax = axes[0, 1]
ax.set_facecolor('#0a0a1a')

distances = np.logspace(1, 5, 100) * Mpc  # 10 Mpc to 100 Gpc

# Source types
sources = [
    ("Stellar BBH (65 Msun)", 65*Msun, 0.247, 0.5, 100, ligo_aplus, 8, 5000, 'cyan'),
    ("Stellar BBH (ET)", 65*Msun, 0.247, 0.5, 100, einstein_telescope, 1, 5000, 'lime'),
    ("IMBH (500 Msun, ET)", 500*Msun, 0.25, 0.55, 20, einstein_telescope, 1, 5000, 'orange'),
    ("SMBH (1e7 Msun, LISA)", 1e7*Msun, 0.25, 0.6, 1e-3, lisa_noise, 1e-5, 1, 'yellow'),
]

for label, M, eta, v, f_c, noise, fl, fh, color in sources:
    snrs = []
    for D in distances:
        h0 = h_spin_memory(M, eta, D, v)
        snr = compute_snr(h0, f_c, noise, fl, fh)
        snrs.append(snr)
    snrs = np.array(snrs)
    d_mpc = distances / Mpc
    valid = snrs > 0.01
    if np.any(valid):
        ax.loglog(d_mpc[valid], snrs[valid], color=color, lw=2.5, label=label)

ax.axhline(y=1, color='red', ls='--', alpha=0.5, label='SNR = 1')
ax.axhline(y=5, color='red', ls=':', alpha=0.3, label='SNR = 5')
ax.set_xlabel('Luminosity distance (Mpc)', color='white', fontsize=12)
ax.set_ylabel('Spin memory SNR', color='white', fontsize=12)
ax.set_title('SNR vs Distance (Single Event)', color='cyan', fontsize=14, fontweight='bold')
ax.legend(fontsize=9, facecolor='#1a1a2e', loc='upper right')
ax.set_ylim(1e-4, 1e4)
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)
for s in ax.spines.values(): s.set_color('#333')

# --- Figure 3: Stacking analysis ---
ax = axes[1, 0]
ax.set_facecolor('#0a0a1a')

N_events = np.logspace(0, 5, 200)

# Single-event SNR for different scenarios
scenarios = [
    ("LIGO A+ (BBH, 400 Mpc)", 0.003, 'cyan'),
    ("ET (BBH, 1 Gpc)", 0.05, 'lime'),
    ("CE (BBH, 2 Gpc)", 0.08, 'orange'),
    ("ET (IMBH, 3 Gpc)", 0.15, 'magenta'),
]

for label, snr1, color in scenarios:
    stacked_snr = snr1 * np.sqrt(N_events)
    ax.loglog(N_events, stacked_snr, color=color, lw=2.5, label=label)

ax.axhline(y=3, color='red', ls='--', alpha=0.6, label='Detection threshold (SNR=3)')
ax.fill_between([1, 1e5], 0, 3, color='red', alpha=0.05)
ax.set_xlabel('Number of stacked events', color='white', fontsize=12)
ax.set_ylabel('Cumulative SNR', color='white', fontsize=12)
ax.set_title('Stacking Analysis: SNR ~ $\\sqrt{N}$', color='cyan', fontsize=14, fontweight='bold')
ax.legend(fontsize=9, facecolor='#1a1a2e')
ax.set_ylim(1e-3, 1e3)
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)
for s in ax.spines.values(): s.set_color('#333')

# --- Figure 4: Detection horizon across detector landscape ---
ax = axes[1, 1]
ax.set_facecolor('#0a0a1a')

# For each detector, find the distance at which SNR = 1 for each source mass
masses = np.logspace(1, 8, 100) * Msun
detectors = [
    ("LIGO A+", ligo_aplus, 8, 5000, 'cyan'),
    ("Einstein Telescope", einstein_telescope, 1, 5000, 'lime'),
    ("Cosmic Explorer", cosmic_explorer, 1, 5000, 'orange'),
    ("LISA", lisa_noise, 1e-5, 1, 'yellow'),
]

for det_name, noise, fl, fh, color in detectors:
    horizons = []
    for M in masses:
        f_char = min(c**3/(6*np.sqrt(6)*np.pi*G*M), fh*0.5)
        if f_char < fl:
            horizons.append(0)
            continue
        # Binary search for SNR=1 distance
        D_low, D_high = 1*Mpc, 1e6*Mpc
        for _ in range(30):
            D_mid = np.sqrt(D_low * D_high)
            h0 = h_spin_memory(M, 0.25, D_mid, 0.5)
            snr = compute_snr(h0, f_char, noise, fl, fh)
            if snr > 1:
                D_low = D_mid
            else:
                D_high = D_mid
        horizons.append(np.sqrt(D_low * D_high) / Mpc)
    horizons = np.array(horizons)
    valid = horizons > 1
    if np.any(valid):
        ax.loglog(masses[valid]/Msun, horizons[valid], color=color, lw=2.5, label=det_name)

ax.set_xlabel('Total binary mass ($M_\\odot$)', color='white', fontsize=12)
ax.set_ylabel('Spin memory horizon (Mpc)', color='white', fontsize=12)
ax.set_title('Detection Horizon for Spin Memory', color='cyan', fontsize=14, fontweight='bold')
ax.legend(fontsize=10, facecolor='#1a1a2e')
ax.tick_params(colors='white')
ax.grid(True, alpha=0.2)
for s in ax.spines.values(): s.set_color('#333')

plt.tight_layout()
plt.savefig('/tmp/detectability_analysis.png', dpi=130, bbox_inches='tight',
            facecolor='#0a0a1a')
plt.close()

# Print summary
print("=== Spin Memory Detectability Summary ===")
print()
print("Single-event SNR estimates:")
for label, M, eta, v, f_c, noise, fl, fh, _ in sources:
    D = 1000 * Mpc
    h0 = h_spin_memory(M, eta, D, v)
    snr = compute_snr(h0, f_c, noise, fl, fh)
    print(f"  {label} at 1 Gpc: SNR = {snr:.4f}")

print()
print("Events needed for SNR=3 detection (stacking):")
for label, snr1, _ in scenarios:
    N_needed = (3.0/snr1)**2
    print(f"  {label}: N = {N_needed:.0f} events")

print()
print("Plot saved to /tmp/detectability_analysis.png")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Infrared Triangle Back to Part VI →