Follow the source behind the result.

The registered Python source is shown as text. Displaying it does not execute the code.

#!/usr/bin/env python3
"""Exact algebra for the free Lorentz-covariant curvature extension.

No TFPT-parent, interacting-gravity, T7-completion, TOE, or RH claim.
The distributional construction and its scope are proved in PROOF.tex.
Only SymPy is required. All checks below are exact, not floating scans.

Port provenance: native verification port of
`toe_round7_covariant_curvature/covariant_curvature_checker.py`
(source SHA-256 10eff5bab2ac8df6a532f5112503678e58233006d2fe93daa7e00271c6d9f210).
The port changes only harness integration and execution lifecycle.
"""
from __future__ import annotations

import json
import time

import sympy as s

from tfpt_constants import check as suite_check, reset, summary

ETA = s.diag(-1, 1, 1, 1)
PAIRS = ((0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3))
CURV = tuple((a, b) for a in range(6) for b in range(a, 6))
SPATIAL = ((0, 0), (1, 1), (2, 2), (1, 2), (0, 2), (0, 1))
CHECKS: list[str] = []
FAILED = 0


def check(label, condition):
    global FAILED
    passed = suite_check(label, bool(condition))
    CHECKS.append(label)
    FAILED += int(not passed)


def zero(value):
    values = list(value) if isinstance(value, s.MatrixBase) else [value]
    return all(s.expand(v) == 0 for v in values)


def symbasis(n, pairs):
    result = []
    for i, j in pairs:
        b = s.zeros(n)
        b[i, j] = b[j, i] = 1 if i == j else 1/s.sqrt(2)
        result.append(b)
    return result


HPAIRS = tuple((i, j) for i in range(4) for j in range(i, 4))
HBASIS = symbasis(4, HPAIRS)
SBASIS = symbasis(3, SPATIAL)


def coordinates(h):
    return s.Matrix([s.trace(b.T*h) for b in HBASIS])


def riemann(k, h, mu, nu, rho, sigma):
    return (k[sigma]*k[nu]*h[mu, rho]
            + k[rho]*k[mu]*h[nu, sigma]
            - k[rho]*k[nu]*h[mu, sigma]
            - k[sigma]*k[mu]*h[nu, rho])/2


def curvature_map(k):
    return s.Matrix([[riemann(k, h, *PAIRS[a], *PAIRS[b])
                      for h in HBASIS] for a, b in CURV])


def covariant_numerator():
    # Pi_{mn,ab}=1/2(eta_ma eta_nb+eta_mb eta_na-eta_mn eta_ab).
    return s.Matrix.hstack(*(
        coordinates(ETA*h*ETA-ETA*s.trace(ETA*h)/2) for h in HBASIS))


def spatial_data(p):
    r2 = (p.T*p)[0]
    b = s.Matrix.hstack(*(h*p for h in SBASIS))
    tr = s.Matrix([1, 1, 1, 0, 0, 0])
    v = b.T*p
    kp = s.eye(6)-tr*tr.T/2
    kq = r2*(s.eye(6)-tr*tr.T)-2*b.T*b+tr*v.T+v*tr.T
    c = s.expand(kq*kp*kq)
    embedded = []
    for h in SBASIS:
        hh = s.zeros(4)
        hh[1:4, 1:4] = h
        embedded.append(coordinates(hh))
    return r2, c, s.Matrix.hstack(*embedded)


def on_cone_zero(matrix, omega, r2):
    modulus = s.Poly(omega**2-r2, omega)
    return all(s.Poly(s.expand(v), omega).rem(modulus).is_zero for v in matrix)


def curvature_tensor_action(lorentz):
    wedge = s.Matrix([
        [lorentz[mu, a]*lorentz[nu, b]-lorentz[mu, b]*lorentz[nu, a]
         for a, b in PAIRS] for mu, nu in PAIRS])
    columns = []
    for a, b in CURV:
        tensor = s.zeros(6)
        tensor[a, b] = tensor[b, a] = 1
        transformed = wedge*tensor*wedge.T
        columns.append(s.Matrix([transformed[i, j] for i, j in CURV]))
    return s.Matrix.hstack(*columns)


