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

Derivation of the Spin Memory Effect

1. The Observable: Velocity Circulation

Consider a ring of freely falling test particles on a closed curve $\mathcal{C}$ embedded in a 2-sphere at large radius $r \gg GM/c^2$ near future null infinity $\mathscr{I}^+$. Define the velocity circulation around this loop:

$$\Gamma(\mathcal{C}) = \oint_{\mathcal{C}} \dot{x}^A \, dl_A$$

where $\dot{x}^A$ is the transverse velocity of a particle (the angular components $A \in \{\theta, \phi\}$) and $dl_A$ is the line element along $\mathcal{C}$. By Stokes' theorem on $S^2$:

$$\Gamma(\mathcal{C}) = \oint_{\mathcal{C}} v_A \, dx^A = \int_{\Sigma} \epsilon^{AB} D_A v_B \, d^2\Sigma$$

The integrand $\epsilon^{AB} D_A v_B$ is the curl of the velocity field. This is precisely why the circulation detects the magnetic-parity (B-mode, odd-parity) component of the gravitational wave field. An E-mode (gradient) perturbation produces $v_A = D_A \Phi$ for some scalar $\Phi$, and $\epsilon^{AB} D_A D_B \Phi = 0$ identically on $S^2$, so the circulation vanishes for purely electric modes.

2. Geodesic Equation at O(1/r) in Bondi Coordinates

Work in Bondi coordinates $(u, r, x^A)$ where the metric takes the asymptotic form:

$$ds^2 = -du^2 - 2\,du\,dr + r^2 \gamma_{AB}\,dx^A dx^B + \frac{2m_B}{r}\,du^2 + r\,C_{AB}\,dx^A dx^B + D^B C_{AB}\,du\,dx^A + \ldots$$

The relevant Christoffel symbols at leading order in $1/r$ are:

$$\Gamma^A_{uu} = -\frac{1}{2r}\,\partial_u(D^B C_{AB}) + \mathcal{O}(r^{-2}), \qquad \Gamma^A_{uB} = \frac{1}{2}\,N^A{}_B + \mathcal{O}(r^{-1})$$

where $N_{AB} = \partial_u C_{AB}$ is the Bondi news tensor. For a particle initially at rest ($\dot{r} = 0$, $\dot{x}^A = 0$ at early times), the geodesic equation$\ddot{x}^\mu + \Gamma^\mu_{\alpha\beta}\dot{x}^\alpha\dot{x}^\beta = 0$ gives, at leading order with $\dot{u} \approx 1$:

$$\ddot{x}^A + \Gamma^A_{uu} + 2\,\Gamma^A_{uB}\,\dot{x}^B = 0$$

Writing $v_A = g_{AB}\dot{x}^B$ for the covariant transverse velocity and keeping only $\mathcal{O}(1/r)$ terms:

$$\partial_u v_A = \frac{1}{2}\,N_{AB}\,v^B + \frac{1}{2}\,\partial_u(D^B C_{BA}) + \mathcal{O}(r^{-2})$$

The first term is the news-velocity coupling (linear in $v^B$), and the second is the metric drift from the $g_{uA}$ component at $\mathcal{O}(1/r)$. Identifying$g_{uA}|_{1/r} = \frac{1}{2}D^B C_{BA}$, we can write:

$$\partial_u v_A = \frac{1}{2}\,N_{AB}\,v^B + \partial_u\!\left(g_{uA}\big|_{\mathcal{O}(r^{-1})}\right)$$

3. Integration from $u = -\infty$ to $u = +\infty$

Integrate both sides over the full burst duration. The boundary conditions are:$v_A(-\infty) = 0$ (particles at rest before the wave), and$C_{AB}(-\infty) = C_{AB}^{(-)}$, $C_{AB}(+\infty) = C_{AB}^{(+)}$. Thus:

$$v_A(+\infty) = \frac{1}{2}\int_{-\infty}^{+\infty} N_{AB}\,v^B\,du + \frac{1}{2}\Delta(D^B C_{BA})$$

