Prove the sharp four-axis native test window 9–12

research/four-axis-sharp-cutoff/COEFFICIENTS.json

@@ -0,0 +1,78 @@
+{
+  "keys": [
+    [
+      1,
+      0,
+      4
+    ],
+    [
+      2,
+      1,
+      4
+    ],
+    [
+      2,
+      2,
+      4
+    ],
+    [
+      3,
+      2,
+      2
+    ],
+    [
+      3,
+      4,
+      0
+    ],
+    [
+      4,
+      2,
+      4
+    ],
+    [
+      4,
+      3,
+      4
+    ],
+    [
+      5,
+      4,
+      4
+    ],
+    [
+      6,
+      3,
+      2
+    ],
+    [
+      6,
+      4,
+      2
+    ],
+    [
+      7,
+      3,
+      4
+    ],
+    [
+      15,
+      4,
+      4
+    ]
+  ],
+  "coefficients": [
+    21,
+    -3,
+    1,
+    0,
+    0,
+    1,
+    -1,
+    1,
+    0,
+    0,
+    0,
+    0
+  ]
+}

research/four-axis-sharp-cutoff/PROOF.md

@@ -0,0 +1,207 @@
+# The sharp four-axis native window is 9 through 12
+
+For the fixed affine/quadratic Gaussian monomial grammar on four axes, the
+exact central-residue representation thresholds are
+
+    (L_0,L_1,L_2,L_3) = (12,9,10,11).
+
+Thus the least uniform cutoff is nine. Four tests at widths 9,10,11,12 decide
+all positive widths. Four residue tests are necessary, and no complete test
+set can have maximum width below 12. This improves the prior sufficient
+four-axis window 11,12,13,14 and proves the new window sharp. It changes no
+physical invoice or complete kappa calculation.
+
+## 1. Grammar and source contract
+
+Let X = F_2^4. Use input-phase operators
+
+    U(g,q)e_x = i^q(x) e_(g(x)),
+    q(x) = c + sum_j a_j x_j + 2 sum_(j<k) b_jk x_j x_k modulo 4,
+
+where g is affine invertible, c,a_j lie in Z/4 and b_jk lie in Z/2.
+These form a finite group G. The diagonal group D has 65536 elements.
+In k[G], for k=Q(i) or C, evaluate a fixed residual by
+rho_f(sum a_U[U]) = sum a_U U^(tensor f). External coefficients stay outside
+the tensor powers. Put z=[iI] and let I_r be the ideal generated by z-i^r[1].
+The precise claim is
+
+    ker rho_f = I_(f modulo 4) if and only if f >= L_(f modulo 4).
+
+The grammar, central ideals, Fourier separation and complete endpoint contract
+are from Ali Romman's
+[PR #5369](https://github.com/CrocSwap/integer-mult-bounds/pull/5369).
+His [PR #5529](https://github.com/CrocSwap/integer-mult-bounds/pull/5529)
+gives the 2n+3 sufficient construction. Joseph Anglada's
+[PR #5542](https://github.com/CrocSwap/integer-mult-bounds/pull/5542)
+proves sharpness on three axes and asks for a higher-axis stabilizer witness.
+SOURCES.json pins their proofs. No predecessor executable is imported.
+
+## 2. A finite GL(4,2) coset certificate
+
+For h in GL(4,2), define a(h) by the triple
+
+    (order(h), rank(h-I), rank(h^2+h+I)).
+
+All ranks here are over F_2. The complete coefficient table is:
+
+| Triple | Number of maps | a(h) |
+|---|---:|---:|
+| (1,0,4) | 1 | 21 |
+| (2,1,4) | 105 | -3 |
+| (2,2,4) | 210 | 1 |
+| (3,2,2) | 1120 | 0 |
+| (3,4,0) | 112 | 0 |
+| (4,2,4) | 1260 | 1 |
+| (4,3,4) | 2520 | -1 |
+| (5,4,4) | 1344 | 1 |
+| (6,3,2) | 3360 | 0 |
+| (6,4,2) | 1680 | 0 |
+| (7,3,4) | 5760 | 0 |
+| (15,4,4) | 2688 | 0 |
+
+For a linear hyperplane V, let K_V be its pointwise stabilizer. It has eight
+elements. The exact certificate is
+
+    sum_(h in g K_V) a(h) = 0                         (1)
+
+for every g and every V. The checker reconstructs all 20160 invertible maps
+in two ways: rank tests on all 65536 binary matrices, and successive choices
+outside the span of the earlier columns. Their inventories agree. It checks
+all 15 hyperplanes, all 2520 cosets per hyperplane and all eight members of
+each coset. Thus (1) has 37800 exact integer checks. COEFFICIENTS.json supplies
+the small table; no character table or floating-point rank is an input.
+
+The three defining invariants make a(h) a conjugacy-invariant function. This
+also follows from order and polynomial-rank invariance under similarity.
+The finite table can be found by solving the coset equations; the proof needs
+only the complete verified sums and a(1)=21, not a representation-theory label.
+
+## 3. Affine cancellation, including the translation part
+
+Define the group-algebra element
+
+    B = sum_(h in GL(4,2)) sum_(t in X) a(h) [x -> h x + t].          (2)
+
+The coefficient of an affine map depends only on its linear part. Conjugation
+by an affine map conjugates that linear part, so these coefficients are
+constant on affine conjugacy classes. Equation (1) therefore holds for the
+pointwise stabilizer of every affine hyperplane, including a translated one.
+
+If an ordered tuple has proper affine span, place that span in an affine
+hyperplane V. For each output tuple, the affine maps that produce it form
+an empty set or a coset of its pointwise stabilizer. That stabilizer contains
+K_V. Split the output fiber into K_V cosets and use (1). It follows that
+
+    rho_f(B)e_tuple = 0 whenever the tuple has proper affine span.  (3)
+
+For a tuple of full affine span, only the identity affine map fixes it. Its
+diagonal coefficient under rho_f(B) is therefore a(1)=21.
+
+The translation sum in (2) is essential. The eight points with last coordinate
+one have full linear span and proper affine span. The GL-only sum has diagonal
+entry 21 there, whereas B has entry zero. The verifier checks both values.
+Thus a GL-only witness cannot prove the required lower bound at width eight.
+
+This gives a reusable separation criterion: in this grammar, a phase character
+has no full-span realization at a matching width f if and only if its Fourier component
+contains a nonzero residual invisible at width f. Necessity uses B times its
+phase projector. Sufficiency is the predecessor affine-bucket argument. A
+similar criterion in another dimension needs its own nonzero coset certificate.
+
+## 4. Complete upper certificate
+
+The phase character of a tuple with multiplicities m_x is
+
+    r = sum_x m_x modulo 4,
+    u_j = sum_x m_x x_j modulo 4,
+    v_jk = sum_x m_x x_j x_k modulo 2.
+
+There are 4*4^4*2^6=65536 such characters. WITNESSES.json.gz has one packed
+multiplicity vector for each character. Four bits store each m_x. Its index
+packs r in bits 0..1, u_j modulo two in bits 2..5, floor(u_j/2) in bits 6..9,
+and the six pair parities in bits 10..15, in lexicographic (j,k) order.
+
+The checker recalculates each character from literal weighted counts and
+checks full affine span by the rank of the homogeneous columns (1,x).
+Every witness has length at most L_r and has residue r. Append groups of
+four zero points to reach L_r or any larger width of that residue. This proves
+that every character is realized with full span at each claimed width.
+
+For a residual outside I_r, Fourier inversion in the diagonal subgroup gives
+an affine bucket with a nonzero character coefficient. Choose the full-span
+tuple for that character. Distinct affine maps have different outputs on it,
+so its matrix entry is exactly that nonzero coefficient. Hence the residual
+cannot be in ker rho_f. The reverse inclusion I_r subset ker rho_f is direct.
+This proves the upper kernel equality, not only a finite list of tests.
+
+The optional C++17 generator enumerates all 30421755 multisets of total length
+at most 12. Its transition arithmetic differs from the literal Python checker.
+Only the checked witnesses are premises of the upper proof; the generator's
+minimum claims and search completeness are not needed for that implication.
+
+## 5. Exact lower bounds
+
+Take the character with every u_j and v_jk zero. The four binary coordinate
+rows of any realizing tuple generate a doubly even, self-orthogonal code.
+Indeed each row has weight divisible by four and distinct rows have even
+intersection. The identity wt(a+b)=wt(a)+wt(b)-2|a intersect b| extends these
+properties to their span.
+
+At lengths five, six or seven, a self-orthogonal binary code has dimension
+at most floor(f/2), which is less than four. The tuple cannot have full affine
+span. At length eight, if the four rows have rank less than four the same
+conclusion holds. If they have rank four, the code is self-dual. Every row
+is even, so the all-ones row is orthogonal to the code and hence lies in it.
+The five homogeneous rows are dependent. Full affine span again fails.
+
+These four lengths are the last widths of their residues below (12,9,10,11).
+If a smaller width in the same residue had a full-span zero-character tuple,
+adding four zero points repeatedly would contradict the preceding argument.
+The verifier separately enumerates all 730626 multisets at lengths five
+through eight. All 439 zero-character multisets have proper affine span,
+using a span-closure implementation separate from the upper rank check.
+
+Define the fixed phase projector and residual
+
+    E_r = (1/65536) sum_(c,a,b) i^(-r c) [D_q],
+    P_r = B E_r.                                                    (4)
+
+Finite Fourier orthogonality makes rho_f(E_r) the zero-nonconstant-character
+projector at residue r and zero at the other residues. Equations (3) and (4)
+show rho_f(P_r)=0 at every positive width below L_r and at every wrong residue.
+At L_r the certified zero-character full-span tuple has diagonal entry 21.
+The same holds after four-zero padding. Thus P_r is a nonzero fixed residual,
+is outside I_r, and proves strict kernel inclusion at every smaller matching
+width. In particular P_0 vanishes at all positive widths below 12 and is
+nonzero at 12. This completes all four sharp threshold proofs.
+
+The four central ideals have zero intersection. A set of widths decides all
+fixed identities if and only if it contains a width at least L_r in each
+residue r: the upper argument proves sufficiency; P_r proves necessity.
+
+## 6. Evidence, limitations and attribution
+
+Registered normal and optimized Python checks verify all witnesses, two full
+group inventories, every hyperplane coset, the low-width multiset census and
+five rejection controls. The controls cover the constant residue, a quadratic
+phase, affine versus linear span, a wrong nonidentity coefficient and omission
+of translations. All checks use exact arithmetic. Same-agent separate methods
+are corroboration, not independent human or proof-kernel acceptance.
+
+The theorem applies entrywise to a single fixed complete register endpoint,
+with all independent dirty inputs and required returns. It excludes Hadamards,
+width-dependent programs or external coefficients, and undeclared aliases.
+It does not provide an efficient group-algebra expansion or a physical supplier.
+No source caller, compiler, stock, precision, tape, outer admission or selected
+cold replay was run. Complete kappa and the selected frontier are unchanged.
+
+Credit Joseph Anglada / fluorine for the three-axis coset method and higher-axis
+handoff; Ali Romman for the native grammar, Fourier method and sufficient phase
+construction; Hiroki KUMAZAKI for
+[PR #5522](https://github.com/CrocSwap/integer-mult-bounds/pull/5522) and the
+representation-kernel distinction; Mihir Srivastava for
+[PR #5521](https://github.com/CrocSwap/integer-mult-bounds/pull/5521).
+Retain Jose Manuel, ywz65, Chris R and the native/phase/compiler source lineage.
+Binary codes, group cosets and Fourier projectors are classical. The four-axis
+certificate, affine translation extension and sharp threshold result are by
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.

research/four-axis-sharp-cutoff/README.md

@@ -0,0 +1,47 @@
+# Sharp four-axis native cutoff
+
+The exact four-axis affine/quadratic Gaussian monomial thresholds are
+**(12,9,10,11)** by residue. The least cutoff is **9**, and the test window
+**9,10,11,12** is sharp. The former sufficient window was 11,12,13,14.
+This reduces a native identity verification bound. Complete kappa is unchanged.
+
+Read [PROOF.md](PROOF.md), [RESULT.json](RESULT.json),
+[COEFFICIENTS.json](COEFFICIENTS.json) and [SOURCES.json](SOURCES.json).
+
+```sh
+python3 -B scripts/research_package.py --package research/four-axis-sharp-cutoff
+```
+
+Python 3.12 and the standard library suffice. Expected markers:
+`PASS_FOUR_AXIS_SHARP_CUTOFF` and `PASS_REGISTERED_RESEARCH_PACKAGE`.
+The normal and optimized runs check all 65536 phase witnesses, 20160 maps,
+37800 hyperplane cosets, 730626 low-width multisets and five rejection controls.
+The proof includes the all-width padding and kernel arguments.
+
+The finite witness file can also be rebuilt with C++17:
+
+```sh
+c++ -O3 -std=c++17 research/four-axis-sharp-cutoff/build_certificate.cpp -o /tmp/four-axis-certificate
+/tmp/four-axis-certificate > /tmp/four-axis-witnesses.txt
+python3 research/four-axis-sharp-cutoff/pack_witnesses.py /tmp/four-axis-witnesses.txt /tmp/four-axis-witnesses.json.gz
+```
+
+The decoded witness vector must match WITNESSES.json.gz. Gzip headers can
+differ between Python versions. Generation is optional;
+the registered verifier checks every witness without trusting the generator.
+No compiler, physical caller, selected cold replay or full multiplication proof
+is included. The fixed grammar and full dirty-input/return contract are required.
+
+## Open next questions
+
+For higher dimensions, find a nonzero conjugacy-invariant GL(n,2) coefficient
+function with zero pointwise-hyperplane coset sums. Translation summation then
+extends it to the affine group as in this proof. Such a certificate would reduce
+sharp representation thresholds to exact full-span phase-character realization.
+A general all-dimension existence and optimal character bound remain open here.
+
+For physical use, bind a complete four-axis endpoint to the grammar before
+using the smaller window. Its expansion and physical invoice remain separate.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0. Predecessor
+roles and classical methods are credited in the proof.