def universal_checks():
    omega, x, y, z = s.symbols('omega x y z', real=True)
    p = s.Matrix([x, y, z])
    k = s.Matrix([-omega, x, y, z])
    a = curvature_map(k)
    pi = covariant_numerator()
    r2, c, embed = spatial_data(p)
    kernel = s.expand(a*pi*a.T)
    check('covariant metric numerator is symmetric but indefinite',
          pi == pi.T and pi.det() != 0
          and pi.eigenvals() == {-1: 4, 1: 6})
    for j in range(4):
        xi = s.eye(4)[:, j]
        check(f'curvature annihilates arbitrary pure gauge column {j}',
              zero(a*coordinates(k*xi.T+xi*k.T)))
    check('kernel has homogeneous degree four and no momentum denominators',
          all(v == 0 or s.Poly(v, omega, x, y, z).is_homogeneous
              and s.Poly(v, omega, x, y, z).total_degree() == 4
              for v in kernel))
    defect = s.expand(a*(r2**2*pi-embed*c*embed.T)*a.T)
    check('all 441 null-cone entries: A Pi A^T equals A P_TT A^T',
          on_cone_zero(defect, omega, r2))
    check('must-fail: same identity is false away from the null cone',
          not zero(defect.subs({omega: 2, x: 0, y: 0, z: 1})))
    trace = coordinates(ETA)
    wrong = s.expand(a*(pi+trace*trace.T/2)*a.T-kernel)
    check('must-fail: omitting trace reversal changes the null curvature kernel',
          not zero(wrong.subs({omega: 1, x: 0, y: 0, z: 1})))

    # Algebraic and differential identities checked on each of 10 metric bases.
    check('Riemann antisymmetries and pair interchange for all metric columns',
          all(zero(riemann(k,h,m,n,r,t)+riemann(k,h,n,m,r,t))
              and zero(riemann(k,h,m,n,r,t)+riemann(k,h,m,n,t,r))
              and zero(riemann(k,h,m,n,r,t)-riemann(k,h,r,t,m,n))
              for h in HBASIS for m,n in PAIRS for r,t in PAIRS))
    check('algebraic Bianchi identity for all metric columns and tensor indices',
          all(zero(riemann(k,h,m,n,r,t)+riemann(k,h,m,r,t,n)
                   +riemann(k,h,m,t,n,r))
              for h in HBASIS for m in range(4) for n in range(4)
              for r in range(4) for t in range(4)))
    check('differential Bianchi identity for all curvature columns',
          all(zero(k[u]*riemann(k,h,m,n,r,t)
                   +k[r]*riemann(k,h,m,n,t,u)
                   +k[t]*riemann(k,h,m,n,u,r))
              for h in HBASIS for m,n in PAIRS for u in range(4)
              for r,t in PAIRS))
    ricci = s.Matrix([
        [sum(ETA[mu,mu]*riemann(k,h,mu,nu,mu,sigma)
             for mu in range(4)) for h in HBASIS]
        for nu in range(4) for sigma in range(4)])
    check('on-cone Ricci tensor annihilates the whole TT range',
          on_cone_zero(s.expand(ricci*embed*c), omega, r2))

    electric = s.Matrix([[riemann(k,h,0,i+1,0,j+1)
                          for h in HBASIS] for i,j in SPATIAL])
    normalization = s.diag(1,1,1,s.sqrt(2),s.sqrt(2),s.sqrt(2))
    electric = normalization*electric
    check('electric curvature R_0i0j is omega^2 q_ij/2 in radiation gauge',
          zero(electric*embed-omega**2*s.eye(6)/2))
    check('null electric covariance is exactly one quarter of Round 6 C',
          on_cone_zero(s.expand(electric*pi*electric.T-c/4), omega, r2))
    # W(x,y) has phase exp(-i omega (t_x-t_y)); differentiate y for <R dot R>.
    delay = s.symbols('delay', real=True)
    scalar_w = s.exp(-s.I*omega*delay)/(2*omega)
    check('second-argument Wightman derivative fixes positive mixed sign',
          s.simplify((-s.diff(scalar_w, delay)).subs(delay, 0)) == s.I/2)
    check('two Wightman time derivatives fix positive derivative covariance',
          s.simplify((-s.diff(scalar_w, delay, 2)).subs(delay, 0)) == omega/2)
    check('mixed electric-time covariance equals i C/8 on the cone',
          on_cone_zero(s.expand(s.I*electric*pi*electric.T/2-s.I*c/8), omega, r2))
    return pi


