Truncations, Gauge Dependence, and Stability

A fixed point found in one functional-renormalization-group truncation is a numerical result inside a specified projection, not yet a property of quantum gravity. Credible stability evidence requires controlled changes of operator basis, background and fluctuation parametrization, gauge, regulator, and numerical resolution. This page supplies both the conceptual protocol and a small executable benchmark whose exact answer exposes implementation errors.

Required background. Flat-Spacetime Quantum Field Theory supplies beta functions, renormalization schemes, and stability matrices; Gravitational Actions and Boundary Terms supplies the operator basis and boundary assumptions being truncated.

Helpful background. Einstein Equations identifies the infrared limit; Quantum Information supplies physical-state criteria; and Quantum Gravity supplies the programme-level evidence standard.

What a truncation test must vary

Write $\Gamma_k=\sum_{i=1}^{N}\bar u_i(k)\mathcal O_i$. Increasing $N$ tests operator-basis stability only if the new backgrounds or momentum projections distinguish the added operators. A sequence $R+R^2+\cdots+R^N$ on constant-curvature backgrounds, for example, does not test independent Ricci- and Weyl-tensor structures. One should also compare background couplings with fluctuation vertices, monitor the modified Ward or Nielsen identities, and distinguish essential couplings from field-redefinition directions.

Gauge and regulator parameters are not experimental knobs. Exact observables should be independent of them, but a finite truncation generally is not. Variation bands are therefore diagnostic error estimates, not probability distributions. A robust pattern has a fixed point away from regulator singularities, stable numbers of essential relevant directions, critical exponents that settle as the basis grows, and compatible infrared trajectories. Losing a fixed point after a physically motivated operator is added is adverse evidence, even when smaller truncations looked stable.

A useful scan changes one axis at a time and then repeats selected combinations. First establish numerical convergence at fixed physics choices. Next vary the regulator shape within an admissible family while holding its normalization convention fixed. Then vary gauge parameters and the linear versus exponential metric split, solving the corresponding symmetry identities to the same accuracy. Finally enlarge the operator or vertex basis. Quoting the narrowest variation from these tests would understate uncertainty: the report should retain the envelope and identify correlations, excluded singular points, and roots that exchange identity.

The exact effective-average-action identity and its background-field specialization were established by Reuter 1998, §§ II–IV. Exactness belongs to that functional identity, whereas every finite projection used below introduces approximation error. This distinction is the reason a numerical residual can be tiny while the scientific truncation error remains large.

A published two-coupling control system

For a transparent benchmark, use the optimized-cutoff Einstein–Hilbert flow in four Euclidean dimensions from Litim 2006, Eqs. (6)–(11). The source absorbs a factor $1/\alpha$ into its definition of $g$ and presents Eqs. (6)–(8) in the $\alpha\to\infty$ gauge limit; it refers the arbitrary-$\alpha$ flow to a separate calculation. Thus this benchmark tests the published transcription and numerical method, not gauge stability. In that rescaled convention, with $d=4$,

$$\beta_\lambda=\frac{P_1}{P_2+4(d+2)g}, \qquad \beta_g=\frac{(d-2)gP_2}{P_2+4(d+2)g},$$ $$\begin{aligned} P_1={}&-16\lambda^3 +4\lambda^2(4-10dg-3d^2g+d^3g)\\ &+4\lambda(10dg+d^2g-d^3g-1) +d(d+2)(d-16g+8dg-3)g,\\ P_2={}&8(\lambda^2-\lambda-dg)+2. \end{aligned}$$

The non-Gaussian control solution is exactly $\lambda_*=1/4$, $g_*=1/64$ before restoring the paper’s factor $c_4=24\pi$, which gives $g_*^{\mathrm{paper}}=3\pi/8$. The critical exponents are

$$\theta_\pm=\frac53\pm i\,\frac{\sqrt{167}}3.$$

