Picard–Lefschetz Theory and Lorentzian Contours

Picard–Lefschetz theory answers a question that stationary-phase reasoning alone cannot: which complex saddles are continuously connected to the original Lorentzian integration cycle? The answer is encoded by steepest-descent thimbles and integer intersection numbers. This page develops that geometry and validates its orientation, Jacobian, branch, and convergence logic on a regulated oscillatory Gaussian. The executable benchmark is a method check, not a computation of the gravitational path integral.

Required background. Gravitational Actions and Boundary Terms supplies the action and endpoint data; Flat-Spacetime Quantum Field Theory supplies complex Gaussian integrals and saddle expansions.

Helpful background. Einstein Equations supplies gravitational saddles; Quantum Information supplies amplitude and state distinctions; and Quantum Gravity supplies the evidence boundaries for finite models.

Complex saddles and thimbles

For a finite-dimensional Lorentzian integral

$$Z=\int_{\mathcal C_{\mathrm L}}d^nz\,e^{iS(z)},$$

complexify $z$ and study the Morse function $h=\operatorname{Re}(iS)$. A downward flow can be written

$$\frac{dz^a}{d\lambda} =-\overline{\frac{\partial(iS)}{\partial z^a}}.$$

Along it, $h$ decreases while $\operatorname{Im}(iS)$ is constant. The downward thimble $\mathcal J_\sigma$ consists of trajectories that approach the critical point $z_\sigma$ as $\lambda\to-\infty$ and flow toward smaller $h$ as $\lambda$ increases. It is therefore the unstable manifold of the displayed forward flow. The dual upward cycle $\mathcal K_\sigma$ is defined by the reversed flow and is the corresponding stable manifold. Under suitable decay and nondegeneracy conditions,

$$\mathcal C_{\mathrm L}\sim\sum_\sigma n_\sigma\mathcal J_\sigma, \qquad n_\sigma=\langle\mathcal C_{\mathrm L},\mathcal K_\sigma\rangle\in\mathbb Z.$$

A saddle contributes only if $n_\sigma\ne0$. Witten gives the relative-homology construction and the flow geometry in Witten 2010, §§2–3. At a Stokes transition, upward flows connect critical points and the individual $n_\sigma$ can jump; the complete contour class remains unchanged.

In gravity the variable may be a lapse, scale factor, or complex metric. Singular lapse endpoints, gauge zero modes, and branch points must be included before the intersection problem is meaningful. Feldbrugge, Lehners, and Turok apply the construction to a specified Lorentzian minisuperspace lapse contour in Feldbrugge, Lehners, and Turok 2017, §§II–IV.

Exact regulated Gaussian

Use the convergent integral

$$I(\epsilon)=\int_{-\infty}^{\infty} \exp\left[-\frac{\epsilon-i}{2}x^2\right]dx =\sqrt{\frac{2\pi}{\epsilon-i}}, \qquad \epsilon\gt0,$$

with the principal square root. Let $a=\epsilon-i$ and $\theta=-\arg(a)/2$. On $z=e^{i\theta}y$, $az^2=\lvert a\rvert y^2$ and $dz=e^{i\theta}dy$, so this ray is the exact steepest-descent thimble with the inherited orientation. The original real contour and the rotated contour must converge to the same analytic value before taking $\epsilon\to0$.

This control exposes four common errors. Omitting $e^{i\theta}$ loses the contour Jacobian. Reversing the $y$ orientation changes the sign. Choosing the other square-root branch changes the sign of the exact result. Truncating the real contour too early leaves an oscillatory tail that can look stable at one resolution.

Complete CPython reference program

The program supports CPython 3.11 or later and was rerun with CPython 3.12.14, using only the Python standard library and no third-party package. Inputs are $\epsilon\in\{0.2,0.1,0.05\}$ and three refinements:

$$(L,N)=(12,2400),\quad(18,4800),\quad(24,9600).$$

Composite Simpson integration uses deterministic binary64 complex arithmetic. Final tolerances are $10^{-6}$ for the real-contour error and contour mismatch and $10^{-10}$ for the thimble error.

Save the following program as picard_lefschetz_gaussian.py. The script writes the semantic refinement table, checks monotone real-contour improvement, detects the omitted Jacobian, reversed orientation, and wrong branch, and exits nonzero on failure.

import cmath
import math
import platform
import sys

EPSILONS = (0.2, 0.1, 0.05)
LEVELS = ((12.0, 2400), (18.0, 4800), (24.0, 9600))
REAL_TOL = 1.0e-6
THIMBLE_TOL = 1.0e-10


def simpson(function, left, right, panels):
    if panels <= 0 or panels % 2:
        raise ValueError("Simpson panels must be positive and even")
    step = (right - left) / panels
    total = function(left) + function(right)
    for index in range(1, panels):
        weight = 4 if index % 2 else 2
        total += weight * function(left + index * step)
    return total * step / 3


def evaluate(epsilon, radius, panels):
    coefficient = complex(epsilon, -1.0)
    exact = cmath.sqrt(2.0 * math.pi / coefficient)
    real_value = simpson(
        lambda x: cmath.exp(-0.5 * coefficient * x * x),
        -radius,
        radius,
        panels,
    )
    angle = -0.5 * cmath.phase(coefficient)
    jacobian = cmath.exp(1j * angle)
    thimble_value = simpson(
        lambda y: jacobian
        * cmath.exp(-0.5 * coefficient * (jacobian * y) ** 2),
        -radius,
        radius,
        panels,
    )
    no_jacobian = thimble_value / jacobian
    return {
        "exact": exact,
        "real": real_value,
        "thimble": thimble_value,
        "no_jacobian": no_jacobian,
    }