def fibre_and_covariance_checks(pi):
    for values in ((1,0,0,1),(3,1,2,2),(7,-2,3,6),(s.Rational(5,3),1,0,s.Rational(4,3))):
        w,x,y,z = values
        k = s.Matrix([-w,x,y,z])
        a = curvature_map(k)
        kernel = s.simplify(a*pi*a.T)
        r2,c,embed = spatial_data(s.Matrix([x,y,z]))
        ptt = c/r2**2
        factor = s.simplify(a*embed*ptt)
        check(f'exact positive factorization at null fibre {values}',
              zero(kernel-factor*factor.T))
        check(f'exact two physical curvature polarizations at fibre {values}',
              kernel.rank() == 2 and factor.rank() == 2)

    boost = s.eye(4)
    boost[0,0] = boost[1,1] = s.Rational(5,3)
    boost[0,1] = boost[1,0] = -s.Rational(4,3)
    k = s.Matrix([-3,1,2,2])
    action = curvature_tensor_action(boost)
    a = curvature_map(k)
    transformed_a = curvature_map(boost*k)
    check('rational boost preserves eta and future null energy',
          boost*ETA*boost.T == ETA and -(boost*k)[0] > 0
          and ((boost*k).T*ETA*(boost*k))[0] == 0)
    check('all 441 curvature kernel entries obey nontrivial boost covariance',
          zero(transformed_a*pi*transformed_a.T-action*a*pi*a.T*action.T))


def little_group_checks():
    k = s.Matrix([-1,0,0,1])
    a = curvature_map(k)
    plus = s.diag(0,1,-1,0)/s.sqrt(2)
    cross = s.zeros(4)
    cross[1,2] = cross[2,1] = 1/s.sqrt(2)
    u,v = s.symbols('u v', real=True)
    q = (u*u+v*v)/2
    null_rotation = s.Matrix([[1+q,-u,-v,q],[-u,1,0,-u],
                              [-v,0,1,-v],[-q,u,v,1-q]])
    check('all-parameter null rotations preserve eta and the reference momentum',
          zero(null_rotation*ETA*null_rotation.T-ETA)
          and zero(null_rotation*k-k))
    for name,h in (('plus',plus),('cross',cross)):
        check(f'null little-group translations act trivially on {name} curvature',
              zero(a*coordinates(null_rotation*h*null_rotation.T-h)))
    t = s.symbols('t', real=True)
    cosine, sine = (1-t*t)/(1+t*t), 2*t/(1+t*t)
    rotation = s.eye(4)
    rotation[1:3,1:3] = s.Matrix([[cosine,-sine],[sine,cosine]])
    pol = s.Matrix.hstack(coordinates(plus),coordinates(cross))
    h_action = s.Matrix.hstack(coordinates(rotation*plus*rotation.T),
                               coordinates(rotation*cross*rotation.T))
    double = s.Matrix([[cosine*cosine-sine*sine,-2*cosine*sine],
                       [2*cosine*sine,cosine*cosine-sine*sine]])
    check('all-angle TT rotation has exactly spin-two double-angle action',
          all(s.cancel(v) == 0 for v in h_action-pol*double))
    for sign in (-1,1):
        vector = s.Matrix([1,sign*s.I])
        phase = (cosine-sign*s.I*sine)**2
        check(f'circular curvature polarization has helicity {2*sign:+d}',
              all(s.cancel(v) == 0 for v in double*vector-phase*vector))


def run() -> int:
    global FAILED
    reset()
    CHECKS.clear()
    FAILED = 0
    started = time.perf_counter()
    pi = universal_checks()
    fibre_and_covariance_checks(pi)
    little_group_checks()
    print(json.dumps({'status':'PASS' if FAILED == 0 else 'FAIL',
                      'exact_checks':len(CHECKS),
                      'elapsed_seconds':time.perf_counter()-started,
                      'claim':'free covariant curvature extension only',
                      'checks':CHECKS}, indent=2))
    return summary("v1032 covariant curvature")


if __name__ == '__main__':
    raise SystemExit(run())

2ba2ff1636eb1f712705d1b50b9e1be703597271d40209e6fb7ecf1ad099aefb

The public registry includes 116 document views, 6,693 section records and 985 physical LaTeX sources. Active publication documents, research material and archives retain their recorded roles. This is source navigation, not a new semantic review or proof run.