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
# -*- coding: utf-8 -*-
"""v1004 -- SEAM.MILNOR.LOCALRING.01 [O]: Milnor algebra of the E8
singularity, rank clock, Galois-Gray action, socle/Frobenius CP, and
the integral dual-number bridge.

Provenance: experiments/tfpt-discovery/milnor_frobenius_gray_probe.py
(review wave 6, 2026-08-30; 36/36 + 3/3 mutants).

THE POINT.  Typed finite algebra; the corpus identification stays open.

  CLASSICAL (cite, no claim): Milnor algebra of x^2+y^3+z^5 congruent
        Q[y,z]/(y^2,z^4) dim 8; spectral numbers = E8 exponents
        {1,7,11,13,17,19,23,29}; Coxeter polynomial Phi_30.
  [E-finite] NEW-IN-CORPUS EXACT: (i) rank clock -- multiplication
        ranks (2-a)(4-b), table sum = 30 = h(E8); general
        S = pqr*mu/8; self-clock S = pqr iff mu = 8; (2,3,5) unique
        among ordered spherical triples; (ii) Galois-Gray -- 11 swaps
        sheets, 7 cycles the seam clock in binary Gray order
        0->1->3->2, -1 = (a,b)->(1-a,3-b); (iii) CP = socle/Frobenius
        duality -- residue pairing nonzero iff a+a'=1, b+b'=3,
        m+m'=30; (iv) INTEGRAL dual-number bridge (retyped):
        Z[y,z]/(y^2,z^4) tensor F2 is free rank 4 over
        D = F2[eps]/(eps^2), Z[i]/(2) congruent D, basis-dependent
        (literal M_Q tensor F2 is undefined).
  [C]  INTERPRETIVE: 15 = 8_R + 7_NS as PG(3,2) = AG(3,2) sqcup PG(2,2);
        no Milnor-to-NS/R identification is asserted.

MUST-FAIL: (2,3,7) has S=63 != pqr=42; A8 self-clock passes but
exponent fingerprint fails; wrong socle z^3 pairing rank 4.

HONEST SCOPE (firewall): finite singularity algebra + integral mod-2
model; no canonical geometric identification of the raw seam collar
with F2[y,z]/(y^2,z^4); SEAM.MILNOR.LOCALRING.01 stays Open.
Python-only / Wolfram mirror deferred.
"""
from __future__ import annotations

from fractions import Fraction
from itertools import permutations, product
from math import gcd

import sympy as sp
from sympy.matrices.normalforms import hermite_normal_form

from tfpt_constants import check, summary, reset


CLAIM_FAILURES = {claim: [] for claim in range(1, 9)}


def report(claim, name, condition, detail=""):
    """Record one exact Boolean gate against tfpt_constants.check."""
    passed = bool(condition)
    if claim in CLAIM_FAILURES and not passed:
        CLAIM_FAILURES[claim].append(name)
    extra = name if claim == 0 else "C%d %s" % (claim, name)
    if detail:
        extra = "%s -- %s" % (extra, detail)
    check(extra, passed)
    return passed


def section(title):
    print("\n== %s ==" % title)


def f2_apply(columns, word):
    """Apply an F2-linear map stored by integer-bit columns."""
    out = 0
    for column_index, column in enumerate(columns):
        if (word >> column_index) & 1:
            out ^= column
    return out


def truncated_product(left, right, bounds):
    """Multiply monomial exponent tuples in a truncated tensor algebra."""
    exponent = tuple(a + b for a, b in zip(left, right))
    return None if any(e >= bound for e, bound in zip(exponent, bounds)) \
        else exponent


