verify-persistent-nilpotence-no-go.py

#!/usr/bin/env python3
"""Dependency-free exact checks for the persistent-nilpotence no-go model."""

from fractions import Fraction


def mul(a, b):
    """Multiply in Q[e]/(e^3), coordinates on (1,e,e^2)."""
    out = [Fraction(0), Fraction(0), Fraction(0)]
    for i, ai in enumerate(a):
        for j, bj in enumerate(b):
            if i + j < 3:
                out[i + j] += ai * bj
    return tuple(out)


one = (Fraction(1), Fraction(0), Fraction(0))
eps = (Fraction(0), Fraction(1), Fraction(0))
eps2 = mul(eps, eps)
zero = (Fraction(0), Fraction(0), Fraction(0))

assert eps2 == (0, 0, 1)
assert mul(eps2, eps) == zero
assert mul(eps2, eps2) == zero


def multiplication_matrix(a):
    basis = [one, eps, eps2]
    columns = [mul(a, b) for b in basis]
    return [[columns[j][i] for j in range(3)] for i in range(3)]


def det3(m):
    return (
        m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
        - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
        + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0])
    )


# The Hessian determinant of x^4/4 plus transverse quadratics is 3e^2.
jacobian = tuple(3 * x for x in eps2)
M_j = multiplication_matrix(jacobian)
assert jacobian != zero
assert mul(jacobian, jacobian) == zero
assert det3(M_j) == 0


def trace(a):
    M = multiplication_matrix(a)
    return sum(M[i][i] for i in range(3))


# Trace-pairing Gram matrix on (1,e,e^2); its determinant is the discriminant.
basis = [one, eps, eps2]
trace_gram = [[trace(mul(a, b)) for b in basis] for a in basis]
assert det3(trace_gram) == 0


# Poisson bracket of separated one-coordinate Hamiltonians.  Each derivative
# record is (d/dx_1,...,d/dx_r,d/dp_1,...,d/dp_r).  H_i and H_j have disjoint
# supports for i != j, so every summand vanishes exactly.
def poisson(grad_f, grad_g, rank):
    return sum(
        grad_f[i] * grad_g[rank + i]
        - grad_f[rank + i] * grad_g[i]
        for i in range(rank)
    )


rank = 4
for i in range(rank):
    for j in range(rank):
        if i == j:
            continue
        # Use arbitrary nonzero exact derivative values on the supported pair.
        gf = [Fraction(0)] * (2 * rank)
        gg = [Fraction(0)] * (2 * rank)
        gf[i], gf[rank + i] = Fraction(2), Fraction(3)
        gg[j], gg[rank + j] = Fraction(5), Fraction(7)
        assert poisson(gf, gg, rank) == 0


print("persistent-nilpotence no-go verification")
print("critical algebra basis: 1, e, e^2")
print("rank over the parameter base: 3")
print("x^3(1+t*x) and x^3 define the same completed local ideal: unit factor")
print("e^3 = 0 and e^2 != 0: PASS")
print("Hessian determinant j = 3e^2 is nonzero nilpotent: PASS")
print("Norm(j) = det(multiplication by j) = 0: PASS")
print("Trace-pairing discriminant = 0: PASS")
print("Reduced support of every fiber is one point: follows from rad(e^3)=(e)")
print("Pairwise Poisson commutativity of separated Hamiltonians: PASS")
print("Conclusion: finite-flat persistent nilpotence and Liouville integrability")
print("do not force a positive-dimensional critical locus in a fiber.")