From 4cf130657160d6b923c0b13d8a0308bd35f79d42 Mon Sep 17 00:00:00 2001 From: CubeJerry <80299683+CubeJerry@users.noreply.github.com> Date: Fri, 30 Oct 2026 23:14:54 +0800 Subject: [PATCH] Classify sharp P104 metric spectra and extend them to Hermitian metrics Prepared for @CubeJerry with coordinated OpenAI Codex assistance. Credit Nick Petalas PR6278, Matarener PR6166, DreamingOfClouds PR6030, Ali Romman and the retained E8/P104 lineage. No new kappa. --- .../CERTIFICATE.json | 1429 ++++++ .../HERMITIAN-PROOF.md | 125 + .../INDEPENDENT-REVIEW.md | 113 + .../p104-selected-metric-orbit/ORBIT-PROOF.md | 209 + .../p104-selected-metric-orbit/ORBITS.json | 4330 +++++++++++++++++ research/p104-selected-metric-orbit/PROOF.md | 214 + research/p104-selected-metric-orbit/README.md | 151 + .../p104-selected-metric-orbit/SOURCES.json | 37 + research/p104-selected-metric-orbit/TASK.json | 82 + .../p104-selected-metric-orbit/VERIFY.json | 107 + .../p104-selected-metric-orbit/generate.py | 75 + .../generate_orbits.py | 58 + .../p104-selected-metric-orbit/geometry.py | 132 + .../p104-selected-metric-orbit/independent.py | 114 + .../independent_orbits.py | 162 + .../p104-selected-metric-orbit/moments.py | 43 + research/p104-selected-metric-orbit/orbits.py | 117 + research/p104-selected-metric-orbit/verify.py | 158 + .../verify_orbits.py | 181 + 19 files changed, 7837 insertions(+) create mode 100644 research/p104-selected-metric-orbit/CERTIFICATE.json create mode 100644 research/p104-selected-metric-orbit/HERMITIAN-PROOF.md create mode 100644 research/p104-selected-metric-orbit/INDEPENDENT-REVIEW.md create mode 100644 research/p104-selected-metric-orbit/ORBIT-PROOF.md create mode 100644 research/p104-selected-metric-orbit/ORBITS.json create mode 100644 research/p104-selected-metric-orbit/PROOF.md create mode 100644 research/p104-selected-metric-orbit/README.md create mode 100644 research/p104-selected-metric-orbit/SOURCES.json create mode 100644 research/p104-selected-metric-orbit/TASK.json create mode 100644 research/p104-selected-metric-orbit/VERIFY.json create mode 100644 research/p104-selected-metric-orbit/generate.py create mode 100644 research/p104-selected-metric-orbit/generate_orbits.py create mode 100644 research/p104-selected-metric-orbit/geometry.py create mode 100644 research/p104-selected-metric-orbit/independent.py create mode 100644 research/p104-selected-metric-orbit/independent_orbits.py create mode 100644 research/p104-selected-metric-orbit/moments.py create mode 100644 research/p104-selected-metric-orbit/orbits.py create mode 100644 research/p104-selected-metric-orbit/verify.py create mode 100644 research/p104-selected-metric-orbit/verify_orbits.py diff --git a/research/p104-selected-metric-orbit/CERTIFICATE.json b/research/p104-selected-metric-orbit/CERTIFICATE.json new file mode 100644 index 0000000000..529f778045 --- /dev/null +++ b/research/p104-selected-metric-orbit/CERTIFICATE.json @@ -0,0 +1,1429 @@ +{ + "schema": "p104-selected-metric-spectrum/1", + "coordinate_frame": [ + 7, + 25, + 42, + 52, + 76, + 82, + 97, + 127 + ], + "second_deleted_frame": [ + 67, + 104, + 137, + 162, + 266, + 289, + 448, + 491 + ], + "energy_convention": "unordered orthogonal unit-root pairs", + "blocks": [ + { + "eigenvalue_times_16": 0, + "basis": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 600, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 604, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 1, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 608, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 1, + 0, + -1, + 1, + 0, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 0, + -1, + 1, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + -1, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 0, + -1, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 1, + 0, + -1, + 1, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 660, + "basis": [ + [ + 1, + 1, + 1, + -1, + 1, + -1, + -1, + -1, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + 0, + -1, + 0, + -1, + 0, + 1, + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 0, + 0, + 0 + ], + [ + 2, + 0, + 0, + 0, + 0, + 0, + 0, + -2, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 1, + -1, + 0, + 0, + -1, + -1, + 0, + -1, + 0, + 0, + 1, + 1, + 0, + 1, + -1, + 0, + -1, + 0, + 0 + ], + [ + 1, + -1, + 1, + -1, + 1, + -1, + 1, + -1, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + -1, + 0, + -1, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + 0, + -1, + 0 + ], + [ + 1, + 1, + -1, + -1, + 1, + 1, + -1, + -1, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 728, + "basis": [ + [ + 0, + 0, + 1, + -1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 1, + 0, + -1, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 0, + -1, + 0, + -1, + 0, + -1, + 0, + 0, + -1, + 0, + 1, + 0, + -1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 796, + "basis": [ + [ + 3, + 3, + 3, + -3, + 3, + -3, + -3, + -3, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 0, + 1, + 0, + 1, + 0, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + 1, + -1, + 0, + 0, + 0 + ], + [ + 6, + 0, + 0, + 0, + 0, + 0, + 0, + -6, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + -1, + 1, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0, + -1, + -1, + 0, + -1, + 1, + 0, + 1, + 0, + 0 + ], + [ + 3, + -3, + 3, + -3, + 3, + -3, + 3, + -3, + 0, + -1, + 0, + -1, + 0, + -1, + 0, + 0, + 1, + 0, + 1, + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 0, + -1, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 3, + 3, + -3, + -3, + 3, + 3, + -3, + -3, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + -1 + ] + ] + } + ] +} diff --git a/research/p104-selected-metric-orbit/HERMITIAN-PROOF.md b/research/p104-selected-metric-orbit/HERMITIAN-PROOF.md new file mode 100644 index 0000000000..59915c0208 --- /dev/null +++ b/research/p104-selected-metric-orbit/HERMITIAN-PROOF.md @@ -0,0 +1,125 @@ +# The sharp constants also hold for common Hermitian metrics + +The real-symmetric sharp constants in [ORBIT-PROOF.md](ORBIT-PROOF.md) extend +unchanged to **all complex Hermitian common metrics** on the original real +root vectors. Equality has no imaginary skew component. This broadens the +permitted ambient common maps; it still says nothing about independent port +motions, normalized correlations, arbitrary masked matrices or complete +multiplier costs. **No new κ.** + +Let U be the full 120 unit root lines, with one real unit vector chosen for +each line. Let F,G be any disjoint orthonormal 8-frames, and put +`P=U\(F∪G)`. For a Hermitian matrix M define + +\[ + E_P(M)=\sum_{\{u,v\}\subset P,\ u\perp v}|u^*Mv|^2. +\] + +All sums count unordered distinct pairs once. Write uniquely `M=S+iK`, where +S is real symmetric and K is real skew-symmetric. Because u,v are real, + +\[ + E_P(M)=E_P(S)+E_P(K),\qquad + \left\|M-\frac{\operatorname{tr}M}8I\right\|_F^2 + =\left\|S-\frac{\operatorname{tr}S}8I\right\|_F^2+\|K\|_F^2. +\] + +Here `E_P(K)` uses `(uᵀKv)²`, which is nonnegative and sign-independent on +unordered pairs even though K is skew. The trace of K is zero. The complex +Frobenius norm is the sum of squared absolute values of the entries. + +## Two exactly checked root identities + +The root coordinates in geometry.py satisfy + +\[ + \sum_{u\in U}uu^{\mathsf T}=15I,\qquad + \sum_{v\in U:\ v\perp u}vv^{\mathsf T}=9(I-uu^{\mathsf T}). +\] + +These are finite identities, not isotropy assumptions. For `c(u)=2u`, +moments.py checks the equivalent integer equations + +\[ + \sum c(u)c(u)^{\mathsf T}=60I,\qquad + \sum_{v\perp u}c(v)c(v)^{\mathsf T}=36I-9c(u)c(u)^{\mathsf T} +\] + +for all 120 roots. Each star contains 63 roots. Both identities are +orthogonally invariant and independent of the representative signs, so they +apply to any first frame after the previously checked isometry reduction. + +## Exact skew-energy accounting + +Skew symmetry gives `uᵀKu=0`. For a fixed root u the incident-edge energy is +therefore + +\[ + \sum_{v\perp u}(u^{\mathsf T}Kv)^2 + =9\,u^{\mathsf T}KK^{\mathsf T}u. +\] + +Summing over all 120 roots and dividing by two gives + +\[ + E_U(K)=\frac92\operatorname{tr}\left(KK^{\mathsf T} + \sum_{u\in U}uu^{\mathsf T}\right) + =\frac{135}2\|K\|_F^2. +\] + +For any orthonormal frame F, summing its eight incident-star energies gives +`9||K||²_F`. The energy on pairs internal to F is `||K||²_F/2`, because in +that orthonormal basis the skew matrix has zero diagonal and opposite entries +at `(i,j)` and `(j,i)`. The sum over the eight stars counts internal edges +twice; hence the energy of edges having at least one endpoint in F is exactly +`(17/2)||K||²_F`. + +Remove the edges incident to F and those incident to G. The intersection of +these two edge sets consists exactly of the orthogonal cross pairs between +F and G, since the frames are disjoint. Inclusion-exclusion yields the exact +identity + +\[ + E_P(K)=\frac{101}2\|K\|_F^2+ + \underbrace{\sum_{u\in F,\ v\in G,\ u\perp v}(u^{\mathsf T}Kv)^2}_{X_{FG}(K)} + \ \ge\ \frac{101}2\|K\|_F^2. +\] + +There is no missing restoration or boundary term in this *geometric* edge +identity; it makes no algorithmic cost claim. The bound 101/2 need not itself +be the sharp skew constant for a given orbit, and no such sharpness is claimed. + +## Hermitian inequality and equality + +Let `c_P` be 37 or 75/2 as determined by the real-symmetric spectrum. Combining +the exact splitting with the skew lower bound gives + +\[ + E_P(M)\ge c_P\left\|M-\frac{\operatorname{tr}M}8I\right\|_F^2 + +\left(\frac{101}2-c_P\right)\|K\|_F^2. +\] + +Since `101/2>75/2≥c_P`, equality in the sharp `c_P` inequality forces `K=0`. +It then occurs exactly in the real-symmetric equality space already certified. +The real attainers belong to the Hermitian domain, so the constants remain +sharp even when restricting to positive definite metrics. The trace-free +Hermitian equality dimensions are therefore 6,1,6 for the three types. + +For any complex common linear map T, its positive semidefinite metric +`M=T* T` is Hermitian, so the theorem applies to the transformed root inner +products. It does not assume T is real. This does not turn the metric +inequality into a universal obstruction for independent decoders or imply +that any selected native construction implements such a map. + +## Verification and credit + +verify_orbits.py executes every root second-moment identity in normal and +optimized Python. Two exact-reason negative controls alter a tight-frame +coefficient and omit one root from a star; both must be rejected. All three +sharp symmetric constants and their complete equality spaces are verified +separately by the orbit spectral certificates. + +The lead proposed the skew-sector mechanism; worker A independently derived +the incident-frame accounting and implemented the exact moment checks. Credit +the full E8/P104 source lineage and Nick Petalas's real-metric predecessor as +in README.md. Jerry Chen, @CubeJerry, with substantial OpenAI Codex assistance. diff --git a/research/p104-selected-metric-orbit/INDEPENDENT-REVIEW.md b/research/p104-selected-metric-orbit/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..064b62c1c8 --- /dev/null +++ b/research/p104-selected-metric-orbit/INDEPENDENT-REVIEW.md @@ -0,0 +1,113 @@ +# Independent exact review of all three energy spectra + +Reviewed Worker A's `research/p104-selected-metric-orbit` at commit +`0fb40d096e78cb332c4de0dc9e6e35b6f5e640d3`, against canonical base +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. No blocker was found in the +normalization, rational multiplicities, four-dimensional quadratic block, +sharp constants, equality dimensions, or positive-definite sharpness. +**No new κ.** + +## Separate mathematical construction + +`independent_orbits.py` imports neither the author's implementation nor the author's +104 rational eigenvectors. It constructs the 120 root lines directly in the +nine-dimensional sum-zero hyperplane: integer vectors `3(e_i-e_j)` and vectors +with three coordinates 2 and six coordinates -1. These are `3r`, where each +root `r` has squared norm 2. The source WORD is authenticated by SHA256 +`7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f`. +The frame classification and representative coverage were separately checked +by a separate maximal-clique/union-find implementation; this review addresses spectra of its three representatives. + +Use the nonorthogonal A8 chart `B=[e_0-e_8,...,e_7-e_8]` and write every +physical symmetric operator as `A=B S B^t`. The 36 coordinates of `S` are its +8 diagonal and 28 upper off-diagonal entries. The Gram matrix `W` is computed +as the Frobenius Gram matrix of the 36 literal nine-dimensional operators +`B E_ij B^t`. Thirty-six positive exact rational LDL pivots certify `W>0`. + +For each root let `w=B^t r`, which is integral. On unit roots `u=r/sqrt(2)`, +`u^t A v = w^t S w'/2`. Sum the outer products of the corresponding integer +linear forms over all unordered orthogonal pairs in the puncture. This gives +an independently assembled integer matrix `H` with + +``` +E(A) = s^t H s / 4; ||A||_F^2 = s^t W s. +``` + +Each puncture has exactly 2,860 such pairs. This independent chart has energy +denominator 4, whereas the author's orthonormal F chart has denominator 16; +the conversion is explicitly accounted for rather than copying a normalization. +The identity on the hyperplane has `S=I-J/9`, lies in the kernel, and has +squared Frobenius norm 8. The trace linear form in this chart is twice the sum +of all 36 coordinates. + +Exact rational Gaussian elimination and back substitution compute the +nullities of `H-4λW`. These yield all the stated rational multiplicities: + +| Orbit size | Rational spectrum, with multiplicities | +|---|---| +|28|0:1, 37:6, 38:16, 91/2:12, 54:1| +|336|0:1, 37:1, 75/2:8, 38:12, 91/2:10| +|896|0:1, 75/2:6, 151/4:8, 38:7, 165/4:4, 91/2:6, 199/4:4| + +The nonzero rational eigenspaces are checked to be trace-free. Their dimensions +sum to 36, 32 and 36. Distinct eigenspaces are independent, and `W>0` makes the +generalized operator self-adjoint, so these are full spectra for sizes 28 and +896 without relying on the author's eigenvectors or modular-rank certificate. + +## The remaining four dimensions + +The four matrices displayed in ORBIT-PROOF.md are treated as claimed data, +converted into physical nine-dimensional matrices using the fixed frame, then +into this separate A8 chart. Their coefficient columns `V` have exact rank 4. +The checker verifies, against its independently assembled size-336 energy, + +``` +4 H V = W V C, +C = [[796,0,0,-68],[0,796,68,0],[0,68,660,0],[-68,0,0,660]]. +``` + +This factor 4 is required: the author's C represents `16λ`, while the new +pencil represents `4λ`. Two explicit 2-by-2 blocks have eigenvalues +`728 +/- 68 sqrt(2)`, each occurring once in each block. The exact polynomial +`C^2-1456 C+520736 I=0` and trace 2912 are independently checked. Its polynomial +is nonzero at each rational eigenvalue already accounted for, so these four +dimensions have zero intersection with the rational 32-dimensional sector. +Consequently the full reported size-336 spectrum is complete. Dividing by16 +gives `(182 +/- 17 sqrt(2))/4`; both exceed `75/2`, certified by `32^2>2*17^2`. + +It follows that the sharp trace-free constants are 37, 37 and 75/2, with +equality dimensions 6, 1 and 6. This conclusion uses exact algebra only. + +## Positive-definite sharpness and controls + +For each representative the independently computed minimal eigenspace supplies +a nonzero trace-free operator A. Set +`t=1/(2 max_i sum_j |A_ij|)` in the physical nine-dimensional chart. The +operator `I_V+tA` is positive definite since the absolute row-sum bound +controls the symmetric operator norm. Its A8-coordinate matrix also passes +exact rational LDL with eight positive pivots. The deterministic examples use +`t=1/4,1/16,1/24`, respectively, and attain the claimed energy-to-anisotropy +ratio exactly. This establishes sharpness within positive-definite metrics, +without claiming a rational square root for these metrics. + +Three controls detect doubling the energy normalization, changing one sign in +the quadratic action, and dropping a quadratic basis column. Both normal and +`-O` runs with warnings as errors produce the identical receipt +`PASS_INDEPENDENT_A8_ALL_SPECTRA`. + +Reproduction from this package directory (or use the registered runner): + +```sh +python3 -B -W error independent_orbits.py --source /path/to/research/p104-helper470-twin-rung-removal/WORD.json.gz +python3 -O -B -W error independent_orbits.py --source /path/to/research/p104-helper470-twin-rung-removal/WORD.json.gz +``` + +This is an exact finite check and mathematical review, not a proof-kernel +formalization or independent human review. The accepted selected multiplier, +physical supplier accounting, and five inherited assumptions are unchanged. +The claimed geometry remains the canonical A8/E8 realization; this review +independently reconstitutes its energy rather than proving an unrelated +coordinate identification. Predecessor credit: the canonical P104/E8 source +lineage, Nick Petalas's PR6278 uniform bound and classification question, and +Worker A's new classification and certificates. Jerry Chen, @CubeJerry; +substantial OpenAI Codex assistance from research worker D (seed79). diff --git a/research/p104-selected-metric-orbit/ORBIT-PROOF.md b/research/p104-selected-metric-orbit/ORBIT-PROOF.md new file mode 100644 index 0000000000..8d1f067157 --- /dev/null +++ b/research/p104-selected-metric-orbit/ORBIT-PROOF.md @@ -0,0 +1,209 @@ +# Complete disjoint-frame orbit and energy classification + +This extends [PROOF.md](PROOF.md) from the source-bound selected puncture to +all punctures of the same 120 E8 root lines by two disjoint orthonormal +8-frames. The result is a finite exact classification, not a random search or +an extrapolation from the selected orbit. **No new κ.** + +## Theorem and conventions + +Use exactly the root lines, normalization, orthogonality energy and Frobenius +inner product defined in PROOF.md. Let `F,G` be two disjoint orthonormal frames +of these root lines, and let `Q` be their 104-line complement. Two pairs are +equivalent if an orthogonal map preserving the 120-line root set carries one +pair to the other. There are **exactly three equivalence classes**, for both +ordered and unordered frame pairs. Their complete energy spectra on the +36-dimensional real symmetric-matrix space are: + +| Type: number of G for fixed F | Spectrum, with multiplicities as exponents | Sharp trace-free constant | Equality dimension | +| --- | --- | --- | --- | +| 28 | `0^1,37^6,38^16,(91/2)^12,54^1` | 37 | 6 | +| 336 | `0^1,37^1,(75/2)^8,38^12,((182−17√2)/4)^2,(91/2)^10,((182+17√2)/4)^2` | 37 | 1 | +| 896 | `0^1,(75/2)^6,(151/4)^8,38^7,(165/4)^4,(91/2)^6,(199/4)^4` | 75/2 | 6 | + +Thus every real symmetric metric perturbation satisfies + +\[ + E_Q(M)\ge c_Q\left\|M-\frac{\operatorname{tr}M}{8}I\right\|_F^2, +\] + +where the exact sharp value is 37 or 75/2 as in the table. The selected PR6030 +port set is in the 896 type. Equality holds precisely when the trace-free part +belongs to the lowest positive eigenspace certified for that type. For any +nonzero such symmetric matrix A, `I+tA` is positive definite for sufficiently +small real t; hence sharpness also holds among positive definite common real +metrics. The stronger rational-common-map attainers for the actual selected +orbit remain in PROOF.md. No rational square-root claim is made for the other +two types. + +The theorem concerns a shared real metric and unnormalized absolute inner +products; it does not concern independently normalized correlations, unrelated +port motions, arbitrary masked fitting matrices, native decoder synthesis or +complete multiplication accounting. HERMITIAN-PROOF.md separately extends +the sharp constants and equality spaces to complex Hermitian common metrics; +the full 36-dimensional spectrum displayed here is the real-symmetric sector. + +## Finite domain and constructive reduction + +The exact source labels are all 9-bit masks of weight 3 or 7. Their signed +9-dimensional representatives and normalization are in PROOF.md. Write `c(q)` +for twice the unit root in the orthonormal coordinates of + +``` +F = (7,25,42,52,76,82,97,127). +``` + +All `c(q)` are integral and have squared norm 4. The checker derives them from +the 9-dimensional coordinates, checks all 14,400 Gram identities, and uses +source labels as permanent identifiers. A root line appears once, while its +negative represents the same line. + +`enumerate_frames` performs an exhaustive increasing-prefix clique search in +the 120-vertex graph of exact orthogonality. At each prefix it tries every +remaining larger vertex adjacent to all previous choices. No valid completion +is pruned except when too few candidates remain to reach eight vertices. +Every eight-clique has one increasing ordering, so the search is both complete +and duplicate-free. There are exactly **2,025** frames. Their intersection +sizes with F have census `{0:1260,1:512,2:224,4:28,8:1}`. + +For each of the 120 root lines a, apply the exact reflection + +\[ + c\longmapsto c-\frac{c\cdot c(a)}2c(a). +\] + +This is an orthogonal reflection because `||c(a)||²=4`. Each transformation +is checked to permute the 120 root lines. Closure traversal from F under all +120 reflections reaches exactly the independently enumerated 2,025 frames. +Consequently every first frame can be carried to F by a verified root-set +isometry; no external transitivity theorem or unverified group order is used. +It is enough to classify the **1,260** frames disjoint from F. + +## Stabilizer coverage and separation + +Use the eight individual coordinate sign flips and these six coordinate +permutations, with convention `c'_i=c[p_i]`: + +``` +(0,1,2,3,5,4,7,6) (0,1,2,3,6,7,4,5) +(0,1,3,2,4,5,7,6) (0,1,4,5,2,3,6,7) +(0,2,1,3,4,6,5,7) (1,0,2,3,4,5,7,6) +``` + +Every generator is a literal orthogonal signed permutation. The checker +verifies that each permutes all 120 root lines and fixes F as a line set. +Their generated subgroup partitions the full disjoint-frame domain as follows: + +| Size | Lexicographically first G | Intersection histogram of its column supports | +| --- | --- | --- | +| 28 | `(11,21,38,56,140,146,161,191)` | `{0:16,4:12}` | +| 336 | `(11,21,44,50,134,152,161,191)` | `{0:8,2:16,4:4}` | +| 896 | `(11,22,44,49,133,152,162,191)` | `{0:4,2:24}` | + +For each pair of the eight roots in G, take the cardinality of the intersection +of their nonzero coordinate supports in the F basis; the histogram includes +all 28 unordered pairs. Every orthogonal isometry fixing the eight F lines +is a signed coordinate permutation, so this histogram is invariant under the +*entire* stabilizer, whether or not the displayed generators generate it. +The three different histograms therefore separate the three subgroup orbits +under the full stabilizer. All 1,260 frames are covered, so there can be no +additional classes. This combinatorial separator was independently supplied +and checked by research worker D using a different frame enumeration. + +The source-selected deleted second frame +`(67,104,137,162,266,289,448,491)` occurs in the 896 class. Transitivity gives +2,551,500 ordered disjoint frame pairs overall, with respective type counts +56,700, 680,400 and 1,814,400. The three spectra below are different, so +swapping the two frames cannot merge distinct types. Therefore the unordered +pair counts are 28,350, 340,200 and 907,200, respectively. + +## Exact spectra, including the irrational block + +For each displayed representative, reconstruct its own 104 roots and all +2,860 unordered orthogonal pairs. Use the same 36 symmetric entries and +Frobenius weights `W=diag(1^8,2^28)` as PROOF.md. Summing the squared linear +forms gives the integral matrix H with `E(A)=aᵀHa/16`. + +`ORBITS.json` contains 104 integer eigenvectors for the rational spectral +blocks of these three matrices. The checker verifies every exact equation +`Hv=μWv`, where `μ=16λ`, and verifies each nonzero block has trace zero. The +zero block is exactly the scalar identity. For the 28 and 896 types, 36 +independent vectors cover each whole matrix space. For the 336 type, the +rational blocks supply 32 dimensions; the remaining four are represented by +the following symmetric matrices in the F basis. Let `Eij` denote the +symmetric matrix with ones in positions `(i,j)` and `(j,i)` when `i≠j`: + +``` +b1 = diag(1,1,0,0,-1,-1,0,0) +b2 = diag(0,0,1,1,0,0,-1,-1) +b3 = E01 - E45 +b4 = E23 + E67. +``` + +In this ordered basis the exact action of `L=W⁻¹H` is + +\[ + C=\begin{pmatrix} + 796&0&0&-68\\ + 0&796&68&0\\ + 0&68&660&0\\ + -68&0&0&660 + \end{pmatrix}. +\] + +The checker verifies `HB=WBC` entry by entry. After regrouping `(b1,b4)` and +`(b2,b3)`, there are two 2×2 blocks with characteristic polynomial +`μ²−1456μ+520736`, hence eigenvalues `728±68√2`, each twice. Dividing by 16 +gives the two irrational values in the theorem. Both exceed 75/2 since +`32²>2·17²`, so they do not affect the sharp constant 37 for this orbit. +The polynomial identity `C²−1456C+520736I=0` is checked exactly as well. + +All 36 certificate columns for each type are independent modulo the prime +1009, which proves rational and real independence. Since H is symmetric and +W is positive definite, L is self-adjoint in the Frobenius inner product. +The complete bases and verified action establish all the eigenvalues, +multiplicities, equality dimensions and sharp constants, with no numerical +eigensolver in generation or replay. Distinct full spectra also independently +separate the three isometry classes. + +## Reproduction, controls and limits + +The registered package command runs both the selected and complete-orbit +checkers, each normally and with `-O`. `verify_orbits.py` expects receipt +`PASS_P104_ALL_DISJOINT_FRAME_ORBITS`, 2,025 frames, 1,260 disjoint frames, +orbit sizes `[28,336,896]`, and sharp constants `[37,37,75/2]`. + +Its eleven rejection controls cover a missing frame, inadequate orbit +coverage, an invalid root-set symmetry, wrong orbit size/representative, +corrupt and duplicate eigenvectors, altered quadratic polynomial/action/basis +dimension, and ordered-pair double counting. Two further root-moment controls +protect the Hermitian extension. These supplement the selected checker's +thirteen controls. Exact rational generation is available as + +```sh +python3 -B research/p104-selected-metric-orbit/generate_orbits.py --output /path/to/new-orbits.json +``` + +The output must equal ORBITS.json byte for byte. The generator refuses to +overwrite existing files. The fixed domain includes **all** disjoint frame +pairs of this root set, with no random seed or unsearched remainder; track +seed 31 selects the research task and is not a computational random seed. +The stopping rule is complete frame coverage, three exact spectra and equality +spaces, and one source-bound selected-orbit identification. Overlapping frame +pairs and other root systems are outside scope. + +The finite checker is ordinary Python, not a proof-kernel formalization. +Its exhaustive combinatorial argument and complete exact spectral certificate +are reviewable without accepting a failed search as an impossibility theorem. +A separate reviewer uses maximal-clique enumeration and union-find in original +9-dimensional coordinates for coverage. The lead separately reconstructs the +selected spectrum in a nonorthogonal A8 chart. These are independent +AI-assisted implementations; independent human or hosted-CI acceptance is not +claimed. The selected multiplier, source pins and all five inherited framework +assumptions are unchanged. + +Jerry Chen, @CubeJerry; substantial OpenAI Codex assistance from worker A, +worker D (independent frame coverage and separator), and the lead (independent +selected energy). Credit Nick Petalas's PR6278 for the uniform coefficient37 +and the explicit orbit-classification question; the canonical P104/E8 +construction and coordinate lineage remain as credited in README.md. diff --git a/research/p104-selected-metric-orbit/ORBITS.json b/research/p104-selected-metric-orbit/ORBITS.json new file mode 100644 index 0000000000..8ae41be812 --- /dev/null +++ b/research/p104-selected-metric-orbit/ORBITS.json @@ -0,0 +1,4330 @@ +{ + "schema": "p104-disjoint-frame-orbits/1", + "coordinate_frame": [ + 7, + 25, + 42, + 52, + 76, + 82, + 97, + 127 + ], + "coordinate_permutations": [ + [ + 0, + 1, + 2, + 3, + 5, + 4, + 7, + 6 + ], + [ + 0, + 1, + 2, + 3, + 6, + 7, + 4, + 5 + ], + [ + 0, + 1, + 3, + 2, + 4, + 5, + 7, + 6 + ], + [ + 0, + 1, + 4, + 5, + 2, + 3, + 6, + 7 + ], + [ + 0, + 2, + 1, + 3, + 4, + 6, + 5, + 7 + ], + [ + 1, + 0, + 2, + 3, + 4, + 5, + 7, + 6 + ] + ], + "sign_flips": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "orbits": [ + { + "size": 28, + "representative": [ + 11, + 21, + 38, + 56, + 140, + 146, + 161, + 191 + ], + "blocks": [ + { + "eigenvalue_times_16": 0, + "basis": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 592, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 608, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 728, + "basis": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 864, + "basis": [ + [ + 1, + 1, + 1, + 1, + -1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + } + ] + }, + { + "size": 336, + "representative": [ + 11, + 21, + 44, + 50, + 134, + 152, + 161, + 191 + ], + "blocks": [ + { + "eigenvalue_times_16": 0, + "basis": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 592, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 600, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 608, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + 1, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 728, + "basis": [ + [ + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ] + ] + } + ], + "quadratic_block": { + "polynomial": [ + 1, + -1456, + 520736 + ], + "basis": [ + [ + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1 + ] + ] + } + }, + { + "size": 896, + "representative": [ + 11, + 22, + 44, + 49, + 133, + 152, + 162, + 191 + ], + "blocks": [ + { + "eigenvalue_times_16": 0, + "basis": [ + [ + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ] + ] + }, + { + "eigenvalue_times_16": 600, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ] + }, + { + "eigenvalue_times_16": 604, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + -1, + -1, + 0, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + -1, + 0, + -1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + -1, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + -1, + 0, + -1, + 0, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 608, + "basis": [ + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 1, + -1, + -1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 1, + 1, + -1, + -1, + 0, + 0, + 1, + 1, + 0, + 1, + 1, + 0, + 0, + -1, + -1, + 0, + 0, + 0, + 1, + -1, + -1, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 0, + 0, + 0, + 0, + -1, + 0, + 0, + 1, + 0, + -1, + -1, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 660, + "basis": [ + [ + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 1, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 0, + 1, + 0, + -1, + 1, + 0, + -1, + -1, + -1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 2, + 0, + 0, + 0, + -2, + -1, + -1, + 0, + 0, + -1, + 1, + 0, + -1, + 0, + 1, + 0, + -1, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 1, + 0, + 0 + ], + [ + 1, + -1, + 1, + -1, + -1, + 1, + -1, + 1, + 0, + 1, + 0, + 0, + 1, + 0, + -1, + 0, + 1, + -1, + 0, + 1, + 0, + 0, + 0, + -1, + 0, + 1, + -1, + 0, + 1, + 0, + 0, + -1, + 0, + 0, + 1, + 0 + ], + [ + 1, + 1, + -1, + -1, + -1, + -1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1, + 1, + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 728, + "basis": [ + [ + 1, + -1, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + -1, + 0, + 1, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 1, + 0, + 0, + -1, + 1, + 0, + 0, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + -1, + 0, + 1, + 0, + 0, + -1, + 0, + -1, + 0, + 0, + 1, + 0, + 1, + -1, + 0, + 0, + 0, + -1, + -1, + 0, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + -1, + 0, + -1, + 1, + 0, + -1, + 0, + 0, + 0, + -1, + 0, + 1, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + 1, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 0, + 0, + 1, + -1, + -1, + -1, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1 + ] + ] + }, + { + "eigenvalue_times_16": 796, + "basis": [ + [ + 3, + -3, + -3, + -3, + -3, + 3, + 3, + 3, + -1, + -1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 0, + -1, + 0, + 1, + -1, + 0, + 1, + 1, + 1, + 0, + 0, + 0 + ], + [ + 0, + 0, + 0, + 6, + 0, + 0, + 0, + -6, + 1, + 1, + 0, + 0, + 1, + -1, + 0, + 1, + 0, + -1, + 0, + 1, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + 0, + 0, + -1, + -1, + 0, + -1, + 0, + 0 + ], + [ + 3, + -3, + 3, + -3, + -3, + 3, + -3, + 3, + 0, + -1, + 0, + 0, + -1, + 0, + 1, + 0, + -1, + 1, + 0, + -1, + 0, + 0, + 0, + 1, + 0, + -1, + 1, + 0, + -1, + 0, + 0, + 1, + 0, + 0, + -1, + 0 + ], + [ + 3, + 3, + -3, + -3, + -3, + -3, + 3, + 3, + -1, + 0, + 0, + 0, + 0, + 1, + -1, + 0, + 0, + 0, + 0, + -1, + 1, + -1, + -1, + 1, + 0, + 0, + -1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + -1 + ] + ] + } + ] + } + ] +} diff --git a/research/p104-selected-metric-orbit/PROOF.md b/research/p104-selected-metric-orbit/PROOF.md new file mode 100644 index 0000000000..e8f7815c85 --- /dev/null +++ b/research/p104-selected-metric-orbit/PROOF.md @@ -0,0 +1,214 @@ +# The selected P104 orbit has sharp metric constant 75/2 + +Jerry Chen (@CubeJerry), with substantial OpenAI Codex assistance. Apache-2.0. + +## 1. Exact object and result + +Let Q be the ordered `ports` field of the selected PR6030 +`research/p104-helper470-twin-rung-removal/WORD.json.gz`, at canonical commit +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. Its SHA256 is +`7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f`. +This is the selected word's own 104 labels, not an assumed equivalence with +another 104-root fixture. The word's complete endpoint/native/caller proof is +not replayed here. + +Use the retained A8 root convention in the eight-dimensional subspace +V = {x in R^9 : sum x_i = 0}. For a weight-three label q with support T, put + + r(q) = sum_{i in T} e_i - (1/3) sum_{i=0}^8 e_i. + +For a weight-seven q with omitted indices i < j, put r(q) = e_i - e_j. +Every root has norm squared two. Write u(q) = r(q)/sqrt(2), and use the +Euclidean structure on V. This convention is the one documented in +Matarener's PR6166 and the retained `p104-two-channel-support/PROOF.md`. +Our certificate independently checks its finite coordinates and Gram +isometry; the identification with the supplier's intended root geometry +retains that source attribution. + +For any real symmetric operator A on V, define + + A0 = A - tr(A) I/8, + E_Q(A) = sum (u(q)^T A u(r))^2, + +where the sum is over **unordered**, distinct q,r in Q with u(q) perpendicular +to u(r). There are exactly 2,860 such pairs. The statement is + + E_Q(A) >= (75/2) ||A0||_F^2. (1) + +The coefficient 75/2 is exact and sharp. Equality holds exactly when A0 is +in the six-dimensional space described in Section 4. The full spectrum of +this quadratic form relative to the Frobenius metric is + +| Eigenvalue | Multiplicity | +| --- | ---: | +| 0 | 1 | +| 75/2 | 6 | +| 151/4 | 8 | +| 38 | 7 | +| 165/4 | 4 | +| 91/2 | 6 | +| 199/4 | 4 | + +The statement also holds for any sign/permutation/orthogonal-coordinate image +of this fixed root set. It does not classify all pairs of deleted E8 frames. + +Nick Petalas's PR6278 proves a sharp **uniform** coefficient 37 over all +two-disjoint-frame punctures, leaving the selected orbit as an explicit open +question. Its equality example is not assumed to be our selected orbit. +Equation (1), its complete spectrum and selected equality space resolve that +source-specific question. Our proof does not use PR6278's executable or its +sum-of-squares identity as a premise. + +## 2. Rational coordinates without square roots + +The full 120-line A8 realization consists of the 84 triple labels and 36 +weight-seven labels. Its complement to Q is the disjoint union of frames + + F = (7, 25, 42, 52, 76, 82, 97, 127), + G = (67, 104, 137, 162, 266, 289, 448, 491). + +Each is an orthonormal frame after dividing r by sqrt(2); this is checked +from all 64 pairings in each frame. In the ordered orthonormal F basis set + + c(q)_i = r(F_i) . r(q) = 2 * coordinate_i(u(q)). + +All c(q) entries are integers. The code first constructs the integer vectors +3r(q), takes their dot products, and divides exactly by nine. It then checks +all 14,400 Gram relations + + 9 c(q).c(r) = 2 (3r(q)).(3r(r)). (2) + +This establishes the complete coordinate isometry, not merely the orthogonality +mask. Every c(q) has norm squared four. + +Represent A by its 36 independent entries a: first A_00,...,A_77, then A_ij +in lexicographic i 0 else -1) + for value in integers]) + return result + + +def generate(): + package = package_path() + ports = load_ports(package) + matrix, _ = energy_matrix(ports, coordinates()) + blocks = [] + for value, multiplicity in SPECTRUM: + shifted = [[matrix[i][j] - value * WEIGHTS[i] * int(i == j) + for j in range(SIZE)] for i in range(SIZE)] + basis = nullspace(shifted) + need(len(basis) == multiplicity, "GENERATED_MULTIPLICITY") + blocks.append({"eigenvalue_times_16": value, "basis": basis}) + return {"schema": "p104-selected-metric-spectrum/1", + "coordinate_frame": list(FIRST), "second_deleted_frame": list(SECOND), + "energy_convention": "unordered orthogonal unit-root pairs", + "blocks": blocks} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + with args.output.open("x", encoding="utf-8") as stream: + json.dump(generate(), stream, indent=2) + stream.write("\n") + + +if __name__ == "__main__": + main() diff --git a/research/p104-selected-metric-orbit/generate_orbits.py b/research/p104-selected-metric-orbit/generate_orbits.py new file mode 100644 index 0000000000..9507e85f4a --- /dev/null +++ b/research/p104-selected-metric-orbit/generate_orbits.py @@ -0,0 +1,58 @@ +"""Generate exact eigenbases for all three disjoint-frame orbit types. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. Apache-2.0. +Normal replay imports neither this generator nor its nullspace algorithm. +""" +import argparse +import json +from pathlib import Path + +from generate import nullspace +from geometry import FIRST, SIZE, WEIGHTS, coordinates, energy_matrix, need, universe +from orbits import PERMUTATIONS, QUADRATIC, TYPES + + +def generate(): + vectors = coordinates() + records = [] + for count, frame, spectrum in TYPES: + ports = sorted(set(universe()) - set(FIRST) - set(frame)) + matrix, _ = energy_matrix(ports, vectors) + blocks = [] + for value, multiplicity in spectrum: + shifted = [[matrix[i][j] - value * WEIGHTS[i] * int(i == j) + for j in range(SIZE)] for i in range(SIZE)] + basis = nullspace(shifted) + need(len(basis) == multiplicity, "GENERATED_MULTIPLICITY") + blocks.append({"eigenvalue_times_16": value, "basis": basis}) + record = {"size": count, "representative": list(frame), "blocks": blocks} + if count == 336: + need(all(matrix[i][j] % WEIGHTS[i] == 0 for i in range(SIZE) + for j in range(SIZE)), "INTEGER_OPERATOR") + operator = [[matrix[i][j] // WEIGHTS[i] for j in range(SIZE)] + for i in range(SIZE)] + polynomial = [[sum(operator[i][k] * operator[k][j] for k in range(SIZE)) + + QUADRATIC[1] * operator[i][j] + + QUADRATIC[2] * int(i == j) + for j in range(SIZE)] for i in range(SIZE)] + basis = nullspace(polynomial) + need(len(basis) == 4, "GENERATED_QUADRATIC_DIMENSION") + record["quadratic_block"] = {"polynomial": list(QUADRATIC), "basis": basis} + records.append(record) + return {"schema": "p104-disjoint-frame-orbits/1", + "coordinate_frame": list(FIRST), + "coordinate_permutations": [list(p) for p in PERMUTATIONS], + "sign_flips": list(range(8)), "orbits": records} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + with args.output.open("x", encoding="utf-8") as stream: + json.dump(generate(), stream, indent=2) + stream.write("\n") + + +if __name__ == "__main__": + main() diff --git a/research/p104-selected-metric-orbit/geometry.py b/research/p104-selected-metric-orbit/geometry.py new file mode 100644 index 0000000000..bdd8d011ce --- /dev/null +++ b/research/p104-selected-metric-orbit/geometry.py @@ -0,0 +1,132 @@ +"""Selected P104 energy, derived from its source port labels. Apache-2.0. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. +The A8 root convention and selected ports retain Matarener/DreamingOfClouds/ +Ali Romman and the P104 lineage's credit. No predecessor executable is imported. +""" +from hashlib import sha256 +from itertools import combinations +from pathlib import Path +import gzip +import json + +DIM = 8 +PAIRS = tuple(combinations(range(DIM), 2)) +SIZE = DIM + len(PAIRS) +WEIGHTS = (1,) * DIM + (2,) * len(PAIRS) +FIRST = (7, 25, 42, 52, 76, 82, 97, 127) +SECOND = (67, 104, 137, 162, 266, 289, 448, 491) +SOURCE = "research/p104-helper470-twin-rung-removal/WORD.json.gz" +SPECTRUM = ((0, 1), (600, 6), (604, 8), (608, 7), + (660, 4), (728, 6), (796, 4)) # sixteen times each eigenvalue + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def dot(a, b): + return sum(x * y for x, y in zip(a, b, strict=True)) + + +def universe(): + triples = [sum(1 << i for i in indices) + for indices in combinations(range(9), 3)] + differences = [511 ^ (1 << i) ^ (1 << j) + for i, j in combinations(range(9), 2)] + return tuple(sorted(triples + differences)) + + +def root_times_three(label): + """Nine coordinates: 3*(indicator(T)-ones/3), or 3*(e_i-e_j).""" + need(type(label) is int and label in universe(), "ROOT_LABEL") + if label.bit_count() == 3: + return tuple(2 if (label >> i) & 1 else -1 for i in range(9)) + i, j = (i for i in range(9) if not (label >> i) & 1) + return tuple(3 * (int(k == i) - int(k == j)) for k in range(9)) + + +def checked_ports(ports): + need(isinstance(ports, list) and len(ports) == 104, "PORT_COUNT") + need(all(type(q) is int and q in universe() for q in ports), "PORT_LABEL") + need(len(set(ports)) == 104, "PORT_DUPLICATE") + need(set(universe()) - set(ports) == set(FIRST + SECOND), "SELECTED_PUNCTURE") + return tuple(ports) + + +def authenticate(raw, expected): + need(sha256(raw).hexdigest() == expected, "SOURCE_SHA256") + + +def load_ports(package): + manifest = json.loads((package / "SOURCES.json").read_bytes()) + pins = [row for row in manifest["files"] if row["path"] == SOURCE] + need(len(pins) == 1 and pins[0]["usage"] == "input", "SOURCE_PIN") + raw = (package.parents[1] / SOURCE).read_bytes() + authenticate(raw, pins[0]["sha256"]) + word = json.loads(gzip.decompress(raw)) + return checked_ports(word["ports"]) + + +def coordinates(): + """Return 2u in the orthonormal FIRST-frame basis, entirely over Z.""" + roots = {q: root_times_three(q) for q in universe()} + for frame in (FIRST, SECOND): + need(len(frame) == len(set(frame)) == DIM, "FRAME_SIZE") + need(all(dot(roots[a], roots[b]) == 18 * int(a == b) + for a in frame for b in frame), "FRAME_ORTHOGONAL") + result = {} + for q, row in roots.items(): + products = tuple(dot(roots[a], row) for a in FIRST) + need(all(value % 9 == 0 for value in products), "INTEGRAL_CHART") + result[q] = tuple(value // 9 for value in products) + for q in universe(): + need(sum(roots[q]) == 0 and dot(roots[q], roots[q]) == 18, + "A8_ROOT_NORM") + need(dot(result[q], result[q]) == 4, "UNIT_ROOT_NORM") + for r in universe(): + need(9 * dot(result[q], result[r]) == 2 * dot(roots[q], roots[r]), + "GRAM_ISOMETRY") + return result + + +def linear_form(left, right): + return tuple(left[i] * right[i] for i in range(DIM)) + tuple( + left[i] * right[j] + left[j] * right[i] for i, j in PAIRS) + + +def energy_matrix(ports, vectors): + """H with E(A)=a^T H a/16; a lists diagonal then upper entries.""" + matrix = [[0] * SIZE for _ in range(SIZE)] + edges = [] + for q, r in combinations(ports, 2): + if dot(vectors[q], vectors[r]) != 0: + continue + edges.append((q, r)) + row = linear_form(vectors[q], vectors[r]) + sparse = [(i, value) for i, value in enumerate(row) if value] + for i, left in sparse: + for j, right in sparse: + matrix[i][j] += left * right + need(len(edges) == 2860, "SELECTED_EDGE_COUNT") + return matrix, tuple(edges) + + +def matrix_from_entries(entries): + need(len(entries) == SIZE, "ENTRY_COUNT") + matrix = [[0] * DIM for _ in range(DIM)] + for i in range(DIM): + matrix[i][i] = entries[i] + for (i, j), value in zip(PAIRS, entries[DIM:], strict=True): + matrix[i][j] = matrix[j][i] = value + return matrix + + +def bilinear(left, matrix, right): + return sum(left[i] * matrix[i][j] * right[j] + for i in range(DIM) for j in range(DIM)) + + +def package_path(): + return Path(__file__).resolve().parent diff --git a/research/p104-selected-metric-orbit/independent.py b/research/p104-selected-metric-orbit/independent.py new file mode 100644 index 0000000000..6bb6436940 --- /dev/null +++ b/research/p104-selected-metric-orbit/independent.py @@ -0,0 +1,114 @@ +"""Independent selected-port energy replay in a nonorthogonal A8 basis. + +Jerry Chen (@CubeJerry), with OpenAI Codex lead-agent assistance. Apache-2.0. +This imports no primary checker, geometry helper, or eigenvector certificate. +""" +import gzip, json, math, hashlib +from itertools import combinations, product +from pathlib import Path + +source = Path(__file__).resolve().parents[2] / 'research/p104-helper470-twin-rung-removal/WORD.json.gz' +if hashlib.sha256(source.read_bytes()).hexdigest() != '7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f': + raise ValueError('selected word source mismatch') +ports = json.loads(gzip.decompress(source.read_bytes()))['ports'] +def root(label): + bits = [i for i in range(9) if label >> i & 1] + if len(bits) == 3: + return tuple(2 if i in bits else -1 for i in range(9)) + if len(bits) == 7: + a,b = [i for i in range(9) if i not in bits] + return tuple(3*(int(i==a)-int(i==b)) for i in range(9)) + raise ValueError(label) +roots = list(map(root,ports)) +if not (len(set(ports)) == 104 and all(sum(v)==0 and sum(z*z for z in v)==18 for v in roots)): + raise ValueError('selected root domain') +indices = [(i,i) for i in range(8)] + list(combinations(range(8),2)) +H = [[0]*36 for _ in range(36)] +edges=0 +for u,v in combinations(roots,2): + if sum(x*y for x,y in zip(u,v)): + continue + edges+=1 + c=[u[i]*v[j] if i==j else u[i]*v[j]+u[j]*v[i] for i,j in indices] + for i in range(36): + for j in range(36): H[i][j]+=c[i]*c[j] +# B=(e_i-e_8), B^T B=I+J; 9*(B^T B)^-1=9I-J. +K=[[9*int(i==j)-1 for j in range(8)] for i in range(8)] +KE=[] +for i,j in indices: + E=[[0]*8 for _ in range(8)] + E[i][j]=E[j][i]=1 + KE.append([[sum(K[a][k]*E[k][b] for k in range(8)) for b in range(8)] for a in range(8)]) +M=[[sum(KE[i][a][b]*KE[j][b][a] for a in range(8) for b in range(8)) for j in range(36)] for i in range(36)] +def rank(a): + a=[row[:] for row in a] + k=0 + for c in range(len(a[0])): + p=next((i for i in range(k,len(a)) if a[i][c]),None) + if p is None: continue + a[k],a[p]=a[p],a[k] + for i in range(k+1,len(a)): + if not a[i][c]: continue + q,pivot=a[i][c],a[k][c] + a[i]=[pivot*x-q*y for x,y in zip(a[i],a[k])] + g=math.gcd(*a[i]) + if g>1: a[i]=[x//g for x in a[i]] + k+=1 + return k +observed={str(m)+'/4':36-rank([[H[i][j]-m*M[i][j] for j in range(36)] for i in range(36)]) for m in [0,150,151,152,165,182,199]} +expected={'0/4':1,'150/4':6,'151/4':8,'152/4':7,'165/4':4,'182/4':6,'199/4':4} +if observed!=expected: raise ValueError(observed) +if sum(observed.values()) !=36 or rank(M)!=36: raise ValueError('incomplete eigenspaces') +# A true coefficient perturbation must destroy the claimed complete spectrum. +changed=[row[:] for row in H] +changed[0][0]+=1 +changed_dims={str(m)+'/4':36-rank([[changed[i][j]-m*M[i][j] for j in range(36)] for i in range(36)]) for m in [0,150,151,152,165,182,199]} +if changed_dims == expected: + raise ValueError('coefficient fault escaped') +# Every original root sign is immaterial; a pair's coefficient outer product +# is unchanged under either sign. Check this directly for all retained pairs. +for u,v in combinations(roots,2): + if sum(x*y for x,y in zip(u,v)): continue + c=[u[i]*v[j] if i==j else u[i]*v[j]+u[j]*v[i] for i,j in indices] + d=[(-u[i])*v[j] if i==j else (-u[i])*v[j]+(-u[j])*v[i] for i,j in indices] + if any(x != -y for x,y in zip(c,d)): + raise ValueError('sign covariance') +print(json.dumps({'status':'PASS_INDEPENDENT_A8_METRIC_SPECTRUM','word_sha256':hashlib.sha256(source.read_bytes()).hexdigest(),'ports':len(ports),'orthogonal_pairs':edges,'eigenspace_dimensions':observed,'metric_rank':rank(M),'coefficient_fault_rejected':True,'sign_covariance_pairs':edges,'method':'Direct 104-port energy in nonorthogonal A8 basis; fraction-free integer elimination; no predecessor or worker code imports'},indent=2)) + +# Independently check the Hermitian extension in the original 9D A8 coordinates. +# H = 202 M + cross corresponds to E_P(K) = (101/2)||K||^2 + X_FG. +labels=[sum(1<0,'LDL_NOT_POSITIVE');piv.append(d) + for i in range(k+1,len(m)): + for j in range(i,len(m)): + m[i][j]-=m[i][k]*m[j][k]/d;m[j][i]=m[i][j] + return piv + +def physical_basis(): + # Build each physical 9x9 operator without using F coordinates. + basis=[] + for i,j in PAIRS: + a=[[0]*9 for _ in range(9)] + for p,q in ((i,j),) if i==j else ((i,j),(j,i)): + for r in (p,8): + for s in (q,8):a[r][s]+=(1 if r==p else -1)*(1 if s==q else -1) + basis.append(a) + return basis + +def energy(root,deleted): + labels=sorted(set(root)-set(deleted));need(len(labels)==104,'PUNCTURE_SIZE') + w={q:tuple((root[q][i]-root[q][8])//3 for i in range(8)) for q in labels} + need(all(all((root[q][i]-root[q][8])%3==0 for i in range(8)) for q in labels),'A8_INTEGRAL') + h=[[0]*36 for _ in range(36)];count=0 + for q,r in combinations(labels,2): + if dot(root[q],root[r]):continue + count+=1;u,v=w[q],w[r] + l=[u[i]*v[j] if i==j else u[i]*v[j]+u[j]*v[i] for i,j in PAIRS] + nonzero=[(i,x) for i,x in enumerate(l) if x] + for i,x in nonzero: + for j,y in nonzero:h[i][j]+=x*y + need(count==2860,'ORTHOGONAL_PAIR_COUNT') + return h,count + +def shift(h,w,a):return [[x-a*y for x,y in zip(r,s)] for r,s in zip(h,w)] +def symmetric(v): + a=[[Q(0)]*8 for _ in range(8)] + for (i,j),x in zip(PAIRS,v):a[i][j]=a[j][i]=x + return a + +def run(source): + need(sha256(Path(source).read_bytes()).hexdigest()==SOURCE_SHA,'SOURCE_SHA256') + root=roots();physical=physical_basis();flat=[sum(a,[]) for a in physical] + w=[[dot(a,b) for b in flat] for a in flat] + wp=positive_ldl(w);need(len(wp)==36,'FROBENIUS_DIMENSION') + trace=[sum(a[i][i] for i in range(9)) for a in physical] + need(trace==[2]*36,'TRACE_COORDINATES') + identity=[Q(8,9) if i==j else Q(-1,9) for i,j in PAIRS] + need(dot(identity,matvec(w,identity))==8,'IDENTITY_NORM') + rows=[];matrices=[] + for rep,spectrum,orbit in zip(REPS,SPECTRA,(28,336,896)): + h,count=energy(root,F+rep);matrices.append(h) + need(not any(matvec(h,identity)),'SCALAR_KERNEL') + found={};bases={} + for value,multiplicity in spectrum.items(): + rank,basis=rank_and_kernel(shift(h,w,value));need(36-rank==multiplicity,'RATIONAL_MULTIPLICITY') + need(all(not dot(trace,v) for v in basis) if value else True,'TRACE_FREE_EIGENSPACE') + found[str(Q(value,4))]=36-rank;bases[value]=basis + need(sum(found.values())==(32 if orbit==336 else 36),'RATIONAL_COVERAGE') + c=min(v for v in spectrum if v) + # A concrete sharp perturbation: in A8 coordinates I+tA, then pull back + # via B. The physical matrix on V has identity P=I_9-J_9/9. + v=bases[c][0];a=[[sum(v[k]*physical[k][i][j] for k in range(36)) for j in range(9)] for i in range(9)] + bound=max(sum(abs(x) for x in r) for r in a);t=Q(1,2)/bound + s=symmetric([x+t*y for x,y in zip(identity,v)]) + pd=positive_ldl(s) # B injective; BSB^t restricted to V is PD iff S is PD. + need(dot(v,matvec(h,v))==c*dot(v,matvec(w,v)),'SHARP_ATTAINER') + rows.append({'orbit':orbit,'orthogonal_pairs':count,'rational_multiplicities':found,'sharp_constant':str(Q(c,4)),'equality_dimension':len(bases[c]),'positive_definite_attainer_t':str(t),'pd_pivots_positive':len(pd)}) + # Independent construction of the stated quadratic subspace in 9D, + # then top-left 8x8 extraction into the nonorthogonal S chart. + bs=[] + b1=[[0]*8 for _ in range(8)];b2=[[0]*8 for _ in range(8)] + for i in (0,1):b1[i][i]=1 + for i in (4,5):b1[i][i]=-1 + for i in (2,3):b2[i][i]=1 + for i in (6,7):b2[i][i]=-1 + b3=[[0]*8 for _ in range(8)];b4=[[0]*8 for _ in range(8)] + for a,i,j,x in ((b3,0,1,1),(b3,4,5,-1),(b4,2,3,1),(b4,6,7,1)):a[i][j]=a[j][i]=x + rf=[[root[q][i] for q in F] for i in range(8)] + for b in (b1,b2,b3,b4): + s=matrix_product(matrix_product(rf,b),transpose(rf)) + bs.append([Q(s[i][j],18) for i,j in PAIRS]) + v=transpose(bs);c=[[796,0,0,-68],[0,796,68,0],[0,68,660,0],[-68,0,0,660]] + hv=matrix_product(matrices[1],v);wvc=matrix_product(matrix_product(w,v),c) + need([[4*x for x in r] for r in hv]==wvc,'QUADRATIC_ACTION') + need(rank_and_kernel(transpose(v))[0]==4,'QUADRATIC_DIMENSION') + cc=matrix_product(c,c) + need(all(cc[i][j]-1456*c[i][j]+520736*(i==j)==0 for i in range(4) for j in range(4)),'QUADRATIC_POLYNOMIAL') + need(sum(c[i][i] for i in range(4))==2912,'QUADRATIC_MULTIPLICITIES') + need(all((4*x)**2-1456*(4*x)+520736!=0 for x in SPECTRA[1]),'QUADRATIC_RATIONAL_OVERLAP') + need(32**2>2*17**2,'QUADRATIC_LOWER_BOUND') + # Independent negative controls: wrong normalization and changed action + # must fail exact equations, not merely alter display fields. + need(any(any(x for x in r) for r in shift(matrices[0],w,296)),'NEGATIVE_NORM_TRIVIAL') + wrong_rank,_=rank_and_kernel(shift(matrices[0],w,296)) + need(wrong_rank==36,'NEGATIVE_DOUBLE_ENERGY') + bad=[r[:] for r in c];bad[0][3]=68 + need([[4*x for x in r] for r in hv]!=matrix_product(matrix_product(w,v),bad),'NEGATIVE_QUADRATIC_SIGN') + need(rank_and_kernel(transpose([r[:3] for r in v]))[0]==3,'NEGATIVE_MISSING_QUADRATIC_COLUMN') + return {'status':'PASS_INDEPENDENT_A8_ALL_SPECTRA','source_sha256':SOURCE_SHA,'normalization':'energy=s^t H s/4; Frobenius=s^t W s; independent A8 chart','frobenius_positive_pivots':len(wp),'classes':rows,'quadratic_mu_polynomial':[1,-1456,520736],'quadratic_dimension':4,'quadratic_lambda':'(182 +/- 17 sqrt(2))/4, each multiplicity 2','negative_controls':3,'no_new_kappa':True} + +if __name__=='__main__': + p=argparse.ArgumentParser();p.add_argument('--source',default=Path(__file__).resolve().parents[2]/'research/p104-helper470-twin-rung-removal/WORD.json.gz');a=p.parse_args() + print(json.dumps(run(a.source),sort_keys=True,indent=2)) diff --git a/research/p104-selected-metric-orbit/moments.py b/research/p104-selected-metric-orbit/moments.py new file mode 100644 index 0000000000..2b3743bd39 --- /dev/null +++ b/research/p104-selected-metric-orbit/moments.py @@ -0,0 +1,43 @@ +"""Exact root second moments behind the Hermitian extension. Apache-2.0. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. +The lead proposed the skew-sector identity; worker A checked its derivation +and implemented these independent root-moment obligations. +""" +from geometry import DIM, dot, need +from verify import rejected + + +def second_moment(rows): + return [[sum(row[i] * row[j] for row in rows) for j in range(DIM)] + for i in range(DIM)] + + +def check_tight(moment): + need(moment == [[60 * int(i == j) for j in range(DIM)] for i in range(DIM)], + "MOMENT_TIGHT_FRAME") + + +def check_star(root, neighbors): + expected = [[36 * int(i == j) - 9 * root[i] * root[j] for j in range(DIM)] + for i in range(DIM)] + need(second_moment(neighbors) == expected, "MOMENT_ORTHOGONAL_STAR") + need(len(neighbors) == 63, "MOMENT_STAR_DEGREE") + + +def check_moments(vectors): + need(len(vectors) == 120, "MOMENT_ROOT_COUNT") + tight = second_moment(list(vectors.values())) + check_tight(tight) + for root in vectors.values(): + neighbors = [row for row in vectors.values() if dot(root, row) == 0] + check_star(root, neighbors) + damaged = [row[:] for row in tight] + damaged[0][0] += 1 + rejected(lambda: check_tight(damaged), "MOMENT_TIGHT_FRAME") + root = next(iter(vectors.values())) + neighbors = [row for row in vectors.values() if dot(root, row) == 0] + rejected(lambda: check_star(root, neighbors[:-1]), "MOMENT_ORTHOGONAL_STAR") + return {"full_tight_frame_coefficient": 15, + "orthogonal_stars_checked": 120, "orthogonal_star_coefficient": 9, + "skew_sector_lower_bound": "101/2", "negative_controls": 2} diff --git a/research/p104-selected-metric-orbit/orbits.py b/research/p104-selected-metric-orbit/orbits.py new file mode 100644 index 0000000000..c0bf7da929 --- /dev/null +++ b/research/p104-selected-metric-orbit/orbits.py @@ -0,0 +1,117 @@ +"""Exact finite E8 frame coverage and signed isometries. Apache-2.0. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. +Coordinates and root labels retain the geometry.py provenance. +""" +from collections import deque + +from geometry import DIM, FIRST, dot, need + +PERMUTATIONS = ( + (0, 1, 2, 3, 5, 4, 7, 6), + (0, 1, 2, 3, 6, 7, 4, 5), + (0, 1, 3, 2, 4, 5, 7, 6), + (0, 1, 4, 5, 2, 3, 6, 7), + (0, 2, 1, 3, 4, 6, 5, 7), + (1, 0, 2, 3, 4, 5, 7, 6), +) +TYPES = ( + (28, (11, 21, 38, 56, 140, 146, 161, 191), + ((0, 1), (592, 6), (608, 16), (728, 12), (864, 1))), + (336, (11, 21, 44, 50, 134, 152, 161, 191), + ((0, 1), (592, 1), (600, 8), (608, 12), (728, 10))), + (896, (11, 22, 44, 49, 133, 152, 162, 191), + ((0, 1), (600, 6), (604, 8), (608, 7), (660, 4), (728, 6), (796, 4))), +) + +QUADRATIC = (1, -1456, 520736) # roots 728 +/- 68*sqrt(2), in mu=16*lambda + + +def enumerate_frames(vectors): + """Exhaustive ordered-prefix clique search; every frame occurs once.""" + labels = sorted(vectors) + adjacent = [sum(1 << j for j, r in enumerate(labels) + if dot(vectors[q], vectors[r]) == 0) for q in labels] + frames = set() + + def extend(prefix, candidates): + if len(prefix) == DIM: + frames.add(tuple(labels[i] for i in prefix)) + return + while candidates.bit_count() >= DIM - len(prefix): + bit = candidates & -candidates + i = bit.bit_length() - 1 + candidates ^= bit + extend(prefix + (i,), candidates & adjacent[i]) + + extend((), (1 << len(labels)) - 1) + return frames + + +def root_lookup(vectors): + lookup = {} + for q, row in vectors.items(): + lookup[row] = q + lookup[tuple(-x for x in row)] = q + need(len(lookup) == 240, "ROOT_SIGNED_COUNT") + return lookup + + +def checked_action(vectors, transform): + lookup = root_lookup(vectors) + action = {} + for q, row in vectors.items(): + target = transform(row) + need(target in lookup, "ROOT_CLOSURE") + action[q] = lookup[target] + need(set(action.values()) == set(vectors), "ROOT_BIJECTION") + return action + + +def reflection_actions(vectors): + actions = [] + for root in vectors.values(): + def reflect(row): + product = dot(row, root) + need(product % 2 == 0, "REFLECTION_INTEGRAL") + return tuple(x - (product // 2) * a + for x, a in zip(row, root, strict=True)) + actions.append(checked_action(vectors, reflect)) + return actions + + +def stabilizer_actions(vectors, permutations=PERMUTATIONS): + actions = [] + for permutation in permutations: + need(sorted(permutation) == list(range(DIM)), "COORDINATE_PERMUTATION") + actions.append(checked_action(vectors, lambda row: tuple( + row[permutation[i]] for i in range(DIM)))) + for coordinate in range(DIM): + actions.append(checked_action(vectors, lambda row: tuple( + -x if i == coordinate else x for i, x in enumerate(row)))) + need(all(tuple(sorted(action[q] for q in FIRST)) == FIRST + for action in actions), "STABILIZER_FIXED_FRAME") + return actions + + +def orbit(start, actions): + seen = {start} + pending = deque([start]) + while pending: + frame = pending.popleft() + for action in actions: + target = tuple(sorted(action[q] for q in frame)) + if target not in seen: + seen.add(target) + pending.append(target) + return seen + + +def orbit_partition(domain, actions): + unseen, result = set(domain), [] + while unseen: + reached = orbit(min(unseen), actions) + need(reached <= unseen, "ORBIT_DOMAIN") + unseen -= reached + result.append(reached) + return result diff --git a/research/p104-selected-metric-orbit/verify.py b/research/p104-selected-metric-orbit/verify.py new file mode 100644 index 0000000000..778c413a7c --- /dev/null +++ b/research/p104-selected-metric-orbit/verify.py @@ -0,0 +1,158 @@ +"""Check a complete exact spectral certificate for selected P104 geometry. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. Apache-2.0. +This checker imports neither the generator nor any predecessor executable. +""" +from copy import deepcopy +from fractions import Fraction +from hashlib import sha256 +import json + +from geometry import (DIM, FIRST, SECOND, SIZE, SOURCE, SPECTRUM, WEIGHTS, + authenticate, bilinear, checked_ports, coordinates, dot, + energy_matrix, linear_form, load_ports, matrix_from_entries, need, + package_path) + + +def modular_rank(columns, prime=1009): + """An invertible reduction proves rational independence; no converse used.""" + rows = [[column[i] % prime for column in columns] for i in range(SIZE)] + rank = 0 + for j in range(len(columns)): + pivot = next((i for i in range(rank, SIZE) if rows[i][j]), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + inverse = pow(rows[rank][j], -1, prime) + rows[rank] = [x * inverse % prime for x in rows[rank]] + for i in range(rank + 1, SIZE): + factor = rows[i][j] + rows[i] = [(x - factor * y) % prime + for x, y in zip(rows[i], rows[rank], strict=True)] + rank += 1 + if rank == SIZE: + break + return rank + + +def check_certificate(certificate, matrix, weights=WEIGHTS): + need(certificate.get("schema") == "p104-selected-metric-spectrum/1", "SCHEMA") + need(certificate.get("coordinate_frame") == list(FIRST), "COORDINATE_FRAME") + need(certificate.get("second_deleted_frame") == list(SECOND), "SECOND_FRAME") + need(certificate.get("energy_convention") == + "unordered orthogonal unit-root pairs", "ENERGY_CONVENTION") + blocks = certificate.get("blocks") + need(isinstance(blocks, list) and len(blocks) == len(SPECTRUM), "BLOCK_COUNT") + columns, equality = [], [] + for block, (mu, count) in zip(blocks, SPECTRUM, strict=True): + need(type(block.get("eigenvalue_times_16")) is int and + block["eigenvalue_times_16"] == mu, "EIGENVALUE") + basis = block.get("basis") + need(isinstance(basis, list) and len(basis) == count, "MULTIPLICITY") + for vector in basis: + need(isinstance(vector, list) and len(vector) == SIZE and + all(type(x) is int and abs(x) <= 1000 for x in vector), "VECTOR") + for i in range(SIZE): + need(dot(matrix[i], vector) == mu * weights[i] * vector[i], + "EIGENVECTOR_EQUATION") + need(mu == 0 or sum(vector[:DIM]) == 0, "POSITIVE_TRACE_ZERO") + need(mu != 0 or vector == [1] * DIM + [0] * (SIZE - DIM), + "SCALAR_KERNEL") + columns.append(vector) + if mu == 600: + equality = basis + need(len(columns) == SIZE and modular_rank(columns) == SIZE, "BASIS_COMPLETE") + return equality + + +def check_attainers(equality, vectors, edges): + for vector in equality: + matrix = matrix_from_entries(vector) + need(sum(matrix[i][i] for i in range(DIM)) == 0, "ATTAINER_TRACE") + need(sum(x * x for row in matrix for x in row) == 8, "ATTAINER_NORM") + for i in range(DIM): + for j in range(DIM): + need(sum(matrix[i][k] * matrix[k][j] for k in range(DIM)) + == int(i == j), "ATTAINER_INVOLUTION") + direct = sum(bilinear(vectors[q], matrix, vectors[r]) ** 2 + for q, r in edges) + need(direct == 4800, "ATTAINER_ENERGY") + need(all(dot([w * x for w, x in zip(WEIGHTS, a, strict=True)], b) == 0 + for i, a in enumerate(equality) for b in equality[i + 1:]), + "EQUALITY_ORTHOGONAL_BASIS") + + +def rejected(call, expected): + try: + call() + except ValueError as error: + need(str(error) == expected, "WRONG_CONTROL_FAILURE") + return + raise ValueError("CONTROL_ACCEPTED:" + expected) + + +def controls(certificate, matrix, ports, vectors, edges, equality): + altered = deepcopy(certificate) + altered["blocks"][1]["eigenvalue_times_16"] += 1 + rejected(lambda: check_certificate(altered, matrix), "EIGENVALUE") + altered = deepcopy(certificate) + altered["blocks"][1]["basis"][0][0] += 1 + rejected(lambda: check_certificate(altered, matrix), "EIGENVECTOR_EQUATION") + altered = deepcopy(certificate) + altered["blocks"][1]["basis"].pop() + rejected(lambda: check_certificate(altered, matrix), "MULTIPLICITY") + altered = deepcopy(certificate) + altered["blocks"][1]["basis"][1] = altered["blocks"][1]["basis"][0] + rejected(lambda: check_certificate(altered, matrix), "BASIS_COMPLETE") + damaged = [row[:] for row in matrix] + damaged[0][0] += 1 + rejected(lambda: check_certificate(certificate, damaged), "EIGENVECTOR_EQUATION") + form = linear_form(vectors[edges[0][0]], vectors[edges[0][1]]) + omitted = [[matrix[i][j] - form[i] * form[j] + for j in range(SIZE)] for i in range(SIZE)] + rejected(lambda: check_certificate(certificate, omitted), "EIGENVECTOR_EQUATION") + doubled = [[2 * value for value in row] for row in matrix] + rejected(lambda: check_certificate(certificate, doubled), "EIGENVECTOR_EQUATION") + rejected(lambda: check_certificate(certificate, matrix, (1,) * SIZE), + "EIGENVECTOR_EQUATION") + repeated = list(ports) + repeated[1] = repeated[0] + rejected(lambda: checked_ports(repeated), "PORT_DUPLICATE") + wrong = list(ports) + wrong[0] = FIRST[0] + rejected(lambda: checked_ports(wrong), "SELECTED_PUNCTURE") + wrong_equality = deepcopy(equality) + wrong_equality[0][0] = 1 + rejected(lambda: check_attainers(wrong_equality, vectors, edges), "ATTAINER_TRACE") + rejected(lambda: authenticate(b"corrupt", sha256(b"source").hexdigest()), + "SOURCE_SHA256") + need(Fraction(300, 8) < Fraction(3751, 100), "STRONGER_CONSTANT_FAILS") + return 13 + + +def main(): + package = package_path() + ports = load_ports(package) + vectors = coordinates() + matrix, edges = energy_matrix(ports, vectors) + certificate = json.loads((package / "CERTIFICATE.json").read_bytes()) + equality = check_certificate(certificate, matrix) + check_attainers(equality, vectors, edges) + count = controls(certificate, matrix, ports, vectors, edges, equality) + files = ("README.md", "PROOF.md", "TASK.json", "SOURCES.json", "VERIFY.json", + "geometry.py", "generate.py", "verify.py", "CERTIFICATE.json") + result = {"status": "PASS_P104_SELECTED_METRIC_ORBIT", "ports": len(ports), + "unordered_orthogonal_pairs": len(edges), "sharp_constant": "75/2", + "equality_dimension_trace_free": len(equality), + "spectrum": {str(Fraction(mu, 16)): count for mu, count in SPECTRUM}, + "eigenvectors_checked": SIZE, "eigenvector_equations": SIZE * SIZE, + "independence_modulus": 1009, "witness_norm_squared": 8, + "witness_energy": 300, "negative_controls": count, + "source_input": SOURCE, + "file_sha256": {name: sha256((package / name).read_bytes()).hexdigest() + for name in files}} + print(json.dumps(result, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/p104-selected-metric-orbit/verify_orbits.py b/research/p104-selected-metric-orbit/verify_orbits.py new file mode 100644 index 0000000000..e8c0c0ac4b --- /dev/null +++ b/research/p104-selected-metric-orbit/verify_orbits.py @@ -0,0 +1,181 @@ +"""Replay exhaustive frame coverage and the three exact spectra. Apache-2.0. + +Jerry Chen (@CubeJerry), with OpenAI Codex assistance. +No generator, numerical eigensolver or predecessor executable is imported. +""" +from collections import Counter +from copy import deepcopy +from hashlib import sha256 +import json + +from geometry import (DIM, FIRST, SECOND, SIZE, WEIGHTS, coordinates, dot, + energy_matrix, load_ports, need, package_path, universe) +from orbits import (PERMUTATIONS, QUADRATIC, TYPES, enumerate_frames, orbit, + orbit_partition, reflection_actions, stabilizer_actions) +from verify import modular_rank, rejected +from moments import check_moments + +QUADRATIC_ACTION = ((796, 0, 0, -68), (0, 796, 68, 0), + (0, 68, 660, 0), (-68, 0, 0, 660)) + + +def check_cover(frames, vectors, actions): + need(len(frames) == 2025, "FRAME_COUNT") + for frame in frames: + need(len(frame) == len(set(frame)) == DIM and + all(dot(vectors[q], vectors[r]) == 0 for i, q in enumerate(frame) + for r in frame[i + 1:]), "FRAME_DOMAIN") + need(orbit(FIRST, reflection_actions(vectors)) == frames, "FRAME_TRANSITIVITY") + census = Counter(len(set(FIRST) & set(frame)) for frame in frames) + need(census == {0: 1260, 1: 512, 2: 224, 4: 28, 8: 1}, "INTERSECTION_CENSUS") + disjoint = {frame for frame in frames if not set(frame) & set(FIRST)} + classes = orbit_partition(disjoint, actions) + actual = [(len(group), min(group)) for group in classes] + need(actual == [(count, frame) for count, frame, _ in TYPES], "ORBIT_CLASSIFICATION") + need(sum(SECOND in group and len(group) == 896 for group in classes) == 1, + "SELECTED_ORBIT_MEMBERSHIP") + histograms = ({0: 16, 4: 12}, {0: 8, 2: 16, 4: 4}, {0: 4, 2: 24}) + for group, expected in zip(classes, histograms, strict=True): + for frame in group: + supports = [{i for i, x in enumerate(vectors[q]) if x} for q in frame] + actual = Counter(len(a & b) for i, a in enumerate(supports) + for b in supports[i + 1:]) + need(actual == expected, "SUPPORT_INTERSECTION_INVARIANT") + return classes + + +def checked_vector(vector): + need(isinstance(vector, list) and len(vector) == SIZE and + all(type(x) is int and abs(x) <= 1000 for x in vector), "ORBIT_VECTOR") + + +def check_quadratic(block, matrix): + need(block.get("polynomial") == list(QUADRATIC), "QUADRATIC_POLYNOMIAL") + basis = block.get("basis") + need(isinstance(basis, list) and len(basis) == 4, "QUADRATIC_DIMENSION") + for column, vector in enumerate(basis): + checked_vector(vector) + need(sum(vector[:DIM]) == 0, "QUADRATIC_TRACE_ZERO") + for i in range(SIZE): + need(dot(matrix[i], vector) == WEIGHTS[i] * sum( + basis[j][i] * QUADRATIC_ACTION[j][column] for j in range(4)), + "QUADRATIC_ACTION") + # The displayed 4x4 rational action has two identical quadratic factors. + for i in range(4): + for j in range(4): + need(sum(QUADRATIC_ACTION[i][k] * QUADRATIC_ACTION[k][j] + for k in range(4)) + QUADRATIC[1] * QUADRATIC_ACTION[i][j] + + QUADRATIC[2] * int(i == j) == 0, "QUADRATIC_IDENTITY") + return basis + + +def check_spectrum(record, matrix, specification): + count, frame, spectrum = specification + need(record.get("size") == count, "ORBIT_SIZE") + need(record.get("representative") == list(frame), "ORBIT_REPRESENTATIVE") + blocks = record.get("blocks") + need(isinstance(blocks, list) and len(blocks) == len(spectrum), "ORBIT_BLOCKS") + columns = [] + for block, (mu, multiplicity) in zip(blocks, spectrum, strict=True): + need(type(block.get("eigenvalue_times_16")) is int and + block["eigenvalue_times_16"] == mu, "ORBIT_EIGENVALUE") + basis = block.get("basis") + need(isinstance(basis, list) and len(basis) == multiplicity, + "ORBIT_MULTIPLICITY") + for vector in basis: + checked_vector(vector) + need(all(dot(row, vector) == mu * weight * x + for row, weight, x in zip(matrix, WEIGHTS, vector, strict=True)), + "ORBIT_EIGENVECTOR_EQUATION") + need(mu == 0 or sum(vector[:DIM]) == 0, "ORBIT_POSITIVE_TRACE_ZERO") + need(mu != 0 or vector == [1] * DIM + [0] * (SIZE - DIM), + "ORBIT_SCALAR_KERNEL") + columns.append(vector) + if count == 336: + columns.extend(check_quadratic(record.get("quadratic_block", {}), matrix)) + else: + need("quadratic_block" not in record, "UNEXPECTED_QUADRATIC") + need(len(columns) == SIZE and modular_rank(columns) == SIZE, "ORBIT_BASIS_COMPLETE") + + +def check_records(certificate, vectors): + need(certificate.get("schema") == "p104-disjoint-frame-orbits/1", "ORBIT_SCHEMA") + need(certificate.get("coordinate_frame") == list(FIRST), "ORBIT_COORDINATE_FRAME") + need(certificate.get("coordinate_permutations") == [list(p) for p in PERMUTATIONS] + and certificate.get("sign_flips") == list(range(DIM)), "ORBIT_GENERATORS") + records = certificate.get("orbits") + need(isinstance(records, list) and len(records) == 3, "ORBIT_RECORD_COUNT") + matrices = [] + for record, specification in zip(records, TYPES, strict=True): + _, frame, _ = specification + ports = sorted(set(universe()) - set(FIRST) - set(frame)) + matrix, _ = energy_matrix(ports, vectors) + check_spectrum(record, matrix, specification) + matrices.append(matrix) + return matrices + + +def controls(certificate, matrices, vectors, frames, actions): + shortened = set(frames) + shortened.remove(min(frames)) + rejected(lambda: check_cover(shortened, vectors, actions), "FRAME_COUNT") + rejected(lambda: check_cover(frames, vectors, []), "ORBIT_CLASSIFICATION") + wrong = (1, 0, 2, 3, 4, 5, 6, 7) + rejected(lambda: stabilizer_actions(vectors, (wrong,)), "ROOT_CLOSURE") + altered = deepcopy(certificate["orbits"][0]) + altered["size"] += 1 + rejected(lambda: check_spectrum(altered, matrices[0], TYPES[0]), "ORBIT_SIZE") + altered = deepcopy(certificate["orbits"][0]) + altered["representative"][0] = FIRST[0] + rejected(lambda: check_spectrum(altered, matrices[0], TYPES[0]), "ORBIT_REPRESENTATIVE") + altered = deepcopy(certificate["orbits"][0]) + altered["blocks"][1]["basis"][0][0] += 1 + rejected(lambda: check_spectrum(altered, matrices[0], TYPES[0]), + "ORBIT_EIGENVECTOR_EQUATION") + altered = deepcopy(certificate["orbits"][0]) + altered["blocks"][1]["basis"][1] = altered["blocks"][1]["basis"][0] + rejected(lambda: check_spectrum(altered, matrices[0], TYPES[0]), "ORBIT_BASIS_COMPLETE") + altered = deepcopy(certificate["orbits"][1]) + altered["quadratic_block"]["polynomial"][2] += 1 + rejected(lambda: check_spectrum(altered, matrices[1], TYPES[1]), "QUADRATIC_POLYNOMIAL") + altered = deepcopy(certificate["orbits"][1]) + altered["quadratic_block"]["basis"][0][8] += 1 + rejected(lambda: check_spectrum(altered, matrices[1], TYPES[1]), "QUADRATIC_ACTION") + altered = deepcopy(certificate["orbits"][1]) + altered["quadratic_block"]["basis"].pop() + rejected(lambda: check_spectrum(altered, matrices[1], TYPES[1]), "QUADRATIC_DIMENSION") + doubled = [[2 * x for x in row] for row in matrices[2]] + rejected(lambda: check_spectrum(certificate["orbits"][2], doubled, TYPES[2]), + "ORBIT_EIGENVECTOR_EQUATION") + need(QUADRATIC[1] ** 2 - 4 * QUADRATIC[2] == 36992, "QUADRATIC_DISCRIMINANT") + need(32 ** 2 > 17 ** 2 * 2, "IRRATIONAL_ROOT_ABOVE_SELECTED_MINIMUM") + return 11 + + +def main(): + package = package_path() + load_ports(package) + vectors = coordinates() + frames = enumerate_frames(vectors) + actions = stabilizer_actions(vectors) + classes = check_cover(frames, vectors, actions) + certificate = json.loads((package / "ORBITS.json").read_bytes()) + matrices = check_records(certificate, vectors) + count = controls(certificate, matrices, vectors, frames, actions) + moments = check_moments(vectors) + files = ("orbits.py", "generate_orbits.py", "verify_orbits.py", "ORBITS.json", + "ORBIT-PROOF.md", "HERMITIAN-PROOF.md", "moments.py") + print(json.dumps({"status": "PASS_P104_ALL_DISJOINT_FRAME_ORBITS", + "frames": len(frames), "disjoint_from_fixed_frame": sum(map(len, classes)), + "fixed_frame_orbit_sizes": [len(group) for group in classes], + "selected_orbit_size": 896, "sharp_constants": ["37", "37", "75/2"], + "rational_eigenvectors_checked": 104, "quadratic_block_dimension": 4, + "quadratic_eigenvalues": "(182 +/- 17*sqrt(2))/4, each multiplicity 2", + "negative_controls": count + moments["negative_controls"], + "hermitian_extension": moments, + "file_sha256": {name: sha256((package / name).read_bytes()).hexdigest() + for name in files}}, indent=2, sort_keys=True)) + + +if __name__ == "__main__": + main()