#!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""v911 -- SEAM.STATE.WIRING.SELECTOR.01 (the v908-registered contract) + SEAM.STATE.THETA.SELECTOR.01 + SEAM.STATE.WIRING.GAUGE.RP.01: THE WIRING FREEDOM THEOREM -- the seam wiring question of round 60 (CXXXIX: "is the deployed PURE-I wiring compiler-forced?") is CLOSED as a compiler-freedom theorem, ONE module from three probes (30/30 + 26/26 + 21/21 checks, zero fails; verdicts WIRING-DEGENERATE + THETA-CONVENTIONAL + RP-FRAME-COVARIANT; discovery probes seam_wiring_groebner_probe.py (Spec-SHA 251a9a80.., note CCXIII), theta_frame_selector_probe.py (Spec-SHA c042726f.., note CCXV), wiring_gauge_rp_audit_probe.py (Spec-SHA 58a9d445.., note CCXXI), rounds 69-71, 2026-08-12, re-run identically at promotion, embedded BYTE-EXACT and executed verbatim, ~90 s). THE CANONICAL SENTENCE (frozen verbatim in the RP audit, sha256 79950314..): "The exact Groebner census determines a single admissible three-dimensional wiring orbit (the rotation cell C_rot); Z- and X-wirings are excluded by orientation propagation, and this exclusion is rule-gauge-invariant. Pure-I and pure-J are connected by an integer rule-gauge element and lie on one orbit: pure-I is a deployment representative, not a compiler theorem. Strict collar reflection positivity is covariant under the rule gauge and depends only on the relative angle delta between collar frame and wiring: strict Hermiticity in the theta_S frame would select pure-J; the same demand in the integer-conjugated frame selects pure-I. A canonical wiring selection requires an additionally derived physical frame." FORBIDDEN (equally frozen): "pure-I is compiler-forced"; "the compiler derives the pure-I wiring"; "strict collar RP excludes the J-wiring" (without the frame qualifier). (1) THE GROEBNER CENSUS (seam_wiring_groebner, 30/30, WIRING-DEGENERATE): the C6-equivariant commutant of the 10x6 coupling space is EXACTLY {2 channel orbits} x {3 boundary seats} x M2(R) = 24-dim (the boundary C6 action is the IDENTITY, O_B = I6); the IOTA seat-stack rule subspace W is 8-dim and contains the deployed PURE-I point (-1,0,0,0|-1,0,0,0); the constraint classes E1 (unit law {ab+cd, ad-bc}), E2 (CAR/KMS, 16/16 exact leading minors at the frozen (1/2, 1/2, 1/20) parent), E3 (Pfaffian pencil, 3 cross quadrics, anchored by the SYMBOLIC Schur identity A_eff = kappa A_CC + (m/(1-m^2)) t^2 V J3 V^T on all of W; within-orbit automatic via u J2 u^T = det(u) J2), E4 (orientation propagation det u > 0) and E5 (covariance + seat stack) are ALL warded exactly at the deployed point (census 10/10, J coordinate exactly +1/200; S_I = 3J = S_J -- the pencil does not distinguish I from J at all); the Groebner basis (7 quadrics, grevlex, 21 elements) decomposes the real variety CERTIFIED into C_rot = V(b2, d2, b3, d3, a2 c3 - c2 a3) and C_refl = V(a2, c2, a3, c3, b2 d3 - d2 b3) (each dim 3; cofactor certificates; mixed branches have no nondegenerate real points; the complex residue is real-point-free); THE CENSUS: exactly ONE admissible component mod rule gauge (C_rot, witnesses pure-I, pure-J and the INTERIOR rational point (3/5, 4/5)); pure-I is an INTERIOR POINT, not a vertex, and the INTEGER gauge g_int = (+)_5 J2 (+) I6 (preserving A_CC, C6, W and the ideal) maps pure-I onto the pure-J ray -- I and J are rule-gauge-equivalent; C_refl (contains V_Z, census 10/10, -1/200) falls at EXACTLY ONE class: orientation (det u = -(b^2 + d^2) < 0 identically) -- Z/X are edge-illegal; SELECTOR THEOREM: the strict-collar two-seat law (rank 12 / kernel 12 reproduced exactly) cuts C_rot EXACTLY in the pure-(+-J) ray -- rules + collar Hermiticity would force PURE-J uniquely (up to flips/scale), and pure-I sits at the MAXIMALLY obstructed angle (defect 2t, the round-60 regression); the secondary relaxation without the IOTA seat rule stays degenerate (one signature-(6,6) quadric, SOS identity). (2) THE COLLAR-FRAME DECISION (theta_frame_selector, 26/26, THETA-CONVENTIONAL): NO compiler-side demand distinguishes the theta_S sheet-swap frame inside the 9-dim rule-gauge algebra -- the frame orbit tangent is 7 of 9 (isotropy 2), the torus generators K_C = (+)_5 J2 and K_B = (+)_3 J2 lie exactly in the stabilizer and move theta_S (the reflection circle cos(2 gamma) X + sin(2 gamma) Z per pair is rule-gauge reachable); the DEMAND CENSUS over five exact demand classes: D1 mu4/C6 COMPATIBLE-NOT-FORCING (family-defining, cuts nothing inside), D2 CAR/state SILENT (A0 = tanh(beta u/2) A16 exactly torus-invariant; coupled h(V) excluded by anti-circularity -- theta h(V) theta = -h(V) IS the relative-angle selector, not a frame demand), D3 pencil/orientation SILENT (no frame variable; det u' = det u exact), D4 doily/edge combinatorics COMPATIBLE-NOT-FORCING (refined stabilizer 9 OF 9 -- the bit level lives on channel labels, never the within-pair basis), D5 the round-59 census property SILENT-ON-ANGLE (bare-point strict RP spectra IDENTICAL on all four frames, closed forms lam_min 1p = tanh(1/2), deg-2 = tanh^2(1/2); the angle of theta_S is v440 LINEAGE, i.e. deployment); THE CLOSURE: the deployed parent (pure-I) PASSES strict collar RP EXACTLY in the integer frame theta' = g_int theta_S g_int^T (Grams exactly Hermitian, PD by exact LDL, float lam_min 0.3064/0.1532 = the round-60 V_J numbers transported) and fails at theta_S with raw defect 0.1 = 2t -- the round-58/59 strict-collar obstruction is FRAME-RELATIVE; equivariant selection map exact: frame (gamma, y) selects the ray (a_o, c_o) = lambda_o (-sin delta, cos delta), delta = y - gamma. (3) THE GAUGE-COVARIANCE AUDIT (wiring_gauge_rp_audit, 21/21, RP-FRAME-COVARIANT; ordered by the program lead): CONJUGATION EXACT both directions (theta' = g_int theta_S g_int^{-1} AND theta_S = g_int theta' g_int^{-1}; g_int^2 lies in the isotropy of theta_S); the generic rule element acts as a delta-circle rotation (symbolic angle addition); THE KERNEL-COVARIANCE LAW symbolic on the full torus with generic wiring: g^T g = I16 and g^T A(V) g = A(g_C^T V g_B) IDENTICALLY, hence Gram(g theta g^T, gF, A(V)) = Gram(theta, F, A(V')) ENTRYWISE -- strict-collar RP is a function of the RELATIVE datum (frame, wiring) mod gauge only; exact Gram covariance at the witnesses (sympy expand == 0, 1p + deg-2); the witness table: (theta_S, pure-J), (theta', pure-I), (theta_r, (4/5, 3/5)) pass strict collar RP EXACTLY, the SAME pure-I fails at theta_S (defect 0.1) and the SAME pure-J fails at theta' (0.1, the mirror witness) -- the lead's OPTION (2) holds: the RP exclusion of pure-I is a statement AT THE FIXED FRAME theta_S, not a gauge-invariant wiring no-go; the Z/X exclusion IS genuinely orbit-invariant (det u = a^2 + c^2 - b^2 - d^2 frame-transport-invariant, C_refl has det <= 0 identically; the only orthogonal element that would flip det u flips the vacuum and leaves the rule gauge). STATUS: closes the v908-registered contract SEAM.STATE.WIRING.SELECTOR.01 -- the answer is DEPLOYMENT-CHOICE, not compiler theorem; the CXXXIX question is closed as a compiler-freedom theorem (freedom group = the rule-gauge frame orbit, selection quotient = the delta-circle, the only gauge-invariant datum of (frame, wiring) is the relative angle). The census covers the FIVE enumerated demand classes; a compiler demand OUTSIDE the list is not excluded; whether the actual seam physics derives a specific collar frame remains outside the formalized rules; the v898/v903 [O] premise stays [O]. Zero RH content. No marker moves beyond this measured closure. PROVENANCE: discovery probes re-run identically at promotion (30/30 in 1.3 s, 26/26 in 14.4 s, 21/21 in 69.6 s on 2026-08-12); ROUND-31 EMBEDDING CONVENTION: frozen sources embedded BYTE-EXACT, executed verbatim in isolated namespaces; printed Spec SHAs 251a9a80.. / c042726f.. / 58a9d445.. reproduce; byte-equality ward vs experiments/tfpt-discovery/ inside the pattern gates. FIREWALL: exact integer/rational sympy census; float64 only in disclosed wards; RNG only in the declared scramble controls; no zeros, no prime oracles (AST firewalls inside the probes). Python-only per GATE.WOLFRAM.02. """ import contextlib import io import os import re import sys import time import types _HERE = os.path.dirname(os.path.abspath(__file__)) if _HERE not in sys.path: sys.path.insert(0, _HERE) # ------------- frozen probe source seam_wiring_groebner_probe (embedded BYTE-EXACT, raw string) _SRC_0 = r''' #!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""seam_wiring_groebner_probe -- SEAM.STATE.WIRING.GROEBNER.01 (EXPLORATION ONLY, experiments/; 2026-08-12 -- the finite algebraic census of the seam wiring question named at the end of round 60, entry CXXXIX: is the deployed PURE-I wiring compiler-FORCED by the orbit/edge rules of the vacuum-orbit construction of A_int, or is a {J, Z}-kernel alternative compiler-legal at equal C6-covariance and equal Pf-pencil? Only then is it decidable whether the strict-collar obstruction of round 58/59 is a compiler THEOREM or a DEPLOYMENT CHOICE.) THE QUESTION (the CXXXIX contract, verbatim scope). Round 60 (seam_ness_parent_probe, SEAM.CFIN.NESS.PARENT.01) measured: the C6-covariant C<->B coupling space has dimension 24; the strict theta_S Hermiticity law has rank 12 with kernel 12 = the {J, Z} sub-block coordinates; the DEPLOYED coupling V = A_int[C, B] is PURE-I (every 2x2 sub-block exactly -I2), a maximally obstructed direction; and the kernel contains zero-entropy-production equilibrium mixing witnesses V_J and V_Z. What was NOT measured: whether the compiler's own orbit/edge rules (one unit per edge orbit, IOTA/I2/J2 units, orientation propagation) PIN the I direction. This probe closes that question as a finite exact computation: parametrize the full equivariant commutant, impose the constraint classes as polynomial equations/inequalities, compute the Groebner basis and a certified decomposition of the real variety, quotient by the structure-preserving gauge, and COUNT the admissible components. FEASIBILITY / REDUNDANCY CHECK (against the corpus, 2026-08-12): round 60 scanned rays and mixtures INSIDE the 24-dim space but never decomposed the constraint variety; probe 7 (rp_parent_dilation) scanned only the deployed direction family; NOTHING in the corpus (a) writes the edge rules as polynomial constraint classes, (b) computes the ideal decomposition, or (c) identifies the gauge group of the wiring space. That is exactly this probe. SMOKE-RUN DISCLOSURE (2026-08-12, declared smoke rounds before freezing; fail-first preserved): (i) the boundary block of the C6 action is the IDENTITY (PI6 fixes channel 0 position-wise), so the equivariant commutant of the coupling space is exactly {2 channel orbits} x {3 boundary seats} x M2(R) = 24 dims (the v898 T-count reproduced structurally); (ii) the per-orbit unit-law ideal (u^T u prop. I) has the exact closed form {ab + cd = 0, ad - bc = 0} whose REAL variety splits into the rotation plane {b = d = 0} and the reflection plane {a = c = 0} (cofactor certificates below); complex residual components are real-point-free; (iii) the Pfaffian-pencil cross-block condition reduces on the rotation x rotation branch to the single determinantal quadric a2*c3 - c2*a3 = 0 (alignment) with pX = pZ = 0 IDENTICALLY, and on mixed rotation x reflection branches it forces the reflection factor to ZERO (degenerate) by exact cofactor identities: mixed wirings are pencil-illegal; (iv) within-orbit pencil blocks are AUTOMATIC: the identity u J2 u^T = det(u) J2 holds for every real 2x2 u, so only cross-orbit blocks constrain; (v) the working hypothesis 'the rules pin the I direction' is REFUTED in the strongest form: the admissible set contains an exact integer gauge transformation g = (+)_5 J2 (+) I6 (preserving A_CC, J3, the C6 action, the seat-stack rule subspace and the constraint ideal) that maps the deployed PURE-I wiring to the PURE-(-J) wiring -- pure-I and pure-J are CONNECTED-GAUGE-EQUIVALENT, and a rational interior witness (3/5, 4/5 rotation) passes every constraint class while being neither I nor J; (vi) the theta_S collar frame BREAKS this gauge to a discrete subgroup (an SO(2) block R commutes with the sheet-swap X iff its sine vanishes, exact), so relative to the FROZEN collar the rotation angle is physical: the admissible component is a genuine circle family, pure-I and pure-J are distinct points on ONE component, and the strict-collar two-seat law intersects the component EXACTLY in the pure-(+-J) ray; (vii) smoke corrections (disclosed, all implementation-level, no claim inverted): (1) the Schur-identity and C_BB-inverse wards need rational CANCELLATION (expand alone does not clear the 1/(1-m^2) denominators); (2) the mixed-branch degeneracy certificate is verified as exact GROEBNER MEMBERSHIP of (a2^2+c2^2) b3 and (a2^2+c2^2) d3 in the branch pencil ideal (a hand-signed cofactor draft had a sign slip and was replaced by the reduction-to-zero check); (3) the structure-gauge algebra dimension 16 and rule stabilizer dimension 9 were hand-predicted and measured EQUAL by the exact nullspaces. CONVENTIONS (round-58/59/60 wiring rebuilt inline; READ-ONLY import of tfpt_constants): 16-dim Majorana space, carrier C = 0..9 (channels 1..5, pairs), boundary B = 10..15 (channel 0, three seats); A_CC = (+)_5 J2, J3 = A16_dep[B, B]; deployed wiring V = A_int[C, B]; parent family A(kappa, m, t, V) = [[kappa A_CC, t V], [-t V^T, m J3]] at the frozen probe-7 point (kappa, m, t) = (1/2, 1/2, 1/20). AMBIENT ALGEBRA: the equivariant commutant Comm = {V in R^{10x6} : O_C V O_B^T = V}; coordinates u_{o} = a_o I + b_o X + c_o J + d_o Z per orbit o in {2-cycle, 3-cycle} after the seat-stack rule (below), 8 rational variables (a2, b2, c2, d2, a3, b3, c3, d3). CONSTRAINT CLASSES (each warded on PURE-I -- the primary consistency ward): E1 CAR / unit edge law: each orbit unit is a scaled isometry of the Majorana pairing, u^T u = mu I (the deployed constructor units I2, J2, IOTA are exact isometries); polynomial closed form {a b + c d, a d - b c} per orbit; E2 KMS: the parent at the frozen point is CAR-strict (||A|| < 1, exact PD of I + A^2 by leading principal minors) hence by the round-59 artanh theorem a beta = 1 KMS state of a covariant Hamiltonian (float round-trip ward); an OPEN scale bound -- it does not cut components (typed); E3 Pfaffian pencil (quasi-free consistency): the Schur compression A_eff = kappa A_CC + (m/(1-m^2)) t^2 V J3 V^T (symbolic identity proven on the rule subspace) carries every carrier duad block proportional to J2 with nonzero canonical Pf4 (cross-orbit blocks give 3 quadrics; within-orbit blocks are automatic by u J2 u^T = det(u) J2); E4 orientation propagation: det u_o > 0 (every deployed constructor unit is orientation-preserving; a det < 0 unit reverses the pair orientation of A16_dep at the target; semialgebraic, selects real positive components); E5 orbit/edge rules: C6-covariance (built into the commutant) + the IOTA seat-stack rule (one unit per boundary edge orbit: u_{o, s} independent of the seat s -- the 8-dim rule subspace W of the 24-dim commutant). NONDEGENERACY (census side condition): all 10 carrier duad blocks of A_eff nonzero with canonical Pf4 sign. NUMERICAL PROTOCOL (declared): commutant, gauge algebra, Groebner basis, certificates, witnesses, CAR minors, census are EXACT (integer/rational sympy); float64 ONLY in disclosed wards (Gram closed-form ward, artanh round-trip, smax reporting); RNG only in controls. FROZEN CLAIMS (2026-08-12, frozen + SHA-hashed before the frozen run): P1 THE AMBIENT ALGEBRA AND ITS GAUGE (exact). (a) the C6 action restricted to the boundary block is the IDENTITY (O_B = I6, integer check), and the equivariant commutant of the 10x6 coupling space has dimension EXACTLY 24 (exact nullspace of the orbit-sum projector); (b) the seat-stack rule subspace W (IOTA rule: one 2x2 unit per orbit stacked over 3 seats) has dimension EXACTLY 8 and contains the deployed wiring: V_dep = A_int[C, B] is PURE-I, every 2x2 sub-block exactly -I2 (integer); (c) the structure gauge algebra g0 = {X in o(16) block-diag: [X, O16] = 0, [X_C, A_CC] = 0, [X_B, J3] = 0} has dimension EXACTLY 16 (exact nullspace; carrier commutant 7 + boundary u(3) = 9); (d) the rule stabilizer (elements of g0 preserving W and mapping the constraint ideal into itself, exact Groebner-remainder linear system) has dimension EXACTLY 9 and acts on the coordinates through the rank-2 torus {u_o -> gamma J2 u_o - y u_o J2} (equal gamma on both orbits: the relative carrier rotation is CUT by the pencil, remainder nonzero) plus a trivially-acting kernel; the theta_S sheet-swap frame breaks the torus to a DISCRETE subgroup: R(p, q) X = X R(p, q) forces q = 0 EXACTLY (symbolic 2x2). P2 CONSTRAINT CLASSES AND THE DEPLOYED-WIRING WARD (exact). (a) E1 closed form warded: u^T u - mu I = 0 iff {a b + c d = 0, a d - b c = 0} (symbolic expansion); PURE-I satisfies both at ZERO exactly; (b) E3 anchored: the symbolic Schur identity A_eff = kappa A_CC + (m/(1-m^2)) t^2 V J3 V^T holds on ALL of W (8 symbolic coordinates x symbolic kappa, m, t), the within-orbit identity u J2 u^T = det(u) J2 holds identically, and the closed-form two-seat linear law of round 60 (deg-2 seat = trace coordinate 2a_o, 1p seat = X coordinate 2b_o) is REPRODUCED by the float Gram machinery on unit couplings (ward <= 1e-12) with exact rank 12 / kernel 12 on the 24-dim commutant; (c) PURE-I passes EVERY constraint class exactly: E1 (0, 0), E3 cross quadrics (0, 0, 0) with S_I = 3 J on all 25 channel blocks (integer identity, equal to S_J), E4 (det = +1), E5 (in W), E2 (I + A^2 exactly PD at the frozen point, 16/16 leading minors positive; artanh round-trip <= 1e-9) and the canonical census 10/10 with J-coordinate EXACTLY +1/200 -- the deployed wiring ward; (d) the strict-collar two-seat law is NOT in the constraint list (pure-I fails it, defect 2t: round-60 regression reproduced float-exactly) -- it enters only as the SELECTOR in P4(d). P3 THE GROEBNER DECOMPOSITION (exact; term order documented). (a) the rule ideal I_rule = (E1_2, E1_3, E3_cross) c Q[a2..d3] (7 generators, all quadrics) in grevlex order with a2 > b2 > c2 > d2 > a3 > b3 > c3 > d3; (b) certified cofactor identities (symbolic expansion == 0): a (b^2 + d^2) = b g1 + d g2, c (b^2 + d^2) = d g1 - b g2, b (a^2 + c^2) = a g1 - c g2, d (a^2 + c^2) = c g1 + a g2 per orbit, so every REAL point of the unit ideal lies in the rotation plane or the reflection plane; on the mixed rotation x reflection branch the pencil forces (a2^2 + c2^2) b3 = 0 = (a2^2 + c2^2) d3 (exact Groebner membership in the branch ideal), i.e. nondegenerate real mixed points DO NOT EXIST; (c) the certified real decomposition of V(I_rule) into irreducible real components away from the degenerate locus {u2 = 0} u {u3 = 0}: C_rot = V(b2, d2, b3, d3, a2 c3 - c2 a3) (dim 3), C_refl = V(a2, c2, a3, c3, b2 d3 - d2 b3) (dim 3), each containing I_rule (generator-wise Groebner reduction to 0) with exact rational parametrization certificates (u3 = lambda u2 on nondegenerate points); complex residual components are real-point-free (sum-of-squares certificates). P4 THE CENSUS (the verdict; every component certified by an exact witness point). (a) admissible components (E1-E5 + nondegeneracy) modulo the rule gauge: EXACTLY ONE -- C_rot (witnesses: pure-I at (-1,0,0,0|-1,0,0,0), pure-J at (0,0,1,0|0,0,1,0), and the INTERIOR rational point (3/5,0,4/5,0|3/5,0,4/5,0), all passing E1-E5 + census 10/10 exactly, CAR-strict by exact minors); C_refl passes E1, E3, E5 and nondegeneracy (witness V_Z at (0,0,0,1|0,0,0,1), canonical census 10/10, J-coordinate -1/200 exact) but FAILS E4 (det u = -(b^2 + d^2) < 0 on every nondegenerate real point, exact identity): orientation propagation is PRECISELY the edge rule that outlaws the Z/X wirings; (b) pure-I is NOT a vertex, NOT isolated, NOT forced: it is an interior point of the 3-dim cell C_rot, and the integer gauge element g = (+)_5 J2 (+) I6 (preserving A_CC, J3, C6, W and I_rule -- all checked exactly) maps it to pure-(-J): I and J are gauge-equivalent under the rules; (c) in the FROZEN theta_S collar frame (gauge broken to the discrete stabilizer, P1.d) the component C_rot is a physical circle x scale family: pure-I (angle pi) and pure-J (angle -pi/2) are DISTINCT admissible wirings -- the J coupling of round 60 (the zero-entropy-production mixing carrier) is COMPILER-LEGAL; (d) THE SELECTOR THEOREM (exact): on C_rot the strict-collar two-seat law (a2 = a3 = 0, b already 0) cuts EXACTLY the pure-(+-J) ray {u_o = c_o J2, c_2 c_3 != 0} -- i.e. orbit/edge rules + strict-collar Hermiticity FORCE PURE-J uniquely (up to gauge flips and scale), and pure-I sits at the MAXIMALLY obstructed angle; the round-58/59 strict-collar obstruction of the deployed wiring is a DEPLOYMENT CHOICE, not a compiler theorem. P5 SECONDARY RELAXATION (seat-nonuniform, 24 variables; typed, verdict-unchanged): dropping the IOTA seat-stack rule keeps the within-orbit blocks automatic (Sum_s det u_{o,s} J2, exact identity), orientation still forces all-rotation blocks, and the cross-pencil reduces to ONE quadric Sum_s (a2s c3s - c2s a3s) = 0 of exact signature (6, 6) (sum-of-squares identity), an indefinite connected quadric: the relaxed census stays degenerate -- removing a rule cannot create forcing (monotonicity, typed). C CONTROLS (must fire; frozen fire rules; RNG only in C1). C1 SEEDED SCRAMBLE (rng 906, 3 draws: random row permutation of the pure-I wiring): breaks exact C6-covariance (commutant membership) on 3/3; C2 X-WIRING (0,1,0,0|0,1,0,0): E4 fires (det = -1) AND the two-seat 1p seat fires (b != 0; raw float defect 2t at the frozen parent, round-60 regression); C3 Z-WIRING near miss: passes E1, E3, E5, census 10/10, two-seat law CLEAN -- but E4 fires (det = -1): exactly one constraint class rejects it; C4 MIXED J-on-2-cycle / Z-on-3-cycle: the pencil quadric fires (cross block = -3Z, pZ = -3 != 0) and the exact canonical census drops to 4/10 (cross duads all anti-canonical) -- the round-60 P3(b) 4/10 law reproduced EXACTLY at block level; C5 NON-UNIT wiring u = I + X: E1 fires (g1 = 1 != 0); C6 PERTURBED PURE-I (u = -I + Z/10): E1 fires (g2 = -1/10 != 0) -- an illegal perturbation of the deployed point violates at least one constraint. KILLS (any one fires => typed gap): K0 AST firewall / compiler rebuild ward breaks -> PIPELINE-BROKEN K1 commutant / gauge-algebra dimension ward -> COMMUTANT-BROKEN K2 a constraint ward (incl. pure-I ward) breaks -> WARD-BROKEN K3 Groebner / certificate / decomposition ward -> DECOMP-BROKEN K4 census / witness / selector ward breaks -> CENSUS-BROKEN K5 secondary relaxation ward breaks -> RELAX-BROKEN K7 a control does not fire -> CONTROL-DEAD VERDICT (frozen enum): WIRING-DEGENERATE [ADMISSIBLE-CENSUS-1 (C_rot unique admissible component mod gauge), I-NOT-FORCED (interior point, not vertex), I-J-GAUGE-CONNECTED (integer witness (+)_5 J2 (+) I6), J-COMPILER-LEGAL (distinct admissible point in the frozen collar frame), Z-X-EDGE-ILLEGAL (orientation propagation, det < 0), STRICT-COLLAR-SELECTS-PURE-J (selector theorem: rules + collar Hermiticity force the +-J ray uniquely), DEPLOYMENT-CHOICE (the strict-collar obstruction of pure-I is not a compiler theorem)] / WIRING-FORCED / WIRING-UNDECIDED / PIPELINE-BROKEN / COMMUTANT-BROKEN / WARD-BROKEN / DECOMP-BROKEN / CENSUS-BROKEN / RELAX-BROKEN / CONTROL-DEAD. Exit 0 iff all checks pass and no kill fired; else 1. FIREWALL: experiments/ probe; EXPLORATION ONLY -- writes nothing but stdout; no verification/, paper, ledger, changelog or website surface; no .md, no commits. NO physics claim beyond the recorded identities and measurements: the census is a statement about the FORMALIZED constraint classes E1-E5 (each warded on the deployed wiring); whether the actual seam demands the strict theta_S collar (which would select pure-J, P4.d) or the deployed frame is UNTOUCHED here; RP remains sector-typed; the v898/v903 [O] premise is unmoved; no marker moves. NO RH claim. SPEC v1 (2026-08-12): frozen after the declared smoke rounds; no amendments at freeze. Sources (read-only, machinery rebuilt inline): seam_ness_parent_ probe (round 60: two-seat law, 24-dim T-count, witnesses), rp_parent_dilation_probe (probe 7: parent family, Schur census), seam_state_derivation_probe (round 58: theta_S machinery), v898_kms_schur_mixing, v519 (RP Gram), tfpt_constants (N_fam, g_car). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/seam_wiring_groebner_probe.py """ import ast import hashlib import itertools import os import sys import time import numpy as np import sympy as sp _HERE = os.path.dirname(os.path.abspath(__file__)) _VERIFY = os.path.abspath(os.path.join(_HERE, "..", "..", "verification")) sys.path.insert(0, _VERIFY) from tfpt_constants import N_fam, g_car # noqa: E402 (READ-ONLY) BANNED_IDS = ("zetazero", "nzeros", "primerange", "isprime", "primepi", "nextprime", "prevprime") CHECKS = [] KILLS = [] T0 = time.time() SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest() ZTOL = 1e-10 NZ_FLOOR = 1e-8 def check(name, ok, detail="", kill=None): CHECKS.append((name, bool(ok))) if kill and not ok: KILLS.append(kill) print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""), flush=True) return bool(ok) def section(title): print("\n" + "=" * 74) print("%s (t=%.1fs)" % (title, time.time() - T0)) print("=" * 74, flush=True) def ast_scan(banned): src = open(os.path.abspath(__file__), encoding="utf-8").read() bad = [] for node in ast.walk(ast.parse(src)): name = None if isinstance(node, ast.Name): name = node.id elif isinstance(node, ast.Attribute): name = node.attr if name and name.lower() in banned: bad.append(name) return bad # ---------------------------------------------------------- bit model def pc(v): return bin(v).count("1") HT = [[(pc(v) * pc(w) - pc(v & w)) % 2 for w in range(16)] for v in range(16)] A_BIT = 0b1000 FSIG = 0b0111 LOWIDX = {1: 0, 2: 1, 4: 2, 8: 3} def sig(v): b = [(v >> i) & 1 for i in range(4)] n = (b[2], b[0], b[1], b[3]) return sum(bit << i for i, bit in enumerate(n)) SIGP = tuple(sig(v) for v in range(16)) def polar_shift(c): return tuple((pc(v) * (pc(v) - 1) // 2 + pc(c & v)) % 2 for v in range(16)) def iota_bits(v): b = [(v >> i) & 1 for i in range(4)] b.append(sum(b) % 2) return tuple(b) IOTA_MSG = [iota_bits(v) for v in range(16)] def iota_support(v): return frozenset(i + 1 for i, bit in enumerate(IOTA_MSG[v]) if bit) def compose(p, q): return tuple(p[q[i]] for i in range(len(q))) def perm_order(p): o, pp = 1, p ident = tuple(range(len(p))) while pp != ident: pp = tuple(p[x] for x in pp) o += 1 return o def cycle_type(perm): n = len(perm) seen = [False] * n cyc = [] for i in range(n): if seen[i]: continue ln, j = 0, i while not seen[j]: seen[j] = True j = perm[j] ln += 1 cyc.append(ln) return tuple(sorted(cyc)) def edge_orbits(perm): n_ord = perm_order(perm) seen = set() out = [] for i, j in itertools.combinations(range(6), 2): e = frozenset({i, j}) if e in seen: continue x, y = i, j edges = set() rev = False for _k in range(n_ord): edges.add(frozenset({x, y})) x, y = perm[x], perm[y] if (x, y) == (j, i): rev = True seen |= edges out.append((frozenset(edges), rev, (i, j))) return out DUADS_CH = sorted(itertools.combinations(range(6), 2)) CAR_DUADS = sorted(itertools.combinations(range(1, 6), 2)) I2s = sp.eye(2) Xs = sp.Matrix([[0, 1], [1, 0]]) Js = sp.Matrix([[0, 1], [-1, 0]]) Zs = sp.Matrix([[1, 0], [0, -1]]) PAULIS = {"I": I2s, "X": Xs, "J": Js, "Z": Zs} def pauli_coords(M): """Exact (I, X, J, Z) coordinates of a real 2x2 sympy matrix.""" return (sp.expand((M[0, 0] + M[1, 1]) / 2), sp.expand((M[0, 1] + M[1, 0]) / 2), sp.expand((M[0, 1] - M[1, 0]) / 2), sp.expand((M[0, 0] - M[1, 1]) / 2)) def main(): print("SEAM.STATE.WIRING.GROEBNER.01 -- the seam wiring census: " "do the orbit/edge rules force PURE-I?") print("FROZEN_SPEC SHA-256: %s" % SPEC_SHA) print("NO physics claim beyond recorded identities/measurements; " "exploration only.") # ================================================================== section("S0 -- firewall + compiler-side setup (round-60 rebuild)") # ================================================================== bad = ast_scan(BANNED_IDS) check("S0.0 AST firewall: no banned identifiers %s" % (BANNED_IDS,), not bad, kill="K0") refs = [polar_shift(c) for c in range(16)] ok_ref = all( all(q[x ^ y] ^ q[x] ^ q[y] == HT[x][y] for x in range(16) for y in range(16)) for q in refs) arf1 = sorted(q for q in refs if q.count(0) == 6) siginv = [q for q in refs if all(q[SIGP[v]] == q[v] for v in range(16))] cand = [q for q in siginv if q[A_BIT] == 1 and q[FSIG] == 0] QSTAR = cand[0] if cand else None NZ = list(range(1, 16)) ovoid = [v for v in NZ if QSTAR[v] == 0] def duad(v): return frozenset(i for i, q in enumerate(arf1) if q[v] == 0) dmap = {v: duad(v) for v in NZ} V0 = arf1.index(QSTAR) phi = {} ok_phi = True for o in ovoid: others = dmap[o] - {V0} islot = frozenset(range(1, 6)) - iota_support(o) ok_phi &= (len(others) == 1 and len(islot) == 1) phi[next(iter(others))] = next(iter(islot)) ok_phi &= (len(phi) == 5 and set(phi.values()) == set(range(1, 6))) def lab(j): return 0 if j == V0 else phi[j] SP6 = [] for imgs in itertools.product(range(1, 16), repeat=4): p = [0] * 16 for v in range(1, 16): lb = v & -v p[v] = p[v ^ lb] ^ imgs[LOWIDX[lb]] if len(set(p)) != 16: continue if all(HT[imgs[x]][imgs[y]] == 1 for x in range(4) for y in range(x + 1, 4)): SP6.append(tuple(p)) S5P = list(itertools.permutations(range(5))) AUT = [] for p in SP6: if any(QSTAR[p[v]] != QSTAR[v] for v in range(16)): continue if compose(p, SIGP) != compose(SIGP, p): continue pis = [pi for pi in S5P if all(IOTA_MSG[p[v]] == tuple(IOTA_MSG[v][pi[s]] for s in range(5)) for v in range(16))] if pis: AUT.append(p) g_pin = [p for p in AUT if perm_order(p) == 6 and compose(p, p) == SIGP] check("S0.1 compiler rebuilt: unique q*, |Aut| = %d == 6, " "generator pin unique" % len(AUT), ok_ref and len(cand) == 1 and ok_phi and len(AUT) == 6 and len(g_pin) == 1, kill="K0") GEN = g_pin[0] a1idx = {q: i for i, q in enumerate(arf1)} tau = [a1idx[tuple(q[GEN[v]] for v in range(16))] for q in arf1] pia = [0] * 6 for j in range(6): pia[tau[j]] = j pia = tuple(pia) PI6 = [0] * 6 for j in range(6): PI6[lab(j)] = lab(pia[j]) PI6 = tuple(PI6) cycles = [] seen = set() for i in range(6): if i in seen: continue cyc, j = [], i while j not in seen: seen.add(j) cyc.append(j) j = PI6[j] cycles.append(cyc) TWO = sorted(next(c for c in cycles if len(c) == 2)) THREE = sorted(next(c for c in cycles if len(c) == 3)) a_ch, b_ch = TWO check("S0.2 deployed pi = %s, cycle type %s == (1, 2, 3); " "2-cycle {%d,%d}, 3-cycle %s" % (PI6, cycle_type(PI6), a_ch, b_ch, THREE), PI6[0] == 0 and cycle_type(PI6) == (1, 2, 3), kill="K0") CH = {0: list(range(10, 16))} for i in range(1, 6): CH[i] = [2 * (i - 1), 2 * (i - 1) + 1] CAR_IDX = list(range(10)) BND_IDX = list(range(10, 16)) img = [0] * 16 for i in range(6): for k, s in enumerate(CH[i]): img[s] = CH[PI6[i]][k] J2i = np.array([[0, 1], [-1, 0]], dtype=np.int64) I2i = np.eye(2, dtype=np.int64) IOTA6i = np.vstack([I2i, I2i, I2i]) orbs = edge_orbits(PI6) def put_ordered(A, x, y, B): rx, cy = CH[x], CH[y] for r in range(len(rx)): for c in range(len(cy)): A[rx[r], cy[c]] = B[r, c] A[cy[c], rx[r]] = -B[r, c] A_int = np.zeros((16, 16), dtype=np.int64) for edges, rev, rep in orbs: i, j = rep B = J2i if rev else (IOTA6i if i == 0 else I2i) x, y = i, j for _k in range(perm_order(PI6)): put_ordered(A_int, x, y, B) x, y = PI6[x], PI6[y] A16_dep = np.zeros((16, 16), dtype=np.int64) for i in range(8): A16_dep[2 * i, 2 * i + 1] = 1 A16_dep[2 * i + 1, 2 * i] = -1 okA = (np.array_equal(A_int[np.ix_(img, img)], A_int) and np.array_equal(A_int, -A_int.T)) okD = np.array_equal(A16_dep[np.ix_(img, img)], A16_dep) A_CC = A16_dep[np.ix_(CAR_IDX, CAR_IDX)] J3 = A16_dep[np.ix_(BND_IDX, BND_IDX)] Vdep = A_int[np.ix_(CAR_IDX, BND_IDX)] check("S0.3 blocks extracted: A_CC = (+)_5 J2, J3, deployed " "wiring V_dep = A_int[C, B]", okA and okD, kill="K0") O16 = np.zeros((16, 16), dtype=np.int64) for src in range(16): O16[img[src], src] = 1 O_C = O16[np.ix_(CAR_IDX, CAR_IDX)] O_B = O16[np.ix_(BND_IDX, BND_IDX)] # edge-orbit anatomy of the C<->B part (the vacuum-orbit rules) cb_orbs = [(edges, rev) for edges, rev, rep in orbs if 0 in {min(rep), max(rep)} or any(0 in e for e in edges)] cb_lens = sorted(len(e) for e, _r in cb_orbs) cb_rev = [r for _e, r in cb_orbs] check("S0.4 C<->B edge orbits: lengths %s == [2, 3], reversals " "%s == none (the IOTA edges are never reversed: the " "J2-on-reversal law does not touch the wiring)" % (cb_lens, cb_rev), cb_lens == [2, 3] and not any(cb_rev), kill="K0") # canonical Pf4 signs (round-60 S0.4 convention) CH2 = {i: [2 * i, 2 * i + 1] for i in range(6)} IOTA_f = IOTA6i.astype(np.float64) def compress12(A): Ahat = np.zeros((12, 12)) for (i, j) in DUADS_CH: if i == 0: Bm = IOTA_f.T @ A[np.ix_(CH[0], CH[j])] / 3.0 else: Bm = A[np.ix_(CH[i], CH[j])] for rr in range(2): for cc in range(2): Ahat[CH2[i][rr], CH2[j][cc]] = Bm[rr, cc] Ahat[CH2[j][cc], CH2[i][rr]] = -Bm[rr, cc] return Ahat pf4_c = {} Ahat_c = compress12(A_int.astype(np.float64) / 200.0) for (i, j) in DUADS_CH: Bm = Ahat_c[np.ix_(CH2[i], CH2[j])] pf4_c[frozenset({i, j})] = -(Bm[0, 0] * Bm[1, 1] - Bm[0, 1] * Bm[1, 0]) sign_c = {d: (1 if v > 0 else -1) for d, v in pf4_c.items()} check("S0.5 canonical G_c Pf4 signs rebuilt: 15 nonzero, all " "negative", all(abs(v) > 1e-16 for v in pf4_c.values()) and all(s == -1 for s in sign_c.values()), kill="K0") # ================================================================== section("P1 -- the ambient algebra: commutant, rule subspace, " "gauge") # ================================================================== okOB = np.array_equal(O_B, np.eye(6, dtype=np.int64)) # exact commutant of V -> O_C V O_B^T on the 10x6 space P60 = sp.zeros(60, 60) for r in range(10): for c in range(6): rr = int(np.flatnonzero(O_C[:, r])[0]) cc = int(np.flatnonzero(O_B[:, c])[0]) P60[rr * 6 + cc, r * 6 + c] = 1 comm_basis = (P60 - sp.eye(60)).nullspace() dim_comm = len(comm_basis) check("P1.1 boundary C6 block is the IDENTITY (O_B = I6: %s); " "equivariant commutant dim = %d == 24 (v898 T-count): " "Comm = {2 orbits} x {3 seats} x M2(R)" % (okOB, dim_comm), okOB and dim_comm == 24, kill="K1") # seat-stack rule subspace W and symbolic coordinates a2, b2, c2, d2, a3, b3, c3, d3 = sp.symbols( "a2 b2 c2 d2 a3 b3 c3 d3", real=True) GENS8 = (a2, b2, c2, d2, a3, b3, c3, d3) u2 = a2 * I2s + b2 * Xs + c2 * Js + d2 * Zs u3 = a3 * I2s + b3 * Xs + c3 * Js + d3 * Zs def mkW(u2m, u3m): V = sp.zeros(10, 6) for i in range(1, 6): uo = u2m if i in TWO else u3m for s in range(3): V[2 * (i - 1):2 * i, 2 * s:2 * s + 2] = uo return V V_sym = mkW(u2, u3) def in_commutant(Vm): Vp = sp.zeros(10, 6) for r in range(10): for c in range(6): rr = int(np.flatnonzero(O_C[:, r])[0]) cc = int(np.flatnonzero(O_B[:, c])[0]) Vp[rr, cc] = Vm[r, c] return sp.expand(Vp - Vm) == sp.zeros(10, 6) ok_Wcov = in_commutant(V_sym) Vdep_s = sp.Matrix(Vdep.tolist()) ok_pureI = all( sp.Matrix(Vdep.tolist())[2 * i:2 * i + 2, 2 * s:2 * s + 2] == -I2s for i in range(5) for s in range(3)) subI = {a2: -1, b2: 0, c2: 0, d2: 0, a3: -1, b3: 0, c3: 0, d3: 0} ok_VdepW = sp.expand(V_sym.subs(subI) - Vdep_s) == sp.zeros(10, 6) check("P1.2 rule subspace W (IOTA seat-stack) dim 8 c commutant " "(covariance symbolic: %s); deployed wiring PURE-I (every " "2x2 block -I2: %s) = W point (-1,0,0,0|-1,0,0,0): %s" % (ok_Wcov, ok_pureI, ok_VdepW), ok_Wcov and ok_pureI and ok_VdepW, kill="K1") # structure gauge algebra g0 (exact nullspace over 60 antisym vars) pairsC = list(itertools.combinations(range(10), 2)) pairsB = list(itertools.combinations(range(6), 2)) nv = len(pairsC) + len(pairsB) A_CCs = sp.Matrix(A_CC.tolist()) J3s = sp.Matrix(J3.tolist()) O_Cs = sp.Matrix(O_C.tolist()) def XC_of(vec): X = sp.zeros(10, 10) for k, (i, j) in enumerate(pairsC): X[i, j] = vec[k] X[j, i] = -vec[k] return X def XB_of(vec): X = sp.zeros(6, 6) for k, (i, j) in enumerate(pairsB): X[i, j] = vec[len(pairsC) + k] X[j, i] = -vec[len(pairsC) + k] return X vsyms = sp.symbols("x0:%d" % nv, real=True) XCs = XC_of(vsyms) XBs = XB_of(vsyms) eqs = [] eqs += list(sp.expand(XCs * O_Cs - O_Cs * XCs)) eqs += list(sp.expand(XCs * A_CCs - A_CCs * XCs)) eqs += list(sp.expand(XBs * J3s - J3s * XBs)) Meq = sp.Matrix([[sp.diff(e, v) for v in vsyms] for e in eqs]) g0_basis = Meq.nullspace() dim_g0 = len(g0_basis) check("P1.3 structure gauge algebra g0 = {X in o(16) blockdiag: " "[X,O16]=[X_C,A_CC]=[X_B,J3]=0}: dim = %d == 16 " "(carrier commutant 7 + boundary u(3) 9)" % dim_g0, dim_g0 == 16, kill="K1") # constraint ideal generators (defined here; justified in P2) UT2 = sp.expand(u2.T * u2) UT3 = sp.expand(u3.T * u3) g1_2 = sp.expand(UT2[0, 1]) # closed form 2(ab+cd) g2_2 = sp.expand(UT2[0, 0] - UT2[1, 1]) # closed form 4(ad-bc) g1_3 = sp.expand(UT3[0, 1]) g2_3 = sp.expand(UT3[0, 0] - UT3[1, 1]) Mcross = sp.expand(3 * u2 * Js * u3.T) pI, pX, pJ, pZ = pauli_coords(Mcross) IDEAL_GENS = [g1_2, g2_2, g1_3, g2_3, sp.expand(2 * pI), sp.expand(2 * pX), sp.expand(2 * pZ)] gb = sp.groebner(IDEAL_GENS, *GENS8, order="grevlex") def rem(expr): return gb.reduce(sp.expand(expr))[1] # rule stabilizer: elements of g0 preserving W and the ideal. # Both the W-preservation conditions and the Groebner normal # form are LINEAR in the gauge element, so compute them per # basis element and assemble one exact linear system. rep2, rep3 = TWO[0], THREE[0] per_elem = [] for base in g0_basis: XCk = XC_of(list(base)) XBk = XB_of(list(base)) dV = sp.expand(XCk * V_sym - V_sym * XBk) du2 = dV[2 * (rep2 - 1):2 * rep2, 0:2] du3 = dV[2 * (rep3 - 1):2 * rep3, 0:2] condsW = [] for i in range(1, 6): ref = du2 if i in TWO else du3 for s in range(3): blk = dV[2 * (i - 1):2 * i, 2 * s:2 * s + 2] for e in sp.expand(blk - ref): condsW.append(e) d_coords = {} for sym, val in zip((a2, b2, c2, d2), pauli_coords(du2)): d_coords[sym] = val for sym, val in zip((a3, b3, c3, d3), pauli_coords(du3)): d_coords[sym] = val condsI = [] for f in IDEAL_GENS: df = sp.expand(sum(sp.diff(f, x) * d_coords[x] for x in GENS8)) condsI.append(sp.expand(rem(df))) per_elem.append((condsW, condsI, d_coords)) # collect all monomials appearing across elements per condition n_condW = len(per_elem[0][0]) n_condI = len(per_elem[0][1]) lin_rows = [] for ci in range(n_condW + n_condI): monos = set() polys = [] for condsW, condsI, _dc in per_elem: e = (condsW[ci] if ci < n_condW else condsI[ci - n_condW]) pe = sp.Poly(e, *GENS8) polys.append(pe) monos |= set(pe.monoms()) for mono in monos: lin_rows.append([pe.nth(*mono) for pe in polys]) Mstab = sp.Matrix(lin_rows) stab_basis = Mstab.nullspace() dim_stab = len(stab_basis) # effective action rank of the stabilizer on W coordinates eff_rows = [] for base in stab_basis: row = [] for x in GENS8: dx = sp.expand(sum(base[k] * per_elem[k][2][x] for k in range(dim_g0))) row += [sp.diff(dx, y) for y in GENS8] eff_rows.append(row) rank_eff = sp.Matrix(eff_rows).rank() # the relative carrier rotation (gamma2 != gamma3) must be CUT: # test the g0 element acting as J2 on the 2-cycle channels only vrel = [sp.Integer(0)] * nv for i in TWO: r0 = 2 * (i - 1) vrel[pairsC.index((r0, r0 + 1))] = 1 Xrel = XC_of(vrel) ok_rel_in_g0 = (sp.expand(Xrel * O_Cs - O_Cs * Xrel) == sp.zeros(10, 10)) and \ (sp.expand(Xrel * A_CCs - A_CCs * Xrel) == sp.zeros(10, 10)) dVrel = sp.expand(Xrel * V_sym) du2r = dVrel[2 * (rep2 - 1):2 * rep2, 0:2] du3r = dVrel[2 * (rep3 - 1):2 * rep3, 0:2] dcr = {} for sym, val in zip((a2, b2, c2, d2), pauli_coords(du2r)): dcr[sym] = val for sym, val in zip((a3, b3, c3, d3), pauli_coords(du3r)): dcr[sym] = val rel_rems = [sp.expand(rem(sp.expand( sum(sp.diff(f, x) * dcr[x] for x in GENS8)))) for f in IDEAL_GENS] rel_cut = any(r != 0 for r in rel_rems) check("P1.4 rule stabilizer (preserves W + maps ideal into " "itself): dim = %d, effective action rank on W = %d == 2 " "(the torus u_o -> gamma J2 u_o - y u_o J2); the RELATIVE " "carrier rotation is cut by the pencil (nonzero remainder: " "%s)" % (dim_stab, rank_eff, rel_cut), dim_stab == 9 and rank_eff == 2 and rel_cut, kill="K1") # theta_S frame breaks the torus: R(p,q) X = X R(p,q) => q = 0 p_s, q_s = sp.symbols("p q", real=True) Rpq = sp.Matrix([[p_s, -q_s], [q_s, p_s]]) commX = sp.expand(Rpq * Xs - Xs * Rpq) sol_q = sp.solve([e for e in commX], [q_s], dict=True) ok_theta = all(s.get(q_s, None) == 0 for s in sol_q) and commX != \ sp.zeros(2, 2) check("P1.5 theta_S frame: an SO(2) gauge block commutes with " "the sheet-swap X iff q = 0 EXACTLY (stabilizer discrete: " "{+-I} per block) -- in the frozen collar frame the " "rotation angle is PHYSICAL", ok_theta, kill="K1") # ================================================================== section("P2 -- constraint classes + the deployed-wiring ward") # ================================================================== # E1 closed form ok_E1cf = (sp.expand(g1_2 - 2 * (a2 * b2 + c2 * d2)) == 0 and sp.expand(g2_2 - 4 * (a2 * d2 - b2 * c2)) == 0) ok_offd = sp.expand(UT2[0, 1] - UT2[1, 0]) == 0 check("P2.1 E1 unit law closed form: u^T u prop. I iff " "{a b + c d = 0, a d - b c = 0} (symbolic; Gram symmetric " "off-diag equal: %s)" % ok_offd, ok_E1cf and ok_offd, kill="K2") # E3 anchors: within-orbit identity + symbolic Schur identity on W ok_det_id = sp.expand(u2 * Js * u2.T - u2.det() * Js) \ == sp.zeros(2, 2) kap_s, m_s, t_s = sp.symbols("kappa m t", positive=True) C_BB = (sp.eye(6) + sp.I * m_s * J3s) / 2 C_BB_inv = 2 * (sp.eye(6) - sp.I * m_s * J3s) / (1 - m_s ** 2) ok_inv = all(sp.cancel(e) == 0 for e in (C_BB * C_BB_inv - sp.eye(6))) Wt = t_s * V_sym C_CC = (sp.eye(10) + sp.I * kap_s * A_CCs) / 2 C_eff = sp.expand(C_CC - (sp.I * Wt / 2) * C_BB_inv * (-sp.I * Wt.T / 2)) S_sym = sp.expand(V_sym * J3s * V_sym.T) A_eff_target = sp.expand(kap_s * A_CCs + (m_s / (1 - m_s ** 2)) * t_s ** 2 * S_sym) ok_schur = True for r in range(10): for c in range(10): lhs = sp.im(sp.expand(2 * C_eff[r, c])) if sp.cancel(sp.together(lhs - A_eff_target[r, c])) != 0: ok_schur = False check("P2.2 E3 anchors: u J2 u^T = det(u) J2 identically (%s; " "within-orbit pencil blocks AUTOMATIC); symbolic Schur " "identity A_eff = kappa A_CC + (m/(1-m^2)) t^2 V J3 V^T " "on ALL of W in (kappa, m, t) (%s; C_BB inverse exact: %s)" % (ok_det_id, ok_schur, ok_inv), ok_det_id and ok_schur and ok_inv, kill="K2") # two-seat linear law: closed forms + float Gram ward + rank 12 P_S = [2 * i for i in range(8)] mixed_ee = [(x, y) for x in P_S if x < 10 for y in P_S if y >= 10] def wick_factory(A): W = np.eye(A.shape[0], dtype=complex) + 1j * A memo = {} def wick(idx): idx = tuple(idx) if len(idx) == 0: return 1.0 + 0j if len(idx) % 2 == 1: return 0.0 + 0j if idx in memo: return memo[idx] head, rest = idx[0], idx[1:] tot = 0.0 + 0j for j, bb in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * W[head, bb] * wick(sub) memo[idx] = tot return tot return wick def gram(basis, r, eta, wick): n = len(basis) M = np.zeros((n, n), dtype=complex) for ai, ma in enumerate(basis): imgs_ = [r[a] for a in reversed(ma)] coeff = eta ** len(ma) lst = list(imgs_) sgn = 1 for i in range(len(lst)): for j in range(len(lst) - 1 - i): if lst[j] > lst[j + 1]: lst[j], lst[j + 1] = lst[j + 1], lst[j] sgn = -sgn ca = coeff * sgn ia = tuple(lst) for bi, mb in enumerate(basis): M[ai, bi] = ca * wick(tuple(list(ia) + list(mb))) return M r_S = {} for i in range(8): r_S[2 * i] = 2 * i + 1 r_S[2 * i + 1] = 2 * i B1_S = [(a,) for a in P_S] B2_S = [()] + [tuple(cmb) for cmb in itertools.combinations(P_S, 2)] A_CCf = A_CC.astype(np.float64) J3f = J3.astype(np.float64) def parentV_f(kap, m, tt, V): A = np.zeros((16, 16)) A[np.ix_(CAR_IDX, CAR_IDX)] = kap * A_CCf A[np.ix_(BND_IDX, BND_IDX)] = m * J3f A[np.ix_(CAR_IDX, BND_IDX)] = tt * V A[np.ix_(BND_IDX, CAR_IDX)] = -tt * V.T return A ok_cf = True for (r0, b0) in ((0, 0), (7, 3)): Vu = np.zeros((10, 6)) Vu[r0, b0] = 1.0 A = parentV_f(0.5, 0.5, 1.0, Vu) wk = wick_factory(A) M1 = gram(B1_S, r_S, 1j, wk) M2 = gram(B2_S, r_S, 1j, wk) D1 = M1 - M1.conj().T for xi, x in enumerate(P_S): for yi, y in enumerate(P_S): if x == y: continue pred = -(A[x + 1, y] + A[x, y + 1]) ok_cf &= abs(D1[xi, yi] - pred) <= 1e-12 D2 = M2 - M2.conj().T for mi, mono in enumerate(B2_S): if len(mono) != 2: continue x, y = mono if (x < 10) == (y < 10): continue pred = 1j * (A[x, y] + A[x + 1, y + 1]) ok_cf &= abs(D2[0, mi] - pred) <= 1e-12 # exact rank 12 on the 24-dim commutant rows = [] for wv in comm_basis: Vm = sp.Matrix(10, 6, list(wv)) r2 = [Vm[x, y - 10] + Vm[x + 1, y - 9] for (x, y) in mixed_ee] r1 = [Vm[x + 1, y - 10] + Vm[x, y - 9] for (x, y) in mixed_ee] rows.append([sp.expand(e) for e in (r2 + r1)]) rk24 = sp.Matrix(rows).T.rank() # restricted to W: deg-2 seat = 2 a_o, 1p seat = 2 b_o d2_forms = {sp.expand(V_sym[x, y - 10] + V_sym[x + 1, y - 9]) for (x, y) in mixed_ee} p1_forms = {sp.expand(V_sym[x + 1, y - 10] + V_sym[x, y - 9]) for (x, y) in mixed_ee} ok_seatW = (d2_forms == {2 * a2, 2 * a3} and p1_forms == {2 * b2, 2 * b3}) check("P2.3 two-seat linear law: closed forms warded against the " "float Gram machinery on unit couplings (<= 1e-12: %s); " "exact rank on the 24-dim commutant = %d == 12 (kernel 12 " "= {J, Z}); restricted to W: deg-2 seat = {2 a_o}, 1p seat " "= {2 b_o} (%s) -- NOT a constraint class here (pure-I " "fails it): the SELECTOR of P4" % (ok_cf, rk24, ok_seatW), ok_cf and rk24 == 12 and ok_seatW, kill="K2") # ------- constraint evaluation helpers (exact) kapQ, mQ, tQ = (sp.Rational(1, 2), sp.Rational(1, 2), sp.Rational(1, 20)) lamQ = mQ / (1 - mQ ** 2) def wiring(u2v, u3v): return {a2: u2v[0], b2: u2v[1], c2: u2v[2], d2: u2v[3], a3: u3v[0], b3: u3v[1], c3: u3v[2], d3: u3v[3]} def eval_E1(sub): return [sp.expand(g.subs(sub)) for g in (g1_2, g2_2, g1_3, g2_3)] def eval_pencil(sub): return [sp.expand(g.subs(sub)) for g in (pI, pX, pZ)], \ sp.expand(pJ.subs(sub)) def eval_dets(sub): return (sp.expand(u2.det().subs(sub)), sp.expand(u3.det().subs(sub))) def exact_parent(sub): Vm = V_sym.subs(sub) A_ex = sp.zeros(16, 16) A_ex[0:10, 0:10] = kapQ * A_CCs A_ex[10:16, 10:16] = mQ * J3s A_ex[0:10, 10:16] = tQ * Vm A_ex[10:16, 0:10] = -tQ * Vm.T return A_ex, Vm def car_strict_exact(sub): A_ex, _ = exact_parent(sub) M = sp.eye(16) + A_ex * A_ex minors = [M[:k, :k].det() for k in range(1, 17)] return all(mm > 0 for mm in minors), minors def census_exact(sub): _, Vm = exact_parent(sub) S = Vm * J3s * Vm.T A_eff = kapQ * A_CCs + lamQ * tQ ** 2 * S n_nz, n_sig = 0, 0 Jco45 = None for (i, j) in CAR_DUADS: Bx = A_eff[2 * (i - 1):2 * i, 2 * (j - 1):2 * j] nz = any(e != 0 for e in Bx) n_nz += nz pf = sp.expand(-(Bx[0, 0] * Bx[1, 1] - Bx[0, 1] * Bx[1, 0])) if pf != 0: n_sig += (int(sp.sign(pf)) == sign_c[frozenset({i, j})]) if (i, j) == (a_ch, b_ch): Jco45 = sp.expand((Bx[0, 1] - Bx[1, 0]) / 2) return n_nz, n_sig, Jco45 # the deployed-wiring ward wI = wiring((-1, 0, 0, 0), (-1, 0, 0, 0)) E1_I = eval_E1(wI) (pen_I, gam_I) = eval_pencil(wI) det_I = eval_dets(wI) S_I = sp.expand((V_sym * J3s * V_sym.T).subs(wI)) ok_SI = all(S_I[2 * i:2 * i + 2, 2 * j:2 * j + 2] == 3 * Js for i in range(5) for j in range(5)) carI, minI = car_strict_exact(wI) nzI, sigI, JcoI = census_exact(wI) # artanh round-trip (float ward) + strict-collar regression A_If = parentV_f(0.5, 0.5, 0.05, Vdep.astype(np.float64)) wA, QA = np.linalg.eigh(1j * A_If) smaxI = float(np.max(np.abs(wA))) w_h = -2.0 * np.arctanh(wA) occ = 1.0 / (1.0 + np.exp(w_h)) A_back = (-1j * (2 * (QA * occ) @ QA.conj().T - np.eye(16))).real rtI = float(np.max(np.abs(A_back - A_If))) wkI = wick_factory(A_If) M2I = gram(B2_S, r_S, 1j, wkI) D2I = M2I - M2I.conj().T defI = float(np.max(np.abs(D2I))) nentI = int(np.sum(np.abs(D2I) > 1e-12)) check("P2.4 THE DEPLOYED-WIRING WARD: pure-I passes E1 %s == 0, " "pencil %s == 0 (gamma = %s == 3, S_I = 3J on 25 blocks: " "%s), E4 dets %s > 0, E2 CAR-strict (16/16 exact minors " "> 0: %s; smax %.4f < 1; artanh round-trip %.1e), census " "%d/10 nonzero %d/10 canonical, J-coordinate %s == 1/200" % (E1_I, pen_I, gam_I, ok_SI, det_I, carI, smaxI, rtI, nzI, sigI, JcoI), all(e == 0 for e in E1_I) and all(e == 0 for e in pen_I) and gam_I == 3 and ok_SI and all(d > 0 for d in det_I) and carI and smaxI < 1 and rtI <= 1e-9 and nzI == 10 and sigI == 10 and JcoI == sp.Rational(1, 200), kill="K2") check("P2.5 the strict-collar law is NOT in the constraint list: " "pure-I FAILS it (deg-2 defect %.4f == 2t = 0.1, %d == 30 " "entries; round-60 regression) -- it enters only as the " "P4 selector" % (defI, nentI), abs(defI - 0.1) <= 1e-12 and nentI == 30, kill="K2") # ================================================================== section("P3 -- Groebner basis + certified real decomposition") # ================================================================== print(" ideal: 7 quadric generators in Q[a2,b2,c2,d2," "a3,b3,c3,d3], term order grevlex") print(" Groebner basis size: %d" % len(gb.exprs)) # cofactor certificates for the unit ideal (per orbit) a_, b_, c_, d_ = sp.symbols("a_ b_ c_ d_", real=True) g1g = 2 * (a_ * b_ + c_ * d_) g2g = 4 * (a_ * d_ - b_ * c_) certs = [ sp.expand(2 * a_ * (b_ ** 2 + d_ ** 2) - (b_ * g1g + d_ * g2g / 2)), sp.expand(2 * c_ * (b_ ** 2 + d_ ** 2) - (d_ * g1g - b_ * g2g / 2)), sp.expand(2 * b_ * (a_ ** 2 + c_ ** 2) - (a_ * g1g - c_ * g2g / 2)), sp.expand(2 * d_ * (a_ ** 2 + c_ ** 2) - (c_ * g1g + a_ * g2g / 2)), ] ok_certs = all(e == 0 for e in certs) check("P3.1 unit-ideal cofactor certificates (exact identities): " "2a(b^2+d^2), 2c(b^2+d^2), 2b(a^2+c^2), 2d(a^2+c^2) all in " "(g1, g2) with explicit cofactors => every REAL unit point " "is rotation (b=d=0) or reflection (a=c=0); complex " "residual is real-point-free (sum of squares)", ok_certs, kill="K3") # branch reductions of the pencil rot_sub = {b2: 0, d2: 0, b3: 0, d3: 0} refl_sub = {a2: 0, c2: 0, a3: 0, c3: 0} mix_sub = {b2: 0, d2: 0, a3: 0, c3: 0} pen_rot = [sp.expand(g.subs(rot_sub)) for g in (pI, pX, pZ)] minor_rot = sp.expand(a2 * c3 - c2 * a3) ok_rot = (sp.expand(pen_rot[0] - 3 * minor_rot) == 0 and pen_rot[1] == 0 and pen_rot[2] == 0) pen_refl = [sp.expand(g.subs(refl_sub)) for g in (pI, pX, pZ)] minor_refl = sp.expand(d2 * b3 - b2 * d3) ok_refl = (sp.expand(pen_refl[0] - 3 * minor_refl) == 0 and pen_refl[1] == 0 and pen_refl[2] == 0) pen_mix = [sp.expand(g.subs(mix_sub)) for g in (pI, pX, pZ)] gb_mix = sp.groebner([e for e in pen_mix if e != 0], a2, c2, b3, d3, order="grevlex") ok_mix_cert = (pen_mix[0] == 0 and gb_mix.reduce( sp.expand((a2 ** 2 + c2 ** 2) * b3))[1] == 0 and gb_mix.reduce( sp.expand((a2 ** 2 + c2 ** 2) * d3))[1] == 0) check("P3.2 branch reductions: rot x rot pencil = single " "determinantal quadric 3(a2 c3 - c2 a3) with pX = pZ = 0 " "(%s); refl x refl analog (%s); MIXED rot x refl: exact " "Groebner membership (a2^2+c2^2) b3, (a2^2+c2^2) d3 in " "the pencil ideal (%s) => nondegenerate real mixed points " "do NOT exist" % (ok_rot, ok_refl, ok_mix_cert), ok_rot and ok_refl and ok_mix_cert, kill="K3") # component containment: I_rule c P_rot and I_rule c P_refl gb_rot = sp.groebner([b2, d2, b3, d3, minor_rot], *GENS8, order="grevlex") gb_refl = sp.groebner([a2, c2, a3, c3, minor_refl], *GENS8, order="grevlex") ok_cont = (all(gb_rot.reduce(g)[1] == 0 for g in IDEAL_GENS) and all(gb_refl.reduce(g)[1] == 0 for g in IDEAL_GENS)) # rational parametrization certificate on C_rot: # (a2^2+c2^2) a3 - (a2 a3 + c2 c3) a2 = -c2 * minor etc. par1 = sp.expand((a2 ** 2 + c2 ** 2) * a3 - (a2 * a3 + c2 * c3) * a2 + c2 * minor_rot) par2 = sp.expand((a2 ** 2 + c2 ** 2) * c3 - (a2 * a3 + c2 * c3) * c2 - a2 * minor_rot) ok_par = (par1 == 0 and par2 == 0) check("P3.3 certified real decomposition away from the " "degenerate locus: V(I_rule)_R = C_rot u C_refl, " "C_rot = V(b2,d2,b3,d3, a2 c3 - c2 a3) dim 3, C_refl = " "V(a2,c2,a3,c3, b2 d3 - d2 b3) dim 3; generator-wise " "containment I_rule c P (%s); rational parametrization " "u3 = lambda u2 certified (%s)" % (ok_cont, ok_par), ok_cont and ok_par, kill="K3") # ================================================================== section("P4 -- THE CENSUS: gauge quotient + admissible components") # ================================================================== # E4 on C_refl: det u = -(b^2+d^2) < 0 identically detu_refl = sp.expand(u2.det().subs({a2: 0, c2: 0})) ok_reflneg = sp.expand(detu_refl + b2 ** 2 + d2 ** 2) == 0 # witness table: point -> (E1, pencil, dets, CAR, census) WITS = { "pure-I": ((-1, 0, 0, 0), (-1, 0, 0, 0)), "pure-J": ((0, 0, 1, 0), (0, 0, 1, 0)), "interior (3/5,4/5)": ( (sp.Rational(3, 5), 0, sp.Rational(4, 5), 0), (sp.Rational(3, 5), 0, sp.Rational(4, 5), 0)), "V_Z (refl)": ((0, 0, 0, 1), (0, 0, 0, 1)), } res = {} for nm, (uu2, uu3) in WITS.items(): sub = wiring(uu2, uu3) E1v = eval_E1(sub) (penv, gamv) = eval_pencil(sub) detv = eval_dets(sub) carv, _ = car_strict_exact(sub) nz, sg, jco = census_exact(sub) res[nm] = dict(E1=E1v, pen=penv, gam=gamv, det=detv, car=carv, nz=nz, sig=sg, jco=jco) print(" %-20s E1=%s pencil=%s gamma=%s det=%s CAR=%s " "census=%d/%d Jco=%s" % (nm, E1v, penv, gamv, detv, carv, nz, sg, jco)) okI = res["pure-I"] okJ = res["pure-J"] okP = res["interior (3/5,4/5)"] okZ = res["V_Z (refl)"] def admissible(r): return (all(e == 0 for e in r["E1"]) and all(e == 0 for e in r["pen"]) and all(d > 0 for d in r["det"]) and r["car"] and r["nz"] == 10 and r["sig"] == 10) check("P4.1 C_rot is ADMISSIBLE with three exact witnesses " "(pure-I, pure-J, interior rational rotation): all pass " "E1-E5 + nondegenerate canonical census 10/10 (%s, %s, %s);" " interior J-coordinate %s (nonzero, canonical)" % (admissible(okI), admissible(okJ), admissible(okP), okP["jco"]), admissible(okI) and admissible(okJ) and admissible(okP), kill="K4") check("P4.2 C_refl passes E1 + pencil + census (V_Z witness: " "census %d/10, J-coordinate %s == -1/200) but FAILS " "orientation E4 IDENTICALLY: det u = -(b^2+d^2) < 0 on " "every nondegenerate real point (%s); dets at V_Z: %s -- " "orientation propagation is the edge rule that outlaws " "Z/X wirings" % (okZ["nz"], okZ["jco"], ok_reflneg, okZ["det"]), okZ["nz"] == 10 and okZ["sig"] == 10 and okZ["jco"] == sp.Rational(-1, 200) and ok_reflneg and all(d < 0 for d in okZ["det"]), kill="K4") # the integer gauge witness g = (+)_5 J2 (+) I6 gC = sp.zeros(10, 10) for i in range(5): gC[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Js okg1 = sp.expand(gC * A_CCs * gC.T - A_CCs) == sp.zeros(10, 10) okg2 = sp.expand(gC * O_Cs - O_Cs * gC) == sp.zeros(10, 10) Vg = sp.expand(gC * V_sym.subs(wI)) wmJ = wiring((0, 0, -1, 0), (0, 0, -1, 0)) okg3 = sp.expand(Vg - V_sym.subs(wmJ)) == sp.zeros(10, 6) # ideal stability of the substitution (a,b,c,d)->(-c,-d,a,b) gsub = {a2: -c2, b2: -d2, c2: a2, d2: b2, a3: -c3, b3: -d3, c3: a3, d3: b3} okg4 = all(rem(g.subs(gsub, simultaneous=True)) == 0 for g in IDEAL_GENS) check("P4.3 I-J GAUGE CONNECTION: the INTEGER gauge g = " "(+)_5 J2 (+) I6 preserves A_CC (%s), commutes with the " "C6 action (%s), maps the ideal into itself (%s) and " "sends PURE-I to PURE-(-J) (%s): under the rule gauge the " "deployed wiring and the J wiring are THE SAME point" % (okg1, okg2, okg4, okg3), okg1 and okg2 and okg3 and okg4, kill="K4") # the selector theorem on C_rot tsA = [sp.expand(2 * a2), sp.expand(2 * a3)] # deg-2 seat on rot tsB = [sp.expand(2 * b2).subs(rot_sub), sp.expand(2 * b3).subs(rot_sub)] # 1p seat: 0 on rot sel = sp.solve([a2, a3, minor_rot.subs({a2: 0, a3: 0})], [a2, a3], dict=True) ok_sel = (sel == [{a2: 0, a3: 0}] and all(e == 0 for e in tsB)) # pure-I maximal obstruction on the unit circle: |a| = 1 check("P4.4 THE SELECTOR THEOREM: on C_rot the strict-collar " "two-seat law reads {2 a2 = 0, 2 a3 = 0} (1p seat " "identically clean: %s) and cuts EXACTLY the pure-(+-J) " "ray {u_o = c_o J2, c_o != 0}: orbit/edge rules + " "strict-collar Hermiticity FORCE PURE-J uniquely (up to " "flips and scale); pure-I sits at |a_o| = 1, the " "MAXIMALLY obstructed angle (deg-2 defect 2t, P2.5)" % (tsB,), ok_sel, kill="K4") print("\n THE CENSUS (real positive components of the " "constraint variety, mod rule gauge):") print(" admissible: 1 (C_rot; contains " "pure-I, pure-J, continuum)") print(" orientation-rejected: 1 (C_refl; contains " "V_Z, V_X)") print(" pencil/nondeg-killed: mixed rot x refl branches " "(exact cofactors)") print(" frozen theta_S frame: C_rot = circle x scales; " "I and J DISTINCT admissible points;") print(" strict-collar law " "intersects C_rot exactly at pure-(+-J)") # ================================================================== section("P5 -- secondary relaxation: drop the IOTA seat-stack " "rule (24 vars)") # ================================================================== zs = {} for o in (2, 3): for s in range(3): zs[(o, s)] = sp.symbols( "A%d%d B%d%d C%d%d D%d%d" % ((o, s) * 4), real=True) def ublk(o, s): A_, B_, C_, D_ = zs[(o, s)] return A_ * I2s + B_ * Xs + C_ * Js + D_ * Zs Moo = sp.expand(sum((ublk(2, s) * Js * ublk(2, s).T for s in range(3)), sp.zeros(2, 2))) det_sum = sp.expand(sum(ublk(2, s).det() for s in range(3))) ok_oo = sp.expand(Moo - det_sum * Js) == sp.zeros(2, 2) Mcr = sp.expand(sum((ublk(2, s) * Js * ublk(3, s).T for s in range(3)), sp.zeros(2, 2))) qI, qX, qJ, qZ = pauli_coords(Mcr) rot24 = {} for o in (2, 3): for s in range(3): rot24[zs[(o, s)][1]] = 0 rot24[zs[(o, s)][3]] = 0 qI_rot = sp.expand(qI.subs(rot24)) qX_rot = sp.expand(qX.subs(rot24)) qZ_rot = sp.expand(qZ.subs(rot24)) # signature (6,6) sum-of-squares identity for the single quadric sos = sp.Integer(0) for s in range(3): A2_, _, C2_, _ = zs[(2, s)] A3_, _, C3_, _ = zs[(3, s)] sos += ((A2_ + C3_) ** 2 - (A2_ - C3_) ** 2 - (C2_ + A3_) ** 2 + (C2_ - A3_) ** 2) ok_sos = sp.expand(4 * qI_rot - sos) == 0 check("P5.1 seat-nonuniform relaxation: within-orbit blocks " "AUTOMATIC (Sum_s det u_{o,s} J2 identity: %s); on the " "orientation-forced all-rotation branch the cross-pencil " "is ONE quadric (pX = pZ = 0: %s, %s) with exact " "signature (6, 6) (sum-of-squares identity: %s): an " "indefinite connected quadric -- the relaxed census stays " "DEGENERATE (dropping a rule cannot create forcing)" % (ok_oo, qX_rot == 0, qZ_rot == 0, ok_sos), ok_oo and qX_rot == 0 and qZ_rot == 0 and ok_sos, kill="K5") # ================================================================== section("P6 -- controls (must fire)") # ================================================================== rng = np.random.default_rng(906) n_fire = 0 for _ in range(3): perm = rng.permutation(10) Vp = sp.Matrix(Vdep[perm, :].tolist()) n_fire += (not in_commutant(Vp)) check("C1 seeded row-permutation of the pure-I wiring breaks " "exact C6-covariance (commutant membership) on %d/3" % n_fire, n_fire == 3, kill="K7") wX = wiring((0, 1, 0, 0), (0, 1, 0, 0)) detX = eval_dets(wX) A_Xf = parentV_f(0.5, 0.5, 0.05, np.array(V_sym.subs(wX).tolist(), dtype=np.float64)) wkX = wick_factory(A_Xf) M1X = gram(B1_S, r_S, 1j, wkX) def1p = float(np.max(np.abs(M1X - M1X.conj().T))) check("C2 X-wiring: E4 fires (dets %s == (-1, -1)) AND the 1p " "seat fires (float defect %.4f == 2t = 0.1; round-60 " "regression)" % (detX, def1p), all(d == -1 for d in detX) and abs(def1p - 0.1) <= 1e-12, kill="K7") zE1 = eval_E1(wiring((0, 0, 0, 1), (0, 0, 0, 1))) zpen, _ = eval_pencil(wiring((0, 0, 0, 1), (0, 0, 0, 1))) zA = [sp.expand((2 * a2).subs({a2: 0})), sp.expand((2 * b2).subs({b2: 0}))] check("C3 Z-wiring near miss: E1 %s == 0, pencil %s == 0, " "two-seat clean %s, census 10/10 (P4.2) -- ONLY " "orientation rejects it (dets %s < 0): exactly one " "constraint class fires" % (zE1, zpen, zA, okZ["det"]), all(e == 0 for e in zE1) and all(e == 0 for e in zpen) and all(e == 0 for e in zA) and all(d < 0 for d in okZ["det"]), kill="K7") wM = wiring((0, 0, 1, 0), (0, 0, 0, 1)) (penM, gamM) = eval_pencil(wM) nzM, sigM, _ = census_exact(wM) MblkM = sp.expand(Mcross.subs(wM)) check("C4 mixed J-on-2-cycle / Z-on-3-cycle: pencil fires " "(cross block %s == -3Z; pZ = %s != 0) and the exact " "canonical census drops to %d/10 == 4/10 (round-60 P3.b " "law reproduced exactly)" % (list(MblkM), penM[2], sigM), sp.expand(MblkM + 3 * Zs) == sp.zeros(2, 2) and penM[2] != 0 and sigM == 4 and nzM == 10, kill="K7") e5 = eval_E1(wiring((1, 1, 0, 0), (1, 0, 0, 0))) check("C5 non-unit wiring u2 = I + X: E1 fires (g1_2 = %s != 0)" % e5[0], e5[0] != 0, kill="K7") e6 = eval_E1(wiring((-1, 0, 0, sp.Rational(1, 10)), (-1, 0, 0, 0))) check("C6 perturbed pure-I (u2 = -I + Z/10): E1 fires " "(g2_2 = %s != 0): an illegal perturbation of the " "deployed point violates at least one constraint" % e6[1], e6[1] != 0, kill="K7") # ================================================================== section("VERDICT") # ================================================================== n_pass = sum(1 for _n, ok in CHECKS if ok) n_tot = len(CHECKS) all_ok = (n_pass == n_tot) and not KILLS if all_ok: verdict = ("WIRING-DEGENERATE [ADMISSIBLE-CENSUS-1(C_rot), " "I-NOT-FORCED(interior point), " "I-J-GAUGE-CONNECTED((+)_5 J2 (+) I6), " "J-COMPILER-LEGAL, Z-X-EDGE-ILLEGAL(orientation), " "STRICT-COLLAR-SELECTS-PURE-J(selector theorem), " "DEPLOYMENT-CHOICE]") else: verdict = " / ".join(sorted(set(KILLS))) or "CHECK-FAILED" print(" checks: %d/%d passed; kills: %s" % (n_pass, n_tot, KILLS if KILLS else "none")) print(" VERDICT: %s" % verdict) print(" runtime: %.1f s" % (time.time() - T0)) print(" (constants sanity: N_fam = %s, g_car = %s)" % (N_fam, g_car)) return 0 if all_ok else 1 if __name__ == "__main__": sys.exit(main()) ''' # ------------- frozen probe source theta_frame_selector_probe (embedded BYTE-EXACT, raw string) _SRC_1 = r''' #!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""theta_frame_selector_probe -- SEAM.STATE.THETA.SELECTOR.01 (EXPLORATION ONLY, experiments/; 2026-08-12 -- the collar-frame decision named at the end of the wiring census, entry CCXIII: does any compiler-side demand distinguish the theta_S sheet-swap frame within the 9-dim rule-gauge algebra? Only then does the selector theorem (rules + strict collar => pure-J) become a compiler statement about the deployed pure-I wiring.) THE QUESTION (the CCXIII residual, verbatim scope). The wiring census (seam_wiring_groebner_probe, 30/30, WIRING-DEGENERATE) proved: the orbit/edge rules E1-E5 leave EXACTLY ONE admissible component C_rot (dim 3) modulo the rule gauge; pure-I is an interior point, gauge-connected to pure-(-J) by the INTEGER gauge g_int = (+)_5 J2 (+) I6; the frozen theta_S collar frame breaks the gauge discretely, and the strict-collar two-seat law intersects C_rot exactly in the pure-(+-J) ray (the SELECTOR THEOREM). Everything therefore hinges on ONE question: is the theta_S frame itself compiler-FORCED, or is it a convention -- exactly formulable as the question whether any compiler-side demand cuts the orbit of theta_S under the 9-dim rule-gauge algebra down to a point (or subfamily). FEASIBILITY / REDUNDANCY CHECK (against the corpus, 2026-08-12): round 58 (seam_state_derivation) deployed theta_S BY HAND as the 16-dim lift of the v440 collar I (x) sigma_x and censused only the two index-permutation reflections; round 59 (rp_twisted_involution_census) censused the 48 TWIST candidates U_g^k o theta -- never the inner rule-gauge conjugates; the wiring census (CCXIII) measured the frame-breaking (P1.5) but did not parametrize the frame ORBIT nor test any demand ON frames. That is exactly this probe. SMOKE-RUN DISCLOSURE (2026-08-12, declared smoke rounds before freezing; fail-first preserved -- smoke-1 corrected FOUR hand-predictions by measurement, none inverting the verdict logic, and the machinery itself rejected one wrong guess): (i) the orbit tangent space {[G, theta_S] : G in the 9-dim rule stabilizer} has dimension EXACTLY 7 (hand prediction was 6; isotropy 2, not 3 -- even the diagonal torus rotates the reflection, [J2, X] = 2Z != 0); (ii) the refined D4 stabilizer is 9 OF 9 (hand prediction 8): EVERY rule-stabilizer direction already commutes with the deployed carrier-carrier interior A_int[C, C] exactly -- the doily demand cuts NOTHING, stronger than predicted; (iii) the bare collar Gram spectra have exact closed forms lam_min(1p) = tanh(1/2) = 0.4621 and lam_min(deg-2) = tanh(1/2)^2 = 0.2136 (hand predictions 1 - tanh(1/2) and 0.2311 were WRONG; the cross-frame equality ward <= 1e-10 is the decisive statement and was correct); (iv) the selection-map sign convention: with J = [[0,1],[-1,0]] a rotation R(t) = cos t I - sin t J, so the transported deg-2 seat reads a' = a C + c S (not a C - c S) and the selected ray is (a_o, c_o) = lambda_o (-S, C); the smoke run itself REJECTED the wrongly-signed theta_r ray (-4/5, 3/5) via a broken deg-2 Hermiticity -- the correct selected ray is (4/5, 3/5), fixed and re-verified (the float defect ward 0.06 was correct throughout); (v) implementation-level: the D2 float route for A0 = -tan(beta h0 / 2) is evaluated through the Hermitian eigenbasis of i h0 (the first smoke attempt double-counted the -i rotation); C2's exact pencil violation is -4/5 (sign from R^T J = (3/5) J - (4/5) I), magnitude as predicted. CONVENTIONS (round-58/59/60 + census wiring rebuilt inline; READ-ONLY import of tfpt_constants): 16-dim Majorana space, carrier C = 0..9 (channels 1..5, pairs), boundary B = 10..15 (channel 0, three seats); A_CC = (+)_5 J2, J3 = A16_dep[B, B]; deployed wiring V_dep = A_int[C, B] (PURE-I); parent family A(kappa, m, t, V) = [[kappa A_CC, t V], [-t V^T, m J3]] at the frozen probe-7 point (1/2, 1/2, 1/20). THETA_S = the pair swap r_S: 2i <-> 2i+1 (Pauli X per Majorana pair, all 8 pairs) = the 16-dim lift of the v440 collar reflection; half-side = even indices; twist eta = +i (v519, forced). THE FRAME SPACE: the orbit {g theta_S g^{-1}} of theta_S under the group generated by the 9-dim rule stabilizer (elements of the structure gauge g0 preserving the rule subspace W and the constraint ideal -- the census P1.4 object, rebuilt and re-warded here). Its selection-relevant coordinate is the TORUS pair (gamma, y): g(gamma, y) = R(gamma) per carrier pair (+) R(y) per boundary pair; per pair R(gamma) X R(-gamma) = cos(2 gamma) X + sin(2 gamma) Z, so the orbit sweeps the full reflection circle; the selected ray depends only on delta = y - gamma. RP GRAMS for a GENERAL orthogonal frame theta with half-side vectors f_p: Theta(f_{p1}...f_{pk}) = eta^k phi(theta f_{pk})...phi(theta f_{p1}) (v519 reversal + degree twist), M[a, b] = omega(Theta(m_a) m_b) by vector-Wick (Pfaffian recursion on kernel dot products u^T (I + iA) v); for permutation frames this REPRODUCES the round-60 index machinery entrywise (warded). DEMAND CENSUS (each demand = an exact constraint tested on the frame orbit; anti-circularity rule: no demand may consume the deployed wiring V_dep -- the wiring is the object in question; the carrier-carrier interior A_int[C, C], the vacuum A16_dep, the C6 action and the bare state are wiring-free and admissible): D1 mu4 step / C6 equivariance: [theta, O16] = 0 and theta A16_dep theta = -A16_dep (the order-4 vacuum step |mu4| = 4 must be REVERSED: antiunitarity w.r.t. the deployed complex structure) and det theta = +1; D2 CAR / quasi-free state structure: the bare KMS covariance A0(u, beta) = tanh(beta u / 2) A16_dep (exact closed form, tan(xJ) = tanh(x) J for J^2 = -I) and every state-canonical object built from it (modular flow generated by h0 prop. A16_dep; the Majorana real structure Theta_0 = entrywise conjugation, v898 R1.2) -- does any of it prefer a frame? Coupled-point modular data h(V) is EXCLUDED by anti-circularity (it consumes V; and theta h(V) theta = -h(V) is exactly the relative-angle selector, not a frame demand); D3 Pfaffian pencil / orientation propagation: the census constraint classes E1/E3/E4 as functions on frames; D4 doily / orbit-combinatorics seat: the wiring-free deployed structure {O16, A_CC, J3, A_int[C, C]} -- which rule-gauge directions preserve ALL of it (the refined stabilizer), and does the refinement cut the delta-circle?; D5 the twisted-involution census (round 59): the property that selected theta_S there (bare-point strict RP with DEFINITE collar Grams at eta = +i; theta_abT is marginal-0) -- constant or not on the frame orbit? Per-demand verdict enum: FORCED / COMPATIBLE-NOT-FORCING / SILENT. NUMERICAL PROTOCOL (declared): frame algebra, orbit tangents, stabilizer, ideal reductions, selection map, closure Grams at the integer and rational witnesses are EXACT (integer/rational sympy); float64 ONLY in disclosed wards (general-Gram machinery wards, bare-point spectra, defect regressions); RNG only in controls. FROZEN CLAIMS (2026-08-12, frozen + SHA-hashed before the frozen run): P1 THE FRAME SPACE (exact). (a) theta_S wards: integer involution, orthogonal, [theta_S, O16] = 0, theta_S A16_dep theta_S = -A16_dep, det = +1, exchanges the sheets (evens <-> odds), preserves the carrier/boundary split; (b) the census gauge objects REPRODUCED: g0 dim 16, rule stabilizer dim 9 (exact nullspaces, same construction); (c) the frame orbit: tangent dim {[G, theta_S]} = 7 of 9 (isotropy 2); the torus generators K_C = (+)_5 J2 (+) 0 and K_B = 0 (+) (+)_3 J2 are IN the stabilizer (exact span membership) and act on theta_S with NONZERO commutators -- the reflection circle is rule-gauge reachable; the RELATIVE carrier rotation stays CUT (census regression, nonzero ideal remainder); (d) frame witnesses are rule-gauge legal (exact): the INTEGER frame theta' = g_int theta_S g_int^T (g_int = exp((pi/2) K_C) = (+)_5 J2 (+) I6; per carrier pair -X, boundary X), the rational carrier frame theta_r = g_r theta_S g_r^T (g_r = R(3/5, 4/5) per carrier pair (+) I6) and the rational boundary frame theta_b (I10 (+) R(3/5, 4/5) per boundary pair): each an involution, in the O16 commutant, A16_dep-reversing; g_int preserves A_CC, O16, W and the ideal (census P4.3 re-warded). P2 THE EQUIVARIANT SELECTOR (the base ward). (a) the general-theta vector-Wick Gram machinery REPRODUCES the round-60 index machinery entrywise (<= 1e-12, 1p + deg-2) at the deployed parent, and reproduces the round-60 strict theta_S regression: raw deg-2 defect 0.1 = 2t with 30 entries; (b) equivariance transport (exact mechanism, float ward <= 1e-12): for g in {g_int, g_r, g_b} and wirings {pure-I, interior (3/5, 4/5)}: Gram in frame g theta_S g^T with half-side g F == Gram in frame theta_S at the transported wiring V' = g_C^T V g_B -- and the bare state is EXACTLY gauge-invariant (g A0 g^T = A0, torus); (c) the transported two-seat law in closed form (symbolic): on W, frame (gamma, y) reads deg-2 seat = 2 a'_o with a'_o = a_o C + c_o S, C = cos(y - gamma), S = sin(y - gamma) (u'_o = R(-gamma) u_o R(y)); on C_rot the 1p seat vanishes IDENTICALLY in EVERY orbit frame; float ward: theta_r deg-2 defect at the deployed parent = 2t * 3/5 = 0.06 exactly (<= 1e-12); (d) THE SELECTION MAP (exact): in frame (gamma, y) the strict-collar law cuts C_rot exactly in the ray (a_o, c_o) = lambda_o (-S, C), delta = y - gamma: delta = 0 reproduces the census selector (pure-(+-J)); the integer frame theta' selects pure-(+-I); theta_r selects the (4/5, 3/5) ray (all exact); EQUIVARIANCE COROLLARY: selected_ray(g.frame) = g.selected_ray(frame) = g_C (c J2) g_B^T -- the selector transports with the frame. P3 THE DEMAND CENSUS (per-demand verdicts, exact). (a) D1 mu4/C6: [g theta_S g^{-1}, O16] = g [theta_S, O16] g^{-1} = 0 and (g theta_S g^{-1}) A16_dep (g theta_S g^{-1}) = -A16_dep IDENTICALLY on the orbit ([G_k, A16_dep] = 0 for all 9 stabilizer directions, exact); det invariant under conjugation. D1 defines the FAMILY (controls: a non-commutant frame fails the first, theta = I16 fails the second) but cuts NOTHING inside: COMPATIBLE-NOT-FORCING; (b) D2 state/modular: the bare covariance A0 = tanh(beta u/2) A16_dep (closed form warded <= 1e-12 against the KMS construction -tan(beta h0 / 2)) is invariant under every stabilizer direction; hence the modular flow intertwining theta e^{s h0} theta = e^{-s h0} holds at EVERY orbit point iff at one (all reduce to D1's anticommutation); Theta_0 (real structure) commutes with every real gauge element identically. No state-canonical object moves on the orbit: SILENT (coupled h(V) excluded by anti-circularity, typed); (c) D3 pencil/orientation: the constraint classes E1-E5 contain NO frame variable; their gauge stability IS the stabilizer definition (re-warded); orientation is frame-transport-invariant: det u'_o = det u_o exactly (det R = 1). On frames: SILENT; (d) D4 doily/edge combinatorics: the refined stabilizer {G in stab : [G_C, A_int[C, C]] = 0} is ALL 9 OF 9 (measured: NO direction is cut -- every rule-gauge direction already preserves the deployed carrier-carrier interior exactly), containing K_C and K_B -- the (gamma, y) torus and with it the FULL delta-circle survive the strongest wiring-free structure-preservation demand: the doily/bit-level data (q*, duads, PI6, orbit lengths, reversal flags) live on channel labels and never reference the within-pair basis. COMPATIBLE-NOT-FORCING (cuts nothing at all); (e) D5 the round-59 census property: bare-point strict RP at eta = +i with DEFINITE Grams holds at theta_S, theta', theta_r, theta_b with IDENTICAL spectra (<= 1e-10; closed forms lam_min 1p = tanh(1/2) = 0.4621, deg-2 = tanh(1/2)^2 = 0.2136) -- the property that distinguished theta_S in round 59 is CONSTANT on the frame orbit; what it does distinguish is the FAMILY (theta_abT bare 1p Gram = 0 exactly, marginal -- reproduced); the specific angle of theta_S is v440 LINEAGE (deployment), not a census output: SILENT-ON-ANGLE. P4 THE CLOSURE (the verdict payload; exact). (a) STRICT COLLAR RP OF THE DEPLOYED PARENT HOLDS IN THE INTEGER FRAME: at (1/2, 1/2, 1/20) with V = V_dep (pure-I), the theta' Grams (1p + deg-2, eta = +i, half-side g_int . evens) are EXACTLY Hermitian and PD by exact rational LDL (float lam_min 0.3064 / 0.1532 = the round-60 V_J numbers, transported); the SAME parent fails strict theta_S RP with raw defect 2t (P2.a) -- the round-58/59 obstruction is FRAME-RELATIVE; (b) second exact closure witness at a generic angle: the rational frame theta_r with its selected wiring u_o = (4/5) I + (3/5) J passes strict RP exactly (rational Grams Hermitian + PD by exact LDL); (c) the composed statement (assembled from P3): NO enumerated compiler-side demand distinguishes a point on the delta-circle -> THETA-CONVENTIONAL: the collar frame is a gauge/deployment choice; the compiler forces the admissible component C_rot and the frame FAMILY (D1), and the gauge-invariant content of (frame, wiring) is ONLY the relative angle; the deployed pair (theta_S, pure-I) sits at maximal relative obstruction, the SAME wiring at ZERO obstruction relative to theta' -- both frames rule-gauge legal. The CXXXIX/CCXIII wiring question is CLOSED as a compiler-freedom theorem with freedom group = the rule-gauge frame orbit (7-dim tangent; D4-refinement cuts nothing; selection-relevant quotient = the delta-circle). C CONTROLS (must fire; frozen fire rules; RNG only in C4). C1 NON-COMMUTANT FRAME: rotating channel 1's pair only (g_1 outside the commutant) gives [theta_c, O16] != 0 (>= 4 nonzero integer entries) -- D1 fires off-orbit; C2 RELATIVE-ROTATION FRAME (g0 but NOT rule stabilizer, rotate 2-cycle carrier channels only, rational 3/5-4/5): the transported pure-J wiring VIOLATES the pencil quadric (a2 c3 - c2 a3 = -4/5 != 0 exact) -- selector transport breaks outside the rule gauge; C3 eta = +1 at the bare point breaks collar Gram Hermiticity (raw defect >= 0.4; v519/round-58 twist regression); C4 SEEDED RANDOM PAIRINGS (rng 907, 3 draws) as frames: each fails D1 (A16_dep-reversal broken, integer check) or breaks bare Gram Hermiticity (defect >= 0.1) -- 3/3; C5 theta = I16 fails side-exchange AND D1 reversal (I A16 I = +A16): the mu4-step demand is non-vacuous; C6 CENSUS REGRESSION GATE: pure-I passes E1 + pencil + E4 + canonical census 10/10 with J-coordinate exactly +1/200, V_Z fails EXACTLY orientation E4 (dets -1) -- the census constraints reproduce. KILLS (any one fires => typed gap): K0 AST firewall / compiler rebuild ward breaks -> PIPELINE-BROKEN K1 frame-space / orbit / stabilizer ward -> FRAMESPACE-BROKEN K2 an equivariance / machinery ward breaks -> EQUIVARIANCE-BROKEN K3 a demand-census computation breaks -> DEMAND-CENSUS-BROKEN K4 a closure Gram / verdict computation breaks -> CLOSURE-BROKEN K7 a control does not fire -> CONTROL-DEAD VERDICT (frozen enum): THETA-CONVENTIONAL [FRAME-ORBIT-MEASURED (tangent 7/9, torus legal), EQUIVARIANT-SELECTOR (transport ward; selected ray = g . (+-J)), ALL-DEMANDS-SILENT-ON-ANGLE (D1 family-defining, D2 silent, D3 silent, D4 not-forcing 9/9, D5 constant-on-orbit), DEPLOYED-STRICT-RP-IN-INTEGER-FRAME (exact Grams), WIRING-QUESTION-CLOSED (compiler-freedom theorem; freedom group = rule-gauge frame orbit, selection quotient = the delta-circle)] / THETA-FORCED / THETA-PARTIAL / PIPELINE-BROKEN / FRAMESPACE-BROKEN / EQUIVARIANCE-BROKEN / DEMAND-CENSUS-BROKEN / CLOSURE-BROKEN / CONTROL-DEAD. Exit 0 iff all checks pass and no kill fired; else 1. FIREWALL: experiments/ probe; EXPLORATION ONLY -- writes nothing but stdout; no verification/, paper, ledger, changelog or website surface; no .md, no commits. NO physics claim beyond the recorded identities and measurements: the demand census is over the FIVE ENUMERATED demand classes (each warded to be non-vacuous by a firing control); a compiler demand OUTSIDE this list could still exist and is not excluded here; the v440 collar lineage of theta_S is typed as DEPLOYMENT, not derived; RP remains sector-typed; the v898/v903 [O] premise is unmoved; no marker moves. NO RH claim. SPEC v1 (2026-08-12): frozen after the declared smoke rounds; no amendments at freeze. Sources (read-only, machinery rebuilt inline): seam_wiring_groebner_probe (CCXIII: census, gauge, selector), seam_ness_parent_probe (round 60: Gram machinery, V_J strict-RP numbers), rp_twisted_involution_census_probe (round 59: census property), seam_state_derivation_probe (round 58: theta_S, bare point), v898_kms_schur_mixing (Theta_0), v519 (eta = +i), tfpt_constants (N_fam, g_car). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/theta_frame_selector_probe.py """ import ast import hashlib import itertools import os import sys import time import numpy as np import sympy as sp _HERE = os.path.dirname(os.path.abspath(__file__)) _VERIFY = os.path.abspath(os.path.join(_HERE, "..", "..", "verification")) sys.path.insert(0, _VERIFY) from tfpt_constants import N_fam, g_car # noqa: E402 (READ-ONLY) BANNED_IDS = ("zetazero", "nzeros", "primerange", "isprime", "primepi", "nextprime", "prevprime") CHECKS = [] KILLS = [] T0 = time.time() SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest() ZTOL = 1e-10 NZ_FLOOR = 1e-8 def check(name, ok, detail="", kill=None): CHECKS.append((name, bool(ok))) if kill and not ok: KILLS.append(kill) print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""), flush=True) return bool(ok) def section(title): print("\n" + "=" * 74) print("%s (t=%.1fs)" % (title, time.time() - T0)) print("=" * 74, flush=True) def ast_scan(banned): src = open(os.path.abspath(__file__), encoding="utf-8").read() bad = [] for node in ast.walk(ast.parse(src)): name = None if isinstance(node, ast.Name): name = node.id elif isinstance(node, ast.Attribute): name = node.attr if name and name.lower() in banned: bad.append(name) return bad # ---------------------------------------------------------- bit model def pc(v): return bin(v).count("1") HT = [[(pc(v) * pc(w) - pc(v & w)) % 2 for w in range(16)] for v in range(16)] A_BIT = 0b1000 FSIG = 0b0111 LOWIDX = {1: 0, 2: 1, 4: 2, 8: 3} def sig(v): b = [(v >> i) & 1 for i in range(4)] n = (b[2], b[0], b[1], b[3]) return sum(bit << i for i, bit in enumerate(n)) SIGP = tuple(sig(v) for v in range(16)) def polar_shift(c): return tuple((pc(v) * (pc(v) - 1) // 2 + pc(c & v)) % 2 for v in range(16)) def iota_bits(v): b = [(v >> i) & 1 for i in range(4)] b.append(sum(b) % 2) return tuple(b) IOTA_MSG = [iota_bits(v) for v in range(16)] def iota_support(v): return frozenset(i + 1 for i, bit in enumerate(IOTA_MSG[v]) if bit) def compose(p, q): return tuple(p[q[i]] for i in range(len(q))) def perm_order(p): o, pp = 1, p ident = tuple(range(len(p))) while pp != ident: pp = tuple(p[x] for x in pp) o += 1 return o def cycle_type(perm): n = len(perm) seen = [False] * n cyc = [] for i in range(n): if seen[i]: continue ln, j = 0, i while not seen[j]: seen[j] = True j = perm[j] ln += 1 cyc.append(ln) return tuple(sorted(cyc)) def edge_orbits(perm): n_ord = perm_order(perm) seen = set() out = [] for i, j in itertools.combinations(range(6), 2): e = frozenset({i, j}) if e in seen: continue x, y = i, j edges = set() rev = False for _k in range(n_ord): edges.add(frozenset({x, y})) x, y = perm[x], perm[y] if (x, y) == (j, i): rev = True seen |= edges out.append((frozenset(edges), rev, (i, j))) return out DUADS_CH = sorted(itertools.combinations(range(6), 2)) CAR_DUADS = sorted(itertools.combinations(range(1, 6), 2)) I2s = sp.eye(2) Xs = sp.Matrix([[0, 1], [1, 0]]) Js = sp.Matrix([[0, 1], [-1, 0]]) Zs = sp.Matrix([[1, 0], [0, -1]]) def pauli_coords(M): return (sp.expand((M[0, 0] + M[1, 1]) / 2), sp.expand((M[0, 1] + M[1, 0]) / 2), sp.expand((M[0, 1] - M[1, 0]) / 2), sp.expand((M[0, 0] - M[1, 1]) / 2)) def main(): print("SEAM.STATE.THETA.SELECTOR.01 -- the collar-frame decision: " "does any compiler demand pin the theta_S frame?") print("FROZEN_SPEC SHA-256: %s" % SPEC_SHA) print("NO physics claim beyond recorded identities/measurements; " "exploration only.") # ================================================================== section("S0 -- firewall + compiler-side setup (census rebuild)") # ================================================================== bad = ast_scan(BANNED_IDS) check("S0.0 AST firewall: no banned identifiers %s" % (BANNED_IDS,), not bad, kill="K0") refs = [polar_shift(c) for c in range(16)] ok_ref = all( all(q[x ^ y] ^ q[x] ^ q[y] == HT[x][y] for x in range(16) for y in range(16)) for q in refs) arf1 = sorted(q for q in refs if q.count(0) == 6) siginv = [q for q in refs if all(q[SIGP[v]] == q[v] for v in range(16))] cand = [q for q in siginv if q[A_BIT] == 1 and q[FSIG] == 0] QSTAR = cand[0] if cand else None NZ = list(range(1, 16)) ovoid = [v for v in NZ if QSTAR[v] == 0] def duad(v): return frozenset(i for i, q in enumerate(arf1) if q[v] == 0) dmap = {v: duad(v) for v in NZ} V0 = arf1.index(QSTAR) phi = {} ok_phi = True for o in ovoid: others = dmap[o] - {V0} islot = frozenset(range(1, 6)) - iota_support(o) ok_phi &= (len(others) == 1 and len(islot) == 1) phi[next(iter(others))] = next(iter(islot)) ok_phi &= (len(phi) == 5 and set(phi.values()) == set(range(1, 6))) def lab(j): return 0 if j == V0 else phi[j] SP6 = [] for imgs in itertools.product(range(1, 16), repeat=4): p = [0] * 16 for v in range(1, 16): lb = v & -v p[v] = p[v ^ lb] ^ imgs[LOWIDX[lb]] if len(set(p)) != 16: continue if all(HT[imgs[x]][imgs[y]] == 1 for x in range(4) for y in range(x + 1, 4)): SP6.append(tuple(p)) S5P = list(itertools.permutations(range(5))) AUT = [] for p in SP6: if any(QSTAR[p[v]] != QSTAR[v] for v in range(16)): continue if compose(p, SIGP) != compose(SIGP, p): continue pis = [pi for pi in S5P if all(IOTA_MSG[p[v]] == tuple(IOTA_MSG[v][pi[s]] for s in range(5)) for v in range(16))] if pis: AUT.append(p) g_pin = [p for p in AUT if perm_order(p) == 6 and compose(p, p) == SIGP] check("S0.1 compiler rebuilt: unique q*, |Aut| = %d == 6, " "generator pin unique" % len(AUT), ok_ref and len(cand) == 1 and ok_phi and len(AUT) == 6 and len(g_pin) == 1, kill="K0") GEN = g_pin[0] a1idx = {q: i for i, q in enumerate(arf1)} tau = [a1idx[tuple(q[GEN[v]] for v in range(16))] for q in arf1] pia = [0] * 6 for j in range(6): pia[tau[j]] = j pia = tuple(pia) PI6 = [0] * 6 for j in range(6): PI6[lab(j)] = lab(pia[j]) PI6 = tuple(PI6) cycles = [] seen = set() for i in range(6): if i in seen: continue cyc, j = [], i while j not in seen: seen.add(j) cyc.append(j) j = PI6[j] cycles.append(cyc) TWO = sorted(next(c for c in cycles if len(c) == 2)) THREE = sorted(next(c for c in cycles if len(c) == 3)) a_ch, b_ch = TWO check("S0.2 deployed pi = %s, cycle type %s == (1, 2, 3); " "2-cycle {%d,%d}, 3-cycle %s" % (PI6, cycle_type(PI6), a_ch, b_ch, THREE), PI6[0] == 0 and cycle_type(PI6) == (1, 2, 3), kill="K0") CH = {0: list(range(10, 16))} for i in range(1, 6): CH[i] = [2 * (i - 1), 2 * (i - 1) + 1] CAR_IDX = list(range(10)) BND_IDX = list(range(10, 16)) img = [0] * 16 for i in range(6): for k, s in enumerate(CH[i]): img[s] = CH[PI6[i]][k] J2i = np.array([[0, 1], [-1, 0]], dtype=np.int64) I2i = np.eye(2, dtype=np.int64) IOTA6i = np.vstack([I2i, I2i, I2i]) orbs = edge_orbits(PI6) def put_ordered(A, x, y, B): rx, cy = CH[x], CH[y] for r in range(len(rx)): for c in range(len(cy)): A[rx[r], cy[c]] = B[r, c] A[cy[c], rx[r]] = -B[r, c] A_int = np.zeros((16, 16), dtype=np.int64) for edges, rev, rep in orbs: i, j = rep B = J2i if rev else (IOTA6i if i == 0 else I2i) x, y = i, j for _k in range(perm_order(PI6)): put_ordered(A_int, x, y, B) x, y = PI6[x], PI6[y] A16_dep = np.zeros((16, 16), dtype=np.int64) for i in range(8): A16_dep[2 * i, 2 * i + 1] = 1 A16_dep[2 * i + 1, 2 * i] = -1 okA = (np.array_equal(A_int[np.ix_(img, img)], A_int) and np.array_equal(A_int, -A_int.T)) okD = np.array_equal(A16_dep[np.ix_(img, img)], A16_dep) A_CC = A16_dep[np.ix_(CAR_IDX, CAR_IDX)] J3 = A16_dep[np.ix_(BND_IDX, BND_IDX)] Vdep = A_int[np.ix_(CAR_IDX, BND_IDX)] check("S0.3 blocks extracted: A_CC = (+)_5 J2, J3, deployed " "wiring V_dep = A_int[C, B]", okA and okD, kill="K0") O16 = np.zeros((16, 16), dtype=np.int64) for src in range(16): O16[img[src], src] = 1 O_C = O16[np.ix_(CAR_IDX, CAR_IDX)] O_B = O16[np.ix_(BND_IDX, BND_IDX)] CH2 = {i: [2 * i, 2 * i + 1] for i in range(6)} IOTA_f = IOTA6i.astype(np.float64) def compress12(A): Ahat = np.zeros((12, 12)) for (i, j) in DUADS_CH: if i == 0: Bm = IOTA_f.T @ A[np.ix_(CH[0], CH[j])] / 3.0 else: Bm = A[np.ix_(CH[i], CH[j])] for rr in range(2): for cc in range(2): Ahat[CH2[i][rr], CH2[j][cc]] = Bm[rr, cc] Ahat[CH2[j][cc], CH2[i][rr]] = -Bm[rr, cc] return Ahat pf4_c = {} Ahat_c = compress12(A_int.astype(np.float64) / 200.0) for (i, j) in DUADS_CH: Bm = Ahat_c[np.ix_(CH2[i], CH2[j])] pf4_c[frozenset({i, j})] = -(Bm[0, 0] * Bm[1, 1] - Bm[0, 1] * Bm[1, 0]) sign_c = {d: (1 if v > 0 else -1) for d, v in pf4_c.items()} check("S0.4 canonical G_c Pf4 signs rebuilt: 15 nonzero, all " "negative", all(abs(v) > 1e-16 for v in pf4_c.values()) and all(s == -1 for s in sign_c.values()), kill="K0") # ================================================================== section("P1 -- the frame space: theta_S, gauge, orbit") # ================================================================== # theta_S = pair swap (X per pair), integer T0i = np.zeros((16, 16), dtype=np.int64) for i in range(8): T0i[2 * i, 2 * i + 1] = 1 T0i[2 * i + 1, 2 * i] = 1 okT_inv = np.array_equal(T0i @ T0i, np.eye(16, dtype=np.int64)) okT_orth = np.array_equal(T0i @ T0i.T, np.eye(16, dtype=np.int64)) okT_c6 = np.array_equal(T0i @ O16, O16 @ T0i) okT_rev = np.array_equal(T0i @ A16_dep @ T0i, -A16_dep) okT_det = int(round(np.linalg.det(T0i.astype(np.float64)))) == 1 P_S = [2 * i for i in range(8)] okT_side = all(T0i[2 * i + 1, 2 * i] == 1 for i in range(8)) okT_split = all(T0i[r, c] == 0 for r in CAR_IDX for c in BND_IDX) check("P1.1 theta_S wards (integer): involution %s, orthogonal " "%s, [theta_S, O16] = 0 %s, mu4-step reversal theta A16 " "theta = -A16 %s, det = +1 %s, side-exchanging %s, " "split-preserving %s" % (okT_inv, okT_orth, okT_c6, okT_rev, okT_det, okT_side, okT_split), okT_inv and okT_orth and okT_c6 and okT_rev and okT_det and okT_side and okT_split, kill="K1") # ---- gauge algebra g0 and rule stabilizer (census rebuild) a2, b2, c2, d2, a3, b3, c3, d3 = sp.symbols( "a2 b2 c2 d2 a3 b3 c3 d3", real=True) GENS8 = (a2, b2, c2, d2, a3, b3, c3, d3) u2 = a2 * I2s + b2 * Xs + c2 * Js + d2 * Zs u3 = a3 * I2s + b3 * Xs + c3 * Js + d3 * Zs def mkW(u2m, u3m): V = sp.zeros(10, 6) for i in range(1, 6): uo = u2m if i in TWO else u3m for s in range(3): V[2 * (i - 1):2 * i, 2 * s:2 * s + 2] = uo return V V_sym = mkW(u2, u3) def in_commutant(Vm): Vp = sp.zeros(10, 6) for r in range(10): for c in range(6): rr = int(np.flatnonzero(O_C[:, r])[0]) cc = int(np.flatnonzero(O_B[:, c])[0]) Vp[rr, cc] = Vm[r, c] return sp.expand(Vp - Vm) == sp.zeros(10, 6) pairsC = list(itertools.combinations(range(10), 2)) pairsB = list(itertools.combinations(range(6), 2)) nv = len(pairsC) + len(pairsB) A_CCs = sp.Matrix(A_CC.tolist()) J3s = sp.Matrix(J3.tolist()) O_Cs = sp.Matrix(O_C.tolist()) def XC_of(vec): X = sp.zeros(10, 10) for k, (i, j) in enumerate(pairsC): X[i, j] = vec[k] X[j, i] = -vec[k] return X def XB_of(vec): X = sp.zeros(6, 6) for k, (i, j) in enumerate(pairsB): X[i, j] = vec[len(pairsC) + k] X[j, i] = -vec[len(pairsC) + k] return X vsyms = sp.symbols("x0:%d" % nv, real=True) XCs = XC_of(vsyms) XBs = XB_of(vsyms) eqs = [] eqs += list(sp.expand(XCs * O_Cs - O_Cs * XCs)) eqs += list(sp.expand(XCs * A_CCs - A_CCs * XCs)) eqs += list(sp.expand(XBs * J3s - J3s * XBs)) Meq = sp.Matrix([[sp.diff(e, v) for v in vsyms] for e in eqs]) g0_basis = Meq.nullspace() dim_g0 = len(g0_basis) UT2 = sp.expand(u2.T * u2) UT3 = sp.expand(u3.T * u3) g1_2 = sp.expand(UT2[0, 1]) g2_2 = sp.expand(UT2[0, 0] - UT2[1, 1]) g1_3 = sp.expand(UT3[0, 1]) g2_3 = sp.expand(UT3[0, 0] - UT3[1, 1]) Mcross = sp.expand(3 * u2 * Js * u3.T) pI, pX, pJ, pZ = pauli_coords(Mcross) IDEAL_GENS = [g1_2, g2_2, g1_3, g2_3, sp.expand(2 * pI), sp.expand(2 * pX), sp.expand(2 * pZ)] gb = sp.groebner(IDEAL_GENS, *GENS8, order="grevlex") def rem(expr): return gb.reduce(sp.expand(expr))[1] rep2, rep3 = TWO[0], THREE[0] per_elem = [] for base in g0_basis: XCk = XC_of(list(base)) XBk = XB_of(list(base)) dV = sp.expand(XCk * V_sym - V_sym * XBk) du2 = dV[2 * (rep2 - 1):2 * rep2, 0:2] du3 = dV[2 * (rep3 - 1):2 * rep3, 0:2] condsW = [] for i in range(1, 6): ref = du2 if i in TWO else du3 for s in range(3): blk = dV[2 * (i - 1):2 * i, 2 * s:2 * s + 2] for e in sp.expand(blk - ref): condsW.append(e) d_coords = {} for symx, val in zip((a2, b2, c2, d2), pauli_coords(du2)): d_coords[symx] = val for symx, val in zip((a3, b3, c3, d3), pauli_coords(du3)): d_coords[symx] = val condsI = [] for f in IDEAL_GENS: df = sp.expand(sum(sp.diff(f, x) * d_coords[x] for x in GENS8)) condsI.append(sp.expand(rem(df))) per_elem.append((condsW, condsI, d_coords)) n_condW = len(per_elem[0][0]) n_condI = len(per_elem[0][1]) lin_rows = [] for ci in range(n_condW + n_condI): monos = set() polys = [] for condsW, condsI, _dc in per_elem: e = (condsW[ci] if ci < n_condW else condsI[ci - n_condW]) pe = sp.Poly(e, *GENS8) polys.append(pe) monos |= set(pe.monoms()) for mono in monos: lin_rows.append([pe.nth(*mono) for pe in polys]) Mstab = sp.Matrix(lin_rows) stab_basis = Mstab.nullspace() dim_stab = len(stab_basis) # stabilizer basis as 60-dim coordinate vectors stab_vecs = [] for base in stab_basis: v = sp.zeros(nv, 1) for k in range(dim_g0): v += base[k] * g0_basis[k] stab_vecs.append(sp.expand(v)) check("P1.2 census gauge objects reproduced: dim g0 = %d == 16, " "rule stabilizer dim = %d == 9" % (dim_g0, dim_stab), dim_g0 == 16 and dim_stab == 9, kill="K1") # ---- orbit tangent {[G, theta_S]} T0s = sp.Matrix(T0i.tolist()) def G16_of(vec): G = sp.zeros(16, 16) G[0:10, 0:10] = XC_of(list(vec)) G[10:16, 10:16] = XB_of(list(vec)) return G tang_rows = [] for v in stab_vecs: G = G16_of(v) Cm = sp.expand(G * T0s - T0s * G) tang_rows.append([Cm[r, c] for r in range(16) for c in range(16)]) Mtang = sp.Matrix(tang_rows) d_orb = Mtang.rank() d_iso = dim_stab - d_orb # torus generators K_C, K_B: membership in the stabilizer span vKC = [sp.Integer(0)] * nv for i in range(5): vKC[pairsC.index((2 * i, 2 * i + 1))] = sp.Integer(1) vKB = [sp.Integer(0)] * nv for i in range(3): vKB[len(pairsC) + pairsB.index((2 * i, 2 * i + 1))] = \ sp.Integer(1) Mspan = sp.Matrix([[v[k, 0] for k in range(nv)] for v in stab_vecs]) rk0 = Mspan.rank() inKC = sp.Matrix(Mspan.tolist() + [vKC]).rank() == rk0 inKB = sp.Matrix(Mspan.tolist() + [vKB]).rank() == rk0 KC16 = G16_of(sp.Matrix(nv, 1, vKC)) KB16 = G16_of(sp.Matrix(nv, 1, vKB)) movesKC = sp.expand(KC16 * T0s - T0s * KC16) != sp.zeros(16, 16) movesKB = sp.expand(KB16 * T0s - T0s * KB16) != sp.zeros(16, 16) # census regression: the RELATIVE carrier rotation stays cut vrel = [sp.Integer(0)] * nv for i in TWO: r0 = 2 * (i - 1) vrel[pairsC.index((r0, r0 + 1))] = sp.Integer(1) Xrel = XC_of(vrel) dVrel = sp.expand(Xrel * V_sym) du2r = dVrel[2 * (rep2 - 1):2 * rep2, 0:2] du3r = dVrel[2 * (rep3 - 1):2 * rep3, 0:2] dcr = {} for symx, val in zip((a2, b2, c2, d2), pauli_coords(du2r)): dcr[symx] = val for symx, val in zip((a3, b3, c3, d3), pauli_coords(du3r)): dcr[symx] = val rel_rems = [sp.expand(rem(sp.expand( sum(sp.diff(f, x) * dcr[x] for x in GENS8)))) for f in IDEAL_GENS] rel_cut = any(r != 0 for r in rel_rems) check("P1.3 THE FRAME ORBIT: tangent dim {[G, theta_S]} = %d " "== 7 of 9 (isotropy %d == 2); torus generators K_C, K_B " "in the stabilizer span (%s, %s) and BOTH move theta_S " "(%s, %s) -- the reflection circle is rule-gauge " "reachable; the relative carrier rotation stays CUT " "(census regression: %s)" % (d_orb, d_iso, inKC, inKB, movesKC, movesKB, rel_cut), d_orb == 7 and d_iso == 2 and inKC and inKB and movesKC and movesKB and rel_cut, kill="K1") # ---- frame witnesses (exact) # g_int = (+)_5 J2 (+) I6 = exp((pi/2) K_C) g_int = sp.zeros(16, 16) for i in range(5): g_int[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Js g_int[10:16, 10:16] = sp.eye(6) # g_r = R(3/5, 4/5) per carrier pair (+) I6 Rr = sp.Matrix([[sp.Rational(3, 5), -sp.Rational(4, 5)], [sp.Rational(4, 5), sp.Rational(3, 5)]]) g_r = sp.zeros(16, 16) for i in range(5): g_r[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Rr g_r[10:16, 10:16] = sp.eye(6) # g_b = I10 (+) R(3/5, 4/5) per boundary pair g_b = sp.zeros(16, 16) g_b[0:10, 0:10] = sp.eye(10) for i in range(3): g_b[10 + 2 * i:12 + 2 * i, 10 + 2 * i:12 + 2 * i] = Rr O16s = sp.Matrix(O16.tolist()) A16s = sp.Matrix(A16_dep.tolist()) def frame_of(g): return sp.expand(g * T0s * g.T) th_int = frame_of(g_int) th_r = frame_of(g_r) th_b = frame_of(g_b) def frame_legal(th): inv = sp.expand(th * th) == sp.eye(16) c6 = sp.expand(th * O16s - O16s * th) == sp.zeros(16, 16) rev = sp.expand(th * A16s * th + A16s) == sp.zeros(16, 16) return inv, c6, rev leg_int = frame_legal(th_int) leg_r = frame_legal(th_r) leg_b = frame_legal(th_b) # g_int census-P4.3 re-ward: preserves A_CC, O16, ideal gC10 = g_int[0:10, 0:10] okg1 = sp.expand(gC10 * A_CCs * gC10.T - A_CCs) == sp.zeros(10, 10) okg2 = sp.expand(gC10 * O_Cs - O_Cs * gC10) == sp.zeros(10, 10) gsub = {a2: -c2, b2: -d2, c2: a2, d2: b2, a3: -c3, b3: -d3, c3: a3, d3: b3} okg4 = all(rem(g.subs(gsub, simultaneous=True)) == 0 for g in IDEAL_GENS) # theta' per carrier pair = -X, boundary = X (integer identity) okg5 = all( th_int[2 * i:2 * i + 2, 2 * i:2 * i + 2] == -Xs for i in range(5)) and all( th_int[10 + 2 * i:12 + 2 * i, 10 + 2 * i:12 + 2 * i] == Xs for i in range(3)) check("P1.4 frame witnesses legal (exact): theta' integer " "(involution/C6/A16-reversal %s; per carrier pair -X, " "boundary X: %s; g_int preserves A_CC %s, O16 %s, ideal " "%s), theta_r rational %s, theta_b rational %s" % (leg_int, okg5, okg1, okg2, okg4, leg_r, leg_b), all(leg_int) and okg5 and okg1 and okg2 and okg4 and all(leg_r) and all(leg_b), kill="K1") # ================================================================== section("P2 -- the equivariant selector (base ward)") # ================================================================== # ---- round-60 index machinery (verbatim conventions) def wick_factory(A): W = np.eye(A.shape[0], dtype=complex) + 1j * A memo = {} def wick(idx): idx = tuple(idx) if len(idx) == 0: return 1.0 + 0j if len(idx) % 2 == 1: return 0.0 + 0j if idx in memo: return memo[idx] head, rest = idx[0], idx[1:] tot = 0.0 + 0j for j, bb in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * W[head, bb] * wick(sub) memo[idx] = tot return tot return wick def gram_idx(basis, r, eta, wick): n = len(basis) M = np.zeros((n, n), dtype=complex) for ai, ma in enumerate(basis): imgs_ = [r[a] for a in reversed(ma)] coeff = eta ** len(ma) lst = list(imgs_) sgn = 1 for i in range(len(lst)): for j in range(len(lst) - 1 - i): if lst[j] > lst[j + 1]: lst[j], lst[j + 1] = lst[j + 1], lst[j] sgn = -sgn ca = coeff * sgn ia = tuple(lst) for bi, mb in enumerate(basis): M[ai, bi] = ca * wick(tuple(list(ia) + list(mb))) return M r_S = {} for i in range(8): r_S[2 * i] = 2 * i + 1 r_S[2 * i + 1] = 2 * i B1_S = [(a,) for a in P_S] B2_S = [()] + [tuple(c) for c in itertools.combinations(P_S, 2)] # positional bases (same order) for the general machinery POS1 = [(p,) for p in range(8)] POS2 = [()] + [tuple(c) for c in itertools.combinations(range(8), 2)] # ---- general-theta vector-Wick machinery (float) def gram_gen(theta_f, F_f, eta, A, basis_pos): W = np.eye(16, dtype=complex) + 1j * A imgs_ = [theta_f @ F_f[p] for p in range(len(F_f))] def wickv(vecs): k = len(vecs) if k % 2 == 1: return 0.0 + 0j if k == 0: return 1.0 + 0j K = [[vecs[p] @ W @ vecs[q] for q in range(k)] for p in range(k)] def rec(idxs): if not idxs: return 1.0 + 0j head, rest = idxs[0], idxs[1:] tot = 0.0 + 0j for j, bpos in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * K[head][bpos] * rec(sub) return tot return rec(list(range(k))) n = len(basis_pos) M = np.zeros((n, n), dtype=complex) for ai, ma in enumerate(basis_pos): va = [imgs_[p] for p in reversed(ma)] coeff = eta ** len(ma) for bi, mb in enumerate(basis_pos): vb = [F_f[p] for p in mb] M[ai, bi] = coeff * wickv(va + vb) return M A_CCf = A_CC.astype(np.float64) J3f = J3.astype(np.float64) def parentV_f(kap, m, tt, V): A = np.zeros((16, 16)) A[np.ix_(CAR_IDX, CAR_IDX)] = kap * A_CCf A[np.ix_(BND_IDX, BND_IDX)] = m * J3f A[np.ix_(CAR_IDX, BND_IDX)] = tt * V A[np.ix_(BND_IDX, CAR_IDX)] = -tt * V.T return A T0f = T0i.astype(np.float64) F_S = [np.eye(16)[:, a] for a in P_S] A_dep = parentV_f(0.5, 0.5, 0.05, Vdep.astype(np.float64)) wk_dep = wick_factory(A_dep) M1_idx = gram_idx(B1_S, r_S, 1j, wk_dep) M2_idx = gram_idx(B2_S, r_S, 1j, wk_dep) M1_gen = gram_gen(T0f, F_S, 1j, A_dep, POS1) M2_gen = gram_gen(T0f, F_S, 1j, A_dep, POS2) dev_m = max(float(np.max(np.abs(M1_idx - M1_gen))), float(np.max(np.abs(M2_idx - M2_gen)))) D2S = M2_gen - M2_gen.conj().T defS = float(np.max(np.abs(D2S))) nentS = int(np.sum(np.abs(D2S) > 1e-12)) check("P2.1 general-theta machinery == round-60 index machinery " "entrywise (max dev %.1e <= 1e-12); strict theta_S " "regression at the deployed parent: raw deg-2 defect " "%.4f == 2t = 0.1, %d == 30 entries" % (dev_m, defS, nentS), dev_m <= 1e-12 and abs(defS - 0.1) <= 1e-12 and nentS == 30, kill="K2") # ---- equivariance transport ward def wiring(u2v, u3v): return {a2: u2v[0], b2: u2v[1], c2: u2v[2], d2: u2v[3], a3: u3v[0], b3: u3v[1], c3: u3v[2], d3: u3v[3]} wI = wiring((-1, 0, 0, 0), (-1, 0, 0, 0)) wP = wiring((sp.Rational(3, 5), 0, sp.Rational(4, 5), 0), (sp.Rational(3, 5), 0, sp.Rational(4, 5), 0)) V_I = np.array(V_sym.subs(wI).tolist(), dtype=np.float64) V_P = np.array(V_sym.subs(wP).tolist(), dtype=np.float64) gauges = {"g_int": g_int, "g_r": g_r, "g_b": g_b} dev_eq = 0.0 for gnm, g in gauges.items(): gf = np.array(g.tolist(), dtype=np.float64) thf = gf @ T0f @ gf.T Fg = [gf @ f for f in F_S] for V in (V_I, V_P): A = parentV_f(0.5, 0.5, 0.05, V) Vp = gf[0:10, 0:10].T @ V @ gf[10:16, 10:16] Ap = parentV_f(0.5, 0.5, 0.05, Vp) for bp in (POS1, POS2): Mg = gram_gen(thf, Fg, 1j, A, bp) Ms = gram_gen(T0f, F_S, 1j, Ap, bp) dev_eq = max(dev_eq, float(np.max(np.abs(Mg - Ms)))) # bare-state gauge invariance (exact) ok_bare_inv = all( sp.expand(g * A16s * g.T - A16s) == sp.zeros(16, 16) for g in (g_int, g_r, g_b)) check("P2.2 equivariance transport: Gram(frame g theta g^T, " "half-side gF, A(V)) == Gram(theta_S, F, A(g_C^T V g_B)) " "on 3 gauges x 2 wirings x 2 sectors (max dev %.1e <= " "1e-12); bare state exactly gauge-invariant " "(g A16_dep g^T = A16_dep: %s)" % (dev_eq, ok_bare_inv), dev_eq <= 1e-12 and ok_bare_inv, kill="K2") # ---- transported two-seat law, symbolic closed form cg, sg, cy, sy = sp.symbols("cg sg cy sy", real=True) Rg = sp.Matrix([[cg, -sg], [sg, cg]]) Ry = sp.Matrix([[cy, -sy], [sy, cy]]) relg = [cg ** 2 + sg ** 2 - 1, cy ** 2 + sy ** 2 - 1] def redrel(e): return sp.expand(sp.reduced(sp.expand(e), relg, cg, sg, cy, sy)[1]) up2 = sp.expand(Rg.T * u2 * Ry) up3 = sp.expand(Rg.T * u3 * Ry) a2p, b2p, c2p, d2p = [redrel(x) for x in pauli_coords(up2)] a3p, b3p, c3p, d3p = [redrel(x) for x in pauli_coords(up3)] # closed form: a' = a C + c S, C = cos(y-gamma), S = sin(y-gamma) # (J = [[0,1],[-1,0]] means R(t) = cos t I - sin t J) Cd = cg * cy + sg * sy Sd = sy * cg - cy * sg rot_sub = {b2: 0, d2: 0, b3: 0, d3: 0} ok_cf2 = redrel(a2p.subs(rot_sub) - (a2 * Cd + c2 * Sd)) == 0 ok_cf3 = redrel(a3p.subs(rot_sub) - (a3 * Cd + c3 * Sd)) == 0 ok_1p = (redrel(b2p.subs(rot_sub)) == 0 and redrel(b3p.subs(rot_sub)) == 0) # gamma = y = 0 reproduces the census law coordinates sub0 = {cg: 1, sg: 0, cy: 1, sy: 0} ok_00 = (sp.expand(a2p.subs(sub0) - a2) == 0 and sp.expand(b2p.subs(sub0) - b2) == 0) # float ward: theta_r deg-2 defect at the deployed parent gf_r = np.array(g_r.tolist(), dtype=np.float64) th_rf = gf_r @ T0f @ gf_r.T F_r = [gf_r @ f for f in F_S] M2r = gram_gen(th_rf, F_r, 1j, A_dep, POS2) D2r = M2r - M2r.conj().T defR = float(np.max(np.abs(D2r))) # predicted: 2t * |a'| with a' = a cos(-gamma... ) = -3/5 check("P2.3 transported two-seat law: on C_rot deg-2 seat = " "2(a_o C + c_o S), C = cos(y-gamma), S = sin(y-gamma) " "(%s, %s); 1p seat IDENTICALLY zero on C_rot in every " "orbit frame (%s); frame (0,0) reproduces the census law " "(%s); float ward theta_r: deg-2 defect %.4f == " "2t*3/5 = 0.06 (<= 1e-12)" % (ok_cf2, ok_cf3, ok_1p, ok_00, defR), ok_cf2 and ok_cf3 and ok_1p and ok_00 and abs(defR - 0.06) <= 1e-12, kill="K2") # ---- THE SELECTION MAP (exact) lam2, lam3 = sp.symbols("lam2 lam3", real=True) ray_sub = {a2: -lam2 * Sd, c2: lam2 * Cd, a3: -lam3 * Sd, c3: lam3 * Cd} ok_ray_in = (redrel(sp.expand( (a2 * Cd + c2 * Sd).subs(ray_sub))) == 0 and redrel(sp.expand( (a3 * Cd + c3 * Sd).subs(ray_sub))) == 0) minor_rot = sp.expand(a2 * c3 - c2 * a3) ok_ray_pen = redrel(sp.expand(minor_rot.subs(ray_sub))) == 0 # uniqueness: the (C, S) kernel is 1-dim per orbit (C^2+S^2=1) ok_unit = redrel(sp.expand(Cd ** 2 + Sd ** 2 - 1)) == 0 # corollaries: theta_S (delta = 0: S = 0, C = 1) -> pure-(+-J); # theta' (gamma = pi/2, y = 0: C = 0, S = -1) -> pure-(+-I); # theta_r (cg = 3/5, sg = 4/5, y = 0: C = 3/5, S = -4/5) # -> ray (a, c) prop. (4/5, 3/5) ok_sel_S = (sp.expand((-lam2 * Sd).subs(sub0)) == 0 and sp.expand((lam2 * Cd).subs(sub0)) == lam2) sub_int = {cg: 0, sg: 1, cy: 1, sy: 0} ok_sel_int = (sp.expand((-lam2 * Sd).subs(sub_int)) == lam2 and sp.expand((lam2 * Cd).subs(sub_int)) == 0) sub_r = {cg: sp.Rational(3, 5), sg: sp.Rational(4, 5), cy: 1, sy: 0} ok_sel_r = (sp.expand((-lam2 * Sd).subs(sub_r)) == sp.Rational(4, 5) * lam2 and sp.expand((lam2 * Cd).subs(sub_r)) == sp.Rational(3, 5) * lam2) # equivariance corollary: selected(g.frame) = g.selected(frame): # u_sel = R(gamma) (c J) R(y)^T = c (-sin(y-gamma) I + cos(.) J) usel = sp.expand(Rg * (Js) * Ry.T) aI_sel, _bX, cJ_sel, _dZ = [redrel(x) for x in pauli_coords(usel)] ok_cor = (redrel(aI_sel + Sd) == 0 and redrel(cJ_sel - Cd) == 0) check("P2.4 THE SELECTION MAP (exact): in frame (gamma, y) the " "strict-collar law cuts C_rot exactly in the ray " "(a_o, c_o) = lambda_o (-S, C), delta = y - gamma " "(membership %s/%s, pencil automatic %s, unit %s); " "corollaries: theta_S -> pure-(+-J) (%s), theta' -> " "pure-(+-I) (%s), theta_r -> (4/5, 3/5) ray (%s); " "equivariance corollary selected(g.frame) = " "g.selected(frame) = g_C (c J2) g_B^T (%s)" % (ok_ray_in, ok_ray_pen, ok_ray_pen, ok_unit, ok_sel_S, ok_sel_int, ok_sel_r, ok_cor), ok_ray_in and ok_ray_pen and ok_unit and ok_sel_S and ok_sel_int and ok_sel_r and ok_cor, kill="K2") # ================================================================== section("P3 -- the demand census (per-demand verdicts)") # ================================================================== # D1 mu4 / C6 equivariance ok_A16_all = all( sp.expand(G16_of(v) * A16s - A16s * G16_of(v)) == sp.zeros(16, 16) for v in stab_vecs) ok_D1_wit = all(frame_legal(th)[1] and frame_legal(th)[2] for th in (th_int, th_r, th_b)) det_wits = [sp.det(th) for th in (th_int, th_r, th_b)] ok_D1_det = all(d == 1 for d in det_wits) check("P3.1 D1 mu4-step/C6 demand: [G_k, A16_dep] = 0 for all " "9 stabilizer directions (%s) => C6-equivariance AND " "A16-reversal hold IDENTICALLY on the orbit (witnesses " "%s); det theta = +1 invariant (%s). VERDICT " "COMPATIBLE-NOT-FORCING (family-defining, cuts nothing " "inside; teeth: controls C1/C5)" % (ok_A16_all, ok_D1_wit, ok_D1_det), ok_A16_all and ok_D1_wit and ok_D1_det, kill="K3") # D2 state / modular data # closed form A0 = tanh(beta u / 2) A16_dep vs -tan(beta h0 / 2) # via the Hermitian eigenbasis of i h0: h0 = Q diag(-i w) Q^*, # so -tan(beta h0 / 2) = i Q diag(tanh(beta w / 2)) Q^* h0 = -A16_dep.astype(np.float64) # u = 1 wH, QH = np.linalg.eigh(1j * h0) A0_dir = (1j * QH @ np.diag(np.tanh(wH / 2)) @ QH.conj().T).real # beta = 1 A0_cf = np.tanh(0.5) * A16_dep.astype(np.float64) dev_cf = float(np.max(np.abs(A0_dir - A0_cf))) # torus invariance of A0 (follows from D1 exactness); Theta_0 # = entrywise conjugation commutes with every REAL g: identical ok_D2 = dev_cf <= 1e-12 and ok_A16_all check("P3.2 D2 CAR/state demand: bare KMS covariance closed " "form A0 = tanh(beta u/2) A16_dep (dev %.1e <= 1e-12) is " "EXACTLY invariant under every stabilizer direction " "(P3.1) => modular flow intertwining and Theta_0 " "(entrywise conjugation, real-gauge-invariant) are " "CONSTANT on the orbit; coupled-point h(V) EXCLUDED by " "anti-circularity (typed: theta h(V) theta = -h(V) is " "the relative-angle selector, not a frame demand). " "VERDICT SILENT" % dev_cf, ok_D2, kill="K3") # D3 pencil / orientation on frames # (i) no frame variable in E1..E5 (structural: generators in # Q[a2..d3] only); (ii) gauge stability of the ideal is the # stabilizer definition -- re-warded along stab_vecs; # (iii) det u' = det u exactly stab_id_ok = True for v in stab_vecs: XCk = XC_of([v[k, 0] for k in range(len(pairsC))]) XBk = XB_of([0] * len(pairsC) + [v[len(pairsC) + k, 0] for k in range(len(pairsB))]) dV = sp.expand(XCk * V_sym - V_sym * XBk) du2k = dV[2 * (rep2 - 1):2 * rep2, 0:2] du3k = dV[2 * (rep3 - 1):2 * rep3, 0:2] dck = {} for symx, val in zip((a2, b2, c2, d2), pauli_coords(du2k)): dck[symx] = val for symx, val in zip((a3, b3, c3, d3), pauli_coords(du3k)): dck[symx] = val for f in IDEAL_GENS: df = sp.expand(sum(sp.diff(f, x) * dck[x] for x in GENS8)) if sp.expand(rem(df)) != 0: stab_id_ok = False det_inv = redrel(sp.expand(up2.det() - u2.det())) == 0 ok_novar = all( set(sp.Poly(f, *GENS8).gens) == set(GENS8) for f in IDEAL_GENS) check("P3.3 D3 pencil/orientation demand: the constraint " "classes contain NO frame variable (generators in " "Q[a2..d3]: %s); ideal stability along all 9 stabilizer " "directions re-warded (%s); orientation frame-transport-" "invariant det u' = det u exactly (%s). VERDICT SILENT" % (ok_novar, stab_id_ok, det_inv), ok_novar and stab_id_ok and det_inv, kill="K3") # D4 doily / edge-combinatorics: refined stabilizer AintCC = sp.Matrix(A_int[np.ix_(CAR_IDX, CAR_IDX)].tolist()) ref_rows = [] for v in stab_vecs: XCk = XC_of([v[k, 0] for k in range(len(pairsC))]) Cm = sp.expand(XCk * AintCC - AintCC * XCk) ref_rows.append([Cm[r, c] for r in range(10) for c in range(10)]) Mref = sp.Matrix(ref_rows) d_cut = Mref.rank() d_ref = dim_stab - d_cut # K_C, K_B pass the refined demand exactly okKC_ref = sp.expand(KC16[0:10, 0:10] * AintCC - AintCC * KC16[0:10, 0:10]) \ == sp.zeros(10, 10) okKB_ref = True # K_B does not touch [C, C]; A_int[B, B] = 0 okBB0 = np.array_equal(A_int[np.ix_(BND_IDX, BND_IDX)], np.zeros((6, 6), dtype=np.int64)) check("P3.4 D4 doily/edge-combinatorics demand (wiring-free " "structure preservation incl. A_int[C, C]): refined " "stabilizer dim = %d == 9 of 9 (NO direction cut: every " "rule-gauge direction preserves the deployed " "carrier-carrier interior exactly); K_C commutes with " "A_int[C, C] (%s), K_B untouched (A_int[B, B] = 0: %s) " "=> the (gamma, y) torus and the FULL delta-circle " "survive. VERDICT COMPATIBLE-NOT-FORCING (cuts nothing)" % (d_ref, okKC_ref, okBB0), d_ref == 9 and okKC_ref and okKB_ref and okBB0, kill="K3") # D5 the round-59 census property on the orbit A0f = np.tanh(0.5) * A16_dep.astype(np.float64) frames_f = {"theta_S": (T0f, F_S)} for gnm, g in gauges.items(): gf = np.array(g.tolist(), dtype=np.float64) frames_f["g" + gnm] = (gf @ T0f @ gf.T, [gf @ f for f in F_S]) spec1, spec2 = {}, {} herm_bare = 0.0 for nm, (thf, Ff) in frames_f.items(): M1 = gram_gen(thf, Ff, 1j, A0f, POS1) M2 = gram_gen(thf, Ff, 1j, A0f, POS2) herm_bare = max(herm_bare, float(np.max(np.abs(M1 - M1.conj().T))), float(np.max(np.abs(M2 - M2.conj().T)))) spec1[nm] = np.sort(np.linalg.eigvalsh( (M1 + M1.conj().T) / 2)) spec2[nm] = np.sort(np.linalg.eigvalsh( (M2 + M2.conj().T) / 2)) dev_sp = max( float(np.max(np.abs(spec1[nm] - spec1["theta_S"]))) for nm in frames_f) dev_sp2 = max( float(np.max(np.abs(spec2[nm] - spec2["theta_S"]))) for nm in frames_f) lm1 = float(spec1["theta_S"][0]) lm2 = float(spec2["theta_S"][0]) lm1_cf = float(np.tanh(0.5)) lm2_cf = float(np.tanh(0.5) ** 2) # theta_abT marginal-0 regression (bare 1p Gram identically 0) r_abT = {k: k for k in range(16)} for k in range(2): r_abT[CH[a_ch][k]] = CH[b_ch][1 - k] r_abT[CH[b_ch][k]] = CH[a_ch][1 - k] B1_ab = [(a,) for a in CH[a_ch]] wk0 = wick_factory(A0f) M1T = gram_idx(B1_ab, r_abT, 1j, wk0) marg = float(np.max(np.abs(M1T))) check("P3.5 D5 round-59 census property on the orbit: bare " "strict RP (eta = +i) holds at ALL 4 frames with " "IDENTICAL spectra (Herm %.1e, spec dev %.1e/%.1e <= " "1e-10); closed forms lam_min 1p %.4f == tanh(1/2) = " "%.4f, deg-2 %.4f == tanh(1/2)^2 = %.4f; theta_abT bare " "1p Gram marginal-0 (%.1e): the census property " "distinguishes the FAMILY, is CONSTANT on the angle; " "theta_S's angle is v440 LINEAGE (deployment). VERDICT " "SILENT-ON-ANGLE" % (herm_bare, dev_sp, dev_sp2, lm1, lm1_cf, lm2, lm2_cf, marg), herm_bare <= 1e-10 and dev_sp <= 1e-10 and dev_sp2 <= 1e-10 and abs(lm1 - lm1_cf) <= 1e-10 and abs(lm2 - lm2_cf) <= 1e-10 and lm1 > 0 and lm2 > 0 and marg <= 1e-12, kill="K3") # ================================================================== section("P4 -- the closure (exact strict RP in orbit frames)") # ================================================================== def wickv_exact_factory(Aex): Wm = sp.eye(16) + sp.I * Aex def wickv(vecs): k = len(vecs) if k % 2 == 1: return sp.Integer(0) if k == 0: return sp.Integer(1) K = [[sp.expand((vecs[p].T * Wm * vecs[q])[0, 0]) for q in range(k)] for p in range(k)] def rec(idxs): if not idxs: return sp.Integer(1) head, rest = idxs[0], idxs[1:] tot = sp.Integer(0) for j, bpos in enumerate(rest): w = K[head][bpos] if w != 0: sub = rest[:j] + rest[j + 1:] tot += sp.Integer(-1) ** j * w * rec(sub) return tot return rec(list(range(k))) return wickv def gram_gen_exact(theta_s, F_cols, eta, wickv, basis_pos): imgs_ = [sp.expand(theta_s * f) for f in F_cols] n = len(basis_pos) M = sp.zeros(n, n) for ai, ma in enumerate(basis_pos): va = [imgs_[p] for p in reversed(ma)] coeff = eta ** len(ma) for bi, mb in enumerate(basis_pos): vb = [F_cols[p] for p in mb] M[ai, bi] = sp.expand(coeff * wickv(va + vb)) return M def herm_exact(M): return sp.expand(M - M.conjugate().T) == sp.zeros(*M.shape) def psd_exact(M): n = M.shape[0] M = sp.Matrix(M) pivots = [] for k in range(n): d = sp.nsimplify(sp.re(M[k, k])) pivots.append(d) if d == 0: if any(sp.expand(M[k, j]) != 0 for j in range(k, n)): return False, pivots continue if d < 0: return False, pivots for i in range(k + 1, n): if M[i, k] != 0: f = M[i, k] / d for j in range(k, n): M[i, j] = sp.expand(M[i, j] - f * M[k, j]) return True, pivots def exact_parent(Vm): kapQ, mQ, tQ = (sp.Rational(1, 2), sp.Rational(1, 2), sp.Rational(1, 20)) A_ex = sp.zeros(16, 16) A_ex[0:10, 0:10] = kapQ * A_CCs A_ex[10:16, 10:16] = mQ * J3s A_ex[0:10, 10:16] = tQ * Vm A_ex[10:16, 0:10] = -tQ * Vm.T return A_ex # (a) deployed parent (pure-I) in the INTEGER frame theta' Vdep_s = sp.Matrix(Vdep.tolist()) A_ex_dep = exact_parent(Vdep_s) wv_dep = wickv_exact_factory(A_ex_dep) F_int = [g_int * sp.eye(16)[:, a] for a in P_S] M1i = gram_gen_exact(th_int, F_int, sp.I, wv_dep, POS1) M2i = gram_gen_exact(th_int, F_int, sp.I, wv_dep, POS2) h1i = herm_exact(M1i) h2i = herm_exact(M2i) p1i, piv1 = psd_exact(M1i) p2i, piv2 = psd_exact(M2i) pd1 = p1i and all(p > 0 for p in piv1) pd2 = p2i and all(p > 0 for p in piv2) l1i = float(np.min(np.linalg.eigvalsh(np.array( M1i.evalf(16), dtype=complex)))) l2i = float(np.min(np.linalg.eigvalsh(np.array( M2i.evalf(16), dtype=complex)))) check("P4.1 THE CLOSURE HEADLINE: strict collar RP of the " "DEPLOYED parent (pure-I, (1/2,1/2,1/20)) in the INTEGER " "frame theta' PASSES EXACTLY: Grams Hermitian (%s, %s), " "PD by exact LDL (%s, %s); float lam_min %.4f == 0.3064 " "+- 0.005 (1p), %.4f == 0.1532 +- 0.005 (deg-2) -- the " "round-60 V_J numbers transported; the SAME parent fails " "strict theta_S with raw defect 0.1 (P2.1): the " "round-58/59 obstruction is FRAME-RELATIVE" % (h1i, h2i, pd1, pd2, l1i, l2i), h1i and h2i and pd1 and pd2 and abs(l1i - 0.3064) <= 5e-3 and abs(l2i - 0.1532) <= 5e-3, kill="K4") # (b) generic-angle closure: theta_r with its selected wiring w_sel = wiring((sp.Rational(4, 5), 0, sp.Rational(3, 5), 0), (sp.Rational(4, 5), 0, sp.Rational(3, 5), 0)) V_sel = V_sym.subs(w_sel) A_ex_sel = exact_parent(V_sel) wv_sel = wickv_exact_factory(A_ex_sel) F_rr = [g_r * sp.eye(16)[:, a] for a in P_S] M1r = gram_gen_exact(th_r, F_rr, sp.I, wv_sel, POS1) M2r_e = gram_gen_exact(th_r, F_rr, sp.I, wv_sel, POS2) h1r = herm_exact(M1r) h2r = herm_exact(M2r_e) p1r, piv1r = psd_exact(M1r) p2r, piv2r = psd_exact(M2r_e) pd1r = p1r and all(p > 0 for p in piv1r) pd2r = p2r and all(p > 0 for p in piv2r) # E1-E5 admissibility of the selected wiring (exact) selE1 = [sp.expand(g.subs(w_sel)) for g in (g1_2, g2_2, g1_3, g2_3)] selPen = [sp.expand(g.subs(w_sel)) for g in (pI, pX, pZ)] selDet = (sp.expand(u2.det().subs(w_sel)), sp.expand(u3.det().subs(w_sel))) check("P4.2 generic-angle closure witness: theta_r with its " "selected wiring u = (4/5) I + (3/5) J: E1 %s == 0, " "pencil %s == 0, dets %s > 0; strict RP EXACT (Hermitian " "%s/%s, PD %s/%s) -- at a NON-integer interior angle the " "frame + its selected ray are strict-collar clean" % (selE1, selPen, selDet, h1r, h2r, pd1r, pd2r), all(e == 0 for e in selE1) and all(e == 0 for e in selPen) and all(d > 0 for d in selDet) and h1r and h2r and pd1r and pd2r, kill="K4") print("\n THE DEMAND CENSUS TABLE (frame orbit of theta_S " "under the 9-dim rule gauge):") print(" D1 mu4-step / C6 equivariance: " "COMPATIBLE-NOT-FORCING (family-defining)") print(" D2 CAR / quasi-free modular: SILENT " "(state exactly torus-invariant)") print(" D3 Pf pencil / orientation: SILENT " "(no frame variable; gauge-stable)") print(" D4 doily / edge combinatorics: " "COMPATIBLE-NOT-FORCING (refined 9/9, cuts nothing)") print(" D5 twisted-involution census: SILENT-ON-ANGLE " "(constant on orbit; family-selecting)") print(" => NO demand pins a point on the delta-circle: " "the collar frame is CONVENTIONAL;") print(" the compiler forces the component C_rot and " "the frame FAMILY, and the invariant") print(" content of (frame, wiring) is ONLY the " "relative angle -- the deployed pure-I is") print(" maximally obstructed relative to theta_S and " "EXACTLY clean relative to theta'.") # ================================================================== section("P5 -- controls (must fire)") # ================================================================== # C1 non-commutant frame: rotate channel 1's pair only g_1 = sp.eye(16) g_1[0:2, 0:2] = Rr th_c = frame_of(g_1) commC1 = sp.expand(th_c * O16s - O16s * th_c) n_nzC1 = sum(1 for e in commC1 if e != 0) check("C1 non-commutant frame (channel-1 rotation): " "[theta_c, O16] has %d >= 4 nonzero entries -- D1 fires " "off-orbit" % n_nzC1, n_nzC1 >= 4, kill="K7") # C2 relative-rotation frame: transported pure-J fails the pencil g_relm = sp.eye(16) for i in TWO: r0 = 2 * (i - 1) g_relm[r0:r0 + 2, r0:r0 + 2] = Rr VJ_s = V_sym.subs(wiring((0, 0, 1, 0), (0, 0, 1, 0))) Vp_rel = sp.expand(g_relm[0:10, 0:10].T * VJ_s) u2rel = Vp_rel[2 * (rep2 - 1):2 * rep2, 0:2] u3rel = Vp_rel[2 * (rep3 - 1):2 * rep3, 0:2] a2r_, _b, c2r_, _d = pauli_coords(u2rel) a3r_, _b3x, c3r_, _d3x = pauli_coords(u3rel) minor_val = sp.expand(a2r_ * c3r_ - c2r_ * a3r_) check("C2 relative-rotation frame (g0, NOT rule stabilizer): " "transported pure-J violates the pencil quadric " "a2 c3 - c2 a3 = %s == -4/5 != 0 -- selector transport " "breaks outside the rule gauge" % minor_val, minor_val == -sp.Rational(4, 5), kill="K7") # C3 eta = +1 breaks bare Hermiticity M1e = gram_gen(T0f, F_S, 1.0, A0f, POS1) defE = float(np.max(np.abs(M1e - M1e.conj().T))) check("C3 eta = +1 at the bare point: 1p Gram Hermiticity " "defect %.4f >= 0.4 (v519/round-58 twist regression)" % defE, defE >= 0.4, kill="K7") # C4 seeded random pairings as frames rng = np.random.default_rng(907) n_fire = 0 for _ in range(3): perm = rng.permutation(16) mt = np.zeros((16, 16), dtype=np.int64) for k in range(0, 16, 2): mt[perm[k], perm[k + 1]] = 1 mt[perm[k + 1], perm[k]] = 1 rev_ok = np.array_equal(mt @ A16_dep @ mt, -A16_dep) if not rev_ok: n_fire += 1 continue Fm = [np.eye(16)[:, a] for a in P_S] M1m = gram_gen(mt.astype(np.float64), Fm, 1j, A0f, POS1) if float(np.max(np.abs(M1m - M1m.conj().T))) >= 0.1: n_fire += 1 check("C4 seeded random pairings (rng 907, 3 draws): each " "fails D1 A16-reversal or breaks bare Hermiticity -- " "%d/3 fire" % n_fire, n_fire == 3, kill="K7") # C5 theta = I16 okC5 = (not np.array_equal( np.eye(16, dtype=np.int64) @ A16_dep, -A16_dep)) check("C5 theta = I16 fails the mu4-step reversal " "(I A16 I = +A16 != -A16) and is not side-exchanging -- " "the D1 demand is non-vacuous", okC5, kill="K7") # C6 census regression gate def eval_E1(sub): return [sp.expand(g.subs(sub)) for g in (g1_2, g2_2, g1_3, g2_3)] def eval_pencil(sub): return [sp.expand(g.subs(sub)) for g in (pI, pX, pZ)] def eval_dets(sub): return (sp.expand(u2.det().subs(sub)), sp.expand(u3.det().subs(sub))) def census_exact(sub): kapQ, mQ, tQ = (sp.Rational(1, 2), sp.Rational(1, 2), sp.Rational(1, 20)) lamQ = mQ / (1 - mQ ** 2) Vm = V_sym.subs(sub) S = Vm * J3s * Vm.T A_eff = kapQ * A_CCs + lamQ * tQ ** 2 * S n_nz, n_sig = 0, 0 Jco45 = None for (i, j) in CAR_DUADS: Bx = A_eff[2 * (i - 1):2 * i, 2 * (j - 1):2 * j] nz = any(e != 0 for e in Bx) n_nz += nz pf = sp.expand(-(Bx[0, 0] * Bx[1, 1] - Bx[0, 1] * Bx[1, 0])) if pf != 0: n_sig += (int(sp.sign(pf)) == sign_c[frozenset({i, j})]) if (i, j) == (a_ch, b_ch): Jco45 = sp.expand((Bx[0, 1] - Bx[1, 0]) / 2) return n_nz, n_sig, Jco45 E1I = eval_E1(wI) penI = eval_pencil(wI) detI = eval_dets(wI) nzI, sigI, JcoI = census_exact(wI) wZ = wiring((0, 0, 0, 1), (0, 0, 0, 1)) detZ = eval_dets(wZ) E1Z = eval_E1(wZ) penZ = eval_pencil(wZ) check("C6 census regression gate: pure-I passes E1 %s == 0, " "pencil %s == 0, dets %s > 0, census %d/10 canonical " "%d/10, J-coordinate %s == 1/200; V_Z passes E1/pencil " "(%s, %s) but fails EXACTLY orientation (dets %s == " "(-1, -1))" % (E1I, penI, detI, nzI, sigI, JcoI, all(e == 0 for e in E1Z), all(e == 0 for e in penZ), detZ), all(e == 0 for e in E1I) and all(e == 0 for e in penI) and all(d > 0 for d in detI) and nzI == 10 and sigI == 10 and JcoI == sp.Rational(1, 200) and all(e == 0 for e in E1Z) and all(e == 0 for e in penZ) and all(d == -1 for d in detZ), kill="K7") # ================================================================== section("VERDICT") # ================================================================== n_pass = sum(1 for _n, ok in CHECKS if ok) n_tot = len(CHECKS) all_ok = (n_pass == n_tot) and not KILLS if all_ok: verdict = ("THETA-CONVENTIONAL [FRAME-ORBIT-MEASURED" "(tangent 7/9, torus legal), " "EQUIVARIANT-SELECTOR(selected ray = g.(+-J)), " "ALL-DEMANDS-SILENT-ON-ANGLE(D1 family, D2 " "silent, D3 silent, D4 not-forcing 9/9, D5 " "constant-on-orbit), " "DEPLOYED-STRICT-RP-IN-INTEGER-FRAME(exact), " "WIRING-QUESTION-CLOSED(freedom group = " "rule-gauge frame orbit; selection quotient = " "the delta-circle)]") else: verdict = " / ".join(sorted(set(KILLS))) or "CHECK-FAILED" print(" checks: %d/%d passed; kills: %s" % (n_pass, n_tot, KILLS if KILLS else "none")) print(" VERDICT: %s" % verdict) print(" runtime: %.1f s" % (time.time() - T0)) print(" (constants sanity: N_fam = %s, g_car = %s)" % (N_fam, g_car)) return 0 if all_ok else 1 if __name__ == "__main__": sys.exit(main()) ''' # ------------- frozen probe source wiring_gauge_rp_audit_probe (embedded BYTE-EXACT, raw string) _SRC_2 = r''' #!/usr/bin/env python3 # -*- coding: utf-8 -*- r"""wiring_gauge_rp_audit_probe -- SEAM.STATE.WIRING.GAUGE.RP.01 (EXPLORATION ONLY, experiments/; 2026-08-12 -- the mandatory gauge-covariance audit of the reflection-positivity exclusion, ordered by the program lead on top of CCXIII (wiring census) and CCXV (theta-frame decision). Two exact questions, one corrected canonical sentence.) THE LEAD'S TWO QUESTIONS (verbatim scope). (a) CONJUGATION: is Theta_S^(J) = g Theta_S^(I) g^{-1} -- i.e. are the collar reflections attached to the pure-J and pure-I representatives exact rule-gauge conjugates under the integer element g_int = (+)_5 J2 (+) I6, and how does the relation extend to a generic rule-gauge element? (b) COVARIANCE OF THE RP GRAM FORMS: do the strict-collar RP Grams transform covariantly under the rule-gauge orbit, so that RP(theta, wiring) depends only on the RELATIVE angle delta(frame, wiring) -- and hence: is the RP exclusion of a wiring (1) gauge-invariant (an orbit statement) or (2) valid only at fixed Theta_S (a frame statement, NOT a wiring no-go)? CONVENTIONS (identical to theta_frame_selector_probe / CCXV; machinery rebuilt inline; READ-ONLY import of tfpt_constants): 16-dim Majorana space, carrier C = 0..9 (channels 1..5, pairs), boundary B = 10..15 (channel 0, three seats); A_CC = (+)_5 J2, J3 = A16_dep[B, B]; deployed wiring V_dep = A_int[C, B] (PURE-I, census point (-1,0,0,0|-1,0,0,0)); parent family A(kappa, m, t, V) at the frozen probe-7 point (1/2, 1/2, 1/20). theta_S = pair swap (X per Majorana pair, v440 lift); half-side = even indices; twist eta = +i (v519). Frames: theta' = g_int theta_S g_int^T (integer), theta_r = g_r theta_S g_r^T with g_r = R(3/5, 4/5) per carrier pair (+) I6 (rational generic angle). Wirings on C_rot: pure-I (u = -I), pure-J (u = J2), the theta_r-selected ray u = (4/5) I + (3/5) J. Wiring transport under a gauge g: V' = g_C^T V g_B (theta-selector convention, CCXV P2.b). RP Grams for a frame theta with half-side vectors f_p: Theta(f_{p1}..f_{pk}) = eta^k phi(theta f_{pk})..phi(theta f_{p1}) (v519 reversal + degree twist), M[a, b] = omega(Theta(m_a) m_b) by vector-Wick (Pfaffian recursion on kernel dot products u^T (I + iA) v). NUMERICAL PROTOCOL (declared): conjugation relations, torus identities, kernel-covariance law, Gram covariance at the witnesses, PD decisions (LDL) and the orientation invariance are EXACT (integer/rational/symbolic sympy); float64 ONLY in disclosed wards (machinery regression, defect-law wards, spectra); RNG nowhere (all controls deterministic). SMOKE-RUN DISCLOSURE (2026-08-12, one declared smoke round before freezing; fail-first preserved): smoke-1 ran 20/21 and corrected EXACTLY ONE hand-prediction by measurement, not inverting any verdict logic: the reflection-circle SIGN -- with the deployed convention J = [[0,1],[-1,0]], R(t) = cos t I - sin t J, the conjugated per-carrier-pair block is cos(2 gamma) X - sin(2 gamma) Z (NOT +; the CCXV "+" statement is the same circle traversed with the opposite orientation -- a pure convention), and the angle-addition target was rebuilt with the corrected sign. Two further hand-DERIVATIONS were pre-registered in this spec before the smoke and CONFIRMED unchanged by it: (i) the g_int wiring transport sends pure-J to pure-(+I) (u' = J2^T J2 I = +I) and pure-I to pure-(+J) (u' = J2^T (-I) = +J2) -- the CCXIII map "pure-I -> pure-(-J)" used the inverse transport direction; both are the same orbit statement (signs are flips inside the selected +-ray); (ii) the strict-collar deg-2 defect law max|M2 - M2^dagger| = 2t|a'| with a' = a cos(delta) + c sin(delta) at all three equal-orbit witness configurations. FROZEN CLAIMS (2026-08-12, frozen + SHA-hashed before the frozen run): P1 THE CONJUGATION ANSWER (question a; exact). (a) theta_S wards reproduced (integer involution, orthogonal, [theta_S, O16] = 0, theta_S A16_dep theta_S = -A16_dep, det +1, side-exchanging, split-preserving); census gauge objects reproduced: dim g0 = 16, rule stabilizer = 9; (b) THE RELATION HOLDS, BOTH DIRECTIONS, EXACTLY: theta^(I) := theta' = g_int theta_S g_int^{-1} AND theta_S = g_int theta' g_int^{-1} (g_int^2 = (+)_5(-I2) (+) I6 lies in the isotropy of theta_S, so conjugation by g_int is an involution on the frame pair); theta' = per carrier pair -X, boundary X (integer identity); (c) the attached-wiring correspondence transports with the frame (exact): the selection map sends theta_S -> pure-(+-J) and theta' -> pure-(+-I); g_int transports the pure-J wiring to pure-(+I) and pure-I to pure-(+J) (u' = g_C^T u g_B per pair; smoke-disclosed signs); (d) GENERIC EXTENSION (symbolic): the rule-gauge torus g(gamma, y) conjugates theta_S to the frame with per-carrier-pair block cos(2 gamma) X - sin(2 gamma) Z (boundary: 2y; smoke-corrected sign, see disclosure), frame legality (involution, C6 commutant, A16-reversal) holds IDENTICALLY on the torus, and conjugation composes by angle addition: g(g0) . frame(gamma) = frame(gamma + g0) exactly -- the generic rule element acts as a rotation of the delta-circle. P2 THE COVARIANCE ANSWER (question b; exact). (a) machinery regression (float): the general-theta vector-Wick Grams reproduce the round-60 index machinery entrywise (<= 1e-12); strict theta_S regression at the deployed parent: raw deg-2 defect 0.1 = 2t, 30 entries; (b) THE KERNEL-COVARIANCE LAW (symbolic, the proof): on the full symbolic torus with the symbolic wiring W, g(gamma, y)^T g(gamma, y) = I16 and g^T A(V) g = A(g_C^T V g_B) IDENTICALLY (256 entries each, reduced by cos^2 + sin^2 = 1); since every Gram entry is a polynomial in kernel dot products u^T (I + iA) v of vectors {theta f_p, f_p}, and the frame/half-side transport multiplies every vector by g, Gram(g theta g^T, gF, A(V)) = Gram(theta, F, A(V')) ENTRYWISE -- strict-collar RP is a function of the RELATIVE datum (frame, wiring) mod gauge only; (c) EXACT GRAM COVARIANCE AT THE WITNESSES: for (g, V) in {(g_int, pure-I), (g_int, pure-J), (g_r, pure-I)}: LHS Gram(g theta_S g^T, gF, A(V)) == RHS Gram(theta_S, F, A(g_C^T V g_B)) with EXACT entrywise equality (sympy expand == 0), 1p and deg-2; (d) THE DELTA REDUCTION (symbolic + float wards): the transported two-seat law a'_o = a_o cos(delta) + c_o sin(delta), delta = y - gamma, with the 1p seat identically zero on C_rot; defect-law wards: raw deg-2 defect = 2t |a'| at (theta_S, pure-I) = 0.1, (theta_r, pure-I) = 0.06, (theta', pure-J) = 0.1 (mirror witness), all <= 1e-12; (e) THE WITNESS TABLE AND THE OPTION VERDICT: strict collar RP passes EXACTLY (Hermitian + PD by exact LDL) at (theta_S, pure-J), (theta', pure-I) and (theta_r, (4/5, 3/5)); the 1p/deg-2 spectra of (theta_S, pure-J) and (theta', pure-I) agree <= 1e-10 (covariance corollary; the round-60 V_J numbers lam_min 0.3064 / 0.1532); the SAME pure-I wiring fails at theta_S (defect 0.1) and the SAME pure-J wiring fails at theta' (defect 0.1). HENCE OPTION (2): the RP exclusion of pure-I is a statement AT THE FIXED FRAME theta_S -- a frame statement, NOT a gauge-invariant wiring no-go; the orbit-invariant content is the covariance law itself: EVERY frame's strict collar selects exactly its delta = 0 ray, and the pair (frame, wiring) enters only through the delta-circle coordinate. P3 THE ORBIT-INVARIANT PART: THE Z/X EXCLUSION (exact). (a) orientation is frame-transport-invariant, symbolically: det(R(-gamma) u R(y)) = det u identically, and det u = a^2 + c^2 - b^2 - d^2 in Pauli coordinates; (b) the Z- and X-wirings have det u = -1 identically, and the whole reflection component C_refl has det u = -(b^2 + d^2) <= 0 -- so the orientation-propagation exclusion E4 fires in EVERY orbit frame: the Z/X exclusion IS genuinely rule-gauge-orbit-invariant (CONFIRMED, as the lead expected). P4 THE CORRECTED CANONICAL SENTENCE (frozen verbatim in this log, SHA-hashed). PERMITTED: "The exact Groebner census determines a single admissible three-dimensional wiring orbit (the rotation cell C_rot); Z- and X-wirings are excluded by orientation propagation, and this exclusion is rule-gauge-invariant. Pure-I and pure-J are connected by an integer rule-gauge element and lie on one orbit: pure-I is a deployment representative, not a compiler theorem. Strict collar reflection positivity is covariant under the rule gauge and depends only on the relative angle delta between collar frame and wiring: strict Hermiticity in the theta_S frame would select pure-J; the same demand in the integer-conjugated frame selects pure-I. A canonical wiring selection requires an additionally derived physical frame." FORBIDDEN (equally frozen): "pure-I is compiler-forced"; "the compiler derives the pure-I wiring"; "strict collar RP excludes the J-wiring" (without the frame qualifier). C CONTROLS (must fire; frozen fire rules; NO RNG). C1 NON-ORTHOGONAL ELEMENT BREAKS THE KERNEL LAW: the shear N = I16 + (1/2) e_0 e_1^T (det 1, not orthogonal) gives max|N^T (I + iA) N - (I + i N^T A N)| >= 1/4 exactly (the real part N^T N - I != 0) -- orthogonality is load-bearing for the covariance; C2 NON-RULE GAUGE ELEMENT BREAKS RULE-COVARIANCE: the relative-rotation element (g0 but NOT rule stabilizer, 2-cycle carrier channels only, rational 3/5-4/5) transports pure-J OFF the admissible variety: pencil quadric a2 c3 - c2 a3 = -4/5 != 0 exact -- the covariance orbit statement lives on the RULE gauge only; C3 ORIENTATION-FLIP CONTROL: s = (+)_5 Z (+) I6 is orthogonal and WOULD legalize the Z-wiring (det(Z u) = -det u symbolically) -- but it is NOT rule-gauge: s A_CC s^T = -A_CC != A_CC exactly (the bare vacuum flips) -- the only way to undo the Z/X exclusion leaves the rule gauge: the P3 orbit-invariance is non-vacuous; C4 eta = +1 at the bare point breaks collar Gram Hermiticity (raw defect >= 0.4; v519 twist regression); C5 CENSUS REGRESSION GATE: pure-I passes E1 + pencil + E4 + canonical census 10/10 with J-coordinate exactly +1/200; V_Z passes E1/pencil but fails EXACTLY orientation E4 (dets == -1). KILLS (any one fires => typed gap): K0 AST firewall / compiler rebuild ward breaks -> PIPELINE-BROKEN K1 a conjugation / frame ward breaks -> CONJUGATION-BROKEN K2 a covariance / machinery ward breaks -> COVARIANCE-BROKEN K3 an orbit-invariance computation breaks -> ORIENTATION-BROKEN K7 a control does not fire -> CONTROL-DEAD VERDICT (frozen enum): RP-FRAME-COVARIANT [CONJUGATION-EXACT(theta' = g_int theta_S g_int^{-1}, both directions; generic element = delta-circle rotation), KERNEL-COVARIANCE-EXACT(symbolic torus + exact Gram witnesses), DELTA-ONLY(defect = 2t|a cos delta + c sin delta|), EXCLUSION-IS-FRAME-STATEMENT(option 2: fixed-Theta_S statement, not a wiring no-go), Z-X-EXCLUSION-ORBIT-INVARIANT(det u gauge-invariant), CANONICAL-SENTENCE-FROZEN] / RP-GAUGE-INVARIANT / COVARIANCE-PARTIAL / PIPELINE-BROKEN / CONJUGATION-BROKEN / COVARIANCE-BROKEN / ORIENTATION-BROKEN / CONTROL-DEAD. Exit 0 iff all checks pass and no kill fired; else 1. FIREWALL: experiments/ probe; EXPLORATION ONLY -- writes nothing but stdout; no verification/, paper, ledger, changelog or website surface; no .md, no commits. NO physics claim beyond the recorded identities and measurements: the covariance statement is over the rule-gauge orbit as constructed in CCXIII/CCXV (torus symbolic + integer/rational witnesses); whether the actual seam physics derives a specific collar frame remains outside the formalized rules; the v898/v903 [O] premise is unmoved; no marker moves. NO RH claim. SPEC v1 (2026-08-12): frozen after the declared smoke round; no amendments at freeze. Sources (read-only, machinery rebuilt inline): theta_frame_selector_probe (CCXV: frame orbit, transport, selection map), seam_wiring_groebner_probe (CCXIII: census, g_int, C_refl), seam_ness_parent_probe (round 60: Gram machinery), v519 (eta = +i), tfpt_constants (N_fam, g_car). Run: experiments/tfpt-discovery/.venv/bin/python \ experiments/tfpt-discovery/wiring_gauge_rp_audit_probe.py """ import ast import hashlib import itertools import os import sys import time import numpy as np import sympy as sp _HERE = os.path.dirname(os.path.abspath(__file__)) _VERIFY = os.path.abspath(os.path.join(_HERE, "..", "..", "verification")) sys.path.insert(0, _VERIFY) from tfpt_constants import N_fam, g_car # noqa: E402 (READ-ONLY) BANNED_IDS = ("zetazero", "nzeros", "primerange", "isprime", "primepi", "nextprime", "prevprime") CHECKS = [] KILLS = [] T0 = time.time() SPEC_SHA = hashlib.sha256(__doc__.encode("utf-8")).hexdigest() PERMITTED_SENTENCE = ( "The exact Groebner census determines a single admissible " "three-dimensional wiring orbit (the rotation cell C_rot); " "Z- and X-wirings are excluded by orientation propagation, " "and this exclusion is rule-gauge-invariant. Pure-I and " "pure-J are connected by an integer rule-gauge element and " "lie on one orbit: pure-I is a deployment representative, " "not a compiler theorem. Strict collar reflection " "positivity is covariant under the rule gauge and depends " "only on the relative angle delta between collar frame and " "wiring: strict Hermiticity in the theta_S frame would " "select pure-J; the same demand in the integer-conjugated " "frame selects pure-I. A canonical wiring selection " "requires an additionally derived physical frame.") FORBIDDEN_SENTENCES = ( "pure-I is compiler-forced", "the compiler derives the pure-I wiring", "strict collar RP excludes the J-wiring " "(without the frame qualifier)") def check(name, ok, detail="", kill=None): CHECKS.append((name, bool(ok))) if kill and not ok: KILLS.append(kill) print(" [%s] %s%s" % ("PASS" if ok else "FAIL", name, (" -- " + detail) if detail else ""), flush=True) return bool(ok) def section(title): print("\n" + "=" * 74) print("%s (t=%.1fs)" % (title, time.time() - T0)) print("=" * 74, flush=True) def ast_scan(banned): src = open(os.path.abspath(__file__), encoding="utf-8").read() bad = [] for node in ast.walk(ast.parse(src)): name = None if isinstance(node, ast.Name): name = node.id elif isinstance(node, ast.Attribute): name = node.attr if name and name.lower() in banned: bad.append(name) return bad # ---------------------------------------------------------- bit model def pc(v): return bin(v).count("1") HT = [[(pc(v) * pc(w) - pc(v & w)) % 2 for w in range(16)] for v in range(16)] A_BIT = 0b1000 FSIG = 0b0111 LOWIDX = {1: 0, 2: 1, 4: 2, 8: 3} def sig(v): b = [(v >> i) & 1 for i in range(4)] n = (b[2], b[0], b[1], b[3]) return sum(bit << i for i, bit in enumerate(n)) SIGP = tuple(sig(v) for v in range(16)) def polar_shift(c): return tuple((pc(v) * (pc(v) - 1) // 2 + pc(c & v)) % 2 for v in range(16)) def iota_bits(v): b = [(v >> i) & 1 for i in range(4)] b.append(sum(b) % 2) return tuple(b) IOTA_MSG = [iota_bits(v) for v in range(16)] def iota_support(v): return frozenset(i + 1 for i, bit in enumerate(IOTA_MSG[v]) if bit) def compose(p, q): return tuple(p[q[i]] for i in range(len(q))) def perm_order(p): o, pp = 1, p ident = tuple(range(len(p))) while pp != ident: pp = tuple(p[x] for x in pp) o += 1 return o def cycle_type(perm): n = len(perm) seen = [False] * n cyc = [] for i in range(n): if seen[i]: continue ln, j = 0, i while not seen[j]: seen[j] = True j = perm[j] ln += 1 cyc.append(ln) return tuple(sorted(cyc)) def edge_orbits(perm): n_ord = perm_order(perm) seen = set() out = [] for i, j in itertools.combinations(range(6), 2): e = frozenset({i, j}) if e in seen: continue x, y = i, j edges = set() rev = False for _k in range(n_ord): edges.add(frozenset({x, y})) x, y = perm[x], perm[y] if (x, y) == (j, i): rev = True seen |= edges out.append((frozenset(edges), rev, (i, j))) return out DUADS_CH = sorted(itertools.combinations(range(6), 2)) CAR_DUADS = sorted(itertools.combinations(range(1, 6), 2)) I2s = sp.eye(2) Xs = sp.Matrix([[0, 1], [1, 0]]) Js = sp.Matrix([[0, 1], [-1, 0]]) Zs = sp.Matrix([[1, 0], [0, -1]]) def pauli_coords(M): return (sp.expand((M[0, 0] + M[1, 1]) / 2), sp.expand((M[0, 1] + M[1, 0]) / 2), sp.expand((M[0, 1] - M[1, 0]) / 2), sp.expand((M[0, 0] - M[1, 1]) / 2)) def main(): print("SEAM.STATE.WIRING.GAUGE.RP.01 -- gauge-covariance audit " "of the RP wiring exclusion") print("FROZEN_SPEC SHA-256: %s" % SPEC_SHA) print("NO physics claim beyond recorded identities/measurements; " "exploration only.") # ================================================================== section("S0 -- firewall + compiler-side setup (census rebuild)") # ================================================================== bad = ast_scan(BANNED_IDS) check("S0.0 AST firewall: no banned identifiers %s" % (BANNED_IDS,), not bad, kill="K0") refs = [polar_shift(c) for c in range(16)] ok_ref = all( all(q[x ^ y] ^ q[x] ^ q[y] == HT[x][y] for x in range(16) for y in range(16)) for q in refs) arf1 = sorted(q for q in refs if q.count(0) == 6) siginv = [q for q in refs if all(q[SIGP[v]] == q[v] for v in range(16))] cand = [q for q in siginv if q[A_BIT] == 1 and q[FSIG] == 0] QSTAR = cand[0] if cand else None NZ = list(range(1, 16)) ovoid = [v for v in NZ if QSTAR[v] == 0] def duad(v): return frozenset(i for i, q in enumerate(arf1) if q[v] == 0) dmap = {v: duad(v) for v in NZ} V0 = arf1.index(QSTAR) phi = {} ok_phi = True for o in ovoid: others = dmap[o] - {V0} islot = frozenset(range(1, 6)) - iota_support(o) ok_phi &= (len(others) == 1 and len(islot) == 1) phi[next(iter(others))] = next(iter(islot)) ok_phi &= (len(phi) == 5 and set(phi.values()) == set(range(1, 6))) def lab(j): return 0 if j == V0 else phi[j] SP6 = [] for imgs in itertools.product(range(1, 16), repeat=4): p = [0] * 16 for v in range(1, 16): lb = v & -v p[v] = p[v ^ lb] ^ imgs[LOWIDX[lb]] if len(set(p)) != 16: continue if all(HT[imgs[x]][imgs[y]] == 1 for x in range(4) for y in range(x + 1, 4)): SP6.append(tuple(p)) S5P = list(itertools.permutations(range(5))) AUT = [] for p in SP6: if any(QSTAR[p[v]] != QSTAR[v] for v in range(16)): continue if compose(p, SIGP) != compose(SIGP, p): continue pis = [pi for pi in S5P if all(IOTA_MSG[p[v]] == tuple(IOTA_MSG[v][pi[s]] for s in range(5)) for v in range(16))] if pis: AUT.append(p) g_pin = [p for p in AUT if perm_order(p) == 6 and compose(p, p) == SIGP] check("S0.1 compiler rebuilt: unique q*, |Aut| = %d == 6, " "generator pin unique" % len(AUT), ok_ref and len(cand) == 1 and ok_phi and len(AUT) == 6 and len(g_pin) == 1, kill="K0") GEN = g_pin[0] a1idx = {q: i for i, q in enumerate(arf1)} tau = [a1idx[tuple(q[GEN[v]] for v in range(16))] for q in arf1] pia = [0] * 6 for j in range(6): pia[tau[j]] = j pia = tuple(pia) PI6 = [0] * 6 for j in range(6): PI6[lab(j)] = lab(pia[j]) PI6 = tuple(PI6) cycles = [] seen = set() for i in range(6): if i in seen: continue cyc, j = [], i while j not in seen: seen.add(j) cyc.append(j) j = PI6[j] cycles.append(cyc) TWO = sorted(next(c for c in cycles if len(c) == 2)) THREE = sorted(next(c for c in cycles if len(c) == 3)) a_ch, b_ch = TWO check("S0.2 deployed pi = %s, cycle type %s == (1, 2, 3); " "2-cycle {%d,%d}, 3-cycle %s" % (PI6, cycle_type(PI6), a_ch, b_ch, THREE), PI6[0] == 0 and cycle_type(PI6) == (1, 2, 3), kill="K0") CH = {0: list(range(10, 16))} for i in range(1, 6): CH[i] = [2 * (i - 1), 2 * (i - 1) + 1] CAR_IDX = list(range(10)) BND_IDX = list(range(10, 16)) img = [0] * 16 for i in range(6): for k, s in enumerate(CH[i]): img[s] = CH[PI6[i]][k] J2i = np.array([[0, 1], [-1, 0]], dtype=np.int64) I2i = np.eye(2, dtype=np.int64) IOTA6i = np.vstack([I2i, I2i, I2i]) orbs = edge_orbits(PI6) def put_ordered(A, x, y, B): rx, cy = CH[x], CH[y] for r in range(len(rx)): for c in range(len(cy)): A[rx[r], cy[c]] = B[r, c] A[cy[c], rx[r]] = -B[r, c] A_int = np.zeros((16, 16), dtype=np.int64) for edges, rev, rep in orbs: i, j = rep B = J2i if rev else (IOTA6i if i == 0 else I2i) x, y = i, j for _k in range(perm_order(PI6)): put_ordered(A_int, x, y, B) x, y = PI6[x], PI6[y] A16_dep = np.zeros((16, 16), dtype=np.int64) for i in range(8): A16_dep[2 * i, 2 * i + 1] = 1 A16_dep[2 * i + 1, 2 * i] = -1 okA = (np.array_equal(A_int[np.ix_(img, img)], A_int) and np.array_equal(A_int, -A_int.T)) okD = np.array_equal(A16_dep[np.ix_(img, img)], A16_dep) A_CC = A16_dep[np.ix_(CAR_IDX, CAR_IDX)] J3 = A16_dep[np.ix_(BND_IDX, BND_IDX)] Vdep = A_int[np.ix_(CAR_IDX, BND_IDX)] check("S0.3 blocks extracted: A_CC = (+)_5 J2, J3, deployed " "wiring V_dep = A_int[C, B]", okA and okD, kill="K0") O16 = np.zeros((16, 16), dtype=np.int64) for src in range(16): O16[img[src], src] = 1 O_C = O16[np.ix_(CAR_IDX, CAR_IDX)] O_B = O16[np.ix_(BND_IDX, BND_IDX)] CH2 = {i: [2 * i, 2 * i + 1] for i in range(6)} IOTA_f = IOTA6i.astype(np.float64) def compress12(A): Ahat = np.zeros((12, 12)) for (i, j) in DUADS_CH: if i == 0: Bm = IOTA_f.T @ A[np.ix_(CH[0], CH[j])] / 3.0 else: Bm = A[np.ix_(CH[i], CH[j])] for rr in range(2): for cc in range(2): Ahat[CH2[i][rr], CH2[j][cc]] = Bm[rr, cc] Ahat[CH2[j][cc], CH2[i][rr]] = -Bm[rr, cc] return Ahat pf4_c = {} Ahat_c = compress12(A_int.astype(np.float64) / 200.0) for (i, j) in DUADS_CH: Bm = Ahat_c[np.ix_(CH2[i], CH2[j])] pf4_c[frozenset({i, j})] = -(Bm[0, 0] * Bm[1, 1] - Bm[0, 1] * Bm[1, 0]) sign_c = {d: (1 if v > 0 else -1) for d, v in pf4_c.items()} check("S0.4 canonical G_c Pf4 signs rebuilt: 15 nonzero, all " "negative", all(abs(v) > 1e-16 for v in pf4_c.values()) and all(s == -1 for s in sign_c.values()), kill="K0") # ================================================================== section("P1 -- question (a): the conjugation relation") # ================================================================== T0i = np.zeros((16, 16), dtype=np.int64) for i in range(8): T0i[2 * i, 2 * i + 1] = 1 T0i[2 * i + 1, 2 * i] = 1 okT_inv = np.array_equal(T0i @ T0i, np.eye(16, dtype=np.int64)) okT_orth = np.array_equal(T0i @ T0i.T, np.eye(16, dtype=np.int64)) okT_c6 = np.array_equal(T0i @ O16, O16 @ T0i) okT_rev = np.array_equal(T0i @ A16_dep @ T0i, -A16_dep) okT_det = int(round(np.linalg.det(T0i.astype(np.float64)))) == 1 P_S = [2 * i for i in range(8)] okT_side = all(T0i[2 * i + 1, 2 * i] == 1 for i in range(8)) okT_split = all(T0i[r, c] == 0 for r in CAR_IDX for c in BND_IDX) # census gauge algebra: g0 and rule stabilizer (dims reproduced) a2, b2, c2, d2, a3, b3, c3, d3 = sp.symbols( "a2 b2 c2 d2 a3 b3 c3 d3", real=True) GENS8 = (a2, b2, c2, d2, a3, b3, c3, d3) u2 = a2 * I2s + b2 * Xs + c2 * Js + d2 * Zs u3 = a3 * I2s + b3 * Xs + c3 * Js + d3 * Zs def mkW(u2m, u3m): V = sp.zeros(10, 6) for i in range(1, 6): uo = u2m if i in TWO else u3m for s in range(3): V[2 * (i - 1):2 * i, 2 * s:2 * s + 2] = uo return V V_sym = mkW(u2, u3) pairsC = list(itertools.combinations(range(10), 2)) pairsB = list(itertools.combinations(range(6), 2)) nv = len(pairsC) + len(pairsB) A_CCs = sp.Matrix(A_CC.tolist()) J3s = sp.Matrix(J3.tolist()) O_Cs = sp.Matrix(O_C.tolist()) def XC_of(vec): X = sp.zeros(10, 10) for k, (i, j) in enumerate(pairsC): X[i, j] = vec[k] X[j, i] = -vec[k] return X def XB_of(vec): X = sp.zeros(6, 6) for k, (i, j) in enumerate(pairsB): X[i, j] = vec[len(pairsC) + k] X[j, i] = -vec[len(pairsC) + k] return X vsyms = sp.symbols("x0:%d" % nv, real=True) XCs = XC_of(vsyms) XBs = XB_of(vsyms) eqs = [] eqs += list(sp.expand(XCs * O_Cs - O_Cs * XCs)) eqs += list(sp.expand(XCs * A_CCs - A_CCs * XCs)) eqs += list(sp.expand(XBs * J3s - J3s * XBs)) Meq = sp.Matrix([[sp.diff(e, v) for v in vsyms] for e in eqs]) g0_basis = Meq.nullspace() dim_g0 = len(g0_basis) UT2 = sp.expand(u2.T * u2) UT3 = sp.expand(u3.T * u3) g1_2 = sp.expand(UT2[0, 1]) g2_2 = sp.expand(UT2[0, 0] - UT2[1, 1]) g1_3 = sp.expand(UT3[0, 1]) g2_3 = sp.expand(UT3[0, 0] - UT3[1, 1]) Mcross = sp.expand(3 * u2 * Js * u3.T) pI, pX, pJ, pZ = pauli_coords(Mcross) IDEAL_GENS = [g1_2, g2_2, g1_3, g2_3, sp.expand(2 * pI), sp.expand(2 * pX), sp.expand(2 * pZ)] gb = sp.groebner(IDEAL_GENS, *GENS8, order="grevlex") def rem(expr): return gb.reduce(sp.expand(expr))[1] rep2, rep3 = TWO[0], THREE[0] per_elem = [] for base in g0_basis: XCk = XC_of(list(base)) XBk = XB_of(list(base)) dV = sp.expand(XCk * V_sym - V_sym * XBk) du2 = dV[2 * (rep2 - 1):2 * rep2, 0:2] du3 = dV[2 * (rep3 - 1):2 * rep3, 0:2] condsW = [] for i in range(1, 6): ref = du2 if i in TWO else du3 for s in range(3): blk = dV[2 * (i - 1):2 * i, 2 * s:2 * s + 2] for e in sp.expand(blk - ref): condsW.append(e) d_coords = {} for symx, val in zip((a2, b2, c2, d2), pauli_coords(du2)): d_coords[symx] = val for symx, val in zip((a3, b3, c3, d3), pauli_coords(du3)): d_coords[symx] = val condsI = [] for f in IDEAL_GENS: df = sp.expand(sum(sp.diff(f, x) * d_coords[x] for x in GENS8)) condsI.append(sp.expand(rem(df))) per_elem.append((condsW, condsI, d_coords)) n_condW = len(per_elem[0][0]) n_condI = len(per_elem[0][1]) lin_rows = [] for ci in range(n_condW + n_condI): monos = set() polys = [] for condsW, condsI, _dc in per_elem: e = (condsW[ci] if ci < n_condW else condsI[ci - n_condW]) pe = sp.Poly(e, *GENS8) polys.append(pe) monos |= set(pe.monoms()) for mono in monos: lin_rows.append([pe.nth(*mono) for pe in polys]) Mstab = sp.Matrix(lin_rows) stab_basis = Mstab.nullspace() dim_stab = len(stab_basis) check("P1.1 theta_S wards + census gauge reproduced: theta_S " "involution/orthogonal/C6/A16-reversal/det+1/side/split " "all exact; dim g0 = %d == 16, rule stabilizer = %d == 9" % (dim_g0, dim_stab), okT_inv and okT_orth and okT_c6 and okT_rev and okT_det and okT_side and okT_split and dim_g0 == 16 and dim_stab == 9, kill="K1") # ---- the integer conjugation relation, both directions (exact) T0s = sp.Matrix(T0i.tolist()) g_int = sp.zeros(16, 16) for i in range(5): g_int[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Js g_int[10:16, 10:16] = sp.eye(6) g_int_inv = g_int.T # orthogonal ok_orth_gi = sp.expand(g_int * g_int.T) == sp.eye(16) th_int = sp.expand(g_int * T0s * g_int_inv) # forward: theta^(I) = g_int theta_S g_int^{-1} ok_fw = all( th_int[2 * i:2 * i + 2, 2 * i:2 * i + 2] == -Xs for i in range(5)) and all( th_int[10 + 2 * i:12 + 2 * i, 10 + 2 * i:12 + 2 * i] == Xs for i in range(3)) # backward: theta_S = g_int theta' g_int^{-1} (conjugation by # g_int is an involution on the frame pair, since g_int^2 is # in the isotropy of theta_S) ok_bw = sp.expand(g_int * th_int * g_int_inv - T0s) \ == sp.zeros(16, 16) gsq = sp.expand(g_int * g_int) ok_iso = sp.expand(gsq * T0s * gsq.T - T0s) == sp.zeros(16, 16) O16s = sp.Matrix(O16.tolist()) A16s = sp.Matrix(A16_dep.tolist()) def frame_legal(th): inv = sp.expand(th * th) == sp.eye(16) c6 = sp.expand(th * O16s - O16s * th) == sp.zeros(16, 16) rev = sp.expand(th * A16s * th + A16s) == sp.zeros(16, 16) return inv and c6 and rev check("P1.2 THE CONJUGATION RELATION (exact, both directions): " "theta^(I) = g_int theta_S g_int^{-1} (per carrier pair " "-X, boundary X: %s) AND theta_S = g_int theta^(I) " "g_int^{-1} (%s; g_int^2 in the isotropy of theta_S: " "%s); g_int orthogonal (%s); both frames rule-legal " "(%s, %s)" % (ok_fw, ok_bw, ok_iso, ok_orth_gi, frame_legal(T0s), frame_legal(th_int)), ok_fw and ok_bw and ok_iso and ok_orth_gi and frame_legal(T0s) and frame_legal(th_int), kill="K1") # ---- attached-wiring correspondence under g_int (exact) def wiring(u2v, u3v): return {a2: u2v[0], b2: u2v[1], c2: u2v[2], d2: u2v[3], a3: u3v[0], b3: u3v[1], c3: u3v[2], d3: u3v[3]} wI = wiring((-1, 0, 0, 0), (-1, 0, 0, 0)) wJ = wiring((0, 0, 1, 0), (0, 0, 1, 0)) V_I = V_sym.subs(wI) V_J = V_sym.subs(wJ) ok_VI = sp.expand(V_I - sp.Matrix(Vdep.tolist())) \ == sp.zeros(10, 6) gC = g_int[0:10, 0:10] gB = g_int[10:16, 10:16] V_J_tr = sp.expand(gC.T * V_J * gB) V_I_tr = sp.expand(gC.T * V_I * gB) # smoke-disclosed signs: pure-J -> pure-(+I), pure-I -> pure-(+J) ok_JtoI = sp.expand(V_J_tr - V_sym.subs( wiring((1, 0, 0, 0), (1, 0, 0, 0)))) == sp.zeros(10, 6) ok_ItoJ = sp.expand(V_I_tr - V_J) == sp.zeros(10, 6) # selected-ray transport: g_C (lam J2) g_B^T per pair = -lam I lam = sp.symbols("lam", real=True) sel_tr = sp.expand(Js * (lam * Js) * sp.eye(2)) ok_sel = sel_tr == sp.expand(-lam * sp.eye(2)) check("P1.3 attached-wiring correspondence under g_int " "(exact): pure-J transports to pure-(+I) (%s), pure-I " "to pure-(+J) (%s) [smoke-disclosed signs; same +-ray " "orbit as CCXIII's pure-(-J)]; selected-ray transport " "g_C (lam J2) g_B^T = -lam I per pair (%s): the frame " "and its selected wiring move together" % (ok_JtoI, ok_ItoJ, ok_sel), ok_JtoI and ok_ItoJ and ok_sel, kill="K1") # ---- generic extension: the symbolic torus (exact) cg, sg, cy, sy = sp.symbols("cg sg cy sy", real=True) cg0, sg0 = sp.symbols("cg0 sg0", real=True) Rg = sp.Matrix([[cg, -sg], [sg, cg]]) Ry = sp.Matrix([[cy, -sy], [sy, cy]]) Rg0 = sp.Matrix([[cg0, -sg0], [sg0, cg0]]) relg = [cg ** 2 + sg ** 2 - 1, cy ** 2 + sy ** 2 - 1, cg0 ** 2 + sg0 ** 2 - 1] def redrel(e): return sp.expand(sp.reduced(sp.expand(e), relg, cg, sg, cy, sy, cg0, sg0)[1]) def redrel_mat(M): return sp.Matrix(M.rows, M.cols, lambda i, j: redrel(M[i, j])) g_tor = sp.zeros(16, 16) for i in range(5): g_tor[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Rg for i in range(3): g_tor[10 + 2 * i:12 + 2 * i, 10 + 2 * i:12 + 2 * i] = Ry th_tor = sp.expand(g_tor * T0s * g_tor.T) # smoke-corrected sign: R X R^T = cos(2g) X - sin(2g) Z in # the deployed J/R convention pair_form = sp.expand((cg ** 2 - sg ** 2) * Xs - 2 * cg * sg * Zs) ok_pair = all( redrel_mat(th_tor[2 * i:2 * i + 2, 2 * i:2 * i + 2] - pair_form) == sp.zeros(2, 2) for i in range(5)) ok_inv_t = redrel_mat(sp.expand(th_tor * th_tor) - sp.eye(16)) \ == sp.zeros(16, 16) ok_c6_t = redrel_mat(sp.expand(th_tor * O16s - O16s * th_tor)) \ == sp.zeros(16, 16) ok_rev_t = redrel_mat(sp.expand(th_tor * A16s * th_tor + A16s)) \ == sp.zeros(16, 16) # angle addition: R(g0) [pair_form(gamma)] R(g0)^T = # pair_form(gamma + g0) Cc = cg * cg0 - sg * sg0 Ss = sg * cg0 + cg * sg0 added = sp.expand((Cc ** 2 - Ss ** 2) * Xs - 2 * Cc * Ss * Zs) conj = sp.expand(Rg0 * pair_form * Rg0.T) ok_add = redrel_mat(conj - added) == sp.zeros(2, 2) check("P1.4 GENERIC EXTENSION (symbolic torus): " "g(gamma, y) theta_S g^T has per-carrier-pair block " "cos(2g) X - sin(2g) Z (%s); frame legality IDENTICAL " "on the torus (involution %s, C6 %s, A16-reversal %s); " "conjugation composes by angle addition (%s): a generic " "rule element acts as a delta-circle rotation" % (ok_pair, ok_inv_t, ok_c6_t, ok_rev_t, ok_add), ok_pair and ok_inv_t and ok_c6_t and ok_rev_t and ok_add, kill="K1") # ================================================================== section("P2 -- question (b): covariance of the RP Gram forms") # ================================================================== def wick_factory(A): W = np.eye(A.shape[0], dtype=complex) + 1j * A memo = {} def wick(idx): idx = tuple(idx) if len(idx) == 0: return 1.0 + 0j if len(idx) % 2 == 1: return 0.0 + 0j if idx in memo: return memo[idx] head, rest = idx[0], idx[1:] tot = 0.0 + 0j for j, bb in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * W[head, bb] * wick(sub) memo[idx] = tot return tot return wick def gram_idx(basis, r, eta, wick): n = len(basis) M = np.zeros((n, n), dtype=complex) for ai, ma in enumerate(basis): imgs_ = [r[a] for a in reversed(ma)] coeff = eta ** len(ma) lst = list(imgs_) sgn = 1 for i in range(len(lst)): for j in range(len(lst) - 1 - i): if lst[j] > lst[j + 1]: lst[j], lst[j + 1] = lst[j + 1], lst[j] sgn = -sgn ca = coeff * sgn ia = tuple(lst) for bi, mb in enumerate(basis): M[ai, bi] = ca * wick(tuple(list(ia) + list(mb))) return M r_S = {} for i in range(8): r_S[2 * i] = 2 * i + 1 r_S[2 * i + 1] = 2 * i B1_S = [(a,) for a in P_S] B2_S = [()] + [tuple(c) for c in itertools.combinations(P_S, 2)] POS1 = [(p,) for p in range(8)] POS2 = [()] + [tuple(c) for c in itertools.combinations(range(8), 2)] def gram_gen(theta_f, F_f, eta, A, basis_pos): W = np.eye(16, dtype=complex) + 1j * A imgs_ = [theta_f @ F_f[p] for p in range(len(F_f))] def wickv(vecs): k = len(vecs) if k % 2 == 1: return 0.0 + 0j if k == 0: return 1.0 + 0j K = [[vecs[p] @ W @ vecs[q] for q in range(k)] for p in range(k)] def rec(idxs): if not idxs: return 1.0 + 0j head, rest = idxs[0], idxs[1:] tot = 0.0 + 0j for j, bpos in enumerate(rest): sub = rest[:j] + rest[j + 1:] tot += (-1) ** j * K[head][bpos] * rec(sub) return tot return rec(list(range(k))) n = len(basis_pos) M = np.zeros((n, n), dtype=complex) for ai, ma in enumerate(basis_pos): va = [imgs_[p] for p in reversed(ma)] coeff = eta ** len(ma) for bi, mb in enumerate(basis_pos): vb = [F_f[p] for p in mb] M[ai, bi] = coeff * wickv(va + vb) return M A_CCf = A_CC.astype(np.float64) J3f = J3.astype(np.float64) def parentV_f(kap, m, tt, V): A = np.zeros((16, 16)) A[np.ix_(CAR_IDX, CAR_IDX)] = kap * A_CCf A[np.ix_(BND_IDX, BND_IDX)] = m * J3f A[np.ix_(CAR_IDX, BND_IDX)] = tt * V A[np.ix_(BND_IDX, CAR_IDX)] = -tt * V.T return A T0f = T0i.astype(np.float64) F_S = [np.eye(16)[:, a] for a in P_S] A_dep = parentV_f(0.5, 0.5, 0.05, Vdep.astype(np.float64)) wk_dep = wick_factory(A_dep) M1_idx = gram_idx(B1_S, r_S, 1j, wk_dep) M2_idx = gram_idx(B2_S, r_S, 1j, wk_dep) M1_gen = gram_gen(T0f, F_S, 1j, A_dep, POS1) M2_gen = gram_gen(T0f, F_S, 1j, A_dep, POS2) dev_m = max(float(np.max(np.abs(M1_idx - M1_gen))), float(np.max(np.abs(M2_idx - M2_gen)))) D2S = M2_gen - M2_gen.conj().T defS = float(np.max(np.abs(D2S))) nentS = int(np.sum(np.abs(D2S) > 1e-12)) check("P2.1 machinery regression: general-theta == round-60 " "index machinery entrywise (max dev %.1e <= 1e-12); " "strict theta_S at the deployed parent: raw deg-2 " "defect %.4f == 2t = 0.1, %d == 30 entries" % (dev_m, defS, nentS), dev_m <= 1e-12 and abs(defS - 0.1) <= 1e-12 and nentS == 30, kill="K2") # ---- THE KERNEL-COVARIANCE LAW (symbolic torus; the proof) kapQ, mQ, tQ = (sp.Rational(1, 2), sp.Rational(1, 2), sp.Rational(1, 20)) def exact_parent(Vm): A_ex = sp.zeros(16, 16) A_ex[0:10, 0:10] = kapQ * A_CCs A_ex[10:16, 10:16] = mQ * J3s A_ex[0:10, 10:16] = tQ * Vm A_ex[10:16, 0:10] = -tQ * Vm.T return A_ex gC_tor = g_tor[0:10, 0:10] gB_tor = g_tor[10:16, 10:16] ok_orth_tor = redrel_mat( sp.expand(g_tor.T * g_tor) - sp.eye(16)) == sp.zeros(16, 16) A_of_V = exact_parent(V_sym) V_tr_sym = sp.expand(gC_tor.T * V_sym * gB_tor) A_of_Vtr = exact_parent(V_tr_sym) E_cov = redrel_mat(sp.expand(g_tor.T * A_of_V * g_tor) - A_of_Vtr) ok_cov_law = E_cov == sp.zeros(16, 16) check("P2.2 THE KERNEL-COVARIANCE LAW (symbolic, generic " "wiring, full torus): g^T g = I16 (%s) and " "g^T A(V) g = A(g_C^T V g_B) IDENTICALLY (%s) => every " "kernel dot product u^T (I + iA) v, hence EVERY Gram " "entry, is invariant under (theta, F, V) -> " "(g theta g^T, gF, V) with V -> g_C^T V g_B: strict-" "collar RP is a function of the RELATIVE (frame, " "wiring) datum only" % (ok_orth_tor, ok_cov_law), ok_orth_tor and ok_cov_law, kill="K2") # ---- exact Gram machinery def wickv_exact_factory(Aex): Wm = sp.eye(16) + sp.I * Aex def wickv(vecs): k = len(vecs) if k % 2 == 1: return sp.Integer(0) if k == 0: return sp.Integer(1) K = [[sp.expand((vecs[p].T * Wm * vecs[q])[0, 0]) for q in range(k)] for p in range(k)] def rec(idxs): if not idxs: return sp.Integer(1) head, rest = idxs[0], idxs[1:] tot = sp.Integer(0) for j, bpos in enumerate(rest): w = K[head][bpos] if w != 0: sub = rest[:j] + rest[j + 1:] tot += sp.Integer(-1) ** j * w * rec(sub) return tot return rec(list(range(k))) return wickv def gram_gen_exact(theta_s, F_cols, eta, wickv, basis_pos): imgs_ = [sp.expand(theta_s * f) for f in F_cols] n = len(basis_pos) M = sp.zeros(n, n) for ai, ma in enumerate(basis_pos): va = [imgs_[p] for p in reversed(ma)] coeff = eta ** len(ma) for bi, mb in enumerate(basis_pos): vb = [F_cols[p] for p in mb] M[ai, bi] = sp.expand(coeff * wickv(va + vb)) return M def herm_exact(M): return sp.expand(M - M.conjugate().T) == sp.zeros(*M.shape) def psd_exact(M): n = M.shape[0] M = sp.Matrix(M) pivots = [] for k in range(n): d = sp.nsimplify(sp.re(M[k, k])) pivots.append(d) if d == 0: if any(sp.expand(M[k, j]) != 0 for j in range(k, n)): return False, pivots continue if d < 0: return False, pivots for i in range(k + 1, n): if M[i, k] != 0: f = M[i, k] / d for j in range(k, n): M[i, j] = sp.expand(M[i, j] - f * M[k, j]) return True, pivots eye16 = sp.eye(16) F_S_sym = [eye16[:, a] for a in P_S] Rr = sp.Matrix([[sp.Rational(3, 5), -sp.Rational(4, 5)], [sp.Rational(4, 5), sp.Rational(3, 5)]]) g_r = sp.zeros(16, 16) for i in range(5): g_r[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Rr g_r[10:16, 10:16] = sp.eye(6) th_r = sp.expand(g_r * T0s * g_r.T) def exact_grams(th, F_cols, Vm): wv = wickv_exact_factory(exact_parent(Vm)) M1 = gram_gen_exact(th, F_cols, sp.I, wv, POS1) M2 = gram_gen_exact(th, F_cols, sp.I, wv, POS2) return M1, M2 def transported(g, Vm): return sp.expand(g[0:10, 0:10].T * Vm * g[10:16, 10:16]) # covariance witness pairs (LHS in the conjugated frame, # RHS at theta_S with the transported wiring) cov_pairs = [("g_int, pure-I", g_int, th_int, V_I), ("g_int, pure-J", g_int, th_int, V_J), ("g_r, pure-I", g_r, th_r, V_I)] lhs_store = {} ok_cov_all = True for nm, g, th, Vm in cov_pairs: F_g = [sp.expand(g * f) for f in F_S_sym] L1, L2 = exact_grams(th, F_g, Vm) R1, R2 = exact_grams(T0s, F_S_sym, transported(g, Vm)) eq1 = sp.expand(L1 - R1) == sp.zeros(*L1.shape) eq2 = sp.expand(L2 - R2) == sp.zeros(*L2.shape) lhs_store[nm] = (L1, L2) ok_cov_all &= (eq1 and eq2) print(" cov witness (%s): 1p exact-equal %s, deg-2 " "exact-equal %s" % (nm, eq1, eq2), flush=True) check("P2.3 EXACT GRAM COVARIANCE at the witnesses: " "Gram(g theta_S g^T, gF, A(V)) == Gram(theta_S, F, " "A(g_C^T V g_B)) with exact entrywise equality on all " "3 (gauge, wiring) pairs, 1p and deg-2", ok_cov_all, kill="K2") # ---- the delta reduction (symbolic two-seat law + defect wards) def redrel4(e): return sp.expand(sp.reduced( sp.expand(e), relg[:2], cg, sg, cy, sy)[1]) up2 = sp.expand(Rg.T * u2 * Ry) up3 = sp.expand(Rg.T * u3 * Ry) a2p, b2p, c2p, d2p = [redrel4(x) for x in pauli_coords(up2)] a3p, b3p, c3p, d3p = [redrel4(x) for x in pauli_coords(up3)] Cd = cg * cy + sg * sy Sd = sy * cg - cy * sg rot_sub = {b2: 0, d2: 0, b3: 0, d3: 0} ok_cf2 = redrel4(a2p.subs(rot_sub) - (a2 * Cd + c2 * Sd)) == 0 ok_cf3 = redrel4(a3p.subs(rot_sub) - (a3 * Cd + c3 * Sd)) == 0 ok_1p = (redrel4(b2p.subs(rot_sub)) == 0 and redrel4(b3p.subs(rot_sub)) == 0) # defect-law float wards: raw deg-2 defect = 2t|a'| at three # equal-orbit configurations gf_r = np.array(g_r.tolist(), dtype=np.float64) th_rf = gf_r @ T0f @ gf_r.T F_rf = [gf_r @ f for f in F_S] M2r_f = gram_gen(th_rf, F_rf, 1j, A_dep, POS2) defR = float(np.max(np.abs(M2r_f - M2r_f.conj().T))) gf_i = np.array(g_int.tolist(), dtype=np.float64) th_if = gf_i @ T0f @ gf_i.T F_if = [gf_i @ f for f in F_S] V_Jf = np.array(V_J.tolist(), dtype=np.float64) A_J = parentV_f(0.5, 0.5, 0.05, V_Jf) M2iJ = gram_gen(th_if, F_if, 1j, A_J, POS2) defIJ = float(np.max(np.abs(M2iJ - M2iJ.conj().T))) check("P2.4 THE DELTA REDUCTION: transported two-seat law " "a' = a cos(delta) + c sin(delta) (%s, %s), 1p seat " "identically 0 on C_rot (%s); defect-law wards " "2t|a'|: (theta_S, pure-I) %.4f == 0.1, " "(theta_r, pure-I) %.4f == 0.06, (theta', pure-J) " "%.4f == 0.1 (mirror witness), all <= 1e-12" % (ok_cf2, ok_cf3, ok_1p, defS, defR, defIJ), ok_cf2 and ok_cf3 and ok_1p and abs(defS - 0.1) <= 1e-12 and abs(defR - 0.06) <= 1e-12 and abs(defIJ - 0.1) <= 1e-12, kill="K2") # ---- the witness table and the option verdict M1_SJ, M2_SJ = exact_grams(T0s, F_S_sym, V_J) h_SJ = herm_exact(M1_SJ) and herm_exact(M2_SJ) p1, piv1 = psd_exact(M1_SJ) p2, piv2 = psd_exact(M2_SJ) pd_SJ = (p1 and all(p > 0 for p in piv1) and p2 and all(p > 0 for p in piv2)) L1_iI, L2_iI = lhs_store["g_int, pure-I"] h_iI = herm_exact(L1_iI) and herm_exact(L2_iI) q1, qiv1 = psd_exact(L1_iI) q2, qiv2 = psd_exact(L2_iI) pd_iI = (q1 and all(p > 0 for p in qiv1) and q2 and all(p > 0 for p in qiv2)) # spectra corollary s1a = np.sort(np.linalg.eigvalsh(np.array( M1_SJ.evalf(16), dtype=complex))) s1b = np.sort(np.linalg.eigvalsh(np.array( L1_iI.evalf(16), dtype=complex))) s2a = np.sort(np.linalg.eigvalsh(np.array( M2_SJ.evalf(16), dtype=complex))) s2b = np.sort(np.linalg.eigvalsh(np.array( L2_iI.evalf(16), dtype=complex))) dev_sp = max(float(np.max(np.abs(s1a - s1b))), float(np.max(np.abs(s2a - s2b)))) lm1, lm2 = float(s1a[0]), float(s2a[0]) # theta' + pure-J fails (exact anti-Hermitian defect) _L1_iJ, L2_iJ = lhs_store["g_int, pure-J"] D_iJ = sp.expand(L2_iJ - L2_iJ.conjugate().T) def_iJ = float(max(abs(complex(x)) for x in np.array(D_iJ.evalf(16), dtype=complex).flatten())) # theta_r + its selected ray passes exactly w_sel = wiring((sp.Rational(4, 5), 0, sp.Rational(3, 5), 0), (sp.Rational(4, 5), 0, sp.Rational(3, 5), 0)) V_sel = V_sym.subs(w_sel) F_r_sym = [sp.expand(g_r * f) for f in F_S_sym] M1_rs, M2_rs = exact_grams(th_r, F_r_sym, V_sel) h_rs = herm_exact(M1_rs) and herm_exact(M2_rs) r1, riv1 = psd_exact(M1_rs) r2, riv2 = psd_exact(M2_rs) pd_rs = (r1 and all(p > 0 for p in riv1) and r2 and all(p > 0 for p in riv2)) check("P2.5 THE WITNESS TABLE => OPTION (2): strict RP passes " "EXACTLY at (theta_S, pure-J) (%s/%s), (theta', pure-I) " "(%s/%s) and (theta_r, (4/5,3/5)) (%s/%s); spectra of " "the first two agree (dev %.1e <= 1e-10; lam_min %.4f " "== 0.3064 +- 0.005, %.4f == 0.1532 +- 0.005); the SAME " "pure-I fails at theta_S (0.1) and the SAME pure-J " "fails at theta' (%.4f == 0.1): the RP exclusion is a " "FIXED-FRAME statement, NOT a gauge-invariant wiring " "no-go" % (h_SJ, pd_SJ, h_iI, pd_iI, h_rs, pd_rs, dev_sp, lm1, lm2, def_iJ), h_SJ and pd_SJ and h_iI and pd_iI and h_rs and pd_rs and dev_sp <= 1e-10 and abs(lm1 - 0.3064) <= 5e-3 and abs(lm2 - 0.1532) <= 5e-3 and abs(def_iJ - 0.1) <= 1e-12, kill="K2") # ================================================================== section("P3 -- the orbit-invariant part: the Z/X exclusion") # ================================================================== det_u = sp.expand(u2.det()) ok_detform = sp.expand( det_u - (a2 ** 2 + c2 ** 2 - b2 ** 2 - d2 ** 2)) == 0 det_tr = redrel4(sp.expand(up2.det()) - det_u) ok_detinv = det_tr == 0 detZ = det_u.subs({a2: 0, b2: 0, c2: 0, d2: 1}) detX = det_u.subs({a2: 0, b2: 1, c2: 0, d2: 0}) # C_refl: a = c = 0 => det = -(b^2 + d^2) det_refl = sp.expand(det_u.subs({a2: 0, c2: 0})) ok_refl = sp.expand(det_refl + b2 ** 2 + d2 ** 2) == 0 check("P3.1 THE Z/X EXCLUSION IS ORBIT-INVARIANT (exact): " "det u = a^2 + c^2 - b^2 - d^2 (%s) is frame-transport-" "invariant det(R(-g) u R(y)) = det u identically (%s); " "det = -1 for Z (%s) and X (%s) in EVERY orbit frame, " "and the whole reflection component has det = " "-(b^2 + d^2) <= 0 (%s): orientation propagation E4 " "fires on the entire rule-gauge orbit -- CONFIRMED " "genuinely gauge-invariant" % (ok_detform, ok_detinv, detZ, detX, ok_refl), ok_detform and ok_detinv and detZ == -1 and detX == -1 and ok_refl, kill="K3") # ================================================================== section("P4 -- the corrected canonical sentence (frozen)") # ================================================================== sent_sha = hashlib.sha256( PERMITTED_SENTENCE.encode("utf-8")).hexdigest() print(" PERMITTED (verbatim, sha256 %s):" % sent_sha[:16]) print(" | " + PERMITTED_SENTENCE.replace(". ", ".\n | ")) print(" FORBIDDEN (verbatim):") for s in FORBIDDEN_SENTENCES: print(" | " + s) check("P4.1 canonical sentence frozen (permitted sha256 %s...; " "%d forbidden formulations recorded)" % (sent_sha[:16], len(FORBIDDEN_SENTENCES)), len(PERMITTED_SENTENCE) > 0 and len(FORBIDDEN_SENTENCES) == 3) # ================================================================== section("P5 -- controls (must fire; deterministic)") # ================================================================== # C1 non-orthogonal element breaks the kernel law N_sh = sp.eye(16) N_sh[0, 1] = sp.Rational(1, 2) A_I_ex = exact_parent(V_I) E_C1 = sp.expand(N_sh.T * (sp.eye(16) + sp.I * A_I_ex) * N_sh - (sp.eye(16) + sp.I * sp.expand(N_sh.T * A_I_ex * N_sh))) max_C1 = float(max(abs(complex(x)) for x in np.array(E_C1.evalf(16), dtype=complex).flatten())) check("C1 non-orthogonal shear N = I + (1/2) e0 e1^T breaks " "the kernel law: max|N^T (I+iA) N - (I + i N^T A N)| = " "%.4f >= 0.25 (the real part N^T N - I != 0) -- " "orthogonality is load-bearing" % max_C1, max_C1 >= 0.25, kill="K7") # C2 non-rule gauge element: transported pure-J leaves the variety g_relm = sp.eye(16) for i in TWO: r0 = 2 * (i - 1) g_relm[r0:r0 + 2, r0:r0 + 2] = Rr Vp_rel = sp.expand(g_relm[0:10, 0:10].T * V_J) u2rel = Vp_rel[2 * (rep2 - 1):2 * rep2, 0:2] u3rel = Vp_rel[2 * (rep3 - 1):2 * rep3, 0:2] a2r_, _b, c2r_, _d = pauli_coords(u2rel) a3r_, _b3x, c3r_, _d3x = pauli_coords(u3rel) minor_val = sp.expand(a2r_ * c3r_ - c2r_ * a3r_) check("C2 relative-rotation element (g0, NOT rule stabilizer): " "transported pure-J violates the pencil quadric " "a2 c3 - c2 a3 = %s == -4/5 != 0 -- the covariance " "orbit statement lives on the RULE gauge only" % minor_val, minor_val == -sp.Rational(4, 5), kill="K7") # C3 orientation-flip control s_fl = sp.zeros(16, 16) for i in range(5): s_fl[2 * i:2 * i + 2, 2 * i:2 * i + 2] = Zs s_fl[10:16, 10:16] = sp.eye(6) ok_orth_s = sp.expand(s_fl * s_fl.T) == sp.eye(16) flip_vac = sp.expand(s_fl[0:10, 0:10] * A_CCs * s_fl[0:10, 0:10].T + A_CCs) \ == sp.zeros(10, 10) det_flip = sp.expand(sp.expand(Zs * u2).det() + det_u) == 0 check("C3 orientation-flip control s = (+)_5 Z (+) I6: " "orthogonal (%s) and WOULD legalize Z " "(det(Z u) = -det u: %s) -- but s A_CC s^T = -A_CC " "(vacuum flips: %s): the only way to undo the Z/X " "exclusion leaves the rule gauge" % (ok_orth_s, det_flip, flip_vac), ok_orth_s and det_flip and flip_vac, kill="K7") # C4 eta = +1 breaks bare Hermiticity A0f = np.tanh(0.5) * A16_dep.astype(np.float64) M1e = gram_gen(T0f, F_S, 1.0, A0f, POS1) defE = float(np.max(np.abs(M1e - M1e.conj().T))) check("C4 eta = +1 at the bare point: 1p Gram Hermiticity " "defect %.4f >= 0.4 (v519 twist regression)" % defE, defE >= 0.4, kill="K7") # C5 census regression gate def eval_E1(sub): return [sp.expand(g.subs(sub)) for g in (g1_2, g2_2, g1_3, g2_3)] def eval_pencil(sub): return [sp.expand(g.subs(sub)) for g in (pI, pX, pZ)] def eval_dets(sub): return (sp.expand(u2.det().subs(sub)), sp.expand(u3.det().subs(sub))) def census_exact(sub): lamQ = mQ / (1 - mQ ** 2) Vm = V_sym.subs(sub) S = Vm * J3s * Vm.T A_eff = kapQ * A_CCs + lamQ * tQ ** 2 * S n_nz, n_sig = 0, 0 Jco45 = None for (i, j) in CAR_DUADS: Bx = A_eff[2 * (i - 1):2 * i, 2 * (j - 1):2 * j] nz = any(e != 0 for e in Bx) n_nz += nz pf = sp.expand(-(Bx[0, 0] * Bx[1, 1] - Bx[0, 1] * Bx[1, 0])) if pf != 0: n_sig += (int(sp.sign(pf)) == sign_c[frozenset({i, j})]) if (i, j) == (a_ch, b_ch): Jco45 = sp.expand((Bx[0, 1] - Bx[1, 0]) / 2) return n_nz, n_sig, Jco45 E1I = eval_E1(wI) penI = eval_pencil(wI) detI = eval_dets(wI) nzI, sigI, JcoI = census_exact(wI) wZ = wiring((0, 0, 0, 1), (0, 0, 0, 1)) detZc = eval_dets(wZ) E1Z = eval_E1(wZ) penZ = eval_pencil(wZ) check("C5 census regression gate: pure-I passes E1 %s == 0, " "pencil %s == 0, dets %s > 0, census %d/10 canonical " "%d/10, J-coordinate %s == 1/200; V_Z passes E1/pencil " "(%s, %s) but fails EXACTLY orientation (dets %s == " "(-1, -1))" % (E1I, penI, detI, nzI, sigI, JcoI, all(e == 0 for e in E1Z), all(e == 0 for e in penZ), detZc), all(e == 0 for e in E1I) and all(e == 0 for e in penI) and all(d > 0 for d in detI) and nzI == 10 and sigI == 10 and JcoI == sp.Rational(1, 200) and all(e == 0 for e in E1Z) and all(e == 0 for e in penZ) and all(d == -1 for d in detZc), kill="K7") # ================================================================== section("VERDICT") # ================================================================== n_pass = sum(1 for _n, ok in CHECKS if ok) n_tot = len(CHECKS) all_ok = (n_pass == n_tot) and not KILLS if all_ok: verdict = ("RP-FRAME-COVARIANT [CONJUGATION-EXACT" "(theta' = g_int theta_S g_int^{-1}, both " "directions; generic element = delta-circle " "rotation), KERNEL-COVARIANCE-EXACT(symbolic " "torus + exact Gram witnesses), DELTA-ONLY" "(defect = 2t|a cos delta + c sin delta|), " "EXCLUSION-IS-FRAME-STATEMENT(option 2: " "fixed-Theta_S statement, not a wiring no-go), " "Z-X-EXCLUSION-ORBIT-INVARIANT(det u " "gauge-invariant), CANONICAL-SENTENCE-FROZEN]") else: verdict = " / ".join(sorted(set(KILLS))) or "CHECK-FAILED" print(" checks: %d/%d passed; kills: %s" % (n_pass, n_tot, KILLS if KILLS else "none")) print(" VERDICT: %s" % verdict) print(" runtime: %.1f s" % (time.time() - T0)) print(" (constants sanity: N_fam = %s, g_car = %s)" % (N_fam, g_car)) return 0 if all_ok else 1 if __name__ == "__main__": sys.exit(main()) ''' # --------------------------------------------------------------- harness _PF_RE = re.compile(r"^\s*\[(PASS|FAIL)\]\s+(\S+)", re.M) _VD_RE = re.compile(r"VERDICT[:\]]") def _probe_file(name): cand = os.path.abspath(os.path.join( _HERE, os.pardir, "experiments", "tfpt-discovery", name + ".py")) return cand if os.path.isfile(cand) else None def _census(out): marks = _PF_RE.findall(out) fails = sorted({tok for st, tok in marks if st == "FAIL"}) verdict = "" for line in out.splitlines(): if _VD_RE.search(line): verdict = line.strip() return len(marks), fails, verdict def _exec_probe(name, src, run_entry=True): """Execute one embedded frozen probe source BYTE-EXACT in its own module namespace (round-31 convention); capture and re-emit stdout; return (stdout, exit_code, byte_equal_or_None).""" if src[:1] == "\n": src = src[1:] path = _probe_file(name) same = None if path is not None: with open(path, encoding="utf-8") as fh: same = (fh.read() == src) fname = path or os.path.abspath(__file__) mod = types.ModuleType(name) mod.__file__ = fname sys.modules[name] = mod buf = io.StringIO() code = 0 with contextlib.redirect_stdout(buf): try: exec(compile(src, fname, "exec"), mod.__dict__) entry = mod.__dict__.get("main") or mod.__dict__.get("run") if run_entry and callable(entry): rc = entry() code = 0 if rc is None else int(rc) except SystemExit as exc: code = 0 if exc.code is None else int(exc.code) except Exception: # regression guard import traceback traceback.print_exc(file=sys.stdout) code = 99 out = buf.getvalue() sys.stdout.write(out) sys.stdout.flush() return out, code, same def _gate(name, out, code, same, exp_n, exp_fails, exp_verdict, exp_code, gates): n, fails, verdict = _census(out) ok = (n == exp_n and fails == list(exp_fails) and exp_verdict in verdict and code == exp_code and same is not False) gates.append(ok) prov = ("byte-exact vs experiments source" if same is True else "embedded copy (source file not present)" if same is None else "SOURCE MISMATCH") print("\n[%s] PATTERN GATE %s: %d checks (exp %d) | FAILs %s " "(exp %s) | exit %d (exp %d) | %s\n verdict line: %s" % ("PASS" if ok else "FAIL", name, n, exp_n, ",".join(fails) if fails else "none", ",".join(exp_fails) if exp_fails else "none", code, exp_code, prov, verdict), flush=True) return ok _PLAN = ( ('seam_wiring_groebner_probe', _SRC_0, 30, (), 'WIRING-DEGENERATE', 0), ('theta_frame_selector_probe', _SRC_1, 26, (), 'THETA-CONVENTIONAL', 0), ('wiring_gauge_rp_audit_probe', _SRC_2, 21, (), 'RP-FRAME-COVARIANT', 0), ) def run(): t0 = time.time() print("=" * 74) print('v911 -- SEAM.STATE.WIRING.SELECTOR.01 (closes the v908-registered contract) + THETA.SELECTOR.01 + WIRING.GAUGE.RP.01: THE WIRING FREEDOM THEOREM -- the compiler determines the wiring ORBIT (one admissible 3-dim component C_rot; Z/X excluded gauge-invariantly by orientation propagation); pure-I is a DEPLOYMENT REPRESENTATIVE, not a compiler theorem (integer gauge connects pure-I and pure-J); no compiler demand pins the theta_S collar frame (THETA-CONVENTIONAL, five demand classes silent-on-angle); strict-collar RP is exactly rule-gauge covariant and depends only on the relative angle delta (RP-FRAME-COVARIANT, the pure-I exclusion is a frame statement, not a wiring no-go)') print("(frozen probes embedded byte-exact and executed verbatim; zero RH content)") print("=" * 74, flush=True) gates = [] for name, src, exp_n, exp_fails, exp_verdict, exp_code in _PLAN: print("\n" + "-" * 74) print("EMBEDDED FROZEN PROBE: %s" % name) print("-" * 74, flush=True) out, code, same = _exec_probe(name, src) _gate(name, out, code, same, exp_n, exp_fails, exp_verdict, exp_code, gates) ok = all(gates) print("\n" + "=" * 74) print("v911: %d/%d pattern gates passed | runtime %.1f s" % (sum(gates), len(gates), time.time() - t0)) print('the wiring question is closed as a compiler-freedom theorem: freedom group = rule-gauge frame orbit, selection quotient = the delta-circle; a canonical wiring selection requires an additionally derived physical frame; "pure-I is compiler-forced" is a FORBIDDEN sentence') print("[%s] v911 VERDICT GATE" % ("PASS" if ok else "FAIL")) return 0 if ok else 1 if __name__ == "__main__": raise SystemExit(run())