def run():
    reset()
    global CLAIM_FAILURES
    CLAIM_FAILURES = {claim: [] for claim in range(1, 9)}
    print("v1004 -- SEAM.MILNOR.LOCALRING.01 Milnor-Frobenius-Gray")
    print("MILNOR-FROBENIUS-GRAY independent audit")
    print("Arithmetic domains: QQ / ZZ / F2 only; no floats, no RNG")


    # ============================================================================
    section("Claim 1: Milnor algebra by Groebner normal form")
    # ============================================================================
    x, y, z = sp.symbols("x y z")
    groebner = sp.groebner(
        [sp.diff(x**2 + y**3 + z**5, variable)
         for variable in (x, y, z)],
        x, y, z, domain=sp.QQ,
    )
    groebner_expressions = tuple(poly.as_expr() for poly in groebner.polys)
    basis_exponents = tuple((a, b) for a in range(2) for b in range(4))
    basis_polynomials = tuple(y**a * z**b for a, b in basis_exponents)
    normal_forms = tuple(groebner.reduce(monomial)[1]
                         for monomial in basis_polynomials)

    report(1, "Jacobian Groebner basis is (x,y^2,z^4)",
          groebner_expressions == (x, y**2, z**4),
          "computed %s" % (groebner_expressions,))
    report(1, "eight standard monomials survive",
          len(basis_polynomials) == 8
          and normal_forms == basis_polynomials,
          "basis=%s" % (basis_exponents,))
    report(1, "defining relations reduce to zero",
          all(groebner.reduce(relation)[1] == 0
              for relation in (x, y**2, z**4, 2*x, 3*y**2, 5*z**4)))


    # ============================================================================
    section("Claim 2: explicit multiplication matrices and rank clock")
    # ============================================================================
    basis_index = {exponent: index
                   for index, exponent in enumerate(basis_exponents)}


    def multiplication_matrix(multiplier):
        matrix = sp.zeros(8, 8)
        for column, exponent in enumerate(basis_exponents):
            target = truncated_product(multiplier, exponent, (2, 4))
            if target is not None:
                matrix[basis_index[target], column] = 1
        return matrix


    multiplication_matrices = {
        exponent: multiplication_matrix(exponent)
        for exponent in basis_exponents
    }
    rank_table = [
        [multiplication_matrices[(a, b)].rank() for b in range(4)]
        for a in range(2)
    ]
    formula_table = [[(2 - a) * (4 - b) for b in range(4)]
                     for a in range(2)]
    matrix_entries_exact = all(
        entry in (0, 1)
        for matrix in multiplication_matrices.values()
        for entry in matrix
    )

    report(2, "all eight 8x8 multiplication matrices built over ZZ",
          len(multiplication_matrices) == 8 and matrix_entries_exact)
    report(2, "rank formula rank(m_{y^a z^b})=(2-a)(4-b)",
          rank_table == formula_table,
          "ranks=%s" % rank_table)
    report(2, "rank table sums to h(E8)=30",
          sum(sum(row) for row in rank_table) == 30,
          "sum=%d" % sum(sum(row) for row in rank_table))


    # ============================================================================
    section("Claim 3: general Brieskorn rank formula and spherical uniqueness")
    # ============================================================================
    n, index = sp.symbols("n index", integer=True, positive=True)
    one_factor_sum = sp.summation(n - index, (index, 0, n - 1))
    report(3, "one-factor rank sum is n(n+1)/2",
          sp.simplify(one_factor_sum - n * (n + 1) / 2) == 0,
          "sum=%s" % one_factor_sum)

    p_symbol, q_symbol, r_symbol = sp.symbols(
        "p q r", integer=True, positive=True)
    mu_symbol = (p_symbol - 1) * (q_symbol - 1) * (r_symbol - 1)
    rank_sum_symbol = (
        p_symbol * (p_symbol - 1)
        * q_symbol * (q_symbol - 1)
        * r_symbol * (r_symbol - 1) / 8
    )
    reviewer_formula = p_symbol * q_symbol * r_symbol * mu_symbol / 8
    report(3, "reviewer formula S=p*q*r*mu/8 is algebraically correct",
          sp.simplify(rank_sum_symbol - reviewer_formula) == 0,
          "S=%s" % sp.factor(rank_sum_symbol))
    report(3, "self-clock S=p*q*r iff mu=8",
          sp.simplify(
              rank_sum_symbol - p_symbol*q_symbol*r_symbol
              - p_symbol*q_symbol*r_symbol*(mu_symbol - 8)/8
          ) == 0)

    finite_tensor_checks = []
    for p_value in range(2, 7):
        for q_value in range(2, 7):
            for r_value in range(2, 7):
                explicit_sum = sum(
                    (p_value - 1 - i_value)
                    * (q_value - 1 - j_value)
                    * (r_value - 1 - k_value)
                    for i_value in range(p_value - 1)
                    for j_value in range(q_value - 1)
                    for k_value in range(r_value - 1)
                )
                mu_value = ((p_value - 1)
                            * (q_value - 1)
                            * (r_value - 1))
                finite_tensor_checks.append(
                    8 * explicit_sum
                    == p_value*q_value*r_value*mu_value)
    report(3, "explicit tensor-rank census agrees for 2<=p,q,r<=6",
          all(finite_tensor_checks),
          "tested=%d" % len(finite_tensor_checks))

    # With p<=q<=r and 1/p+1/q+1/r>1: p=2.  If q>=4 the sum is
    # at most 1; q=2 is the dihedral family, and q=3 forces r<6.
    exceptional_spherical = [
        triple for triple in product(range(2, 6), repeat=3)
        if triple[0] <= triple[1] <= triple[2]
        and triple[1] >= 3
        and sum(Fraction(1, value) for value in triple) > 1
    ]
    strict_spherical = [
        triple for triple in product(range(2, 6), repeat=3)
        if triple[0] < triple[1] < triple[2]
        and sum(Fraction(1, value) for value in triple) > 1
    ]
    strict_self_clock = [
        triple for triple in strict_spherical
        if (triple[0] - 1)*(triple[1] - 1)*(triple[2] - 1) == 8
    ]
    report(3, "exceptional spherical triples are exactly 233,234,235",
          exceptional_spherical == [(2, 3, 3), (2, 3, 4), (2, 3, 5)],
          "triples=%s; (2,2,r) is the excluded dihedral family"
          % exceptional_spherical)
    report(3, "strict spherical triples are 234 and 235",
          strict_spherical == [(2, 3, 4), (2, 3, 5)],
          "triples=%s" % strict_spherical)
    report(3, "235 is uniquely strict-spherical and self-clocking",
          strict_self_clock == [(2, 3, 5)],
          "solutions=%s" % strict_self_clock)


    # ============================================================================
    section("Claim 4: spectrum, E8 exponents, and Coxeter polynomial")
    # ============================================================================
    spectral_numbers = [
        [Fraction(1, 2) + Fraction(a + 1, 3) + Fraction(b + 1, 5) - 1
         for b in range(4)]
        for a in range(2)
    ]
    spectral_m_table = [
        [30 * spectral_numbers[a][b] for b in range(4)]
        for a in range(2)
    ]
    expected_m_table = [[1, 7, 13, 19], [11, 17, 23, 29]]
    unit_set_30 = {value for value in range(30) if gcd(value, 30) == 1}
    flat_m = sorted(int(value) for row in spectral_m_table for value in row)

    report(4, "weighted-homogeneous spectral formula gives stated table",
          spectral_m_table == expected_m_table,
          "30*alpha=%s" % spectral_m_table)
    report(4, "scaled spectrum is the unit set modulo 30",
          set(flat_m) == unit_set_30,
          "spectrum=%s" % flat_m)

    # Rebuild the E8 Cartan matrix from the exact simple roots used by the
    # corpus v1 module, then independently form a Coxeter element.
    identity8 = sp.eye(8)
    coordinate_rows = []
    coordinate_rows.append([
        Fraction(1, 2), Fraction(-1, 2), Fraction(-1, 2),
        Fraction(-1, 2), Fraction(-1, 2), Fraction(-1, 2),
        Fraction(-1, 2), Fraction(1, 2),
    ])
    coordinate_rows.extend([
        [1, 1, 0, 0, 0, 0, 0, 0],
        [-1, 1, 0, 0, 0, 0, 0, 0],
        [0, -1, 1, 0, 0, 0, 0, 0],
        [0, 0, -1, 1, 0, 0, 0, 0],
        [0, 0, 0, -1, 1, 0, 0, 0],
        [0, 0, 0, 0, -1, 1, 0, 0],
        [0, 0, 0, 0, 0, -1, 1, 0],
    ])
    simple_roots = sp.Matrix(coordinate_rows)
    cartan_e8 = simple_roots * simple_roots.T
    simple_reflections = []
    for reflection_index in range(8):
        reflection = sp.eye(8)
        for column in range(8):
            reflection[reflection_index, column] -= \
                cartan_e8[reflection_index, column]
        simple_reflections.append(reflection)
    coxeter = sp.eye(8)
    for reflection in simple_reflections:
        coxeter = coxeter * reflection
    t = sp.symbols("t")
    coxeter_polynomial = sp.expand(coxeter.charpoly(t).as_expr())
    phi30 = sp.expand(sp.cyclotomic_poly(30, t))

    report(4, "exact E8 Cartan reconstruction is even unimodular",
          cartan_e8.det() == 1
          and all(cartan_e8[i, i] == 2 for i in range(8)))
    report(4, "Coxeter characteristic polynomial is Phi_30",
          coxeter_polynomial == phi30,
          "chi=%s" % coxeter_polynomial)
    report(4, "Coxeter element has exact order 30",
          coxeter**30 == identity8
          and all(coxeter**divisor != identity8
                  for divisor in (1, 2, 3, 5, 6, 10, 15)))


    # ============================================================================
    section("Claim 5: Galois action and Gray cycle")
    # ============================================================================
    label_by_m = {
        1 + 10*a + 6*b: (a, b)
        for a in range(2) for b in range(4)
    }


    def mod30_label(multiplier, a, b):
        return label_by_m[(multiplier * (1 + 10*a + 6*b)) % 30]


    gray_column_map = {0: 1, 1: 3, 3: 2, 2: 0}
    report(5, "multiplication by 11 swaps the two rows",
          all(mod30_label(11, a, b) == (1 - a, b)
              for a in range(2) for b in range(4)))
    report(5, "multiplication by 7 follows column Gray cycle 0,1,3,2",
          all(mod30_label(7, a, b) == (a, gray_column_map[b])
              for a in range(2) for b in range(4)))
    report(5, "multiplication by -1 is (a,b)->(1-a,3-b)",
          all(mod30_label(-1, a, b) == (1 - a, 3 - b)
              for a in range(2) for b in range(4)))

    powers7 = [(7**power) % 30 for power in range(4)]
    generated_units = {
        (11**row_swap * 7**column_turn) % 30
        for row_swap in range(2) for column_turn in range(4)
    }
    gray_words = ((0, 0), (0, 1), (1, 1), (1, 0))
    gray_steps = [
        sum(left ^ right
            for left, right in zip(gray_words[k], gray_words[(k + 1) % 4]))
        for k in range(4)
    ]
    report(5, "(Z/30)^x=<11>x<7> is C2 x C4",
          (11**2) % 30 == 1
          and powers7 == [1, 7, 19, 13]
          and generated_units == unit_set_30
          and 11 not in set(powers7),
          "generated=%s" % sorted(generated_units))
    report(5, "column labels are the binary Gray cycle",
          gray_steps == [1, 1, 1, 1],
          "words=%s, steps=%s" % (gray_words, gray_steps))


    # ============================================================================
    section("Claim 6: Frobenius/socle pairing from multiplication matrices")
    # ============================================================================
    socle = (1, 3)
    socle_row = basis_index[socle]
    frobenius_gram = sp.Matrix([
        [multiplication_matrices[left][socle_row, basis_index[right]]
         for right in basis_exponents]
        for left in basis_exponents
    ])
    expected_frobenius = sp.Matrix([
        [int(left[0] + right[0] == 1 and left[1] + right[1] == 3)
         for right in basis_exponents]
        for left in basis_exponents
    ])
    report(6, "socle coefficient pairing is the complement permutation",
          frobenius_gram == expected_frobenius
          and frobenius_gram.det() in (-1, 1))
    report(6, "socle complement equals the -1/CP label involution",
          all(label_by_m[30 - (1 + 10*a + 6*b)] == (1 - a, 3 - b)
              for a in range(2) for b in range(4)))
    report(6, "paired spectral labels sum to 30",
          all((1 + 10*a + 6*b)
              + (1 + 10*(1 - a) + 6*(3 - b)) == 30
              for a in range(2) for b in range(4)))

    frobenius_associative = True
    for left in basis_exponents:
        for middle in basis_exponents:
            for right in basis_exponents:
                left_middle = truncated_product(left, middle, (2, 4))
                middle_right = truncated_product(middle, right, (2, 4))
                lhs = int(left_middle is not None
                          and truncated_product(left_middle, right, (2, 4))
                          == socle)
                rhs = int(middle_right is not None
                          and truncated_product(left, middle_right, (2, 4))
                          == socle)
                frobenius_associative &= lhs == rhs
    report(6, "pairing is Frobenius-associative on all basis triples",
          frobenius_associative)


    # ============================================================================
    section("Claim 7: dual-number bus and Gaussian E8 cross-check")
    # ============================================================================
    # Honest mod-2 object: M_Z tensor F2, not the nonexistent Q-algebra tensor F2.
    def milnor_epsilon(word):
        """Multiplication by eps=y on F2[y,z]/(y^2,z^4)."""
        return ((word & 0b1111) << 4)


    milnor_d_generators = tuple(1 << b for b in range(4))  # 1,z,z^2,z^3
    milnor_d_span = set()
    for coefficients in product(range(4), repeat=4):
        word = 0
        for generator, coefficient in zip(milnor_d_generators, coefficients):
            if coefficient & 1:
                word ^= generator
            if coefficient & 2:
                word ^= milnor_epsilon(generator)
        milnor_d_span.add(word)
    report(7, "retyped M_Z mod 2 is D[z]/(z^4)=D^4",
          len(milnor_d_span) == 256
          and all(milnor_epsilon(milnor_epsilon(word)) == 0
                  for word in range(256)),
          "D-basis=(1,z,z^2,z^3); literal M_Q tensor F2 is undefined")

    # Z[i]/(2) -> D, a+bi |-> (a+b)+b eps because i=1+eps.
    zi_elements = tuple(product((0, 1), repeat=2))


    def zi_add(left, right):
        return ((left[0] + right[0]) % 2, (left[1] + right[1]) % 2)


    def zi_multiply(left, right):
        return ((left[0]*right[0] - left[1]*right[1]) % 2,
                (left[0]*right[1] + left[1]*right[0]) % 2)


    def dual_add(left, right):
        return ((left[0] + right[0]) % 2, (left[1] + right[1]) % 2)


    def dual_multiply(left, right):
        return ((left[0]*right[0]) % 2,
                (left[0]*right[1] + left[1]*right[0]) % 2)


    def zi_to_dual(value):
        return ((value[0] + value[1]) % 2, value[1])


    ring_iso_ok = (
        len({zi_to_dual(value) for value in zi_elements}) == 4
        and zi_to_dual((1, 1)) == (0, 1)
        and all(
            zi_to_dual(zi_add(left, right))
            == dual_add(zi_to_dual(left), zi_to_dual(right))
            and zi_to_dual(zi_multiply(left, right))
            == dual_multiply(zi_to_dual(left), zi_to_dual(right))
            for left in zi_elements for right in zi_elements
        )
    )
    report(7, "Z[i]/(2) is D with eps=image(1+i)",
          ring_iso_ok
          and zi_multiply((1, 1), (1, 1)) == (0, 0))

    # Rebuild the exact Gaussian Construction-A placement used in
    # note_e8_gaussian_code/v833, then compute eps=1+J on L/2L.
    g_naive = (
        (1, 0, 0, 0, 0, 1, 1, 1),
        (0, 1, 0, 0, 1, 0, 1, 1),
        (0, 0, 1, 0, 1, 1, 0, 1),
        (0, 0, 0, 1, 1, 1, 1, 0),
    )
    c_naive = frozenset(
        tuple(sum(message[k]*g_naive[k][j] for k in range(4)) % 2
              for j in range(8))
        for message in product((0, 1), repeat=4)
    )
    pi_j = (1, 0, 3, 2, 5, 4, 7, 6)
    pi_sigma = (2, 3, 4, 5, 0, 1, 6, 7)


    def code_image(code, permutation):
        return frozenset(
            tuple(codeword[permutation[k]] for k in range(8))
            for codeword in code
        )


    placements = {
        code_image(c_naive, permutation)
        for permutation in permutations(range(8))
    }
    invariant_placements = [
        code for code in placements
        if code_image(code, pi_j) == code
        and code_image(code, pi_sigma) == code
    ]
    w0246 = (1, 0, 1, 0, 1, 0, 1, 0)
    c_star = next(code for code in invariant_placements if w0246 in code)
    report(7, "corpus Gaussian placement census reproduces 30 and 2",
          len(placements) == 30 and len(invariant_placements) == 2)

    lattice_generators = sp.Matrix(
        [list(codeword) for codeword in sorted(c_star)]
        + [[2*int(row == column) for column in range(8)]
           for row in range(8)]
    ).T
    lattice_basis = hermite_normal_form(lattice_generators)
    j_matrix = sp.zeros(8, 8)
    for pair_index in range(4):
        j_matrix[2*pair_index, 2*pair_index + 1] = -1
        j_matrix[2*pair_index + 1, 2*pair_index] = 1
    epsilon_matrix = lattice_basis.inv() * (sp.eye(8) + j_matrix) \
        * lattice_basis
    j_lattice_matrix = lattice_basis.inv() * j_matrix * lattice_basis
    report(7, "J preserves L and satisfies J^2=-1",
          all(entry.is_Integer for entry in j_lattice_matrix)
          and j_lattice_matrix**2 == -sp.eye(8))

    epsilon_columns = []
    for column in range(8):
        bit_column = 0
        for row in range(8):
            if int(epsilon_matrix[row, column]) % 2:
                bit_column ^= 1 << row
        epsilon_columns.append(bit_column)


    def e8_epsilon(word):
        return f2_apply(epsilon_columns, word)


    epsilon_image = {e8_epsilon(word) for word in range(256)}
    epsilon_kernel = {
        word for word in range(256) if e8_epsilon(word) == 0
    }
    report(7, "on E8/2E8, eps^2=0 and ker(eps)=im(eps)=F2^4",
          all(e8_epsilon(e8_epsilon(word)) == 0 for word in range(256))
          and len(epsilon_image) == 16
          and epsilon_image == epsilon_kernel)


    def d_scalar_multiple(coefficient, generator, epsilon_action):
        value = 0
        if coefficient & 1:
            value ^= generator
        if coefficient & 2:
            value ^= epsilon_action(generator)
        return value


    e8_d_generators = []
    e8_d_span = {0}
    for candidate in range(1, 256):
        candidate_span = {
            previous ^ d_scalar_multiple(coefficient, candidate, e8_epsilon)
            for previous in e8_d_span for coefficient in range(4)
        }
        if len(candidate_span) == 4*len(e8_d_span):
            e8_d_generators.append(candidate)
            e8_d_span = candidate_span
        if len(e8_d_generators) == 4:
            break
    report(7, "E8/2E8 is free D-rank 4 with explicit generators",
          len(e8_d_generators) == 4 and len(e8_d_span) == 256,
          "generators=%s" %
          [format(generator, "08b") for generator in e8_d_generators])


    def milnor_to_e8(word):
        target = 0
        for b, generator in enumerate(e8_d_generators):
            if (word >> b) & 1:
                target ^= generator
            if (word >> (4 + b)) & 1:
                target ^= e8_epsilon(generator)
        return target


    bridge_images = {milnor_to_e8(word) for word in range(256)}
    report(7, "chosen D-bases give an explicit Milnor-to-E8 intertwiner",
          len(bridge_images) == 256
          and all(milnor_to_e8(milnor_epsilon(word))
                  == e8_epsilon(milnor_to_e8(word))
                  for word in range(256)),
          "exact and basis-dependent, not canonical")


    # ============================================================================
    section("Claim 8: PG(3,2)=AG(3,2)+PG(2,2), interpretation only")
    # ============================================================================
    pg32_points = [
        vector for vector in product((0, 1), repeat=4) if any(vector)
    ]
    hyperplane_at_infinity = [
        vector for vector in pg32_points if vector[0] == 0
    ]
    affine_chart = [
        vector for vector in pg32_points if vector[0] == 1
    ]
    report(8, "PG(3,2) has 15 points",
          len(pg32_points) == (2**4 - 1)//(2 - 1))
    report(8, "hyperplane plus affine chart has sizes 7+8",
          len(hyperplane_at_infinity) == 7
          and len(affine_chart) == 8
          and set(hyperplane_at_infinity).isdisjoint(affine_chart)
          and set(hyperplane_at_infinity) | set(affine_chart)
          == set(pg32_points))
    print("  [C] Corpus comparison only: 7 points at infinity + 8 affine "
          "points has the same hyperplane/coset shape as 7_NS + 8_R "
          "(v819); no Milnor-to-NS/R identification is asserted.")


    # ============================================================================
    section("Mutants: required failures")
    # ============================================================================
    mutant_failures = []

    p237 = (2, 3, 7)
    mu237 = (p237[0] - 1)*(p237[1] - 1)*(p237[2] - 1)
    sum237 = p237[0]*p237[1]*p237[2]*mu237 // 8
    mutant_237_fires = sum237 != p237[0]*p237[1]*p237[2]
    mutant_failures.append(mutant_237_fires)
    print("  [%s] MUTANT (2,3,7): mu=%d, S=%d != pqr=%d" %
          ("PASS" if mutant_237_fires else "FAIL",
           mu237, sum237, p237[0]*p237[1]*p237[2]))

    # A8: x^2+y^2+z^9 has mu=8 and therefore passes the rank self-clock,
    # but its Coxeter exponents are 1,...,8 at h=9, not (Z/30)^x.
    a8_mu = (2 - 1)*(2 - 1)*(9 - 1)
    a8_rank_sum = 2*2*9*a8_mu // 8
    a8_exponents = set(range(1, 9))
    mutant_a8_fires = (
        a8_mu == 8 and a8_rank_sum == 36
        and a8_exponents != unit_set_30
    )
    mutant_failures.append(mutant_a8_fires)
    print("  [%s] MUTANT A8: self-clock survives (%d=36), "
          "but exponents %s != units mod 30" %
          ("PASS" if mutant_a8_fires else "FAIL",
           a8_rank_sum, sorted(a8_exponents)))

    # Wrong "socle" z^3 omits y and produces a degenerate rank-four form.
    wrong_socle_row = basis_index[(0, 3)]
    wrong_pairing = sp.Matrix([
        [multiplication_matrices[left][wrong_socle_row, basis_index[right]]
         for right in basis_exponents]
        for left in basis_exponents
    ])
    wrong_pairing_fires = wrong_pairing.rank() == 4 \
        and wrong_pairing.rank() < 8
    mutant_failures.append(wrong_pairing_fires)
    print("  [%s] MUTANT wrong socle z^3: pairing rank=%d < 8" %
          ("PASS" if wrong_pairing_fires else "FAIL", wrong_pairing.rank()))


    # ============================================================================
    section("Typing and verdict")
    # ============================================================================
    claim_types = {
        1: "VERIFIED -- classical singularity theory",
        2: "VERIFIED -- exact rank identity; new-in-corpus packaging",
        3: "VERIFIED -- reviewer formula correct; uniqueness includes hypotheses",
        4: "VERIFIED -- classical E8 singularity spectrum/Coxeter exponents",
        5: "VERIFIED -- exact Galois/Gray identity; new-in-corpus packaging",
        6: "VERIFIED -- exact socle=-1/CP identity; new-in-corpus packaging",
        7: "RETYPED+VERIFIED -- integral mod-2 model; exact basis-dependent D^4 bridge",
        8: "VERIFIED COUNTS / [C] CONSISTENT-INTERPRETATION only",
    }
    for claim in range(1, 9):
        failures = CLAIM_FAILURES[claim]
        status = claim_types[claim] if not failures \
            else "FAILED -- %s" % ", ".join(failures)
        print("  C%d: %s" % (claim, status))

    failed_claims = {
        claim: failures for claim, failures in CLAIM_FAILURES.items() if failures
    }
    controls_ok = all(mutant_failures)

    if failed_claims:
        verdict = "MILNOR_GRAY_PARTIAL(%s)" % sorted(failed_claims)
    elif not controls_ok:
        verdict = "MILNOR_GRAY_REFUTED(['mutant-control-dead'])"
    else:
        verdict = (
            "MILNOR_GRAY_VERIFIED([1,2,3,4,5,6,'7-retyped','8-C'])"
        )
    print("VERDICT: %s" % verdict)

    report(2, "MUTANT (2,3,7): S=63 != pqr=42", mutant_237_fires,
           "mu=%d S=%d pqr=%d" % (mu237, sum237, p237[0]*p237[1]*p237[2]))
    report(4, "MUTANT A8: self-clock survives, exponents != units mod 30",
           mutant_a8_fires, "rank_sum=%d" % a8_rank_sum)
    report(6, "MUTANT wrong socle z^3: pairing rank 4 < 8",
           wrong_pairing_fires, "rank=%d" % wrong_pairing.rank())
    report(0, "FIREWALL (scope): finite singularity algebra + integral "
           "mod-2 model; no canonical geometric identification of the raw "
           "seam collar with F2[y,z]/(y^2,z^4); SEAM.MILNOR.LOCALRING.01 "
           "stays Open; no status-marker move", True)
    return summary(
        "v1004 Milnor-Frobenius-Gray: classical cite + rank/Gray/CP "
        "[E-finite] + integral D^4 bridge (basis-dependent) + PG(3,2) [C]"
    )


if __name__ == "__main__":
    raise SystemExit(1 if run() else 0)

82dabfd912ea409bf5e5a2e3bbdeaf8ae4698017db3c22a15057b3f7a2c1b695

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.