| |
| """Exact audit of a fixed-five-dimensional holonomy completion example. |
| |
| All arithmetic is rational. The base is S^1 x R^4, the flat connection is |
| d + N dt, and N is a nilpotent Jordan shift. No surreal or differential |
| geometry package is required. The general statements are proved separately. |
| """ |
| from fractions import Fraction as Q |
| from math import factorial |
| from pathlib import Path |
| import json |
|
|
|
|
| def identity(n): |
| return [[Q(int(i == j)) for j in range(n)] for i in range(n)] |
|
|
|
|
| def multiply(a, b): |
| return [[sum(a[i][k] * b[k][j] for k in range(len(b))) |
| for j in range(len(b[0]))] for i in range(len(a))] |
|
|
|
|
| def power(a, j): |
| result = identity(len(a)) |
| for _ in range(j): |
| result = multiply(result, a) |
| return result |
|
|
|
|
| def rank(a): |
| a = [list(row) for row in a] |
| i = 0 |
| for j in range(len(a[0])): |
| p = next((p for p in range(i, len(a)) if a[p][j]), None) |
| if p is None: |
| continue |
| a[i], a[p] = a[p], a[i] |
| pivot = a[i][j] |
| a[i] = [x/pivot for x in a[i]] |
| for p in range(len(a)): |
| if p != i: |
| scale = a[p][j] |
| a[p] = [x-scale*y for x, y in zip(a[p], a[i])] |
| i += 1 |
| if i == len(a): |
| break |
| return i |
|
|
|
|
| def determinant(a): |
| a = [list(row) for row in a] |
| result = Q(1) |
| for j in range(len(a)): |
| p = next((p for p in range(j, len(a)) if a[p][j]), None) |
| if p is None: |
| return Q(0) |
| if p != j: |
| a[j], a[p] = a[p], a[j] |
| result = -result |
| pivot = a[j][j] |
| result *= pivot |
| for p in range(j+1, len(a)): |
| scale = a[p][j]/pivot |
| for k in range(j, len(a)): |
| a[p][k] -= scale*a[j][k] |
| return result |
|
|
|
|
| def jordan_shift(n): |
| return [[Q(int(j == i+1)) for j in range(n)] for i in range(n)] |
|
|
|
|
| def exp_negative_nilpotent(n, epsilon=Q(1)): |
| N = jordan_shift(n) |
| result = [[Q(0) for _ in range(n)] for _ in range(n)] |
| for p in range(n): |
| term = power(N, p) |
| coefficient = (-epsilon)**p / factorial(p) |
| for i in range(n): |
| for j in range(n): |
| result[i][j] += coefficient*term[i][j] |
| return result |
|
|
|
|
| def orbit_matrix(n, start, epsilon=Q(1)): |
| T = exp_negative_nilpotent(n, epsilon) |
| vector = [[Q(int(i == start))] for i in range(n)] |
| columns = [] |
| for j in range(n): |
| columns.append([row[0] for row in vector]) |
| vector = multiply(T, vector) |
| return [list(row) for row in zip(*columns)] |
|
|
|
|
| def log_unipotent(T): |
| n = len(T) |
| S = [[T[i][j]-Q(int(i == j)) for j in range(n)] for i in range(n)] |
| result = [[Q(0) for _ in range(n)] for _ in range(n)] |
| for p in range(1, n): |
| term = power(S, p) |
| coefficient = Q((-1)**(p+1), p) |
| for i in range(n): |
| for j in range(n): |
| result[i][j] += coefficient*term[i][j] |
| return result |
|
|
|
|
| def wedge(a, b): |
| """Exterior monomial product, returning (sign, sorted indices).""" |
| if set(a) & set(b): |
| return 0, () |
| sign = (-1)**sum(x > y for x in a for y in b) |
| return sign, tuple(sorted(a+b)) |
|
|
|
|
| def main(): |
| |
| B_indices = (0, 2, 3, 4) |
| derivative_sign, F_indices = wedge((1,), B_indices) |
| |
| assert -derivative_sign == 1 and F_indices == (0, 1, 2, 3, 4) |
| assert wedge((0,), B_indices)[0] == 0 |
| assert wedge((0,), (0,))[0] == 0 |
| cases = [] |
| for n in range(1, 13): |
| N = jordan_shift(n) |
| assert all(x == 0 for row in power(N, n) for x in row) |
| orbit = orbit_matrix(n, n-1) |
| det = determinant(orbit) |
| assert det == 1 and rank(orbit) == n |
| for i in range(n): |
| for j in range(n): |
| p = n-1-i |
| assert orbit[i][j] == Q((-j)**p, factorial(p)) |
| partial_ranks = [] |
| for s in range(n): |
| r = rank(orbit_matrix(n, s)) |
| assert r == s+1 |
| partial_ranks.append(r) |
| cases.append({'coefficient_rank': n, |
| 'pointwise_curvature_rank': 1, |
| 'holonomy_saturated_rank': rank(orbit), |
| 'cyclic_orbit_determinant': str(det), |
| 'nonterminal_vector_orbit_ranks': partial_ranks}) |
| scaled_cases = [] |
| prefix_checks = 0 |
| for n in range(1, 9): |
| N = jordan_shift(n) |
| v = [[Q(int(i == n-1))] for i in range(n)] |
| for epsilon in (Q(0), Q(1, 7), Q(-2, 3)): |
| T = exp_negative_nilpotent(n, epsilon) |
| orbit = orbit_matrix(n, n-1, epsilon) |
| det = determinant(orbit) |
| expected_det = epsilon**(n*(n-1)//2) |
| assert det == expected_det |
| assert rank(orbit) == (n if epsilon else 1) |
| assert log_unipotent(T) == [[-epsilon*x for x in row] for row in N] |
| if epsilon: |
| for r in range(n): |
| |
| |
| P = [[Q(int(i == j and i < r)) for j in range(n)] |
| for i in range(n)] |
| assert multiply(P, multiply(N, P)) == multiply(N, P) |
| assert multiply(P, multiply(T, P)) == multiply(T, P) |
| projection = multiply(P, v) |
| assert all(row[0] == 0 for row in projection) |
| error_squared = sum((v[i][0]-projection[i][0])**2 |
| for i in range(n)) |
| assert error_squared == 1 |
| prefix_checks += 1 |
| scaled_cases.append({'coefficient_rank': n, |
| 'epsilon': str(epsilon), |
| 'orbit_determinant': str(det), |
| 'expected_epsilon_power': str(expected_det), |
| 'orbit_rank': rank(orbit), |
| 'finite_logarithm_identity': True}) |
| result = { |
| 'status': 'all exact checks passed', |
| 'arithmetic': 'fractions.Fraction', |
| 'base': 'S^1 x R^4 (dimension five)', |
| 'connection': 'd + N dt; t has period one', |
| 'monodromy': 'exp(-N)', |
| 'potential': '-x1 v dt wedge dx2 wedge dx3 wedge dx4', |
| 'curvature': 'v dt wedge dx1 wedge dx2 wedge dx3 wedge dx4', |
| 'flatness_and_wedge_sign_checks': 'passed', |
| 'cases': cases, |
| 'scaled_connection_cases': scaled_cases, |
| 'proper_invariant_prefix_and_unit_error_checks': prefix_checks, |
| 'prefix_scope': 'Invariant-space classification is proved separately; the verifier checks every prefix in the tested dimensions.', |
| 'scope': 'Finite exact certificates for the separately proved arbitrary-rank family.' |
| } |
| target = Path(__file__).with_name('holonomy_completion_results.json') |
| target.write_text(json.dumps(result, indent=2)+'\n') |
| print(json.dumps(result, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