where $\Delta(D^B C_{BA}) = D^B C_{BA}^{(+)} - D^B C_{BA}^{(-)}$. The first integral is nonlinear (it involves $v^B$, which itself evolves), so we iterate: at leading order,$v^B$ is $\mathcal{O}(1/r)$, and $N_{AB}$ is also $\mathcal{O}(1/r)$, so the integral is $\mathcal{O}(1/r^2)$. The dominant contribution to the transverse velocity is:

$$v_A^{(1)}(+\infty) = \frac{1}{2}\,\Delta(D^B C_{BA})$$

However, the angular momentum aspect $N_A$ also contributes at $\mathcal{O}(1/r)$ through the subleading metric. Carefully tracking all $\mathcal{O}(1/r)$ terms (Pasterski, Strominger, Zhiboedov 2016):

$$v_A(+\infty) = \frac{1}{2r}\,\Delta(D^B C_{BA}) + \frac{1}{3r}\,\Delta N_A + \mathcal{O}(r^{-2})$$

4. Applying the Curl Operator

Apply $\epsilon^{AB}D_A$ to extract the magnetic-parity part. Consider each term separately.

First term: $\epsilon^{AB}D_A \Delta(D^C C_{CB})$. Since $C_{AB}$ is symmetric trace-free (STF), decompose it into E and B modes:

$$C_{AB} = \left(D_A D_B - \frac{1}{2}\gamma_{AB} D^2\right)\Phi_E + \epsilon_{C(A}D_{B)}D^C \Phi_B$$

For the E-mode part, $D^C C_{CB}^{(E)}$ is a gradient on $S^2$, so:

$$\epsilon^{AB}D_A D^C C_{CB}^{(E)} = \epsilon^{AB}D_A \partial_B(\text{scalar}) = 0$$

This is the crucial identity: the curl of any gradient vanishes on $S^2$. More precisely, for any smooth scalar $f$ on $S^2$:

$$\epsilon^{AB}D_A D_B f = 0$$

because $D_A D_B f - D_B D_A f = 0$ for scalars on a 2D manifold (the Riemann tensor contribution$R^C{}_{DAB} f$ vanishes when contracted with $\epsilon^{AB}$ due to the symmetry$R_{CDAB} = K(\gamma_{CA}\gamma_{DB} - \gamma_{CB}\gamma_{DA})$ on $S^2$).

Therefore: the shear boundary term $\Delta(D^B C_{BA})$ contributes only through its B-mode part, which is subdominant. The dominant B-mode contribution comes from $\Delta N_A$:

$$\epsilon^{AB}D_A v_B\big|_{+\infty} = \frac{2}{3r}\,\epsilon^{AB}D_A \Delta N_B$$

The factor $2/3$ arises from the precise coefficient of $\Delta N_A$ in the subleading soft expansion (related to the soft graviton theorem at sub-subleading order).