def stop(message):
    raise SystemExit("FAIL: " + message)


def main():
    if sys.implementation.name != "cpython" or sys.version_info[:2] < (3, 11):
        stop("requires CPython 3.11 or later; found " + platform.python_version())

    rows = []
    previous_real_error = math.inf
    final_results = None
    for radius, panels in LEVELS:
        results = [evaluate(epsilon, radius, panels) for epsilon in EPSILONS]
        real_error = max(abs(item["real"] - item["exact"]) for item in results)
        thimble_error = max(
            abs(item["thimble"] - item["exact"]) for item in results
        )
        contour_gap = max(
            abs(item["real"] - item["thimble"]) for item in results
        )
        if real_error >= previous_real_error:
            stop("real-contour refinement is not monotone")
        previous_real_error = real_error
        rows.append((radius, panels, real_error, thimble_error, contour_gap))
        final_results = results

    final_real = rows[-1][2]
    final_thimble = rows[-1][3]
    final_gap = rows[-1][4]
    if final_real > REAL_TOL or final_gap > REAL_TOL:
        stop("final real-contour or cross-contour tolerance failed")
    if final_thimble > THIMBLE_TOL:
        stop("final thimble tolerance failed")

    for item in final_results:
        exact = item["exact"]
        if abs(item["no_jacobian"] - exact) < 0.5:
            stop("omitted-Jacobian control was not detected")
        if abs(-item["thimble"] - exact) < 1.0:
            stop("reversed-orientation control was not detected")
        if abs(-exact - exact) < 1.0:
            stop("wrong-square-root-branch control was not detected")

    print("CPython", platform.python_version(), "standard-library-only")
    print("L N max_real_error max_thimble_error max_contour_gap")
    for row in rows:
        print(f"{row[0]:.0f} {row[1]} {row[2]:.6e} {row[3]:.6e} {row[4]:.6e}")
    print("PASS: principal branch, orientation, Jacobian, and tolerances")


if __name__ == "__main__":
    main()

Use this exact save-and-run recipe; the final line is the clean rerun command.

python3 --version
python3 -m py_compile picard_lefschetz_gaussian.py
python3 picard_lefschetz_gaussian.py

The source above was compiled and run with CPython 3.12.14 during the 2026-09-27 check. It printed the three rows below followed by PASS: principal branch, orientation, Jacobian, and tolerances; no package beyond that interpreter’s standard library was used. The values agree with the earlier 2026-08-20 calculation on CPython 3.11.3.

Static convergence output

The numerical kernel gives the following three-level target. Errors are maxima over the three regulator values; the slowest real-contour convergence occurs at $\epsilon=0.05$ because its damping tail is longest.

Refinement	$L$	$N$	Maximum real-contour error	Maximum thimble error	Maximum contour difference
Coarse	12	2400	$4.546162\times10^{-3}$	$7.444292\times10^{-15}$	$4.546162\times10^{-3}$
Medium	18	4800	$3.367857\times10^{-5}$	$4.189529\times10^{-15}$	$3.367857\times10^{-5}$
Fine	24	9600	$4.638693\times10^{-8}$	$5.515474\times10^{-15}$	$4.638694\times10^{-8}$

For $\epsilon=0.05$ at the fine level, the real-contour value is approximately $1.8150374032+1.7265529305i$, while both the thimble and exact values are approximately $1.8150374441+1.7265529525i$. The table demonstrates tail and quadrature control for this Gaussian only.

Interpretation and gravitational limitations

In a minisuperspace lapse integral, one would locate complex saddles, integrate upward flows to determine $n_\sigma$, and refine the original contour and regulator. Stokes transitions require tracking the sum rather than an isolated saddle. Lehners explains how these choices enter competing cosmological prescriptions Lehners 2023, §3.6 and Appendix C.

The Gaussian has one entire action, one critical point, no gauge zero mode, and no singular endpoint. Full gravity has infinitely many modes, a diffeomorphism quotient, conformal directions, boundary terms, and possible topology change. Passing this benchmark validates the implementation of a rotated contour; it supplies no evidence that a proposed gravitational contour is unique or physically correct.

Exercises

The thimble error is already near roundoff at the coarse level, while the real-contour error falls by roughly five orders of magnitude. Which refinement controls each error, and why would comparing only the two finest thimble values be a misleading convergence test?

Solution

On the rotated contour the exponent is a decaying real Gaussian, so $L=12$ already suppresses the tail and Simpson error to binary64 roundoff. Further refinement cannot decrease that error monotonically because rounding dominates. The real contour retains an oscillatory tail damped only by $\epsilon$, so increasing both $L$ and $N$ reduces truncation and discretization error from $4.5\times10^{-3}$ to $4.6\times10^{-8}$. Comparing only thimble levels would show a noisy roundoff plateau and miss whether the deformed contour agrees with the original cycle. The exact value and real–thimble difference are the necessary independent controls.

References

• Feldbrugge, Job, Jean-Luc Lehners, and Neil Turok. “Lorentzian Quantum Cosmology.” Physical Review D 95 (2017): 103508. DOI.
• Lehners, Jean-Luc. “Review of the No-Boundary Wave Function.” Physics Reports 1022 (2023): 1–82. arXiv:2303.08802.
• Witten, Edward. “Analytic Continuation of Chern–Simons Theory.” AMS/IP Studies in Advanced Mathematics 50 (2011): 347–446. arXiv:1001.2933.