Construct an explicit dyadic A1 multiplicity operator (no κ)

research/a1-dihedral-multiplicity-matrix/PROOF.md

@@ -0,0 +1,119 @@
+# A concrete multiplicity operator for the dihedral component
+
+This contribution was produced by Nick Petalas. New material is Apache-2.0.
+Claim type: scoped written proof with an exact finite matrix certificate.
+
+## Input and predecessor boundary
+
+Use the signed-orbit basis of the historical c=1, joint (+1,+1) space E and
+its integer matrix B=4A_1 from unpaidmoon #6964. They are the two live JSON
+inputs under `research/a1-joint-216-charpoly/evidence/`. E has dimension 216.
+This package takes that representation and B as inputs. It does not rebuild
+its characteristic polynomial or certify its origin as a physical operator.
+
+The question and dihedral generators are unpaidmoon
+[#7065](https://github.com/CrocSwap/integer-mult-bounds/pull/7065), head
+`ee0202a8eafa4c0b84bef97ecfb5691f6affc9c6`. Its PROOF.md, sections "Operator
+and group" and "The isotypic component", fixes the following convention.
+The coordinate signed permutation has output i equal to eps[i] times input
+inv[i]. Its label map sends each query port to the port of the corresponding
+canonical root. Extend that map linearly to F2^9. On the 4096 coordinates
+(i,a), it acts by the coordinate permutation, its sign, and that label map.
+
+For R use inv=(0,1,6,7,3,2,5,4) and minus signs at 0,7. For U use
+inv=(0,1,2,3,7,6,5,4), with all signs positive. In the pinned E basis they
+are signed permutation matrices. The new checker derives those matrices
+from the pinned query and the supplied orbit vectors, without importing any
+predecessor executable.
+
+Put
+
+    P6 = 2I + R - R^2 - 2R^3 - R^4 + R^5,
+    W = image_Q(P6).
+
+The checker verifies P6^2=6P6 and trace(P6)=768. Since an idempotent over Q
+has eigenvalues zero and one, rank(P6)=128. This identifies exactly the
+component named W in #7065; no census of the full signed stabilizer is needed.
+
+## Explicit construction
+
+All indices below are zero based. For each j=0,...,215 form the integer column
+
+    v_j = (I+U) P6 e_j.
+
+Scan j in increasing order. Retain a column precisely when it is independent
+over Q of the previously retained columns. The rule is unambiguous and the
+checker finds 64 retained columns. Let V be their 216-by-64 matrix. Every
+column has two or three nonzero entries. Thus this is a concrete basis
+specified by fixed input bytes and rational arithmetic, without a search seed
+or an arbitrary choice of a complement.
+
+Express each Bv_j in this basis. Define the 64-by-64 matrix K by
+
+    2 B V = V K.                                      (1)
+
+The checker performs exact rational elimination for this construction. Every
+entry of K is an integer. Define T=K/8, so A_1 V=V T.
+The `--matrix` command emits every entry of K and every retained column of V,
+together with the selected source-column indices and a canonical SHA256.
+No predecessor polynomial is used to select or compute an entry of K.
+
+Let C=[V,RV]. The exact identities checked on every column are
+
+    U V = V,
+    R^2 V = RV - V,
+    U RV = V - RV,
+    P6 V = 6V,
+    2 B RV = RV K.                                    (2)
+
+They imply P6 RV=6RV because P6 is a polynomial in R. Consequently image(C)
+is contained in W. A separate dense modular elimination finds rank(C)=128;
+a nonzero minor modulo 1000003 is also nonzero over Q. Thus C is an
+isomorphism Q^128 -> W. In its coordinates,
+
+    C^-1 (A_1|W) C = [[T,0],[0,T]],
+    C^-1 (R|W) C   = [[0,-I],[I,I]],
+    C^-1 (U|W) C   = [[I,I],[0,-I]].                   (3)
+
+Here C^-1 means the inverse onto W, not an inverse of a rectangular map on
+all of E. Equations (1)-(3) construct the multiplicity-space operator and
+its actual intertwiner, rather than infer its existence from a squared
+characteristic polynomial. The dihedral action is the usual rational
+2-dimensional representation on the displayed two blocks. The commutant
+therefore has the displayed two equal copies of T.
+
+## Exact claim and remaining arithmetic question
+
+The output T is dyadic. Its least positive common denominator in this basis
+is exactly eight, certified by 8T=K integral and an odd entry of K. This is
+an explicit rational answer to the matrix part of #7065's question. It does
+not provide the integer matrix of T requested there. In particular, the
+integral matrix K represents 8A_1, not A_1. No normalization factor is free.
+
+As a consequence of (3), chi_(A_1|W)=chi_T^2. If the characteristic-polynomial
+result of #7065 is used as a cited premise, uniqueness of the monic square
+root in Q[x] gives chi_T=q, with q exactly as published there. This package
+neither recomputes q nor independently verifies that predecessor result.
+Likewise it computes no new zero-eigenspace or shifted rank of B.
+
+## Certificate and verification scope
+
+The replay constructs the matrix, verifies all exact identities, and checks
+rank with an independently encoded dense modular elimination. A further dense
+integer product checks both operator blocks directly. The output receipt binds
+all six package files and all three live inputs by SHA256. `--matrix` includes
+the complete executable certificate. The receipt is computed, never handwritten.
+
+Controls change an entry of K, omit or duplicate a basis column, rescale K
+incorrectly, or change its domain basis without changing K. They distinguish
+one 64-dimensional block from the required 128-dimensional component, and
+verify that the component is proper in E. These are finite certificate controls,
+not an exhaustive perturbation census.
+
+The result is exact linear algebra on the stated pinned inputs. It supplies no
+native decoder, physical realization, changed recursive invoice, new kappa,
+selected-frontier change or complete multiplication theorem. Numerical rounding,
+source access, dirty restoration, ownership, frames, storage/tapes, compiler
+closure and outer recovery remain separate obligations. Independent human and
+formal proof-kernel review are unclaimed. No Lean, Docker, selected cold replay,
+degree-881 replay or predecessor characteristic-polynomial suite is run.

research/a1-dihedral-multiplicity-matrix/README.md

@@ -0,0 +1,106 @@
+# An explicit dyadic 64-dimensional multiplicity operator
+
+This contribution was produced by Nick Petalas. Apache-2.0.
+
+A new exact basis exposes the 128-dimensional dihedral component W of the
+historical A_1 centre block as two equal 64-dimensional operator blocks:
+
+    C^-1 (A_1|W) C = diag(T,T),     T=K/8,     K integral.
+
+The basis C=[V,RV] is explicit; each column of V has only two or three nonzero
+entries in the pinned 216-dimensional orbit basis. The least common denominator
+of T in this basis is eight. The complete matrix and intertwiner are emitted
+by the command below, with a generated source-bound receipt.
+
+Claim type: scoped written proof with an exact finite matrix certificate.
+This is a partial answer to unpaidmoon
+[#7065](https://github.com/CrocSwap/integer-mult-bounds/pull/7065), Open next
+question 2, which requests an integer multiplicity operator. The rational
+operator is now concrete; a change of lattice giving an integer T remains open.
+The predecessor's characteristic polynomial is cited, rather than replayed.
+No new kappa is claimed. [PROOF.md](PROOF.md) gives the exact construction,
+intertwining identities and distinction between T and its integer dilation K.
+
+## Reproduce
+
+From the repository root, CPython 3.12 and its standard library:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/a1-dihedral-multiplicity-matrix/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -O -W error -B research/a1-dihedral-multiplicity-matrix/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/a1-dihedral-multiplicity-matrix
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/a1-dihedral-multiplicity-matrix --check-source-history
+```
+
+Replace the executable with another CPython 3.12 path if needed. The standalone
+checker authenticates its three live JSON inputs before constructing the result.
+It imports no predecessor program. Normal replay writes nothing. To retain the
+complete new matrix and basis, add `--matrix --emit /absolute/new/scratch/result.json`
+to a direct command. Receipt paths inside the checkout and existing files reject.
+The matrix convention is `T=K/8`, `C=[V,RV]`, `2BC=C diag(K,K)` for B=4A_1.
+
+The marker is `PASS_A1_DIHEDRAL_MULTIPLICITY_MATRIX`. Every entry of both
+operator blocks is checked exactly, all new group-action identities are checked,
+and dense modular elimination proves the doubled basis is independent. Controls
+reject corrupted matrices, missing or repeated columns, a wrong scale and an
+unmatched domain-basis change. The integer K has 668 nonzero entries in [-64,96]. The doubled basis has
+rank 128; a separate dense calculation checks all 27,648 operator identity
+entries, and nine semantic controls pass. The canonical certificate SHA256 is
+`98ceb6e760b187a30e185e3b5dcd4041018801bca9ea0d60c94631001e86e7f7`.
+Warning-strict normal and optimized runs on CPython 3.12.15 take about 0.22
+seconds each locally, below their separate 120-second limits. These are timeout
+checks, not performance comparisons. Counts and hashes are generated by the verifier.
+Finite certificate verification and the written argument have no proof-kernel or
+independent human acceptance claim. Hosted CI status belongs in the PR body.
+
+## Scope, sources and credit
+
+[SOURCES.json](SOURCES.json) pins the main-tree input bytes and historical card
+and selected-record provenance at `e54523517d0f03e58352e647c403a5af3e525a57`.
+The formal-interface-lemma card changes to a constructive algebraic side result,
+with no formalization or discharge of a selected framework assumption. The first
+source-binding orientation command passed for selected kappa `0.00363005817`.
+The output is tied to one historical centre query, not the selected physical word.
+
+Credit unpaidmoon #7065 at `ee0202a8eafa4c0b84bef97ecfb5691f6affc9c6` for W,
+its dihedral generators, polynomial and explicit-matrix question; unpaidmoon
+#6964 for the orbit basis and B; #6944/#7008/#7023 for the sign and normalizer
+splittings; JoyboyBrian for the initial handoff; Ali Romman #4958/#4720 for the
+query/Bell action; Krzysztof Wojt for the degree-881 certificate; and the retained
+#1719 representation lineage. Nick Petalas #5120/#6302/#7172 are related
+annihilator and width bounds, not inputs or steps of this construction.
+The elementary representation and elimination methods are classical.
+
+Entry checks read live open/account PRs, recent handoffs and active Discussions,
+main-tree and merged object/formula searches, and the relevant open PR bodies.
+The cached helper covered 760 open PRs and 7347 Discussion records with reported
+complete pagination; its sparse local notes covered only 208 of 10178 paths.
+Separate Git searches covered omitted main READMEs. Unpublished work and arbitrary
+historical diffs remain outside that bounded overlap picture.
+[Advance CLAIM](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19571932).
+
+## Open next questions
+
+- Can an explicit invariant lattice turn this particular T into an integer
+  matrix with a similarly sparse intertwiner? Begin with the emitted dyadic
+  matrix and retain its factor of eight. No such lattice basis is supplied.
+- Can a physical consumer use this multiplicity decomposition at a favorable
+  complete cost? First specify its source/target access, actual basis conversion,
+  dirty restoration and complete recursive bill. Those costs are unknown here.
+
+No native or rounded execution, selected cold replay, degree-881 replay, Lean,
+Docker, new kappa, supplier admission or selected-frontier change is supplied.
+Independent human and formal proof-kernel review are unclaimed.
+
+## Implementation bounds
+
+The terminating checker has no recursion, subprocesses, network or generated
+code. Dimensions are fixed at 4096 ambient coordinates, 216 input coordinates,
+128 output-basis columns and a 64-by-64 multiplicity matrix. JSON reads are capped
+at two million bytes. Every algebraic loop ranges over those bounded finite
+collections. Python's managed arithmetic allocates dynamically; this is the
+Power of Ten fixed-allocation deviation, with fixed domains bounding live data.
+The optional receipt stream is closed on every exit. All functions are below
+60 lines. Explicit exceptions preserve checks under optimized Python.
+Warning-strict normal/optimized execution and source compilation are the available
+diagnostics. No external static analyzer or allocator instrumentation is claimed.

research/a1-dihedral-multiplicity-matrix/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
+      "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/a1-joint-216-charpoly/evidence/basis.json",
+      "usage": "input",
+      "git_blob": "5e524a41ed1c65017b7d902b5445aedd2eb606ff",
+      "sha256": "e198cd71f4100d2629ecc25fb40b135a8c18c7756be8bc80bf24d7b349af418a"
+    },
+    {
+      "path": "research/a1-joint-216-charpoly/evidence/matrix.json",
+      "usage": "input",
+      "git_blob": "23bccaef6f24e6e644bdba81f58e9217787ab16c",
+      "sha256": "44f40ad5a12daf7c8493b42e1e9ddc4ef338b317ee5fdfc6de1b413642ca97aa"
+    },
+    {
+      "path": "research/centre-polynomial-cache-limits/frozen/work/centre-encoding-campaign-20261014/lanes/circuit-interface/INTERFACE.json",
+      "usage": "input",
+      "git_blob": "4201e9a04c12273b919e2cae60a6b6482c8150f3",
+      "sha256": "5c6c51fbffc07a683e922f17532fd90262ae9e23cc3560a696002073dd234ef3"
+    }
+  ]
+}