Connection I — Diffeomorphism Gauging: DeTurck ↔ BMS

1. DeTurck Vector Field and Strict Parabolicity

Hamilton’s Ricci flow $\partial_t g_{ij} = -2R_{ij}$ is only weakly parabolic: the principal symbol of $-2R_{ij}$ viewed as a second-order operator on $g_{ij}$ has a kernel spanned by pure gauge modes (infinitesimal diffeomorphisms). To see this, linearise $R_{ij}$ around a background $\bar{g}$ with $g_{ij} = \bar{g}_{ij} + h_{ij}$:

$$-2\,\delta R_{ij} = -\bar{\nabla}^2 h_{ij} + \bar{\nabla}_i V_j + \bar{\nabla}_j V_i + \text{lower order}$$

where $V_j = \bar{\nabla}^k h_{jk} - \frac{1}{2}\bar{\nabla}_j h^k{}_k$. The principal symbol in Fourier space ($\bar{\nabla} \to i\xi$) is:

$$\sigma(\xi)_{ij,kl}\,h^{kl} = |\xi|^2 h_{ij} - \xi_i\xi^k h_{jk} - \xi_j\xi^k h_{ik} + \cdots$$

For gauge modes $h_{ij} = \nabla_i v_j + \nabla_j v_i$, we have $\sigma(\xi)\,h = 0$, confirming the kernel. DeTurck’s trick introduces a background metric $\hat{g}$ and defines:

$$\boxed{W^k = g^{pq}\!\left(\Gamma^k_{pq} - \hat{\Gamma}^k_{pq}\right)}$$

The Ricci-DeTurck flow is $\partial_t g_{ij} = -2R_{ij} + \mathcal{L}_W g_{ij}$. The Lie derivative contributes to the principal symbol:

$$\mathcal{L}_W g_{ij}\Big|_{\rm principal} = \nabla_i W_j + \nabla_j W_i \sim \nabla_i g^{pq}\nabla_p h_{qj} + \cdots$$

This exactly cancels the degenerate directions. The full principal symbol of the Ricci-DeTurck operator becomes:

$$\sigma_{\rm RDT}(\xi)_{ij,kl}\,h^{kl} = |\xi|^2\,h_{ij}$$

This is the symbol of the scalar Laplacian acting on each component of $h_{ij}$ independently — manifestly strictly parabolic. Standard PDE theory (Schauder estimates) then guarantees short-time existence and uniqueness.

2. BRST Complex for DeTurck

The gauge redundancy of Ricci flow under $\mathrm{Diff}(M)$ is encoded in a BRST complex. Introduce a Grassmann-odd ghost field $c^i$ with ghost number 1. The BRST operator $s_{\rm DT}$ acts as:

$$s_{\rm DT}\,g_{ij} = \mathcal{L}_c\,g_{ij} = \nabla_i c_j + \nabla_j c_i$$

$$s_{\rm DT}\,c^i = c^j\partial_j c^i$$

Proof of nilpotency $s_{\rm DT}^2 = 0$: Compute $s_{\rm DT}^2 g_{ij}$:

$$s_{\rm DT}^2 g_{ij} = s_{\rm DT}(\nabla_ic_j + \nabla_jc_i) = \mathcal{L}_{s(c)}g_{ij} + \mathcal{L}_c(\mathcal{L}_c g_{ij})$$

Using $s_{\rm DT} c^i = c^j\partial_j c^i = \frac{1}{2}[c,c]^i_{\rm Lie}$ and the identity $\mathcal{L}_{[c,c]} = 2\mathcal{L}_c\mathcal{L}_c$ for Grassmann-odd parameters (where the factor of 2 accounts for the anticommutation), we get:

$$s_{\rm DT}^2 g_{ij} = \mathcal{L}_{\frac{1}{2}[c,c]}g_{ij} - \frac{1}{2}\mathcal{L}_{[c,c]}g_{ij} = 0$$

The DeTurck vector $W^k$ serves as the gauge-fixing fermion: $\mathcal{L}_W g_{ij} = s_{\rm DT}\,\psi_{ij}$ for an appropriate anti-ghost $\psi$, ensuring the gauge-fixed action remains in the same BRST cohomology class.

3. BRST Complex for BMS

On $\mathscr{I}^+$, the BMS ghosts are $(c^A, c_f)$ corresponding to superrotations and supertranslations. The BRST transformation of the asymptotic shear is:

$$s_{\rm BMS}\,C_{AB} = \mathcal{L}_{c^A}C_{AB} + 2D_{\langle A}D_{B\rangle}c_f + \frac{u}{2}(D_Cc^C)\,N_{AB}$$