This is not a current best estimate and not an observable. It is valuable because the exact root and exponent provide an independent benchmark for a nonlinear solver and finite-difference Jacobian.

Executable benchmark

The reference program uses CPython 3.11 or newer and only its standard library; there are no third-party packages. The table below was reproduced with CPython 3.12.14. Save the following program as frg_stability.py. The driver produces the fixed point, residual, and critical exponent at three Jacobian resolutions; record the exact interpreter version with each rerun.

from math import pi, sqrt

D = 4.0

def beta(lam, g):
    p1 = (
        -16.0 * lam**3
        + 4.0 * lam**2 * (4.0 - 10.0*D*g - 3.0*D**2*g + D**3*g)
        + 4.0 * lam * (10.0*D*g + D**2*g - D**3*g - 1.0)
        + D*(D + 2.0)*(D - 16.0*g + 8.0*D*g - 3.0)*g
    )
    p2 = 8.0 * (lam**2 - lam - D*g) + 2.0
    denominator = p2 + 4.0*(D + 2.0)*g
    if abs(denominator) < 1.0e-12:
        raise ArithmeticError("flow denominator is too close to its pole")
    return p1 / denominator, (D - 2.0)*g*p2 / denominator

def jacobian(point, step):
    columns = []
    for axis in range(2):
        plus, minus = point.copy(), point.copy()
        plus[axis] += step
        minus[axis] -= step
        f_plus, f_minus = beta(*plus), beta(*minus)
        columns.append([(f_plus[j] - f_minus[j])/(2.0*step) for j in range(2)])
    return [[columns[col][row] for col in range(2)] for row in range(2)]

def solve(tolerance=1.0e-13):
    point = [0.21, 0.02]
    for iteration in range(50):
        value = beta(*point)
        residual = max(abs(value[0]), abs(value[1]))
        if residual < tolerance:
            return point, iteration, residual
        matrix = jacobian(point, max(sqrt(tolerance), 1.0e-7))
        determinant = matrix[0][0]*matrix[1][1] - matrix[0][1]*matrix[1][0]
        if abs(determinant) < 1.0e-14:
            raise ArithmeticError("Newton matrix is singular")
        change = [
            (-value[0]*matrix[1][1] + value[1]*matrix[0][1])/determinant,
            (-matrix[0][0]*value[1] + matrix[1][0]*value[0])/determinant,
        ]
        point = [point[j] + change[j] for j in range(2)]
    raise RuntimeError("Newton iteration did not converge")

def exponents(point, step):
    matrix = jacobian(point, step)
    trace = matrix[0][0] + matrix[1][1]
    determinant = matrix[0][0]*matrix[1][1] - matrix[0][1]*matrix[1][0]
    discriminant = complex(trace*trace - 4.0*determinant)**0.5
    eigenvalues = ((trace + discriminant)/2.0, (trace - discriminant)/2.0)
    return tuple(-value for value in eigenvalues)

point, iterations, residual = solve()
print(f"lambda={point[0]:.12f} g={point[1]:.12f} "
      f"g_restored={24.0*pi*point[1]:.12f}")
print(f"iterations={iterations} residual={residual:.3e}")
for step in (1.0e-3, 1.0e-4, 1.0e-5):
    theta = exponents(point, step)[1]
    print(f"h={step:.0e} theta={theta.real:.9f}+{theta.imag:.9f}i")
print(f"exact={5.0/3.0:.9f}+{sqrt(167.0)/3.0:.9f}i")

The clean rerun recipe creates no hidden inputs:

python3 --version
python3 frg_stability.py
python3 frg_stability.py > frg_stability.out

For the reproduced environment, the first command reports Python 3.12.14. The program produces $\lambda_*=0.25$, $g_*=0.015625$, restored $g_*=1.178097245096$, five Newton updates, and a residual at floating-point zero for this exact control root. Other compatible runtimes may differ in the final rounding; require the stated residual tolerance rather than bitwise agreement.

Stability output and interpretation

The central-difference refinement gives:

