From 48d027a664288ea1d4e987de63cb79588b8b936b Mon Sep 17 00:00:00 2001 From: Chinmay Arvind <144177741+chinmayarvind23@users.noreply.github.com> Date: Tue, 13 Oct 2026 00:22:07 -0500 Subject: [PATCH] research: certify Gaussian maximal-clique ceiling and independent replay --- research/gaussian-e8-copy-bound/CLAIM.md | 73 +++ .../gaussian-e8-copy-bound/INDEPENDENT.json | 52 ++ research/gaussian-e8-copy-bound/NOTICE.md | 72 +++ research/gaussian-e8-copy-bound/PROOF.md | 304 +++++++++++ research/gaussian-e8-copy-bound/README.md | 79 +++ research/gaussian-e8-copy-bound/RESULTS.json | 138 +++++ research/gaussian-e8-copy-bound/SOURCES.json | 35 ++ research/gaussian-e8-copy-bound/VALIDATION.md | 199 +++++++ .../independent_check.py | 487 ++++++++++++++++++ .../vendor/pr703/NOTICE.md | 49 ++ .../vendor/pr703/PROOF.md | 183 +++++++ research/gaussian-e8-copy-bound/verify.py | 347 +++++++++++++ 12 files changed, 2018 insertions(+) create mode 100644 research/gaussian-e8-copy-bound/CLAIM.md create mode 100644 research/gaussian-e8-copy-bound/INDEPENDENT.json create mode 100644 research/gaussian-e8-copy-bound/NOTICE.md create mode 100644 research/gaussian-e8-copy-bound/PROOF.md create mode 100644 research/gaussian-e8-copy-bound/README.md create mode 100644 research/gaussian-e8-copy-bound/RESULTS.json create mode 100644 research/gaussian-e8-copy-bound/SOURCES.json create mode 100644 research/gaussian-e8-copy-bound/VALIDATION.md create mode 100644 research/gaussian-e8-copy-bound/independent_check.py create mode 100644 research/gaussian-e8-copy-bound/vendor/pr703/NOTICE.md create mode 100644 research/gaussian-e8-copy-bound/vendor/pr703/PROOF.md create mode 100644 research/gaussian-e8-copy-bound/verify.py diff --git a/research/gaussian-e8-copy-bound/CLAIM.md b/research/gaussian-e8-copy-bound/CLAIM.md new file mode 100644 index 0000000000..fa213ac06d --- /dev/null +++ b/research/gaussian-e8-copy-bound/CLAIM.md @@ -0,0 +1,73 @@ +# Sprint claim + +- Track: bit supplier; OS-random assignment seed **6** (one-byte rejection sampling). +- Base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +- Started: 2026-10-13 04:46:52 UTC; planned handoff by 06:16 UTC. +- Object: #620's 60 Gaussian E8 lines, scalar binary fitting decoders with + arbitrary reader/source supports and any number of totals. +- Hypothesis: averaging maximum nonorthogonality-clique rank inequalities + yields a stronger exact pairing-rank COPY lower bound. Close supports to + their rational Gaussian spans and exhaust all flat pairs; check independently. +- Deliverable: scoped proof or counterexample, offline exact verifier, + deterministic certificate, meaningful negative controls and source pins. + No new kappa or physical supplier is promised. + +Three candidates considered: (1) the fixed P111 nine-total decoder basis, +(2) Gaussian/Eisenstein extension-unit pairing-rank bounds, and (3) the +fixed-plan P111 mini-node helper floor. #620 already computes candidate (1). +Candidate (2) directly addresses an open report question, using #703's rank +averaging approach on a different geometry. Seed parity chooses Gaussian +(6 is even); its maximum nonorthogonal clique has 12 ports, compared with +7 for Eisenstein, making its optimistic bound more promising. + +Before computation, two orthogonal-root hyperplanes show that averaging +maximum 12-cliques can prove at most 40 Gaussian COPY units. Thus even a +successful certificate will not prove the reported approximately 42.6-unit +threshold needed to exclude this unit as a possible improvement. A stronger +partial lower bound and a precise limitation of the method remain useful. + +No pinned sprint coordination issue was available: the open issue search +returned only #650 (requesting Discussions). This claim is therefore local. +Initial overlap review includes current selected #626/#543, #620, #631, #703, #715, +and recent bit circuit/frame work through #720. #703 treats ten quaternionic +lines, while #631/#715 treat real E8 star decoders/punctures. No matching +Gaussian asymmetric COPY-cost contribution was located at that initial check. Claims in unreviewed +PRs are treated as source context, not accepted mathematical conclusions. + +Prepared for @chinmayarvind23 with substantial OpenAI Codex assistance. + +## Completed result and final overlap update + +The completed [proof and review package](README.md) establishes a ceiling of +40 for all nonnegative weighted inclusion-maximal-clique certificates on +the 60 Gaussian E8 lines, attained by the uniform maximum-clique certificate. +Two separate exact implementations reproduce the corresponding copy floor +on all 2,582,128 unordered flat pairs. The actual decoder optimum remains +in [40,60], with no new supplier or kappa claim. + +The final overlap refresh found Sagar Thakrar / @thakrarsagar's +[#738](https://github.com/CrocSwap/integer-mult-bounds/pull/738), inspected at +`9671c5d72f3119ba26f3774f40aa7130c67bcf77`. It already reports the same floor, +closure reduction and uniform-weight sharpness. The scope was therefore +reframed as independent verification plus the stronger ceiling for arbitrary +nonnegative weights on inclusion-maximal cliques. Its inspected proof gives +48 for general clique weights; our theorem gives 40 in this specified class. +Non-maximal cliques are outside the extension. Including empty supports +explains the pair-count difference from #738 and is not a new mathematical +domain. No #738 code was imported. + +The refresh inspected Gaussian search results and new PR metadata through +#763, including the distinct P111 factorization work in #757/#761. A last +Gaussian search before submission also inspected #767: its planar and +incidence decoder subclass obstructions differ from this maximal-clique +certificate ceiling, and no code or theorem from it is used here. Main and +the inspected #703/#738 heads remained unchanged. The only open issue was +still #650; no separate reservation issue or claim comment was posted. + +The 21-case reproducibility and rejection run completed on 2026-10-13 at +05:14:34 UTC; [VALIDATION.md](VALIDATION.md) also records the subsequent +replay of exact staged bytes after manifest line-ending normalization. The experiment +stopped after exhaustive flat-pair and maximal-clique coverage. The remaining +sprint time was used for verification, overlap review and handoff, rather +than further speculative search. The original seed and selected object +were retained. diff --git a/research/gaussian-e8-copy-bound/INDEPENDENT.json b/research/gaussian-e8-copy-bound/INDEPENDENT.json new file mode 100644 index 0000000000..a16022bec2 --- /dev/null +++ b/research/gaussian-e8-copy-bound/INDEPENDENT.json @@ -0,0 +1,52 @@ +{ + "arithmetic": "Gaussian integers; fraction-free rank and exact minors", + "copy_lower_bound": 40, + "flat_count": 2272, + "flat_counts": { + "0:0": 1, + "1:1": 60, + "2:2": 360, + "2:3": 320, + "2:6": 30, + "3:15": 60, + "3:4": 960, + "3:6": 480, + "4:60": 1 + }, + "geometry_self_checks": "mandatory; distinct lines and principal two-line Gram ranks", + "inclusion_maximal_clique_count": 8704, + "inclusion_maximal_clique_weighting_ceiling": 40, + "line_count": 60, + "maximal_clique_counts": { + "10": 2304, + "11": 1920, + "12": 640, + "7": 1920, + "8": 1920 + }, + "maximum_clique_count": 640, + "maximum_clique_size": 12, + "maximum_clique_weight": "1/192", + "maximum_clique_weighting_ceiling": 40, + "negative_control_count": 10, + "negative_controls": [ + "overstrong_denominator_191", + "false_rank_one_for_sharp_gram_block", + "orthogonal_pair_called_clique", + "changed_gram_normalization", + "nonhermitian_gram", + "dependent_flat_basis", + "omitted_flat_member", + "corrupt_bound_receipt", + "corrupt_clique_count_receipt", + "modified_pinned_source_bytes" + ], + "per_clique_sharp_pair_incidence": 270, + "root_count": 240, + "sharp_hyperplane_pairs": 450, + "sharp_pair_clique_incidence": 384, + "source_manifest_sha256": "cc694727a7f6b8705549918f2bb991be5968f37cbf73ae15df0642e30a7b7191", + "source_pin_count": 7, + "status": "PASS_INDEPENDENT_GAUSSIAN_COPY_BOUND", + "unordered_flat_pairs_with_repetition": 2582128 +} diff --git a/research/gaussian-e8-copy-bound/NOTICE.md b/research/gaussian-e8-copy-bound/NOTICE.md new file mode 100644 index 0000000000..1cbb79cde4 --- /dev/null +++ b/research/gaussian-e8-copy-bound/NOTICE.md @@ -0,0 +1,72 @@ +# Attribution, source status and license + +Prepared for **@chinmayarvind23** with substantial **OpenAI Codex** assistance +in research selection, proof development, implementation, automated checking, +code review and documentation. Separate AI agents developed the primary and +independent replays. This does not constitute independent human review, and +no human-only authorship or human review is claimed. + +**Concurrent result.** During the final overlap refresh, after this package's +proof and code had been developed, we located **Sagar Thakrar / @thakrarsagar's +[PR #738](https://github.com/CrocSwap/integer-mult-bounds/pull/738)** at +`9671c5d72f3119ba26f3774f40aa7130c67bcf77`. That contribution already states +the same Gaussian copy floor of 40, the closure reduction, the uniform +640-clique certificate, its uniform-weight sharpness and the interval +[40,60]. It was prepared with substantial OpenAI Codex assistance. Those +overlapping conclusions are credited here; this package does not claim a +new discovery of the floor or treat its inclusion of empty-support pairs +as a mathematical advance. No #738 executable code was imported or used +to produce our replays. + +The resulting scope is **independent verification plus an extension**. +The inspected #738 proof gives a ceiling of 48 for general nonnegative +clique weights. Section 5 of our [proof](PROOF.md) strengthens that ceiling +to 40 for all nonnegative weighted inclusion-maximal-clique certificates, +including mixtures of different maximal-clique sizes. It does not address +certificates using non-maximal cliques. The pinned +[#738 proof](https://github.com/CrocSwap/integer-mult-bounds/blob/9671c5d72f3119ba26f3774f40aa7130c67bcf77/research/gaussian-clique-copy-bound/PROOF.md) +documents the comparison rather than relying on its PR summary alone. + +The Gaussian E8 line configuration, extension-ring reduction, decoder +question, symmetric cost-60 result and open copy-floor problem come from +**Joel Pulikkan / GamingPuzzled's +[PR #620](https://github.com/CrocSwap/integer-mult-bounds/pull/620)**, prepared +with Claude Opus 5.5 assistance. Its retained extension-ring files are pinned +in [SOURCES.json](SOURCES.json). This contribution does not claim that +geometry, problem formulation or upper bound as new. + +The weighted-clique rank-averaging approach follows **Douglas R. Colkitt / +Mister-Meeseeks' [PR #703](https://github.com/CrocSwap/integer-mult-bounds/pull/703)** +for the ten Hurwitz E8 lines. The inspected head is +`358383e2f1b0f292d4d6eb897c06fd8558a4f5e6`. Its +[original proof](https://github.com/CrocSwap/integer-mult-bounds/blob/358383e2f1b0f292d4d6eb897c06fd8558a4f5e6/research/hurwitz-asymmetric-copy-floor/PROOF.md) +and [original notice](https://github.com/CrocSwap/integer-mult-bounds/blob/358383e2f1b0f292d4d6eb897c06fd8558a4f5e6/research/hurwitz-asymmetric-copy-floor/NOTICE.md) +are retained byte-for-byte under [vendor/pr703](vendor/pr703), including +their attribution and license statements. Relative links within those +unchanged copies refer to the original package context. + +The source/reader pairing-rank model and associated accounting derive from +**DreamingOfClouds' [#446](https://github.com/CrocSwap/integer-mult-bounds/pull/446) +and [#595](https://github.com/CrocSwap/integer-mult-bounds/pull/595)** work as +used by #620. Their use here is explicit and conditional. Standard E8 root +coordinates, Gram-rank identities and clique rank subadditivity are not +claimed as new. + +The scoped contribution is the independent exact replays and the proof that +nonnegative weighting of inclusion-maximal-clique rank inequalities cannot +exceed 40 in this geometry. The lower bound and closure reduction overlap +with #738. We neither assert global novelty nor claim to settle the remaining +charge interval [40,60]. No predecessor implementation is imported by either +verifier. Pinned source files are read as data for provenance checks. + +The repository base is +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. +[CLAIM.md](CLAIM.md) records the bounded overlap review; unreviewed PR claims +are source context, not adopted mathematical conclusions. The existing +selected construction and its predecessor lineage retain their credit and +assumptions. This package adds no supplier and changes no selected kappa. + +New files are provided under the repository's +[Apache License 2.0](../../LICENSE). The original authorship and license +notices of the retained #703 documents remain in their unchanged copies; +this notice supplements them. diff --git a/research/gaussian-e8-copy-bound/PROOF.md b/research/gaussian-e8-copy-bound/PROOF.md new file mode 100644 index 0000000000..ecd7b342e1 --- /dev/null +++ b/research/gaussian-e8-copy-bound/PROOF.md @@ -0,0 +1,304 @@ +# A copy lower bound for Gaussian E8 scalar decoders + +**Result.** Every fitting binary scalar-total decoder on the +60 Gaussian E8 lines has copy charge at least **40 Gaussian rank units = 80 +rational rank units**, even with asymmetric reader/source sets and arbitrarily +many totals. Every fitting matrix has a row decomposition of charge 60, so the +result leaves the optimal charge in **[40, 60]**. It does not construct a new +supplier or improve the selected multiplication constant. + +**Concurrent overlap and the additional result.** The bound 40, the uniform +weight 1/192 on the 640 maximum cliques, closure to flats, the interval +[40,60], and the conditional three-stage consequence are already present in +Sagar Thakrar / thakrarsagar's concurrent +[PR #738](https://github.com/CrocSwap/integer-mult-bounds/pull/738), discovered +during the final overlap refresh. The inspected head is +`9671c5d72f3119ba26f3774f40aa7130c67bcf77` +([proof](https://github.com/CrocSwap/integer-mult-bounds/blob/9671c5d72f3119ba26f3774f40aa7130c67bcf77/research/gaussian-clique-copy-bound/PROOF.md)). +This package supplies an independent replay of that bound, not a priority +claim for it. Its additional theorem is Section 5: **40 is the optimal +certificate value even with arbitrary nonnegative weights on all +inclusion-maximal cliques**. The inspected #738 proof establishes 40 as the +uniform-weight optimum and gives the weaker ceiling 48 for arbitrary +nonnegative clique weights, including non-maximal cliques. Our ceiling 40 +does not cover that latter, larger class. + +The weighted-clique proof method is adapted from Douglas R. Colkitt / +Mister-Meeseeks' [PR #703](https://github.com/CrocSwap/integer-mult-bounds/pull/703) +on the ten Hurwitz E8 lines. The Gaussian geometry, scalar decoder question, +rank accounting and previously found cost-60 symmetric decoder come from +Joel Pulikkan / GamingPuzzled's +[PR #620](https://github.com/CrocSwap/integer-mult-bounds/pull/620), retained in +[the extension-ring report](../e8-decoder-floors-and-cold14-notes/s1-extension-rings/REPORT.md). +The finite calculations here concern the Gaussian configuration and its full +reader/source pairing ranks. Neither the predecessor's geometry nor the +cost-60 upper bound is claimed as new. + +The inspected #703 proof is pinned at commit +`358383e2f1b0f292d4d6eb897c06fd8558a4f5e6` +([source](https://github.com/CrocSwap/integer-mult-bounds/blob/358383e2f1b0f292d4d6eb897c06fd8558a4f5e6/research/hurwitz-asymmetric-copy-floor/PROOF.md)). +The pairing-rank accounting traces to DreamingOfClouds' #446/#595 work as +used by #620; the bound here is explicitly conditional on using that model. + +## 1. Geometry and decoder model + +Work with the 240 E8 roots in doubled standard coordinates in Q^8: + +- vectors with exactly two nonzero coordinates, both in {−2, 2}; +- vectors in {−1, 1}^8 with an even number of minus signs. + +Let J act on each consecutive coordinate pair by (x, y) -> (−y, x). +Then J^2 = −I, J preserves the roots, and J is orthogonal. It gives Q^8 the +structure of a four-dimensional vector space over K = Q(i). A root r spans +the Gaussian line L_r = span_Q{r, Jr}. The roots partition into 60 distinct +such lines, with four roots on each line. The exact replay checks line +distinctness and the root partition. + +Two different lines are called nonorthogonal when either r dot s or +r dot Js is nonzero. Write G for this nonorthogonality graph. Its complement +on distinct vertices is the orthogonality graph; every vertex of that graph +has degree 15. All ranks and orthogonality tests below use exact arithmetic. + +A fitting matrix B over F2 has + + B_tt = 1, + B_ts = 0 whenever t != s and L_t is nonorthogonal to L_s. + +Its entries on orthogonal pairs are free and need not be symmetric. An +arbitrary scalar-total decomposition is + + B = sum_j 1_{R_j} 1_{A_j}^T over F2, + +with reader sets R_j and source sets A_j. Any finite number of totals is +allowed; sets may be empty and terms may repeat. + +For a set S of lines, let V_S have the rows r and Jr for every representative +r in S. Define the charge of one total by + + q(R,A) = rank_Q(V_R V_A^T) / 2. + +Equivalently, this is the rank over K of the restricted Hermitian pairing +between the K-spans of R and A. In particular it is an integer in {0,1,2,3,4}. +The total charge is Q = sum_j q(R_j,A_j). This is the Gaussian form of the +source/reader pairing-rank charge used by the predecessor's Theorem-C +relaxation. It is not the binary rank of the decoder rectangle, and a total +need not have full Gaussian rank four. The factor two is restored whenever +the charge is expressed in rational rank units. + +## 2. Reducing all supports to finitely many flats + +For a support S, define its closure by + + cl(S) = {t : L_t is contained in span_K(S)}. + +A flat is such a closed set, including the empty set and all 60 lines. +Replacing R and A by their closures preserves q(R,A): every appended row of +V_cl(R) or V_cl(A) is a rational linear combination of existing rows. Thus +the Gram-block rank can neither increase nor decrease. + +For a clique C of G, put + + a_C(R,A) = 1 if C meets both R and A, and 0 otherwise. + +Closing supports can only increase this indicator. Consequently a local +inequality proved for every ordered pair of flats proves the same inequality +for every pair of arbitrary reader/source supports. This reduction concerns +the charge and the local indicator; it does not replace a decoder by a +different decoder or assume its fitting conditions survive closure. + +There are exactly 2,272 flats. Their census, together with the number of +maximum cliques meeting each flat, is: + +| Gaussian rank | Lines in flat | Number of flats | Maximum cliques meeting each flat | +| ---: | ---: | ---: | ---: | +| 0 | 0 | 1 | 0 | +| 1 | 1 | 60 | 128 | +| 2 | 2 | 360 | 256 | +| 2 | 3 | 320 | 308 | +| 2 | 6 | 30 | 320 | +| 3 | 4 | 960 | 436 | +| 3 | 6 | 480 | 492 | +| 3 | 15 | 60 | 512 | +| 4 | 60 | 1 | 640 | + +The closure enumeration is exhaustive: start with the empty flat and the +one-line flats, and extend every rank-r span by every line outside its +closure. Every rank-(r+1) root-spanned subspace has such a basis extension. +Exact row reduction and closure deduplication produce the next level. Rank +four has the unique full flat. This induction proves coverage, rather than +assuming that the displayed census is a complete search domain. + +## 3. The finite pairing-rank certificate + +Let C be the family of all maximum cliques of G. Exhaustive graph search +gives exactly 640 of them, each of size 12, and proves there is no larger +clique. The key finite certificate is + + sum_{C in C} a_C(F,H) <= 192 q(F,H) (1) + +for every pair of flats F,H. + +The primary replay checks (1) for all 2,582,128 unordered pairs with +repetition; both sides are symmetric in F,H, so this covers all ordered +pairs. It computes the exact pairing rank and the number of maximum cliques +meeting both flats. The result is: + +| Pairing rank q | Unordered flat pairs | Largest joint hit count | Allowed count 192q | +| ---: | ---: | ---: | ---: | +| 0 | 4,997 | 0 | 0 | +| 1 | 184,920 | 192 | 192 | +| 2 | 1,316,050 | 384 | 384 | +| 3 | 1,076,160 | 512 | 576 | +| 4 | 1 | 640 | 768 | + +Its exact rank calculation reduces to small cases. Empty or full spans and +a one-dimensional side have immediate ranks. Two rank-two sides use their +two-by-two Gaussian Gram determinant and, when that vanishes, their entries. +For ranks two and three, write the hyperplane as n-perp. The pairing rank is +one if n lies in the rank-two span and two otherwise. For two rank-three +hyperplanes, with normals n and m, the rank is two if n and m are orthogonal +and three otherwise. These formulas all follow from + + q(F,H) = dim_K(F) - dim_K(F intersect H-perp). + +The real-coordinate replay constructs each normal by exact rational nullspace +calculation. Because its spaces are J-invariant, one nonzero real normal +and its J-translate span the whole Gaussian normal line. + +A separate replay uses four Gaussian-integer coordinates, independent flat +generation and exact nonzero minors. For each pair it certifies that q is +at least the ceiling of the joint hit count divided by 192. It may also use +the rigorous bound q(F,H) >= dim_K(F) + dim_K(H) - 4, since the pairing kernel +F intersect H-perp has dimension at most 4 - dim_K(H). This certifies (1) +independently without claiming to recompute the primary rank histogram. +Both exhaustive pair checks pass. They concern the actual source/reader +Gram block, not just the rank of F intersect H, the cardinality of either +support, or an assumed full-rank total. + +When q=0 all lines across the two supports are orthogonal, so no clique can +meet both. Such totals are allowed and contribute zero to both sides. The +flat census and its individual hit counts help reproduce the check, but +they are not substitutes for the pairwise inequality (1). + +By Section 2, (1) holds for arbitrary supports R,A as well. + +## 4. The lower bound, including arbitrary asymmetric decompositions + +Every maximum clique C contains only pairwise nonorthogonal lines, so the +fitting conditions imply B[C,C] = I_12. Over F2, the restriction of a +rectangle 1_R 1_A^T to C by C has rank a_C(R,A). Rank subadditivity gives + + 12 <= sum_j a_C(R_j,A_j). + +Sum this inequality over the 640 maximum cliques and apply (1) to each +total: + + 640 * 12 + <= sum_j sum_{C in C} a_C(R_j,A_j) + <= 192 sum_j q(R_j,A_j). + +Therefore + + Q >= (640 * 12) / 192 = 40. + +This argument handles every finite number of scalar totals. It requires no +symmetry of B, no minimum-rank assumption on B, no limit on its number of +totals, and no uniform rank assumption on the totals. The extension from the +finite local certificate to all decompositions is the displayed rank +argument, rather than an enumeration of decoders. + +For the upper bound, decompose any fitting B into its 60 rows: for row t, +take R_t={t} and A_t equal to the nonzero positions in that row. The diagonal +condition puts t in A_t. Hence the Gram block has Gaussian rank exactly one, +and these 60 totals have total charge 60. In particular this upper bound +holds separately for every fitting matrix. It is an abstract charge bound, +not a claim of a physical supplier realizing it without additional costs. + +## 5. Forty is the limit of this maximal-clique method + +This section is a separate exact limitation of the proof method. It does not +prove that any actual decoder has charge 40. + +For a line t, let H_t be the set of the 15 configuration lines orthogonal to +t. The geometry check verifies that these lines span the whole Gaussian +hyperplane t-perp. If t and u are orthogonal distinct lines, then + + q(H_t,H_u) = 2. + +Indeed H_t and H_u both have dimension three, and the kernel of the pairing +on H_t against H_u is H_t intersect span_K(u) = span_K(u), of dimension one. + +An inclusion-maximal clique C of G meets H_t exactly when t is not in C. +If t is in C, orthogonality excludes every element of H_t. If t is not in C +and C missed H_t, then t would be nonorthogonal to every element of C and +could be added, contrary to maximality. + +Allow arbitrary nonnegative weights w_C on inclusion-maximal cliques. A +proof using only their principal-identity rank inequalities and a local +domination by q would require, for every pair of supports R,A, + + sum_C w_C a_C(R,A) <= q(R,A). (2) + +Its resulting copy lower bound is sum_C |C| w_C. Apply (2) to the 900 ordered +orthogonal pairs through the rectangles (H_t,H_u), and sum. A clique of size +k contains no orthogonal pair. Among the 900 ordered orthogonal pairs, +exactly 15k have their first endpoint in C and exactly 15k have their second +endpoint in C, with no overlap. It therefore contributes + + 900 - 30k + +to the sum of the indicators. Since k <= 12, + + 900 - 30k >= 45k. + +The summed right side of (2) is 900 * 2. Consequently + + 45 sum_C |C| w_C + <= sum_C (900 - 30|C|) w_C + <= 1800, + +and this proof method cannot yield a lower bound exceeding 40. In the +certified uniform construction, the 640 size-12 cliques each have weight +1/192, attaining exactly 40. + +This establishes optimality among such nonnegative weighted +**inclusion-maximal-clique** rank certificates. It does not address +certificates using non-maximal cliques, other submatrices or inequalities, +or additional algebraic information about the decoder. + +## 6. Consequences and limits + +The extension-ring report recorded a computational lower bound of 9 for its +bounded-total searches and a symmetric cost-60 solution. The result here +supplies a lower bound of 40 in the stated all-total asymmetric pairing-rank +model, with normalized charge + + x_K = Q/60 >= 2/3. + +The report's approximate charge threshold for beating its bit-E8 comparison +is about 0.71. Since 2/3 is below that value, this bound does **not** exclude +an improved Gaussian construction. The interval [40,60], including the +region near its reported threshold, remains unresolved. + +Conditionally applying exactly the report's Dfc accounting, Gaussian rank +scaling k=2 and port count v=60, the rational copy charge is at least 80: + + D/T = (s-1) * 120 - s * cst + <= (s-1) * 120 - s * 80 + = 40s - 120. + +Thus this optimistic accounting has no positive deficit for integer stage +counts s <= 3. It gives no exclusion for s >= 4. Helpers, source access, +restoration and recursive work are not supplied or certified here, and the +conditional accounting is not needed for the finite copy-floor theorem. + +The scope is the fixed 60-line Gaussian E8 geometry, binary scalar totals, +the stated fitting pattern, and the source/reader pairing-rank charge. +Other geometries, altered patterns, vector-valued totals, rational sub-line +supports and different supplier formats are outside scope. This is a +finite mathematical argument supported by exact computation, not a +proof-assistant formalization or a proof of the full multiplication theorem. + +Prepared for chinmayarvind23 with substantial OpenAI Codex assistance in +proof development, implementation and checking. No independent human review +is claimed. diff --git a/research/gaussian-e8-copy-bound/README.md b/research/gaussian-e8-copy-bound/README.md new file mode 100644 index 0000000000..e737cda773 --- /dev/null +++ b/research/gaussian-e8-copy-bound/README.md @@ -0,0 +1,79 @@ +# Gaussian E8: independent replay and a stronger certificate ceiling + +**Extension:** nonnegative weighting of any inclusion-maximal +nonorthogonality cliques in the 60-line Gaussian E8 geometry cannot prove a +copy floor above **40 Gaussian units**. This includes nonuniform weights and +mixtures of maximal cliques of different sizes. Uniform weighting of the +640 maximum cliques attains 40, so the method optimum is exactly 40. + +The matching copy lower bound was independently reported in **Sagar Thakrar / +@thakrarsagar's [PR #738](https://github.com/CrocSwap/integer-mult-bounds/pull/738)**, +discovered during the final overlap refresh after this package's proof and +code were developed. We claim an independent replay and the broader method +ceiling, not a new discovery of its floor. At the inspected #738 head, its +sharpness proof covers uniform maximum-clique weights; its bound for general +nonuniform clique weights is 48. Our extension reduces that ceiling to 40 +for inclusion-maximal cliques. Non-maximal-clique certificates remain outside +this extension. + +Two complete replays confirm **40 Gaussian units = 80 rational units** for +every fitting binary scalar-total decoder, with asymmetric reader/source +sets and arbitrarily many totals. Every fitting matrix has a charge-60 row +decomposition, leaving its optimum in **[40,60]**. The replays cover 2,582,128 +unordered pairs of the 2,272 root-span flats. The difference from #738's +nonempty-pair count is only inclusion of empty-support pairs, not a stronger +mathematical domain. Method optimality does not construct a charge-40 decoder. + +**No new kappa or physical supplier is claimed.** The normalized floor 2/3 +does not reach the predecessor's approximate 0.71 comparison threshold. +The mathematical model, unresolved interval and conditional accounting are +specified in [PROOF.md](PROOF.md). + +## Reproduce + +From the repository root, use Python 3.11 or later with only its standard +library. This command runs both complete replays in separate processes and +stops if either fails: + +```sh +python -I -B -c "import subprocess, sys; base='research/gaussian-e8-copy-bound/'; [subprocess.run([sys.executable, '-I', '-B', base + name], check=True) for name in ('verify.py', 'independent_check.py')]" +``` + +Expected output: + +```text +PASS_GAUSSIAN_E8_COPY_BOUND lower=40 upper=60 flats=2272 pairs=2582128 controls=8 +PASS_INDEPENDENT_GAUSSIAN_COPY_BOUND lower=40 pairs=2582128 maximal_cliques=8704 controls=10 +``` + +Both replays check pinned source bytes and compare their freshly computed +receipts with the committed receipts. The first computes exact pairing ranks +in eight rational coordinates. The second uses four Gaussian-integer +coordinates, independent flat enumeration and exact rank certificates. Both +run their rejection controls by default. They need no network, solver, +third-party dependency or predecessor-code import. Their checks remain +active with Python's optional `-O` flag. + +## Review map + +- [PROOF.md](PROOF.md): model, closure reduction, lower bound, upper bound and + proof-method ceiling. +- [RESULTS.json](RESULTS.json) and [INDEPENDENT.json](INDEPENDENT.json): + deterministic receipts from [verify.py](verify.py) and + [independent_check.py](independent_check.py). +- [SOURCES.json](SOURCES.json): SHA-256 source pins; exact repository base + `66849e1475c930fd7732b1a0067ffee7e1e95f60` and inspected #703 head + `358383e2f1b0f292d4d6eb897c06fd8558a4f5e6`. +- Concurrent [#738 proof](https://github.com/CrocSwap/integer-mult-bounds/blob/9671c5d72f3119ba26f3774f40aa7130c67bcf77/research/gaussian-clique-copy-bound/PROOF.md): + overlap comparison at `9671c5d72f3119ba26f3774f40aa7130c67bcf77`. +- [CLAIM.md](CLAIM.md): seed-6 sprint scope and overlap check. +- [VALIDATION.md](VALIDATION.md): actual replay environment, rejection checks + and verification limits. +- [NOTICE.md](NOTICE.md): predecessor attribution, AI assistance and license. + +The result concerns this fixed geometry, binary scalar totals, its fitting +pattern and the stated pairing-rank charge. Vector-valued totals, rational +sub-line supports, different geometries or supplier formats are outside +scope. The written argument extends the finite certificate to arbitrarily +many totals. It is not a proof-assistant formalization, a full multiplication +proof or an independent human review. diff --git a/research/gaussian-e8-copy-bound/RESULTS.json b/research/gaussian-e8-copy-bound/RESULTS.json new file mode 100644 index 0000000000..b04e79d71e --- /dev/null +++ b/research/gaussian-e8-copy-bound/RESULTS.json @@ -0,0 +1,138 @@ +{ + "ambient_gaussian_rank": 4, + "ceiling": { + "hits_per_pair": 384, + "hyperplane_pair_rank": 2, + "method_ceiling": 40, + "orthogonal_pairs": 450, + "witness_pairs_hit_per_maximum_clique": 270 + }, + "controls": { + "negative": [ + "orthogonal_pair_called_clique", + "one_root_missing_from_closed_flat", + "unsupported_copy_bound_191", + "hyperplane_pair_rank_undercharged", + "source_rank_used_instead_of_pairing_rank", + "missing_decoder_diagonal", + "forbidden_decoder_entry", + "one_clique_omitted_from_claimed_coverage" + ], + "positive": [ + "asymmetric_orthogonal_entry", + "zero_charge_rectangle", + "identity_decoder" + ] + }, + "flat_census": [ + { + "count": 1, + "hits": 0, + "rank": 0, + "size": 0 + }, + { + "count": 60, + "hits": 128, + "rank": 1, + "size": 1 + }, + { + "count": 360, + "hits": 256, + "rank": 2, + "size": 2 + }, + { + "count": 320, + "hits": 308, + "rank": 2, + "size": 3 + }, + { + "count": 30, + "hits": 320, + "rank": 2, + "size": 6 + }, + { + "count": 960, + "hits": 436, + "rank": 3, + "size": 4 + }, + { + "count": 480, + "hits": 492, + "rank": 3, + "size": 6 + }, + { + "count": 60, + "hits": 512, + "rank": 3, + "size": 15 + }, + { + "count": 1, + "hits": 640, + "rank": 4, + "size": 60 + } + ], + "flat_count": 2272, + "gaussian_copy_lower_bound": 40, + "gaussian_lines": 60, + "gaussian_row_upper_bound": 60, + "maximum_clique_count": 640, + "maximum_clique_size": 12, + "pairs": { + "maximum_hits": { + "0": 0, + "1": 192, + "2": 384, + "3": 512, + "4": 640 + }, + "pair_count": 2582128, + "pair_digest": "dee0345bcd98f8ec25ae8499b54f686af268c901cd0cedb7c6648c6b1161892d", + "pair_rank_counts": { + "0": 4997, + "1": 184920, + "2": 1316050, + "3": 1076160, + "4": 1 + }, + "tight_counts": { + "0": 4997, + "1": 180, + "2": 450 + }, + "witnesses": { + "0": [ + 0, + 0 + ], + "1": [ + 35184372094983, + 1134907106097367033 + ], + "2": [ + 18313810480211481, + 20275167025448473 + ], + "3": [ + 18313810480211481, + 18313810480211481 + ], + "4": [ + 1152921504606846975, + 1152921504606846975 + ] + } + }, + "rational_copy_lower_bound": 80, + "roots": 240, + "schema": 1, + "source_manifest_sha256": "cc694727a7f6b8705549918f2bb991be5968f37cbf73ae15df0642e30a7b7191" +} diff --git a/research/gaussian-e8-copy-bound/SOURCES.json b/research/gaussian-e8-copy-bound/SOURCES.json new file mode 100644 index 0000000000..48c3ff88c6 --- /dev/null +++ b/research/gaussian-e8-copy-bound/SOURCES.json @@ -0,0 +1,35 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "predecessor_pr703_head": "358383e2f1b0f292d4d6eb897c06fd8558a4f5e6", + "source_code_imports": [], + "sources": [ + { + "path": "certificates/selected-result.json", + "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53" + }, + { + "path": "research/e8-decoder-floors-and-cold14-notes/s1-extension-rings/REPORT.md", + "sha256": "e8de809976a1253087e9058d346dfcc7b098f6481c64f1569aa3072d27345e02" + }, + { + "path": "research/e8-decoder-floors-and-cold14-notes/s1-extension-rings/algebra_lines.py", + "sha256": "bc4037049debf9b7affeb7e6b30da0193dea8c3850a7317afd045ac7ac481108" + }, + { + "path": "research/e8-decoder-floors-and-cold14-notes/s1-extension-rings/hurwitz_exact.py", + "sha256": "5b66e4e4d22004307c197259d5a258a4d683862cf4d52ab72bb1b5ae1d9ff22b" + }, + { + "path": "research/format-limits/README.md", + "sha256": "0fa0d6b2df96ddc06b876c41c5fa8d2335b97f36bc8f17d1371296d23199c263" + }, + { + "path": "research/gaussian-e8-copy-bound/vendor/pr703/PROOF.md", + "sha256": "7355fcb0eadef64ffd7909e6c3d7717d5a3fb2628449fa3c6c754cb2a5665585" + }, + { + "path": "research/gaussian-e8-copy-bound/vendor/pr703/NOTICE.md", + "sha256": "af8ad6e0abf3da1a33b5e36cc72b6a57b8e2263620979bdcff866616fa1904c4" + } + ] +} diff --git a/research/gaussian-e8-copy-bound/VALIDATION.md b/research/gaussian-e8-copy-bound/VALIDATION.md new file mode 100644 index 0000000000..1f552b00dc --- /dev/null +++ b/research/gaussian-e8-copy-bound/VALIDATION.md @@ -0,0 +1,199 @@ +# Validation record + +Final checks of the actual staged Git blobs completed **2026-10-13 05:20:43 +UTC**, with all six targeted checks passing or rejecting as intended. The +post-staging section below records the final artifact hashes and LF-normalized +manifest. The earlier, broader validation remains recorded separately. + +The initial full validation completed **2026-10-13 05:14:34 UTC**. That run began +at 05:10:13 UTC and took **260.823 seconds**. All **21 external QA cases** +had the expected outcome: 11 successful executions and 10 deliberate +rejections. No verifier, receipt, or pinned input in the checkout was edited +during this run. + +This validates the package's independent reconstruction of the Gaussian +copy bound and its weighted inclusion-maximal-clique method ceiling. It +does not establish priority for the bound, produce a physical supplier, or +improve the selected multiplication constant. Concurrent work is discussed +in the README and proof. + +## Environment and executed commands + +- Python **3.12.15**, GCC 14.2.0 build; standard library only. +- Linux 6.18.33.2-microsoft-standard-WSL2, x86-64, glibc 2.41. +- Existing image: + `python@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1`. +- Docker flags: `--pull never --network none --read-only --cap-drop ALL + --security-opt no-new-privileges --cpus 2 --memory 1g --pids-limit 64 + --tmpfs /tmp:rw,size=128m`. +- The checkout was mounted read-only at `/repo`. Only the external local QA + output directory was mounted writable, at `/output`. Working directory: + `/repo`. No dependency installation or network access occurred in the run. + +The following commands were executed with absolute script paths: + +```sh +python -I -B /repo/research/gaussian-e8-copy-bound/verify.py +python -I -B -O /repo/research/gaussian-e8-copy-bound/verify.py +python -I -B /repo/research/gaussian-e8-copy-bound/independent_check.py +python -I -B -O /repo/research/gaussian-e8-copy-bound/independent_check.py +python -I -B /repo/scripts/verify_selected_result.py +``` + +| Check | Seconds | Outcome | +| --- | ---: | --- | +| Primary, default | 22.750 | PASS; 8 internal negative controls | +| Primary, optimized Python | 21.750 | Same PASS | +| Independent, default | 4.407 | PASS; 10 internal negative controls | +| Independent, optimized Python | 4.377 | Same PASS | +| Selected-result integrity | 79.664 | PASS; selected witness unchanged | + +Observed success lines: + +```text +PASS_GAUSSIAN_E8_COPY_BOUND lower=40 upper=60 flats=2272 pairs=2582128 controls=8 +PASS_INDEPENDENT_GAUSSIAN_COPY_BOUND lower=40 pairs=2582128 maximal_cliques=8704 controls=10 +PASS selected record, exact kappa, original source inventory and proof supplement: 51110230636731/31250000000000000 +``` + +The primary calculation uses real-coordinate subspaces and computes the +exact pairing-rank census. The independent implementation regenerates the +geometry and flats using Gaussian-integer arithmetic, cofactor normals, +and exact nonzero minors. It certifies the required rank lower bound for +each of the 2,582,128 flat pairs; it does not claim to reproduce the primary +rank histogram. Its 8,704 inclusion-maximal cliques also verify the method +ceiling. Both implementations check source hashes and deterministic +receipts, and neither imports predecessor code or the other verifier. + +## Relocation, mutations, and regeneration + +An external QA driver copied only this package and the seven files listed +in `SOURCES.json` into `/tmp/relocated`, preserving their relative paths. +Both default commands passed there before any mutation: primary **21.204 s**, +independent **3.933 s**. This minimal tree contains no Git checkout or other +repository source packages. + +Each mutation below was made separately to that temporary tree and then +restored from the original bytes. The checkout remained read-only. Each +verifier returned a nonzero exit status with the indicated reason, rather +than merely failing later on an unrelated receipt comparison. + +| Deliberate mutation | Primary rejection | Independent rejection | +| --- | --- | --- | +| Append bytes to the pinned extension-ring `REPORT.md` | `source hash mismatch` | `source pin mismatch` | +| Change the default receipt's claimed bound from 40 to 41 | `computed receipt differs from RESULTS.json` | `independent receipt differs from complete exact replay` | +| Remove the pinned `REPORT.md` | `FileNotFoundError` | `FileNotFoundError` | +| Change a manifest path to `../outside-pinned.txt` | `source path escapes repository` | `source path escape` | + +For the last case, the outside file existed and its declared hash was +correct; both verifiers rejected the path itself. These tests invoked the +ordinary default command, so the receipt tests exercised the committed +default receipt paths rather than a special test-only comparison. + +Both verifiers were then run with `--write` pointing to a new file under +`/tmp`. The generated receipts were **byte-identical** to `RESULTS.json` +and `INDEPENDENT.json`, respectively. Repeating each command with the same +output path produced `FileExistsError`, confirming exclusive creation. +Final default runs after restoration passed again: primary **21.091 s**, +independent **3.829 s**. + +The internal controls cover mathematical failures as well as artifact +integrity. Examples include an orthogonal pair presented as a clique, an +incomplete flat, the unsupported denominator 191, a wrongly charged Gram +block, and decoder fitting violations. The independent controls additionally +exercise Gram normalization and symmetry, a dependent flat basis, receipt +corruption, and modified pinned bytes. These guards remain active under +optimized Python. + +## Initial full-run bytes and scope + +The following historical SHA-256 values were recorded before the initial +execution and confirmed unchanged afterward, together with all seven pinned +inputs. The manifest and receipt hashes changed in the later normalization +step; use the final hashes in the next section for the submitted artifacts. + +| File | SHA-256 | +| --- | --- | +| `verify.py` | `dbdd82e853b5c19420d6f3d145342f48102edcbfbb6effa1e76a71d4e97032a1` | +| `independent_check.py` | `8704c9517c94809e91de407c79891cebb5b03cb2cfda8435153c92c7fee60cdf` | +| `RESULTS.json` | `d9195a37cba97e089a7bc5362c1a53dca47d1994e691a4f8bb57c44a8dfb84c3` | +| `INDEPENDENT.json` | `23fd1b11cef67de3f9896b896f911063914f8b1573b8358961da04bb8694964e` | +| `SOURCES.json` | `3656cd4cccebff87c30f10c5ecf05f61fe76961c8432f0dee9621bd1cfa556e3` | + +The unchanged base is recorded in `SOURCES.json` as +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The selected-result integrity +check verifies its source inventory and proof bindings; it is not a fresh +execution of the selected supplier's full physical replay. + +Neither stage executed `make verify`, the full selected-frontier cold +replay, or remote CI. It does not discharge the repository's inherited +compiler, realization, hosting, precision, tape, or analytic assumptions. +The two verification implementations were produced with substantial Codex +assistance; no independent human or proof-assistant review is claimed. + +## Final staged-blob checks after LF normalization + +Packaging detected that the initial `SOURCES.json` had CRLF line endings, +while Git normalized its staged contents to LF. The manifest was normalized +to LF in the working tree, and only the manifest-hash field in each receipt +was updated to +`cc694727a7f6b8705549918f2bb991be5968f37cbf73ae15df0642e30a7b7191`. +Both verifier scripts and all seven pinned inputs were unchanged. No +mathematical result or other receipt field changed. + +To check the bytes that would actually be submitted, the package files and +seven pinned inputs were exported from the index using `git show :path`. +The exporter captured subprocess output as bytes and wrote bytes directly, +avoiding text-mode newline conversion. This produced a fresh minimal tree +containing 17 distinct files, mounted read-only at `/repo` in the same +digest-pinned container with the same restrictions. The writable QA output +directory was a separate sibling of the exported tree, so there was no +writable mount alias to the staged inputs. + +The targeted run began **2026-10-13 05:19:24 UTC**, finished at **05:20:43 +UTC**, and took **79.337 seconds**. The ordinary commands against this +export were: + +```sh +python -I -B /repo/research/gaussian-e8-copy-bound/verify.py +python -I -B /repo/research/gaussian-e8-copy-bound/independent_check.py +``` + +Both produced the same success lines recorded above, including all 8 and +10 internal controls. A temporary copy under `/tmp/relocated` was then +used to change each default receipt's claimed bound to 41, invoke that +verifier's ordinary command, and restore the receipt bytes. Each rejected +the corrupted default receipt for the intended mismatch. Finally: + +```sh +python -I -B /tmp/relocated/research/gaussian-e8-copy-bound/verify.py --write /tmp/staged-RESULTS.json +python -I -B /tmp/relocated/research/gaussian-e8-copy-bound/independent_check.py --write /tmp/staged-INDEPENDENT.json +``` + +Both generated files were byte-identical to their actual staged receipt +blobs, including the updated manifest digest. + +| Staged-blob check | Seconds | Outcome | +| --- | ---: | --- | +| Primary default | 22.366 | PASS | +| Independent default | 4.167 | PASS | +| Primary altered default receipt | 21.387 | Intended receipt-mismatch rejection | +| Primary receipt regeneration | 22.771 | PASS; byte-identical | +| Independent altered default receipt | 4.213 | Intended receipt-mismatch rejection | +| Independent receipt regeneration | 3.878 | PASS; byte-identical | + +Final tested SHA-256 values, unchanged throughout the staged-blob run: + +| File | SHA-256 | +| --- | --- | +| `verify.py` | `dbdd82e853b5c19420d6f3d145342f48102edcbfbb6effa1e76a71d4e97032a1` | +| `independent_check.py` | `8704c9517c94809e91de407c79891cebb5b03cb2cfda8435153c92c7fee60cdf` | +| `RESULTS.json` | `3cbdaeddb56a7cc2a5a5743efcfa6621e1140f4d1bf74e8f15bdcc8c09b14d52` | +| `INDEPENDENT.json` | `05074c91e8578c31867081109e8efefedf2200db7c7e8a6b701c7165faa063a2` | +| `SOURCES.json` | `cc694727a7f6b8705549918f2bb991be5968f37cbf73ae15df0642e30a7b7191` | + +The seven pinned input hashes also matched the initial stage. Optimized +Python, source/path mutation cases, and selected-result inventory validation +were not repeated in this targeted stage because their executing code and +pinned inputs were unchanged; their actual earlier results are recorded +above. No submitted script or receipt was modified by this final validation. diff --git a/research/gaussian-e8-copy-bound/independent_check.py b/research/gaussian-e8-copy-bound/independent_check.py new file mode 100644 index 0000000000..5c2d34694a --- /dev/null +++ b/research/gaussian-e8-copy-bound/independent_check.py @@ -0,0 +1,487 @@ +#!/usr/bin/env python3 +"""Independent Gaussian-integer geometry for the Gaussian E8 copy bound. + +Uses four complex coordinates and fraction-free Gaussian-integer elimination, +rather than the primary verifier's eight-dimensional rational calculation. +Only the Python standard library is needed. No repository modules are imported. +""" + +from itertools import combinations, product +from math import gcd +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def add(a, b): + return (a[0] + b[0], a[1] + b[1]) + + +def subtract(a, b): + return (a[0] - b[0], a[1] - b[1]) + + +def multiply(a, b): + return (a[0] * b[0] - a[1] * b[1], + a[0] * b[1] + a[1] * b[0]) + + +def hermitian(a, b): + result = (0, 0) + for x, y in zip(a, b): + result = add(result, multiply((x[0], -x[1]), y)) + return result + + +def gaussian_rank(matrix): + """Rank over Q(i), using only multiplication and exact integer division. + + At a pivot, row <- pivot * row - entry * pivot_row. A nonzero + Gaussian pivot makes this an invertible row operation over Q(i). + Dividing by the positive gcd of all real/imaginary components controls + growth without changing rank. No floating point or modular rank is used. + """ + if not matrix: + return 0 + width = len(matrix[0]) + require(all(len(row) == width for row in matrix), 'ragged matrix') + rows = [[tuple(value) for value in row] for row in matrix] + pivot_row = 0 + for column in range(width): + pivot = next((i for i in range(pivot_row, len(rows)) + if rows[i][column] != (0, 0)), None) + if pivot is None: + continue + rows[pivot_row], rows[pivot] = rows[pivot], rows[pivot_row] + pivot_value = rows[pivot_row][column] + for i in range(pivot_row + 1, len(rows)): + entry = rows[i][column] + if entry == (0, 0): + continue + for j in range(column + 1, width): + rows[i][j] = subtract(multiply(pivot_value, rows[i][j]), + multiply(entry, rows[pivot_row][j])) + rows[i][column] = (0, 0) + divisor = 0 + for value in rows[i][column + 1:]: + divisor = gcd(divisor, abs(value[0])) + divisor = gcd(divisor, abs(value[1])) + if divisor > 1: + rows[i][column + 1:] = [ + (value[0] // divisor, value[1] // divisor) + for value in rows[i][column + 1:]] + pivot_row += 1 + if pivot_row == len(rows): + break + return pivot_row + + +def complexify(root): + return tuple((root[i], root[i + 1]) for i in range(0, 8, 2)) + + +def times_i(root): + return tuple(value for i in range(0, 8, 2) + for value in (-root[i + 1], root[i])) + + +def geometry(): + roots = set() + for first, second in combinations(range(8), 2): + for signs in product((-2, 2), repeat=2): + root = [0] * 8 + root[first], root[second] = signs + roots.add(tuple(root)) + for signs in product((-1, 1), repeat=8): + if sum(value == -1 for value in signs) % 2 == 0: + roots.add(signs) + require(len(roots) == 240, 'E8 root census') + require(all(sum(x * x for x in root) == 8 for root in roots), 'root norms') + require({times_i(root) for root in roots} == roots, 'complex structure') + orbit_keys = set() + for root in roots: + jr = times_i(root) + orbit_keys.add(min(root, jr, tuple(-x for x in root), tuple(-x for x in jr))) + representatives = sorted(orbit_keys) + require(len(representatives) == 60, 'Gaussian line census') + lines = [complexify(root) for root in representatives] + require(gaussian_rank(lines) == 4, 'ambient complex rank') + require(all(gaussian_rank([lines[i], lines[j]]) == 2 + for i, j in combinations(range(60), 2)), + 'distinct Gaussian lines outside unit orbits') + gram = [[hermitian(a, b) for b in lines] for a in lines] + check_gram(gram) + degrees = [sum(j != i and value != (0, 0) + for j, value in enumerate(row)) for i, row in enumerate(gram)] + require(set(degrees) == {44}, 'nonorthogonality degrees') + return representatives, lines, gram + + +def check_gram(gram): + require(len(gram) == 60 and all(len(row) == 60 for row in gram), 'Gram dimensions') + for i, row in enumerate(gram): + require(row[i] == (8, 0), 'doubled-root Gram normalization') + for j, value in enumerate(row): + require(value == (gram[j][i][0], -gram[j][i][1]), 'Hermitian Gram symmetry') + + +def pairing_rank(left, right, gram): + return gaussian_rank([[gram[i][j] for j in right] for i in left]) + + +def rank_two_flats(gram): + """Enumerate all two-dimensional flats by exact 3x3 Gram determinants.""" + def norm(value): + return value[0] * value[0] + value[1] * value[1] + + result = set() + covered_pairs = set() + for first, second in combinations(range(len(gram)), 2): + if (first, second) in covered_pairs: + continue + flat = [] + ab = gram[first][second] + for third in range(len(gram)): + ac, bc = gram[first][third], gram[second][third] + triple = multiply(multiply(ab, bc), (ac[0], -ac[1])) + determinant = 512 - 8 * (norm(ab) + norm(ac) + norm(bc)) + 2 * triple[0] + require(determinant >= 0, 'negative principal Gram determinant') + if determinant == 0: + flat.append(third) + key = tuple(flat) + result.add(key) + covered_pairs.update(combinations(key, 2)) + return sorted(result) + + +def maximal_cliques(gram): + """Bron--Kerbosch enumeration, used for independent certificate diagnostics.""" + adjacency = [sum(1 << j for j, value in enumerate(row) + if i != j and value != (0, 0)) + for i, row in enumerate(gram)] + + def visit(chosen, possible, excluded): + if not (possible or excluded): + yield chosen + return + remaining = possible | excluded + pivot = None + score = -1 + while remaining: + bit = remaining & -remaining + index = bit.bit_length() - 1 + candidate_score = (possible & adjacency[index]).bit_count() + if candidate_score > score: + pivot, score = index, candidate_score + remaining ^= bit + candidates = possible & ~adjacency[pivot] + while candidates: + bit = candidates & -candidates + index = bit.bit_length() - 1 + yield from visit(chosen | bit, possible & adjacency[index], + excluded & adjacency[index]) + possible ^= bit + excluded |= bit + candidates ^= bit + + yield from visit(0, (1 << len(gram)) - 1, 0) + + +def determinant(matrix): + """Exact determinant over Gaussian integers (matrices here have size <= 3).""" + size = len(matrix) + if size == 0: + return (1, 0) + if size == 1: + return matrix[0][0] + if size == 2: + return subtract(multiply(matrix[0][0], matrix[1][1]), + multiply(matrix[0][1], matrix[1][0])) + result = (0, 0) + for column in range(size): + minor = [[value for j, value in enumerate(row) if j != column] + for row in matrix[1:]] + term = multiply(matrix[0][column], determinant(minor)) + result = add(result, term) if column % 2 == 0 else subtract(result, term) + return result + + +def canonical_direction(vector): + pivot = next((value for value in vector if value != (0, 0)), None) + if pivot is None: + return None + values = [multiply(value, (pivot[0], -pivot[1])) for value in vector] + content = 0 + for real, imag in values: + content = gcd(content, abs(real)) + content = gcd(content, abs(imag)) + return tuple((real // content, imag // content) for real, imag in values) + + +def flat_catalogue(lines, gram): + """All root-generated Gaussian flats, with an independent complex basis. + + Rank-two closures use positive Gram determinants. Rank-three flats are + kernels of the cofactor normal of each independent triple. Every flat + has a basis among its root lines, so these enumerations are exhaustive. + """ + catalogue = {0: (0, ())} + for i in range(len(lines)): + catalogue[1 << i] = (1, (i,)) + for indices in rank_two_flats(gram): + mask = sum(1 << i for i in indices) + catalogue[mask] = (2, indices[:2]) + normals = {} + for basis in combinations(range(len(lines)), 3): + rows = [lines[i] for i in basis] + normal = [] + for column in range(4): + minor = [[value for j, value in enumerate(row) if j != column] + for row in rows] + value = determinant(minor) + normal.append(value if column % 2 == 0 else (-value[0], -value[1])) + key = canonical_direction(normal) + if key is not None and key not in normals: + normals[key] = basis + for normal, basis in normals.items(): + mask = 0 + for index, line in enumerate(lines): + value = (0, 0) + for a, b in zip(normal, line): + value = add(value, multiply(a, b)) + if value == (0, 0): + mask |= 1 << index + require(mask not in catalogue, 'duplicate/low-rank hyperplane') + catalogue[mask] = (3, basis) + basis = [] + for index, line in enumerate(lines): + if gaussian_rank([lines[i] for i in basis] + [line]) > len(basis): + basis.append(index) + if len(basis) == 4: + break + catalogue[(1 << len(lines)) - 1] = (4, tuple(basis)) + return [(rank, mask, basis) for mask, (rank, basis) in sorted(catalogue.items())] + + +def has_minor_rank_at_least(left, right, gram, required): + """Certify a rank lower bound by an explicitly nonzero Gaussian minor.""" + if required == 0: + return True + if len(left) + len(right) - 4 >= required: + # Restrict the positive definite ambient form to the two subspaces: + # rank >= dim(left) + dim(right) - ambient_dimension. + return True + for rows in combinations(left, required): + for columns in combinations(right, required): + if determinant([[gram[i][j] for j in columns] for i in rows]) != (0, 0): + return True + return False + + +def pair_bound(left, right, gram, hit_count, denominator=192): + require(denominator > 0, 'positive clique denominator') + needed = (hit_count + denominator - 1) // denominator + require(has_minor_rank_at_least(left, right, gram, needed), 'clique/Gram rank inequality') + + +def check_clique(clique, gram): + vertices = [i for i in range(60) if clique & (1 << i)] + require(all(gram[i][j] != (0, 0) for i, j in combinations(vertices, 2)), + 'nonorthogonality clique') + + +def check_flat_record(rank, mask, basis, lines): + require(gaussian_rank([lines[i] for i in basis]) == rank, 'flat-basis rank') + closure = sum(1 << j for j, line in enumerate(lines) + if gaussian_rank([lines[i] for i in basis] + [line]) == rank) + require(mask == closure, 'complete flat closure') + + +def compare_receipt(expected, actual): + require(expected == actual, 'independent receipt differs from complete exact replay') + + +def check_source_payload(payload, expected_hash): + from hashlib import sha256 + require(sha256(payload).hexdigest() == expected_hash, 'source pin mismatch') + + +def verify_sources(): + import json + from hashlib import sha256 + + payload = (HERE / 'SOURCES.json').read_bytes() + manifest = json.loads(payload) + require(manifest['source_code_imports'] == [], 'no predecessor code imports') + seen = set() + for source in manifest['sources']: + relative = Path(source['path']) + require(not relative.is_absolute() and '..' not in relative.parts, 'source path escape') + require(source['path'] not in seen, 'duplicate source pin') + seen.add(source['path']) + path = (ROOT / relative).resolve() + require(path.is_relative_to(ROOT.resolve()), 'resolved source path escape') + check_source_payload(path.read_bytes(), source['sha256']) + require(len(seen) > 0, 'empty source manifest') + return {'source_manifest_sha256': sha256(payload).hexdigest(), 'source_pin_count': len(seen)} + + +def negative_controls(flats, lines, gram, cliques, hits, orthogonal, hyperplanes, index_by_mask): + """Deliberately wrong claims must be rejected by the same exact primitives.""" + passed = [] + + def reject(name, operation): + try: + operation() + except ValueError: + passed.append(name) + else: + raise ValueError('negative control accepted: ' + name) + + first, second = orthogonal[0] + fi, fj = index_by_mask[hyperplanes[first]], index_by_mask[hyperplanes[second]] + left, right = flats[fi][2], flats[fj][2] + count = (hits[fi] & hits[fj]).bit_count() + pair_bound(left, right, gram, count, 192) + reject('overstrong_denominator_191', lambda: pair_bound(left, right, gram, count, 191)) + reject('false_rank_one_for_sharp_gram_block', lambda: require( + pairing_rank(left, right, gram) == 1, 'incorrect pairing rank')) + reject('orthogonal_pair_called_clique', lambda: check_clique((1 << first) | (1 << second), gram)) + doubled = [[(2 * real, 2 * imag) for real, imag in row] for row in gram] + reject('changed_gram_normalization', lambda: check_gram(doubled)) + nonhermitian = [row[:] for row in gram] + nonhermitian[0][1] = add(nonhermitian[0][1], (0, 1)) + reject('nonhermitian_gram', lambda: check_gram(nonhermitian)) + rank, mask, basis = next(flat for flat in flats if flat[0] == 2 and flat[1].bit_count() == 6) + check_flat_record(rank, mask, basis, lines) + reject('dependent_flat_basis', lambda: check_flat_record(rank, mask, (basis[0], basis[0]), lines)) + reject('omitted_flat_member', lambda: check_flat_record(rank, mask ^ (mask & -mask), basis, lines)) + reject('corrupt_bound_receipt', lambda: compare_receipt({'copy_lower_bound': 41}, {'copy_lower_bound': 40})) + reject('corrupt_clique_count_receipt', lambda: compare_receipt({'maximum_clique_count': 639}, {'maximum_clique_count': 640})) + from hashlib import sha256 + reject('modified_pinned_source_bytes', lambda: check_source_payload( + b'changed source', sha256(b'pinned source').hexdigest())) + return passed + + +def audit(): + from collections import Counter + from fractions import Fraction + + sources = verify_sources() + self_check() + representatives, lines, gram = geometry() + all_maximal = list(maximal_cliques(gram)) + largest = max(clique.bit_count() for clique in all_maximal) + cliques = [clique for clique in all_maximal if clique.bit_count() == largest] + require(largest == 12 and len(cliques) == 640, 'maximum-clique census') + flats = flat_catalogue(lines, gram) + census = Counter((rank, mask.bit_count()) for rank, mask, _ in flats) + expected = {(0, 0): 1, (1, 1): 60, (2, 2): 360, (2, 3): 320, + (2, 6): 30, (3, 4): 960, (3, 6): 480, (3, 15): 60, (4, 60): 1} + require(dict(census) == expected, 'flat census') + hits = [sum(1 << i for i, clique in enumerate(cliques) if clique & mask) + for _, mask, _ in flats] + pair_count = 0 + for first, (_, _, left) in enumerate(flats): + for second in range(first, len(flats)): + hit_count = (hits[first] & hits[second]).bit_count() + pair_bound(left, flats[second][2], gram, hit_count) + pair_count += 1 + # The 450 orthogonal line pairs yield rank-two pairs of perpendicular + # hyperplanes. Each maximum clique meets both hyperplanes for 270 pairs. + # Thus no nonnegative reweighting of this maximum-clique family exceeds 40. + orthogonal = [(i, j) for i, j in combinations(range(60), 2) if gram[i][j] == (0, 0)] + hyperplanes = [sum(1 << j for j, value in enumerate(row) if value == (0, 0)) + for row in gram] + require(len(orthogonal) == 450, 'orthogonal-pair census') + index_by_mask = {mask: index for index, (_, mask, _) in enumerate(flats)} + require(all(mask.bit_count() == 15 and flats[index_by_mask[mask]][0] == 3 + for mask in hyperplanes), 'root-normal hyperplanes') + for first, second in orthogonal: + fi, fj = index_by_mask[hyperplanes[first]], index_by_mask[hyperplanes[second]] + require(pairing_rank(flats[fi][2], flats[fj][2], gram) == 2, + 'hyperplane-pair rank') + require((hits[fi] & hits[fj]).bit_count() == 384, 'sharp pair incidence') + require(all(sum(bool(clique & hyperplanes[i]) and bool(clique & hyperplanes[j]) + for i, j in orthogonal) == 270 for clique in cliques), + 'maximum-clique weighting ceiling') + for clique in all_maximal: + size = clique.bit_count() + incidence = sum(bool(clique & hyperplanes[i]) and bool(clique & hyperplanes[j]) + for i, j in orthogonal) + require(incidence == 450 - 15 * size, 'maximal-clique sharp-pair incidence') + require(2 * incidence >= 45 * size, 'maximal-clique weighting ceiling') + lower = Fraction(len(cliques) * largest, 192) + ceiling = Fraction(largest * len(orthogonal) * 2, 270) + require(lower == ceiling == 40, 'copy bound and weighting ceiling') + controls = negative_controls(flats, lines, gram, cliques, hits, + orthogonal, hyperplanes, index_by_mask) + return { + 'status': 'PASS_INDEPENDENT_GAUSSIAN_COPY_BOUND', + 'arithmetic': 'Gaussian integers; fraction-free rank and exact minors', + 'root_count': 240, 'line_count': len(representatives), + 'maximum_clique_size': largest, 'maximum_clique_count': len(cliques), + 'maximal_clique_counts': {str(k): v for k, v in sorted(Counter( + clique.bit_count() for clique in all_maximal).items())}, + 'flat_count': len(flats), + 'flat_counts': {'%d:%d' % key: value for key, value in sorted(census.items())}, + 'unordered_flat_pairs_with_repetition': pair_count, + 'maximum_clique_weight': '1/192', 'copy_lower_bound': 40, + 'maximum_clique_weighting_ceiling': 40, + 'inclusion_maximal_clique_weighting_ceiling': 40, + 'inclusion_maximal_clique_count': len(all_maximal), + 'sharp_hyperplane_pairs': len(orthogonal), + 'sharp_pair_clique_incidence': 384, + 'per_clique_sharp_pair_incidence': 270, + 'negative_controls': controls, + 'negative_control_count': len(controls), + 'geometry_self_checks': 'mandatory; distinct lines and principal two-line Gram ranks', + **sources, + } + + +def self_check(): + zero, one, imag = (0, 0), (1, 0), (0, 1) + require(gaussian_rank([]) == 0, 'empty rank') + require(gaussian_rank([[zero]]) == 0, 'zero rank') + require(gaussian_rank([[one, imag], [imag, (-1, 0)]]) == 1, + 'complex dependent rank') + require(gaussian_rank([[one, imag], [imag, one]]) == 2, + 'complex independent rank') + representatives, lines, gram = geometry() + for first, second in combinations(range(60), 2): + require(gaussian_rank([lines[first], lines[second]]) == 2, + 'two distinct complex lines') + require(pairing_rank([first, second], [first, second], gram) == 2, + 'positive two-line Gram block') + return {'roots': 240, 'lines': len(representatives), 'complex_rank': 4, + 'nonorthogonal_degree': 44, 'two_line_checks': 1770} + + +if __name__ == '__main__': + import argparse + import json + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--geometry-only', action='store_true') + mode = parser.add_mutually_exclusive_group() + mode.add_argument('--check', type=Path, default=HERE / 'INDEPENDENT.json') + mode.add_argument('--write', type=Path) + args = parser.parse_args() + result = self_check() if args.geometry_only else audit() + if not args.geometry_only: + if args.write: + with args.write.open('x', encoding='utf-8', newline='\n') as handle: + handle.write(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + compare_receipt(json.loads(args.check.read_text(encoding='utf-8')), result) + if args.geometry_only: + print(json.dumps(result, sort_keys=True)) + else: + print('PASS_INDEPENDENT_GAUSSIAN_COPY_BOUND lower=40 pairs=2582128 maximal_cliques=8704 controls=10') diff --git a/research/gaussian-e8-copy-bound/vendor/pr703/NOTICE.md b/research/gaussian-e8-copy-bound/vendor/pr703/NOTICE.md new file mode 100644 index 0000000000..897f3b5234 --- /dev/null +++ b/research/gaussian-e8-copy-bound/vendor/pr703/NOTICE.md @@ -0,0 +1,49 @@ +# Attribution, license and source status + +Prepared by **Douglas R. Colkitt (@Mister-Meeseeks)**, with substantial +**OpenAI Codex** assistance in research selection, proof development, +implementation, checking and documentation. No human-only or independent +human review is claimed. New files are under the repository's +[Apache-2.0 license](../../LICENSE). + +The ten-line quaternionic E8 model, orthogonality observation, symmetric +cost-ten result, exact asymmetric SAT formulation and open question come +from **Joel Pulikkan / GamingPuzzled's +[PR #620](https://github.com/CrocSwap/integer-mult-bounds/pull/620)**, prepared +with Claude Opus 5.5 assistance. This contribution supplies the weighted +transversal proof and a new standard-library exact implementation. It does +not claim to have discovered that geometry or the cost-ten upper bound. + +The pairing-rank accounting is inherited from **DreamingOfClouds' +#446/#595** work as used by #620; the conditional deficit screen uses the +retained [format-limits-corrected](../format-limits-corrected/README.md) +accounting. The Hamilton multiplication law and E8 root coordinates are +standard. The implementation uses no copied predecessor routines. + +The main-branch base is 66849e1475c930fd7732b1a0067ffee7e1e95f60. +The maintainer's retained #620 head was +419c7374c3bf5f2eee28f08b1e50c1d57934081c, with a **partial** review. +The current open head inspected for overlap was +e9cf03bbdf7094b5a83f6dbd1d74bfd77a05fb87. Its four relevant extension-ring +source files have the same Git blob IDs as the retained base files. +Its later README adds an E6 correction and unrelated unit/dispatch work; +the Hurwitz asymmetric case remains marked open. All consumed file bytes +and base Git blob IDs are pinned in [SOURCES.json](SOURCES.json). + +The predecessor's hurwitz_exact.py docstring says costs below ten are +UNSAT. Its accompanying REPORT.md explicitly says that run **did not +finish**. We treat the case as open in that source and do not cite the +docstring as evidence of solver success. The new proof and exact replay +stand independently of any claimed SAT outcome. + +Concurrent work checked for overlap includes Zhao Chi / vectorsss' #631 +on star punctures, Sam Sung / the-missionary-company's #669 on asymmetric +hypercube stars, Shike Chen's #634 on coding/Lorentzian families, and +Scott Woolsey Biggart's #682 auditing Artus / artuskg's #647 tensor E8 +profile. These contributions concern different objects and are not +dependencies. The selected #626/#543 construction and its full predecessor +lineage retain their existing credit and assumptions. + +Before submission, metadata was refreshed through #700. Scott Woolsey +Biggart's newer #697 directly reads sources in the complex #647 supplier; +it does not address the quaternionic ten-line decoder considered here. diff --git a/research/gaussian-e8-copy-bound/vendor/pr703/PROOF.md b/research/gaussian-e8-copy-bound/vendor/pr703/PROOF.md new file mode 100644 index 0000000000..f0b6a80eae --- /dev/null +++ b/research/gaussian-e8-copy-bound/vendor/pr703/PROOF.md @@ -0,0 +1,183 @@ +# The asymmetric copy floor for the ten Hurwitz E8 lines + +**Result.** In the scalar-total model specified below, the minimum copied +information is **10 quaternionic rank units = 40 rational rank units**. +This holds for every fitting decoder matrix separately, including every +nonsymmetric completion and decompositions with arbitrarily many totals. +It closes the particular asymmetric case left open in +[#620's extension-ring report](../e8-decoder-floors-and-cold14-notes/s1-extension-rings/REPORT.md). +It is a statement about that finite model, not a new supplier or a universal +lower bound for integer multiplication. + +## 1. Geometry and the exact model + +Use the 240 E8 roots in doubled standard coordinates in Q^8: + +- all vectors with two nonzero coordinates, each equal to +2 or -2; +- all vectors in {+1,-1}^8 with an even number of minus signs. + +Identify Q^8 with two copies of the rational Hamilton quaternions, and let +1, i, j, k act by **left** multiplication on both blocks. The Q-span of these +four translates of a root is a four-dimensional line over the quaternions. +The roots partition into ten such Q-subspaces L_0,...,L_9, with 24 roots each. +Our deterministic ordering has orthogonal pairs + + (0,9), (1,8), (2,7), (3,6), (4,5). + +Each pair of distinct lines spans Q^8. Each line is orthogonal to precisely +its mate. The verifier constructs this geometry from scratch using the +Hamilton multiplication formula. Equality of the matrices 8 P_L, where P_L +is the orthogonal projector onto L, identifies the lines; no floating rank +test or tolerance is used. + +Let B be a 10 by 10 matrix over F2. Its fitting conditions are + + B_tt = 1; + B_ts = 0 whenever t != s and L_t is not orthogonal to L_s. + +There is no restriction on either directed mate entry. In particular B need +not be symmetric. Write an arbitrary finite scalar-total decomposition as + + B = sum_j 1_{R_j} 1_{A_j}^T over F2, + +where R_j is the reader set and A_j is the source set. Every binary rank-one +term has this form. Both sets may be empty, terms may repeat, and no bound on +the number of terms or on rank(B) is assumed. + +For a set S, concatenate the four-vector bases of its lines into a matrix +V_S. Define the charge exactly as in #620's proposed Theorem-C relaxation: + + c(R,A) = rank_Q(V_R V_A^T) / 4. + +The total charge is C = sum_j c(R_j,A_j). This is the proposed pairing-rank +copy floor, not the F2 rank of the decoder rectangle. The factor four must +be restored when using the repository's rational-rank accounting. + +For this geometry, direct linear algebra gives + + c(R,A) = 0 if either set is empty, or R={t}, A={mate(t)}; + 1 otherwise, if either nonempty set is a singleton; + 2 if both sets have at least two elements. + +Indeed two distinct lines span Q^8, so two sets of size at least two have a +Gram block of rank eight. A singleton against a spanning set has rank four. +Two quaternionic lines have a zero Gram block when orthogonal and an +invertible four by four Gram block otherwise. The verifier checks all 3,025 +ordered pairs of singleton or two-line sets with two independent rational +rank implementations. Every larger set has the same span as its first two +lines; this is an exact reduction, not a sample of larger supports. + +## 2. A weighted transversal rank bound + +A transversal T chooses one line from each of the five orthogonal pairs. +There are 32 transversals. Two different elements of T are nonorthogonal, +so the fitting conditions force + + B[T,T] = I_5. + +For a single rectangle R x A, its restriction to T x T has rank one exactly +when R meets T and A meets T, and otherwise has rank zero. Denote this +indicator by a_T(R,A). Rank subadditivity over F2 yields, for each T, + + 5 <= sum_j a_T(R_j,A_j). (1) + +For every rectangle the following local inequality holds: + + (1/16) sum_T a_T(R,A) <= c(R,A). (2) + +There are only three cases: + +1. If c=0, an empty set makes all indicators zero. In the other zero-cost + case, a transversal cannot contain both orthogonal mates, so again all + indicators are zero. +2. If c=1, at least one set is a singleton. Its one line belongs to exactly + 16 transversals, so the sum of indicators is at most 16. +3. If c=2, there are only 32 transversals, so the sum is at most 32. + +Multiply (1) by 1/16 and sum it over the 32 transversals. Then apply (2) +term by term: + + 10 = (32/16)*5 + <= sum_j (1/16) sum_T a_T(R_j,A_j) + <= sum_j c(R_j,A_j) = C. + +This is the complete lower-bound argument. In particular it does not +assume that all totals have full rank, that B has minimum possible rank, +that the decomposition is symmetric, or that the number of totals is ten. +Zero-cost terms are allowed and are invisible to every inequality (1). +No solver infeasibility claim is used. + +The same argument works for 2m distinct lines in quaternionic dimension +two when their orthogonality graph is a perfect matching and the displayed +charge formula holds: average over the 2^m transversals and obtain C >= 2m. +Only the m=5 E8 instance is certified here. + +## 3. Sharpness, including nonsymmetric matrices + +For the symmetric completion with all directed mate entries equal to one, +use one total R=A={t,mate(t)} per orthogonal pair. These five disjoint two +by two all-one blocks satisfy the fitting pattern. Each costs two, so C=10. +Its F2 rank is five, also the minimum possible by B[T,T]=I_5. + +More strongly, **every** fitting B has a cost-ten decomposition. For each +row t, take R={t} and A equal to that row's nonzero positions. The set A is +either {t} or {t,mate(t)}; the charge is one in both cases. These ten +rectangles sum to B. Combining this with the lower bound proves that +the minimum charge is ten for each of the 1,024 directed completions. + +There are 32 symmetric and 992 nonsymmetric completions. Their ranks +5,6,7,8,9,10 occur with multiplicities 1,15,90,270,405,243 respectively. +Each mate block has rank one only when both free entries are one, and +rank two for the other three choices, giving these counts. The replay +also enumerates and row-reduces all completions independently. + +This attains the abstract Gram-block charge. It does not assert that a +complete physical supplier implements it without any additional expense. + +## 4. Optimistic complete-budget screen + +The [format accounting, axiom Dfc](../format-limits-corrected/README.md) +and #620's rank-four scaling give, conditionally on using that same stage +format, v=10, k=4 and cst=4C >= 40: + + D/T = (s-1) v k - s cst + <= (s-1)*40 - s*40 + = -40 + +for every positive stage count s. Equivalently x_K=C/v >= 1, with equality +already at the most favorable abstract copy cost. Even granting zero +additional cost for helpers, source access, frame changes, restoration, +and recursive work cannot make this accounting produce positive deficit. +There is therefore no reason to implement a paid supplier for this +particular mechanism before changing another premise. No assembly or +other supplier can turn this negative local deficit into a positive one +within the stated Dfc criterion. + +The finite receipt checks the arithmetic for s=1,...,32 as error controls; +the displayed identity, not those examples, supplies the all-s argument. +The abstract floor does not depend on the validity of this accounting +interface. Its application to a multiplication bound does. + +## 5. Scope and verification + +The finite exhaustive domain is all 1,024 reader sets times all 1,024 +source sets, all 32 transversals, and all 1,024 fitting matrices. The +certificate records every transversal and the exact weight 1/16. The +verifier checks each local inequality (2), all principal identities (1), +and attaining decompositions. Eight deliberately corrupted controls are +rejected; nonsymmetric and zero-cost examples are accepted. + +The written rank argument extends the finite certificate to every finite +number of totals. Enumeration alone is not presented as that proof. +This is not a proof-assistant formalization. + +The result does not address arbitrary rational sub-line supports, +matrix-valued or vector-linear totals, altered fitting patterns, punctured +units, other Gaussian/Eisenstein units, changing the stage format, or +physical realizations outside the declared pairing-rank model. In +particular it is not a universal obstruction to quaternionic methods. +It neither improves the selected kappa nor discharges the selected +construction's compiler, hosting, precision, tape or analytic assumptions. + +Prepared by Douglas R. Colkitt with substantial OpenAI Codex assistance. +See [NOTICE.md](NOTICE.md) for predecessor credit and source status. diff --git a/research/gaussian-e8-copy-bound/verify.py b/research/gaussian-e8-copy-bound/verify.py new file mode 100644 index 0000000000..6427ecc25d --- /dev/null +++ b/research/gaussian-e8-copy-bound/verify.py @@ -0,0 +1,347 @@ +"""Exact Gaussian E8 COPY lower bound, using real-coordinate subspaces. + +Written for chinmayarvind23 with substantial OpenAI Codex assistance. +No third-party imports or predecessor code execution. +""" +import itertools +import json +import math +import hashlib +import argparse +from pathlib import Path +from collections import Counter +from fractions import Fraction + +PACKAGE = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def check_sources(): + manifest = json.loads((PACKAGE / 'SOURCES.json').read_text(encoding='utf-8')) + root = PACKAGE.parent.parent + for source in manifest['sources']: + path = (root / source['path']).resolve() + require(path.is_relative_to(root.resolve()), 'source path escapes repository') + require(hashlib.sha256(path.read_bytes()).hexdigest() == source['sha256'], + 'source hash mismatch: ' + source['path']) + return hashlib.sha256((PACKAGE / 'SOURCES.json').read_bytes()).hexdigest() + + +def primitive(row): + g = math.gcd(*row) + if not g: + return tuple(row) + if next(x for x in row if x) < 0: + g = -g + return tuple(x // g for x in row) + + +def reduce_row(row, basis): + row = tuple(row) + for b in basis: + p = next(i for i, x in enumerate(b) if x) + if row[p]: + row = primitive(tuple(x * b[p] - y * row[p] for x, y in zip(row, b))) + return row + + +def extend(basis, row): + row = primitive(reduce_row(row, basis)) + if not any(row): + return basis + p = next(i for i, x in enumerate(row) if x) + out = [] + for b in basis: + if b[p]: + b = primitive(tuple(x * row[p] - y * b[p] for x, y in zip(b, row))) + out.append(b) + out.append(row) + return tuple(sorted(out, key=lambda b: next(i for i, x in enumerate(b) if x))) + + +def rotation(r): + return tuple(z for k in range(0, 8, 2) for z in (-r[k + 1], r[k])) + + +def geometry(): + roots = [] + for i, j in itertools.combinations(range(8), 2): + for a, b in itertools.product((-2, 2), repeat=2): + r = [0] * 8 + r[i], r[j] = a, b + roots.append(tuple(r)) + roots += [r for r in itertools.product((-1, 1), repeat=8) if sum(x < 0 for x in r) % 2 == 0] + lines = sorted({min(r, rotation(r), tuple(-x for x in r), tuple(-x for x in rotation(r))) for r in roots}) + require(len(set(roots)) == 240 and len(lines) == 60, 'incorrect root/line census') + root_set = set(roots) + require(all(rotation(r) in root_set for r in roots), 'J does not preserve roots') + require(all(rotation(rotation(r)) == tuple(-x for x in r) for r in roots), 'J squared is not -I') + for r in lines: + basis = extend(extend((), r), rotation(r)) + require(len(basis) == 2, 'line is not two-dimensional over Q') + require(sum(not any(reduce_row(s, basis)) for s in roots) == 4, 'Gaussian line has unexpected roots') + require(sum(not any(reduce_row(s, basis)) for s in lines) == 1, 'duplicate Gaussian line') + adj = [] + for i, r in enumerate(lines): + adj.append(sum(1 << j for j, s in enumerate(lines) if i != j and + (sum(x*y for x, y in zip(r, s)) or sum(x*y for x, y in zip(r, rotation(s)))))) + return lines, adj + + +def clique_census(adj): + maximum, cliques, nodes = 12, [], 0 + def visit(r, p, x): + nonlocal maximum, cliques, nodes + nodes += 1 + if r.bit_count() + p.bit_count() < maximum: + return + if not p and not x: + n = r.bit_count() + if n > maximum: + maximum, cliques = n, [] + if n == maximum: + cliques.append(r) + return + union = p | x + candidates = [] + while union: + bit = union & -union + candidates.append(bit.bit_length()-1) + union ^= bit + pivot = max(candidates, key=lambda u: (p & adj[u]).bit_count()) + todo = p & ~adj[pivot] + while todo: + bit = todo & -todo + v = bit.bit_length()-1 + visit(r | bit, p & adj[v], x & adj[v]) + p ^= bit + x |= bit + todo ^= bit + visit(0, (1 << len(adj))-1, 0) + return maximum, sorted(cliques), nodes + + +def flat_census(lines): + n = len(lines) + first = {} + for i, r in enumerate(lines): + b = extend(extend((), r), rotation(r)) + first[1 << i] = b + levels = [{0: ()}, first] + for rank in (2, 3): + new = {} + seen_bases = set() + for mask, basis in levels[-1].items(): + for i, r in enumerate(lines): + if mask >> i & 1: + continue + b = extend(extend(basis, r), rotation(r)) + if b in seen_bases: + continue + seen_bases.add(b) + closure = sum(1 << j for j, s in enumerate(lines) if not any(reduce_row(s, b))) + new[closure] = b + levels.append(new) + require(all(len(b)==2*rank for b in new.values()), 'incorrect flat dimension') + full = () + for r in lines: + full = extend(extend(full, r), rotation(r)) + levels.append({(1 << n)-1: full}) + return [(rank, mask, basis) for rank, lev in enumerate(levels) for mask, basis in sorted(lev.items())] + + +def perpendicular_vector(basis): + pivots = [next(i for i, x in enumerate(b) if x) for b in basis] + free = next(i for i in range(8) if i not in pivots) + row = [Fraction(0) for _ in range(8)] + row[free] = Fraction(1) + for p, b in zip(pivots, basis): + row[p] = -Fraction(b[free], b[p]) + denominator = math.lcm(*(x.denominator for x in row)) + return primitive(tuple(int(x * denominator) for x in row)) + + +def inner(a, b): + return (sum(x*y for x,y in zip(a,b)), sum(x*y for x,y in zip(a,rotation(b)))) + + +def cmul(a,b): + return (a[0]*b[0]-a[1]*b[1], a[0]*b[1]+a[1]*b[0]) + + +def pair_census(lines, cliques, flats): + enriched = [] + for rank, mask, basis in flats: + generators, b = [], () + for i,r in enumerate(lines): + if mask >> i & 1 and any(reduce_row(r,b)): + generators.append(i) + b=extend(extend(b,r),rotation(r)) + if len(generators)==rank: + break + if b != basis or len(b)!=2*rank: + raise ValueError('flat generators inconsistent') + hits = sum(1<b[0]: + a,b=b,a + ra,ma,ba,ga,ha,na=a + rb,mb,bb,gb,hb,nb=b + if not ra or rb==4: + return ra + if ra==1: + return int(any(gram[ga[0]][j]!=(0,0) for j in gb)) + if ra==2 and rb==2: + p,q=ga + r,s=gb + x,y,z,w=gram[p][r],gram[p][s],gram[q][r],gram[q][s] + if cmul(x,w)!=cmul(y,z): + return 2 + return int(any(v!=(0,0) for v in (x,y,z,w))) + if ra==2 and rb==3: + # q(F,H)=dim(F)-dim(F intersect H-perp). H-perp is the + # Gaussian line generated by nb, so the intersection is 0 or 1. + return 2 if any(reduce_row(nb,ba)) else 1 + if ra==3 and rb==3: + # The one-dimensional H-perp lies in F iff their normals + # are Hermitian-orthogonal. Then the rank drops from 3 to 2. + return 3 if inner(na,nb)!=(0,0) else 2 + raise ValueError('unhandled rank pair') + counts, maxima, witnesses, tight = Counter(), {}, {}, Counter() + digest=hashlib.sha256() + for i,a in enumerate(enriched): + for j in range(i,len(enriched)): + b=enriched[j] + q=pairing(a,b) + h=(a[4]&b[4]).bit_count() + counts[q]+=1 + digest.update(f'{i},{j},{q},{h}\n'.encode()) + if q not in maxima or h>maxima[q]: + maxima[q]=h + witnesses[q]=[i,j] + if h==192*q: + tight[q]+=1 + require(h<=192*q, f'COPY inequality fails at flats {i},{j}: {h} > 192*{q}') + result=dict(pair_count=sum(counts.values()),pair_rank_counts=dict(counts),maximum_hits=maxima, + witnesses={q:[flats[i][1],flats[j][1]] for q,(i,j) in witnesses.items()}, + tight_counts=dict(tight),pair_digest=digest.hexdigest()) + return result,enriched,pairing + + +def validate_clique(mask, adj): + require(mask>0 and mask < (1<>i&1: + require(not (mask & ~(adj[i] | (1<=0 and row < (1<>i&1, 'decoder diagonal not one') + require(not row&adj[i], 'decoder has forbidden nonorthogonal entry') + + +def method_ceiling(lines,adj,cliques,enriched,pairing): + allmask=(1<>j&1] + require(len(orthpairs)==450,'incorrect orthogonal-pair census') + for i,j in orthpairs: + a,b=lookup[hypers[i]],lookup[hypers[j]] + require(pairing(a,b)==2,'hyperplane witness has wrong pairing rank') + require((a[4]&b[4]).bit_count()==384,'hyperplane witness has wrong incidence') + for c in cliques: + require(all(bool(c&hypers[i]) == (not bool(c>>i&1)) for i in range(60)), 'maximal-clique hyperplane identity fails') + require(sum(bool(c&hypers[i]) and bool(c&hypers[j]) for i,j in orthpairs)==270,'method ceiling incidence fails') + return dict(orthogonal_pairs=450,hyperplane_pair_rank=2,hits_per_pair=384, + witness_pairs_hit_per_maximum_clique=270,method_ceiling=40), orthpairs, hypers + + +def controls(lines,adj,cliques,flats,enriched,pairing,orthpairs,hypers): + passed=[] + def rejects(name, function): + try: + function() + except ValueError: + passed.append(name) + else: + raise ValueError('negative control accepted: '+name) + i,j=orthpairs[0] + rejects('orthogonal_pair_called_clique',lambda:validate_clique((1<