Follow the source behind the result.

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

"""v427 -- OVERDET.WITNESS.MAP.01: the honest over-determination accounting.
A reviewer's sharpest methodological point: "every independent restriction multiplies
the implausibility of coincidence" is only true when the witnesses come from
GENUINELY DISJOINT grammars; witnesses that are projections of the SAME generator
count as COMPRESSION, not Bayesian multiplication.  This module makes that split
machine-explicit -- the auditable map behind the over-determination claim.

  >>> REFINED (and partly walked back) BY v428 (OVERDET.WITNESS.RECLASS.01).  An
  early version of this module classified the seven arithmetic witnesses below as
  DISJOINT grammars that MULTIPLY.  Applying this module's own multiply-vs-compress
  test to itself (v428) shows that is wrong: by v236 (TOPO.BRIESKORN.01) the
  (2,3,5) Brieskorn singularity is the ONE generator behind the order-30 clock, so
  the seven are different number-theoretic READINGS of that one object -- they
  COMPRESS, they do not multiply.  The check texts below therefore state the
  arithmetic only (each grammar's value is correct) and DEFER the multiply/compress
  verdict to v428.  What honestly multiplies is the INPUT forced several independent
  ways (the "8" in c3 from rank(E8), h(D5), phi(30), Milnor) plus foreign witnesses
  (alpha^-1).  See v428 for the corrected accounting.

  [E] 1. SEVEN GRAMMAR READOUTS.  Seven syntactically distinct grammars each
         reproduce a carrier-skeleton integer, each computed FROM ITS OWN syntax:
           Gauss Z[i]:      N(3+2i)   = 3^2+2^2        = 13 (=Delta_Q)
           Eisenstein Z[w]: N(3+2w)   = 3^2-3*2+2^2    = 7  (hex norm)
           Cyclotomy Q(z5): N(3+2 z5) = 2^4 Phi5(-3/2) = 55 (quark numerator)
           Galois (Z/5)^x:  |Gal Q(z5)| = phi(5)       = 4  (=|mu4|)
           Root lattice:    |det Cartan(E8)|            = 1  (holomorphic)
           Pascal/exterior: C(4,0)+C(4,1)+C(4,2)        = 11; 2^4 = 16 = dim S+
           Coxeter:         h(E8) = 30 = 2*3*5;  phi(30) = 8 = rank E8
         (Whether these MULTIPLY or COMPRESS is settled in v428: compression.)
  [E] 2. SYNTACTIC DISTINCTNESS (NOT independence).  The seven are pairwise
         different syntaxes (two quadratic rings, a degree-4 field, a finite group,
         a root lattice, a binomial/exterior algebra, a Coxeter invariant) -- but by
         v236 they are facets of ONE (2,3,5)/E8 object, so syntactic distinctness is
         NOT statistical independence (corrected in v428).
  [E] 3. COMPRESSION CLASS.  The anchor a=(1,1,2) emits MANY readouts from ONE
         generator: elementary-symmetric (e1,e2,e3)=(4,5,2) (e2=g_car), power sums,
         and the E8 data (240 roots, 248 dim, rank 8) -- a compression GAIN, not
         independent witnesses.  The flavor matrix R likewise (trace, det, minors
         from one R).  v428 shows the seven grammar readouts above belong to THIS
         class too.
  [E] 4. THE HONEST SPLIT.  The framework -- multiplicative witnesses vs.
         compression readouts -- is the right axis; the CLASSIFICATION of the seven
         is corrected by v428 (they compress).  The genuinely multiplicative
         evidence is the input forced several independent ways (v428) + foreign
         witnesses, NOT one undifferentiated "everything multiplies".
  [C] 5. VERDICT.  The multiply-vs-compress framework stands; this module's
         CLASSIFICATION of the seven arithmetic witnesses is refined by v428 (they
         are readings of one (2,3,5)/E8 object = compression).  The auditable map
         still replaces the rhetorical claim and shows coincidence is an expensive
         explanation of the discrete core, but it does NOT by itself establish
         physics (the seam/anchor/transfer bridge problem) -- and the multiplicative
         strength is the multiply-forced inputs + foreign witnesses (v428), not the
         seven readings.

Python-only (sympy/numpy exact arithmetic).
"""
import numpy as np
import sympy as sp

from tfpt_constants import check, summary, reset, g_car

SKELETON = {1, 2, 3, 4, 5, 7, 8, 11, 13, 16, 30, 55, 240, 248}


def cartan_E8():
    return np.array([
        [2, 0, -1, 0, 0, 0, 0, 0], [0, 2, 0, -1, 0, 0, 0, 0],
        [-1, 0, 2, -1, 0, 0, 0, 0], [0, -1, -1, 2, -1, 0, 0, 0],
        [0, 0, 0, -1, 2, -1, 0, 0], [0, 0, 0, 0, -1, 2, -1, 0],
        [0, 0, 0, 0, 0, -1, 2, -1], [0, 0, 0, 0, 0, 0, -1, 2]], dtype=float)