Jacobian resolution $h$	Critical exponent real part	Critical exponent imaginary part	Absolute error in imaginary part
0.001	1.669111625	4.309095863	0.001480
0.0001	1.666691105	4.307630795	0.00001480
0.00001	1.666666911	4.307616142	0.0000001480

The error falls by approximately $10^2$ when $h$ falls by $10$, as expected for a centered derivative before roundoff dominates. Agreement with the exact $\sqrt{167}/3=4.307615994\ldots$ is an independent implementation check. It validates this transcription and solver, not the Einstein–Hilbert truncation as a fundamental theory.

An analytic check does not need numerical differencing. Differentiating the rational beta functions at $(\lambda_*,g_*)=(1/4,1/64)$ gives

$$B=\begin{pmatrix}-2/3&176/3\\-1/3&-8/3\end{pmatrix}, \qquad \operatorname{tr}B=-10/3, \qquad \det B=64/3.$$

The roots of $z^2-(\operatorname{tr}B)z+\det B=0$ are $-5/3\pm i\sqrt{167}/3$, so changing their signs reproduces the stated critical exponents. Tightening the Newton tolerance through $10^{-7}$, $10^{-10}$, and $10^{-13}$ gives beta-function residuals about $2.1\times10^{-11}$, $1.4\times10^{-13}$, and floating-point zero in the reproduced run. Neither this refinement nor the Jacobian table varies the gauge or regulator.

Failure modes and a research-grade protocol

The driver deliberately stops near the flow-denominator pole, on a singular Newton matrix, or after failed iteration. Seeds on another basin can converge to the Gaussian root or cross the singular curve. Steps that are too large incur truncation error; steps near machine epsilon suffer cancellation. A production calculation should use analytic or automatic derivatives, arbitrary precision where justified, continuation in gauge and regulator parameters, and archived raw outputs.

For a genuine truncation study, repeat the same workflow over nested operator bases and independent projections. Report the regulator shape, gauge, background, field parametrization, zero-mode treatment, solver tolerances, residuals, and every discarded root. Compare essential critical exponents rather than only fixed-point coordinates. The result becomes persuasive only when stability survives these changes and symmetry-identity violations shrink.

Two additional controls matter. First, evaluate each candidate root with a second algorithm—such as safeguarded continuation rather than Newton iteration—and compare beta-function residuals in the original equations, not only the projected variables. Second, verify that the root connects continuously to neighboring gauge and regulator choices without crossing the denominator singularity. A discontinuous jump may indicate a branch swap. Neither control proves universality, but together they separate elementary solver failures from genuine scheme sensitivity.

The archived record should include machine-readable parameters and output, not a plot alone. In particular, preserve enough digits to recompute the stability matrix, state whether complex pairs were sorted by real or imaginary part, and record the convention that critical exponents are minus the beta-function Jacobian eigenvalues. These details prevent an apparent sign disagreement from being mistaken for a physical conflict.

Exercise

Use the first and second rows of the table to estimate the finite-difference convergence order $p$ from $E(h)\propto h^p$. Then predict the third-row error.

Solution

The step ratio is $h_1/h_2=10$ and the error ratio is approximately $(1.480\times10^{-3})/(1.480\times10^{-5})=100$. Therefore

$$p=\frac{\ln 100}{\ln 10}=2,$$

which is the expected centered-difference order. Reducing $h$ by another factor of ten predicts $E_3=E_2/10^2\approx1.48\times10^{-7}$, matching the table. Continued refinement would eventually stop improving because subtraction and double-precision roundoff grow relative to the derivative signal.

References

• Litim, Daniel F. (2006), “On Fixed Points of Quantum Gravity,” AIP Conference Proceedings 841, 322–329, arXiv:hep-th/0606044.
• Reuter, Martin (1998), “Nonperturbative Evolution Equation for Quantum Gravity,” Physical Review D 57, 971–985, arXiv:hep-th/9605030, §§ II–IV.