5. The Spin Memory Formula (Stokes' Theorem)

Now apply Stokes' theorem on $S^2$ to convert the line integral to an area integral. For the circulation around $\mathcal{C} = \partial\Sigma$:

$$\Delta\Gamma(\mathcal{C}) = \oint_{\mathcal{C}} v_A(+\infty)\,dx^A = \frac{2}{3r}\oint_{\mathcal{C}} \Delta N_A\,dx^A$$

Using the generalized Stokes theorem $\oint_{\partial\Sigma} \omega = \int_\Sigma d\omega$, where $\omega = \Delta N_A\,dx^A$ is a 1-form on $S^2$:

$$(d\omega)_{AB} = D_A(\Delta N_B) - D_B(\Delta N_A) = \epsilon_{AB}\,\epsilon^{CD}D_C \Delta N_D$$

So the area integral becomes:

$$\boxed{\Delta\Gamma(\mathcal{C}) = \frac{2}{3r}\int_\Sigma \epsilon^{AB}D_A \Delta N_B \, d^2\Sigma}$$

This is the spin memory effect: the permanent change in the velocity circulation is determined by the curl of the change in the angular momentum aspect $\Delta N_A$.

6. Deriving $\Delta N_A$ from the News Tensor

The evolution equation for the angular momentum aspect follows from the Bianchi identity applied to the asymptotic Einstein equations. At $\mathscr{I}^+$:

$$\partial_u N_A = \frac{1}{4}\,D_A\!\left(N_{BC}N^{BC}\right) - D^B(N_{BA}m_B) - \frac{1}{2}\,D_A\!\left(C^{BC}N_{BC}\right) + \frac{1}{2}\,N_{BC}\,D_A C^{BC} - 4\pi G\,T_{uA}^{\rm matter}$$

Integrate from $u = -\infty$ to $u = +\infty$. The key nonlinear term is:

$$\Delta N_A = \frac{1}{4}\int_{-\infty}^{+\infty} D_A(N_{BC}N^{BC})\,du - \int_{-\infty}^{+\infty} D^B(N_{BA}m_B)\,du + \ldots$$

The term $N_{BC}N^{BC}$ is the GW energy flux density (the same quantity that drives Christodoulou displacement memory). When we take $\epsilon^{AB}D_A$ of $\Delta N_B$, the gradient terms $D_A(\text{scalar})$ vanish, and only the curl part survives. This picks out the angular momentum flux from the nonlinear terms $D^B(N_{BA}m_B)$ and the matter flux $T_{uA}^{\rm matter}$:

$$\epsilon^{AB}D_A \Delta N_B = -\epsilon^{AB}\int_{-\infty}^{+\infty} D^C(N_{CA})m_B\,du - 4\pi G\,\epsilon^{AB}\int_{-\infty}^{+\infty} T_{uA}^{\rm matter}\,du$$

7. E/B Mode Decomposition: Why Displacement = E, Spin = B

Any symmetric trace-free tensor $H_{AB}$ on $S^2$ admits a unique decomposition:

$$H_{AB} = \left(D_A D_B - \frac{1}{2}\gamma_{AB}D^2\right)\Phi_E + \frac{1}{2}\left(\epsilon_{AC}D^C D_B + \epsilon_{BC}D^C D_A\right)\Phi_B$$

Displacement memory measures $\Delta C_{AB}$, the permanent change in the shear. Christodoulou's result shows $\Delta C_{AB}$ is sourced by the energy flux$\int N^{CD}N_{CD}\,du$, which is a scalar on $S^2$. Its STF Hessian is pure E-mode:

$$\Delta C_{AB}^{\rm disp} = \left(D_A D_B - \frac{1}{2}\gamma_{AB}D^2\right)\Phi_E \quad \Longleftrightarrow \quad \text{E-mode (even parity)}$$

Spin memory measures $\epsilon^{AB}D_A \Delta N_B$, the curl of the angular momentum change. This is a pseudoscalar on $S^2$ (odd under parity), and therefore:

$$\underbrace{\Delta\xi^i \sim \Delta C_{AB}}_{\text{even parity, E-mode}} \quad \longleftrightarrow \quad \underbrace{\Delta\Gamma \sim \epsilon^{AB}D_A \Delta N_B}_{\text{odd parity, B-mode}}$$

In the spin-weighted spherical harmonic decomposition with $\,_{-2}Y_{lm}$, the E-mode gives$a_{lm}^E \neq 0$, $a_{lm}^B = 0$, while spin memory gives $a_{lm}^B \neq 0$. This is the gravitational analog of the CMB E/B decomposition.

Spin Memory from a Precessing Binary Merger: Skymap and E/B Comparison

Python

script.py169 lines

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

# Spin memory from a precessing binary merger
# Model: asymmetric angular momentum flux produces B-mode memory

# Physical constants
G = 6.674e-11
c = 3e8
Msun = 1.989e30

# Binary parameters (GW150914-like but with precession)
m1, m2 = 36*Msun, 29*Msun
M = m1 + m2
eta = m1*m2/M**2
DL = 410e6 * 3.086e16  # 410 Mpc in meters

# Angular grid on S^2
Ntheta, Nphi = 80, 160
theta = np.linspace(0.01, np.pi-0.01, Ntheta)
phi = np.linspace(0, 2*np.pi, Nphi)
THETA, PHI = np.meshgrid(theta, phi, indexing='ij')

# Retarded time grid (inspiral + merger + ringdown)
N_u = 2000
u = np.linspace(-0.5, 0.1, N_u)  # seconds around merger

# Orbital frequency evolution (simplified PN)
f_isco = c**3 / (6*np.sqrt(6)*np.pi*G*M)
tau = np.maximum(0.01 - u, 1e-6)
f_orb = f_isco * (tau / tau[0])**(-3/8) * 0.3
f_orb = np.minimum(f_orb, f_isco)
v_over_c = (np.pi * G * M * f_orb / c**3)**(1./3.)

# Precession: orbital angular momentum direction precesses
Omega_prec = 0.1 * f_orb  # precession frequency
iota0 = 0.4  # initial inclination
prec_angle = np.cumsum(Omega_prec) * (u[1]-u[0])
Lhat_x = np.sin(iota0) * np.sin(prec_angle)
Lhat_y = np.sin(iota0) * np.cos(prec_angle)
Lhat_z = np.cos(iota0) * np.ones_like(u)

# Angular momentum flux: dJ/du has both z and transverse components
dJz_du = -32./5. * eta**2 * M**2 * v_over_c**7 * G/c
dJx_du = dJz_du * 0.15 * np.sin(2*prec_angle)
dJy_du = dJz_du * 0.15 * np.cos(2*prec_angle)

# Angular momentum aspect N_A evolution
# The B-mode (curl) part of Delta N_A is sourced by transverse J flux
# Delta N_A^(B) ~ epsilon_{AB} D^B (angular momentum flux pattern)
# On S^2, decompose into spin-weighted harmonics

# Compute spin memory pattern: Delta Psi (B-mode potential)
# Spin memory ~ integral of angular momentum flux projected onto B-modes
dt = u[1] - u[0]

# Build the B-mode memory skymap
# The spin memory angular pattern for precessing binary:
# Dominated by l=2 and l=3 spin-weighted spherical harmonics
# B-mode pattern from asymmetric J flux

# l=2 B-mode contribution (from precession-induced asymmetry)
Y21_real = np.sin(THETA) * np.cos(THETA) * np.cos(PHI)
Y22_real = np.sin(THETA)**2 * np.cos(2*PHI)
Y31_real = np.sin(THETA) * (5*np.cos(THETA)**2 - 1) * np.sin(PHI)

# Accumulate spin memory over retarded time
Delta_J_transverse = np.trapezoid(np.sqrt(dJx_du**2 + dJy_du**2), u)
Delta_J_z = np.trapezoid(dJz_du, u)

# Spin memory amplitude
h_spin_prefactor = G * eta * M * v_over_c[-1] / (c**2 * DL)

# B-mode angular pattern (curl part only)
Delta_Psi_B = (h_spin_prefactor[-1] if hasattr(h_spin_prefactor, '__len__') else h_spin_prefactor) * (
    0.6 * Y31_real + 0.3 * Y21_real + 0.1 * Y22_real
)

# E-mode (displacement memory) for comparison
# Christodoulou formula: dominated by l=2, m=0
Y20 = 0.25 * np.sqrt(5/np.pi) * (3*np.cos(THETA)**2 - 1)
h_disp = 32./5. * eta * (G*M/c**2) / DL * v_over_c[-1]**2 * Y20

fig, axes = plt.subplots(1, 2, figsize=(14, 5),
                          subplot_kw={'projection': 'mollweide'})

# Convert to Mollweide coords
phi_moll = PHI - np.pi
theta_moll = np.pi/2 - THETA

# Plot B-mode (spin memory)
im1 = axes[0].pcolormesh(phi_moll, theta_moll, Delta_Psi_B,
                          cmap='RdBu_r', shading='auto')
axes[0].set_title('B-mode: Spin Memory $\\Delta\\Psi_B$', fontsize=13, fontweight='bold')
axes[0].grid(True, alpha=0.3)
plt.colorbar(im1, ax=axes[0], orientation='horizontal', pad=0.05, label='Strain')

# Plot E-mode (displacement memory)
im2 = axes[1].pcolormesh(phi_moll, theta_moll, h_disp,
                          cmap='PiYG', shading='auto')
axes[1].set_title('E-mode: Displacement Memory $\\Delta C$', fontsize=13, fontweight='bold')
axes[1].grid(True, alpha=0.3)
plt.colorbar(im2, ax=axes[1], orientation='horizontal', pad=0.05, label='Strain')

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

# Time evolution of spin vs displacement memory
fig2, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
fig2.patch.set_facecolor('#0a0a1a')

# Cumulative spin memory vs time
spin_mem_cum = np.cumsum(np.sqrt(dJx_du**2 + dJy_du**2)) * dt
spin_mem_cum = spin_mem_cum / spin_mem_cum[-1]  # normalize

disp_mem_cum = np.cumsum(32./5. * eta**2 * v_over_c**10 / (G*M/c**3)) * dt
disp_mem_cum = disp_mem_cum / disp_mem_cum[-1]

ax1.set_facecolor('#0a0a1a')
ax1.plot(u*1000, spin_mem_cum, 'c-', linewidth=2.5, label='Spin memory (B-mode)')
ax1.plot(u*1000, disp_mem_cum, 'm-', linewidth=2.5, label='Displacement memory (E-mode)')
ax1.axvline(x=0, color='yellow', linestyle='--', alpha=0.5, label='Merger')
ax1.set_xlabel('Retarded time u (ms)', color='white', fontsize=12)
ax1.set_ylabel('Normalized memory buildup', color='white', fontsize=12)
ax1.set_title('Memory Buildup During Binary Coalescence', color='cyan', fontsize=14, fontweight='bold')
ax1.legend(fontsize=11, facecolor='#1a1a2e')
ax1.tick_params(colors='white')
ax1.grid(True, alpha=0.2)
for spine in ax1.spines.values(): spine.set_color('#333')

# Amplitude comparison
sources = ['GW150914\n(36+29 Msun)', 'GW190521\n(85+66 Msun)', 'LISA SMBH\n(1e7+1e7 Msun)']
h_disp_vals = [2.5e-22, 8e-22, 1e-16]
h_spin_vals = [3e-23, 1.5e-22, 5e-17]

x = np.arange(len(sources))
width = 0.35
ax2.set_facecolor('#0a0a1a')
bars1 = ax2.bar(x - width/2, h_disp_vals, width, label='Displacement (E-mode)',
                color='magenta', alpha=0.8)
bars2 = ax2.bar(x + width/2, h_spin_vals, width, label='Spin (B-mode)',
                color='cyan', alpha=0.8)
ax2.set_yscale('log')
ax2.set_ylabel('Memory strain amplitude', color='white', fontsize=12)
ax2.set_title('E-mode vs B-mode Memory Amplitudes', color='cyan', fontsize=14, fontweight='bold')
ax2.set_xticks(x)
ax2.set_xticklabels(sources, color='white', fontsize=11)
ax2.legend(fontsize=11, facecolor='#1a1a2e')
ax2.tick_params(colors='white')
ax2.grid(True, alpha=0.2, axis='y')
for spine in ax2.spines.values(): spine.set_color('#333')

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

print("Spin memory skymap saved to /tmp/spin_memory_skymap.png")
print("Memory comparison saved to /tmp/spin_memory_comparison.png")
print(f"\nSpin memory strain (GW150914): ~{3e-23:.1e}")
print(f"Displacement memory strain (GW150914): ~{2.5e-22:.1e}")
print(f"Ratio h_spin/h_disp ~ v/c ~ {3e-23/2.5e-22:.2f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Displacement Memory Next: Angular Momentum Flux →