The ghost self-interactions encoding the BMS algebra are:

$$s_{\rm BMS}\,c^A = c^B\partial_B c^A, \qquad s_{\rm BMS}\,c_f = c^A\partial_A c_f - \frac{1}{2}(D_Ac^A)\,c_f$$

Nilpotency check: For $s_{\rm BMS}^2 C_{AB}$, the supertranslation part gives $2D_{\langle A}D_{B\rangle}(s_{\rm BMS}\,c_f)$. Substituting $s_{\rm BMS}c_f = c^A\partial_Ac_f - \frac{1}{2}(D_Ac^A)c_f$ and combining with $s_{\rm BMS}(\mathcal{L}_{c^A}C_{AB}) = \mathcal{L}_{[c,c]}C_{AB} + 2D_{\langle A}D_{B\rangle}(\mathcal{L}_c c_f)$, all terms cancel by the BMS algebra relations, confirming $s_{\rm BMS}^2 = 0$.

4. Physical Observables as BRST Cohomology

DeTurck side: Perelman’s $\mathcal{W}$-entropy is $s_{\rm DT}$-closed. Under an infinitesimal diffeomorphism generated by $c^i$:

$$s_{\rm DT}\,\mathcal{W}[g,f,\tau] = \int_M \frac{\delta\mathcal{W}}{\delta g_{ij}}\left(\nabla_ic_j + \nabla_jc_i\right)e^{-f}\,d\mu = 0$$

The vanishing follows because $\mathcal{W}$ is diffeomorphism-invariant by construction (the integrand transforms as a scalar density). Moreover, $\mathcal{W}$ is not $s_{\rm DT}$-exact (it is not purely gauge), so $[\mathcal{W}] \in H^0(s_{\rm DT})$.

BMS side: The spin memory $\Delta\Psi$ is $s_{\rm BMS}$-closed. Under a supertranslation, $C_{AB} \to C_{AB} + 2D_{\langle A}D_{B\rangle}c_f$. The B-mode part of this shift is:

$$\delta\Psi = \epsilon^{AB}D_A D_B c_f = 0$$

since $\epsilon^{AB}D_AD_B$ acting on a scalar vanishes identically (antisymmetric derivatives on a scalar commute on $S^2$ up to curvature, which is pure trace). Therefore $\Delta\Psi$ is gauge-invariant: $[\Delta\Psi] \in H^0(s_{\rm BMS})$.

5. Riemannian Moduli Space and the Slice Theorem

The space of Riemannian metrics on a closed manifold $M$ is an infinite-dimensional Frechet manifold:

$$\mathrm{Met}(M) = \{g \in \Gamma(S^2T^*M) : g > 0\}$$

The diffeomorphism group $\mathrm{Diff}(M)$ acts by pullback: $\phi \cdot g = \phi^*g$. The moduli space $\mathcal{M} = \mathrm{Met}(M)/\mathrm{Diff}(M)$ is the orbit space. The slice theorem (Ebin 1970) states that at each $g \in \mathrm{Met}(M)$, there exists a local slice $\mathcal{S}_g$ transverse to the orbit:

$$T_g\mathrm{Met}(M) = T_g(\mathrm{Diff}(M)\cdot g) \oplus T_g\mathcal{S}_g$$

The orbit tangent space is $T_g(\mathrm{Diff}\cdot g) = \{\mathcal{L}_X g : X \in \mathfrak{X}(M)\} = \mathrm{Im}(\delta^*_g)$ where $(\delta^*_g X)_{ij} = \nabla_iX_j + \nabla_jX_i$. The slice is the $L^2$-orthogonal complement:

$$\mathcal{S}_g = \ker(\delta_g) = \{h_{ij} : \nabla^i h_{ij} - \frac{1}{2}\nabla_j h^k{}_k = 0\}$$

This is exactly the de Donder (harmonic) gauge condition. The DeTurck vector field $W^k$ projects the Ricci flow trajectory onto this slice, ensuring the flow remains transverse to diffeomorphism orbits.

6. BMS Phase Space as Symplectic Reduction

The gravitational phase space at $\mathscr{I}^+$ starts from the extended space of radiative data:

$$\widetilde{\mathcal{P}} = \{(C_{AB}(u,x^C),\, N_A(u,x^B),\, m_B(u,x^A))\}$$

equipped with the Ashtekar-Streubel symplectic form:

$$\Omega = \frac{1}{16\pi G}\int_{\mathscr{I}^+}du\oint_{S^2}\delta N_{AB} \wedge \delta C^{AB}\,d^2\Omega$$