def run():
    reset()
    print("v427 OVERDET.WITNESS.MAP: disjoint-grammar witnesses multiply, "
          "same-generator projections compress")

    a, b = 3, 2
    # ---- 1+2. seven disjoint-grammar witnesses, each from its own grammar ----
    gauss = a**2 + b**2                                          # N(3+2i)=13
    eisen = a**2 - a * b + b**2                                  # N(3+2w)=7
    phi5 = lambda x: x**4 + x**3 + x**2 + x + 1
    cyclo = int(b**4 * phi5(sp.Rational(-a, b)))                 # N(3+2 z5)=55
    galois = int(sp.totient(5))                                  # |(Z/5)^x|=4
    latt = int(round(np.linalg.det(cartan_E8())))               # |det Cartan E8|=1
    pascal = sum(int(sp.binomial(4, kk)) for kk in range(3))    # 11
    spinor = 2**4                                               # 16 = dim S+
    coxeter = 30                                                 # h(E8)
    cox_factor = sorted(sp.factorint(coxeter).keys())           # [2,3,5]
    cox_phi = int(sp.totient(coxeter))                          # 8 = rank E8

    witnesses = {
        "Gauss Z[i] N(3+2i)": gauss,
        "Eisenstein Z[w] N(3+2w)": eisen,
        "Cyclotomy Q(z5) N(3+2 z5)": cyclo,
        "Galois |(Z/5)^x|": galois,
        "Root lattice |det Cartan E8|": latt,
        "Pascal C(4,<=2)": pascal,
        "Coxeter phi(h(E8))": cox_phi,
    }
    landed = all(v in SKELETON for v in witnesses.values())
    values_ok = (gauss == 13 and eisen == 7 and cyclo == 55 and galois == 4
                 and latt == 1 and pascal == 11 and spinor == 16
                 and cox_factor == [2, 3, 5] and cox_phi == 8)
    check("SEVEN GRAMMAR READOUTS [E]: seven distinct syntaxes each reproduce "
          "a carrier-skeleton integer FROM ITS OWN grammar -- N(3+2i)=13, N(3+2w)=7, "
          "N(3+2 z5)=55, |(Z/5)^x|=4, |det Cartan E8|=1, C(4,<=2)=11 (2^4=16), "
          "h(E8)=30=2*3*5 with phi(30)=8=rank E8 -- whether they MULTIPLY or COMPRESS "
          "is settled in v428 (compression: facets of one (2,3,5)/E8 object, v236)",
          landed and values_ok and len(witnesses) == 7)

    grammars = ["quadratic ring Z[i]", "quadratic ring Z[w]", "degree-4 field Q(z5)",
                "finite group (Z/5)^x", "root lattice E8", "exterior/binomial",
                "Coxeter invariant"]
    check("SYNTACTIC DISTINCTNESS [E]: the seven witnesses are pairwise distinct "
          "syntaxes (%d named grammars); but per v236 they are facets of ONE "
          "(2,3,5)/E8 object, so syntactic distinctness is NOT statistical "
          "independence -- the multiply/compress verdict is corrected in v428"
          % len(set(grammars)),
          len(set(grammars)) == 7)

    # ---- 3. compression class: one generator -> many readouts ----
    anchor = [1, 1, 2]
    e1 = sum(anchor)
    e2 = anchor[0] * anchor[1] + anchor[0] * anchor[2] + anchor[1] * anchor[2]
    e3 = anchor[0] * anchor[1] * anchor[2]
    p1 = sum(x for x in anchor)
    p2 = sum(x**2 for x in anchor)
    compression = (e1 == 4 and e2 == 5 and e3 == 2 and p1 == 4 and p2 == 6
                   and e2 == g_car)
    check("COMPRESSION CLASS [E]: the anchor a=(1,1,2) emits MANY readouts from ONE "
          "generator -- elementary-symmetric (e1,e2,e3)=(4,5,2) (e2=g_car=5), power "
          "sums (p1,p2)=(4,6), and the E8 data (240,248,rank 8) -- a compression "
          "gain, NOT independent witnesses (they do not multiply)",
          compression)

    # ---- 4. the honest split ----
    n_independent = len(witnesses)
    check("THE HONEST SPLIT [E]: the AXIS is right (multiplicative witnesses vs. "
          "compression readouts); the CLASSIFICATION of these %d grammar readouts is "
          "corrected by v428 -- they compress one (2,3,5)/E8 object. The genuinely "
          "multiplicative evidence is the input forced several independent ways + "
          "foreign witnesses (v428), not one undifferentiated 'everything multiplies'"
          % n_independent,
          n_independent >= 7 and compression and landed)

    # ---- 5. verdict (typed [C]) ----
    check("VERDICT [C]: the multiply-vs-compress framework stands; this module's "
          "classification of the seven arithmetic witnesses is refined by v428 (they "
          "are readings of one (2,3,5)/E8 object = compression). The map still shows "
          "coincidence is an expensive explanation of the discrete core, but the "
          "multiplicative strength is the multiply-forced inputs + foreign witnesses "
          "(v428), and it does NOT by itself establish physics (the seam/anchor/"
          "transfer bridge problem)",
          values_ok and compression and n_independent >= 7)

    return summary("v427 OVERDET.WITNESS.MAP (seven grammar readouts; classification "
                   "refined by v428 -- they compress one (2,3,5)/E8 object; the "
                   "auditable over-determination map)")


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

cff164ec9b00f99a8d7493d40c0d41f34a255b10277fd4e371c5ed1deb61c35d

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.