Gauge Dynamics in Numerical Relativity

Black holes are often drawn as simple circles on a slide, but in my master's thesis I explored that how big they look on a computer grid is actually a choice – a choice of coordinates, or "gauge," and that choice can make simulations much harder or much easier. My project was about understanding and controlling this gauge freedom in numerical relativity to make black-hole simulations more efficient without changing the underlying physics.

Einstein's equations on a computer

The starting point is Einstein's field equations, which relate space-time curvature to matter and energy:

$$G_{ab} = R_{ab} - \frac{1}{2} g_{ab} R = 8\pi T_{ab}.$$

Here $g_{ab}$ is the metric (the object that tells you distances and times), $R_{ab}$ and $R$ describe curvature, and $T_{ab}$ is the energy–momentum tensor. For black hole simulations, one often works in vacuum, so $T_{ab} = 0$ and the equations reduce to setting each component of the Ricci tensor to zero, but they still form a highly nonlinear system of second‑order partial differential equations.

To solve these equations numerically, the space-time is sliced into "3+1" form: three-dimensional space evolving in time. This leads to the ADM/BSSN formulations, which rewrite the equations as evolution equations plus constraint equations on 3D spatial slices, forming the basis of modern numerical relativity codes.

Gauge: choosing coordinates wisely

General relativity allows enormous freedom in choosing coordinates, often called gauge freedom. Two simulations that use different coordinates can describe the same physical black hole, even though the shapes and sizes of objects on the computational grid look quite different.

In the 3+1 language, this freedom shows up in the lapse function $\alpha$ and shift vector $\beta^i$. Very roughly:

The lapse $\alpha$ tells how much proper time elapses between slices.
The shift $\beta^i$ tells how spatial coordinates move from one slice to the next.

The "moving puncture" approach, used in many black‑hole binary simulations, relies on specific gauge conditions for $\alpha$ and $\beta^i$, which let the code evolve black holes stably as "punctures" moving through the grid. However, these standard choices also fix the coordinate size of the black hole horizons, which strongly influences how fine the numerical grid must be near the black hole.

Why horizon size matters for simulations

Numerical relativity codes typically use a grid with spacing $dx$; the time step $dt$ is limited by a stability condition, often written schematically as

$$dt \lesssim \frac{1}{2} dx.$$

This is a Courant-type relation: the smaller the grid spacing, the smaller the allowed time step, and therefore the more expensive the simulation becomes.

If the coordinate radius of the black hole's apparent horizon is very small, the code needs extremely fine resolution $dx$ in that region to resolve the geometry properly. That fine resolution then dictates a tiny $dt$, and the simulation runs slowly. Conceptually, if one could "stretch" the horizon in coordinates (make it larger on the grid without changing its physical size), one could use coarser resolution near the hole and take larger time steps, making the simulation cheaper.

My thesis idea: stretching the horizon

In my thesis, I explored modifying the gauge conditions, in particular the shift vector, in a controlled way to change the coordinate size of a Schwarzschild black hole's apparent horizon. The core idea was:

Keep the physical solution (the space-time geometry) the same.
Adjust the coordinates near the black hole so that the horizon appears larger on the numerical grid.

Technically, this meant adding an extra term to the standard moving‑puncture shift condition, designed to push grid points away from the horizon and "stretch" its coordinate radius. The goal was to rescale the horizon size while maintaining stable evolution and keeping constraint violations under control.

The apparent horizon itself is defined using trapped surfaces: roughly, a closed surface from which even outgoing light rays are locally converging instead of expanding. In the code (BAM), an apparent horizon finder based on a "flow" algorithm locates the surface that satisfies a certain geometric equation for the expansion of null rays. By monitoring how this surface moves in coordinates when the shift is modified, one can measure how effectively the horizon is being stretched.

What the experiments showed

Using a single Schwarzschild black hole as a testbed, I:

Verified that the baseline BAM implementation reproduces the expected stationary "trumpet" solution and shows good convergence when the resolution is increased.
Implemented the modified shift condition and observed that the coordinate size of the apparent horizon can indeed be rescaled toward a desired value.

From a lay perspective, the black hole's "circle" on the grid could be made bigger or smaller by tweaking how the coordinates flow, even though the underlying physical black hole remained the same. This confirmed that gauge freedom can be used to manipulate resolution requirements in principle.

However, a closer look at the Einstein constraint equations showed that the constraint violations did not converge cleanly to zero as resolution increased. This indicated some inconsistency or bug in the implementation, rather than a fundamental problem with the idea itself. Long‑term evolutions with horizon stretching became unstable, suggesting that more careful code work and analysis were needed.

Why this matters for gravitational-wave astronomy

Accurate simulations of binary black hole mergers are essential for interpreting gravitational-wave signals measured by detectors like LIGO and Virgo. These simulations provide waveform templates used to extract source parameters—such as masses and spins—from noisy data.

Any method that can reduce the computational cost of these simulations without sacrificing accuracy is extremely valuable. Gauge control, like the horizon-stretching strategy explored in my thesis, aims to:

Relax the resolution requirements near black holes.
Allow larger time steps and cheaper runs.
Potentially make high-accuracy simulations of more extreme systems (e.g., high mass ratios, large spins) more accessible.

Although my work identified implementation issues that still need to be fixed, it showed that dynamically controlling the coordinate size of horizons is a promising direction for improving the efficiency of moving‑puncture codes. In that sense, my master's thesis sat at the interface of deep general relativity and very practical computational concerns: using the freedom to choose coordinates not only to make the equations solvable, but to make future simulations faster and more powerful.