The trivial diffeomorphisms $\mathrm{Diff}_0$ (those that vanish at $\mathscr{I}^+$) generate Hamiltonian flows with moment map $\mu = 0$ (constraints). Symplectic reduction gives the physical phase space:

$$\boxed{\mathcal{P}_{\rm grav} = \mu^{-1}(0)\,/\,\mathrm{Diff}_0 = \widetilde{\mathcal{P}}\,/\!/\,\mathrm{Diff}_0}$$

The BMS group acts as the residual symmetry on $\mathcal{P}_{\rm grav}$, analogous to how global isometries act on the Riemannian moduli space after DeTurck gauge-fixing. The structural parallel is: DeTurck quotients by $\mathrm{Diff}(M)$ to get $\mathcal{M}$, while the BMS programme quotients by $\mathrm{Diff}_0$ to get $\mathcal{P}_{\rm grav}$.

Simulation: DeTurck Flow vs Ricci Flow on a Deformed Sphere

We simulate the 2D Ricci flow on an axially symmetric deformed sphere, comparing the pure Ricci flow (weakly parabolic, gauge modes present) with the Ricci-DeTurck flow (strictly parabolic, gauge-fixed). The DeTurck vector field $W^k$ corrects the gauge drift and ensures smooth convergence to the round metric.

DeTurck Flow vs Ricci Flow: Convergence to Round Sphere

Python

script.py141 lines

import numpy as np
import matplotlib.pyplot as plt

# === DeTurck Flow vs Ricci Flow on a Deformed 2-Sphere ===
# We simulate 2D Ricci flow on an axially symmetric surface of revolution.
# The metric is ds^2 = dpsi^2 + f(psi,t)^2 dphi^2, where psi in [0, pi].
# Ricci flow: df/dt = -K * f, where K is Gaussian curvature.
# K = -(1/f) * d^2f/dpsi^2  for surface of revolution.
#
# DeTurck trick: adds a gauge-fixing term that makes the PDE strictly parabolic.
# Without DeTurck, gauge modes (reparameterizations of psi) are not damped.

N = 200          # spatial grid points
psi = np.linspace(0, np.pi, N)
dpsi = psi[1] - psi[0]
dt = 0.0001
n_steps = 8000
save_every = 1000

# Initial deformed sphere: f(psi, 0) = sin(psi) * (1 + 0.3*cos(2*psi) + 0.15*sin(3*psi))
f_init = np.sin(psi) * (1 + 0.3 * np.cos(2*psi) + 0.15 * np.sin(3*psi))
f_init[0] = 0.0; f_init[-1] = 0.0  # boundary conditions: poles

# Reference metric for DeTurck: round sphere f_hat = sin(psi)
f_hat = np.sin(psi)

def compute_curvature(f, dpsi):
    """Gaussian curvature K = -(1/f) d^2f/dpsi^2"""
    d2f = np.zeros_like(f)
    d2f[1:-1] = (f[2:] - 2*f[1:-1] + f[:-2]) / dpsi**2
    K = np.zeros_like(f)
    mask = np.abs(f) > 1e-12
    K[mask] = -d2f[mask] / f[mask]
    return K, d2f

def compute_deturck_vector(f, f_hat, dpsi):
    """DeTurck vector W = g^{pq}(Gamma - hat{Gamma})
    For 1D: W^psi = -(1/f)(df/dpsi) + (1/f_hat)(df_hat/dpsi)"""
    df = np.zeros_like(f)
    df[1:-1] = (f[2:] - f[:-2]) / (2*dpsi)
    df_hat = np.zeros_like(f_hat)
    df_hat[1:-1] = (f_hat[2:] - f_hat[:-2]) / (2*dpsi)
    W = np.zeros_like(f)
    mask = (np.abs(f) > 1e-12) & (np.abs(f_hat) > 1e-12)
    W[mask] = -df[mask]/f[mask] + df_hat[mask]/f_hat[mask]
    return W, df

# --- Run both flows ---
f_ricci = f_init.copy()
f_deturck = f_init.copy()
history_ricci = [f_init.copy()]
history_deturck = [f_init.copy()]
W_history = []

for step in range(n_steps):
    # Ricci flow: df/dt = -K*f = d^2f/dpsi^2
    K_r, d2f_r = compute_curvature(f_ricci, dpsi)
    f_ricci[1:-1] += dt * d2f_r[1:-1]
    f_ricci[0] = 0.0; f_ricci[-1] = 0.0

# DeTurck flow: df/dt = d^2f/dpsi^2 + L_W f
    K_d, d2f_d = compute_curvature(f_deturck, dpsi)
    W, df_d = compute_deturck_vector(f_deturck, f_hat, dpsi)
    # Lie derivative of f along W in psi direction: L_W f = W * df/dpsi + f * dW/dpsi
    dW = np.zeros_like(W)
    dW[1:-1] = (W[2:] - W[:-2]) / (2*dpsi)
    L_W_f = W * df_d + f_deturck * dW
    f_deturck[1:-1] += dt * (d2f_d[1:-1] + L_W_f[1:-1])
    f_deturck[0] = 0.0; f_deturck[-1] = 0.0

if (step + 1) % save_every == 0:
        history_ricci.append(f_ricci.copy())
        history_deturck.append(f_deturck.copy())
        W_history.append(W.copy())

# --- Plotting ---
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Panel 1: Ricci flow snapshots
ax1 = axes[0][0]
colors = plt.cm.viridis(np.linspace(0, 1, len(history_ricci)))
for i, (f_snap, col) in enumerate(zip(history_ricci, colors)):
    t_val = i * save_every * dt
    ax1.plot(np.degrees(psi), f_snap, color=col, linewidth=1.5,
        label=f't={t_val:.2f}' if i % 2 == 0 else None)
ax1.plot(np.degrees(psi), np.sin(psi), 'r--', linewidth=2, label='Round sphere')
ax1.set_xlabel(r'$\psi$ (degrees)')
ax1.set_ylabel(r'$f(\psi, t)$')
ax1.set_title('Pure Ricci Flow')
ax1.legend(fontsize=8)
ax1.grid(True, alpha=0.3)

# Panel 2: DeTurck flow snapshots
ax2 = axes[0][1]
for i, (f_snap, col) in enumerate(zip(history_deturck, colors)):
    t_val = i * save_every * dt
    ax2.plot(np.degrees(psi), f_snap, color=col, linewidth=1.5,
        label=f't={t_val:.2f}' if i % 2 == 0 else None)
ax2.plot(np.degrees(psi), np.sin(psi), 'r--', linewidth=2, label='Round sphere')
ax2.set_xlabel(r'$\psi$ (degrees)')
ax2.set_ylabel(r'$f(\psi, t)$')
ax2.set_title('Ricci-DeTurck Flow (Gauge-Fixed)')
ax2.legend(fontsize=8)
ax2.grid(True, alpha=0.3)

# Panel 3: DeTurck vector field at various times
ax3 = axes[1][0]
colors_w = plt.cm.plasma(np.linspace(0, 1, len(W_history)))
for i, (W_snap, col) in enumerate(zip(W_history, colors_w)):
    t_val = (i + 1) * save_every * dt
    ax3.plot(np.degrees(psi), W_snap, color=col, linewidth=1.5,
        label=f't={t_val:.2f}')
ax3.set_xlabel(r'$\psi$ (degrees)')
ax3.set_ylabel(r'$W^\psi$')
ax3.set_title('DeTurck Vector Field (Gauge Correction)')
ax3.legend(fontsize=8)
ax3.grid(True, alpha=0.3)
ax3.axhline(y=0, color='white', linewidth=0.5, alpha=0.5)

# Panel 4: Convergence comparison
ax4 = axes[1][1]
err_ricci = [np.sqrt(np.mean((f_snap - np.sin(psi))**2)) for f_snap in history_ricci]
err_deturck = [np.sqrt(np.mean((f_snap - np.sin(psi))**2)) for f_snap in history_deturck]
t_vals = [i * save_every * dt for i in range(len(history_ricci))]
ax4.semilogy(t_vals, err_ricci, 'b-o', linewidth=2, markersize=5, label='Ricci flow')
ax4.semilogy(t_vals, err_deturck, 'r-s', linewidth=2, markersize=5, label='Ricci-DeTurck flow')
ax4.set_xlabel('Flow time t')
ax4.set_ylabel('RMS deviation from round sphere')
ax4.set_title('Convergence to Round Metric')
ax4.legend(fontsize=11)
ax4.grid(True, alpha=0.3)

plt.suptitle('DeTurck Flow vs Ricci Flow on a Deformed 2-Sphere', fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('output.png', dpi=130, bbox_inches='tight')
plt.close()
print("Plot saved. Both flows converge to the round sphere.")
print(f"Final Ricci error: {err_ricci[-1]:.6f}")
print(f"Final DeTurck error: {err_deturck[-1]:.6f}")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Soft Graviton Theorem Next: Holonomy & L-Geometry →