From 72bfdf66d9823244ee8dab4c8898af834e34853b Mon Sep 17 00:00:00 2001 From: ToikY <27568617+ToikY@users.noreply.github.com> Date: Tue, 13 Oct 2026 12:35:59 -0700 Subject: [PATCH] research: certify sharp nine-coordinate five-subset shared nodes Add the complement-isometry lower bound, exact h9 residual bases, complete canonical frame census and independent labeled set census. Seed48 structural research; no new kappa or supplier claim. Prepared for ToikY with substantial OpenAI Codex assistance. --- .../CERTIFICATE.json | 123 ++++++++++ .../five-subset-shared-node-seed48/CLAIM.json | 40 +++ .../five-subset-shared-node-seed48/PROOF.md | 89 +++++++ .../five-subset-shared-node-seed48/README.md | 132 ++++++++++ .../SOURCES.json | 32 +++ .../VALIDATION.md | 53 ++++ .../independent.py | 174 +++++++++++++ .../five-subset-shared-node-seed48/verify.py | 228 ++++++++++++++++++ 8 files changed, 871 insertions(+) create mode 100644 research/five-subset-shared-node-seed48/CERTIFICATE.json create mode 100644 research/five-subset-shared-node-seed48/CLAIM.json create mode 100644 research/five-subset-shared-node-seed48/PROOF.md create mode 100644 research/five-subset-shared-node-seed48/README.md create mode 100644 research/five-subset-shared-node-seed48/SOURCES.json create mode 100644 research/five-subset-shared-node-seed48/VALIDATION.md create mode 100644 research/five-subset-shared-node-seed48/independent.py create mode 100644 research/five-subset-shared-node-seed48/verify.py diff --git a/research/five-subset-shared-node-seed48/CERTIFICATE.json b/research/five-subset-shared-node-seed48/CERTIFICATE.json new file mode 100644 index 0000000000..5286567bba --- /dev/null +++ b/research/five-subset-shared-node-seed48/CERTIFICATE.json @@ -0,0 +1,123 @@ +{ + "format": "five-subset-shared-node-seed48-v1", + "base_commit": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "seed": 48, + "new_kappa": false, + "sharp_ambient_threshold": 9, + "canonical_census": { + "8_source_intersection_3": { + "target_labels": 11, + "target_pairs_tested": 55, + "rectangles": 0, + "labeled_source_pairs": 840, + "target_intersection_histogram": {} + }, + "9_source_intersection_1": { + "target_labels": 32, + "target_pairs_tested": 496, + "rectangles": 288, + "labeled_source_pairs": 315, + "target_intersection_histogram": { + "3": 288 + }, + "dimension_four_frames_tested": 44640, + "legal_frame_count_histogram": { + "48": 288 + } + }, + "9_source_intersection_3": { + "target_labels": 30, + "target_pairs_tested": 435, + "rectangles": 96, + "labeled_source_pairs": 3780, + "target_intersection_histogram": { + "1": 24, + "3": 72 + }, + "dimension_four_frames_tested": 14880, + "legal_frame_count_histogram": { + "48": 96 + } + } + }, + "labeled_rectangles": { + "8": 0, + "9": 453600 + }, + "labeled_by_source_intersection": { + "8": { + "3": 0 + }, + "9": { + "1": 90720, + "3": 362880 + } + }, + "canonical_frame_records_sha256": "402c740ffe67383768de7439144e917fa4bf8d4ac6e7643be3ed415b13d84417", + "fixture": { + "h": 9, + "sources": [ + 31, + 481 + ], + "targets": [ + 47, + 87 + ], + "kernel": [ + [ + 1, + 1 + ], + [ + -1, + -1 + ] + ], + "frame_basis": [ + 31, + 481, + 3, + 40 + ], + "frame_characteristic": 40, + "complement_characteristic": 471, + "incoming_residual_bases": [ + [ + 52, + 457, + 458 + ], + [ + 28, + 55, + 482 + ] + ], + "outgoing_residual_bases": [ + [ + 59, + 67, + 131, + 259 + ], + [ + 131, + 279, + 367, + 379 + ] + ], + "incident_residual_dimensions": [ + 3, + 3, + 4, + 4 + ] + }, + "controls": { + "semantic_controls": 6, + "isometry_vector_pairs": 65536, + "five_subset_kernel_pairs": 3136 + } +} diff --git a/research/five-subset-shared-node-seed48/CLAIM.json b/research/five-subset-shared-node-seed48/CLAIM.json new file mode 100644 index 0000000000..3caea4b412 --- /dev/null +++ b/research/five-subset-shared-node-seed48/CLAIM.json @@ -0,0 +1,40 @@ +{ + "track": "structural decoder research", + "seed": 48, + "randomness": "One fresh Python secrets.randbelow(100) draw, operating-system randomness", + "base_commit": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "started_utc": "2026-10-13 19:15:16 UTC", + "claimed_utc": "2026-10-13 19:20:01 UTC", + "expected_finish_utc": "2026-10-13 19:45:16 UTC", + "verification_reserve_utc": "2026-10-13 19:37:46 UTC", + "coordination": "No pinned sprint coordination issue found: open non-PR issues 650 and 913. Claim recorded locally.", + "candidates": [ + "Five-subset norm-one labels: change the local shared-node geometry and test a nine-coordinate threshold", + "Bit E8 decoder beyond 25 punctures: deferred due adjacent PR1084/1020 and potentially larger classification work", + "P104 delivery-stage mixing: deferred due recent PR1125's comprehensive fixed-term carrier bound and expensive full invoice" + ], + "object": "One two-source/two-target shared node, five-subset labels, both endpoint pairs degenerate, signed rank-one kernel, disjoint binary spans and historical orthonormal-residual frame interface", + "method": "Prove impossibility below nine via the general frame floor and the eight-coordinate complement isometry to triples; exhaust canonical source intersections 1 and 3 at h=9, test every legal dimension-four completion and give explicit residual bases", + "domain": "Canonical h=8/9 five-subset rectangles; all quotient two-subspaces for h=9 dimension-four frames, plus an independent labeled rectangle census", + "stopping_rule": "Complete this fixed local class and certificate; do not construct or price a global decoder", + "optimistic_budget": "The mechanism changes only local geometry. No paid saving is claimed; even zero-cost local sharing leaves global label coverage, source access, helper lifecycle, copies, restoration, transfers, recursive children, hosting and analytic obligations unresolved.", + "overlap": "PR920 supplies the general norm-one floor and old fixtures. PR1139 proves the triple-only ten-coordinate theorem; this tests a different odd-weight label alphabet. PR968/1077/1084/1125 concern punctured E8 pairing or delivery classes, not this local five-subset frame geometry. Refreshed open PRs through1154; targeted quintuple/five-subset/shared searches found no matching scope.", + "expected_deliverable": "One structural research note with a sharp scoped threshold, exact finite census, witness and semantic controls; no new kappa", + "attribution": "Prepared for ToikY with substantial OpenAI Codex assistance. Credit ArnavSwiggy PR920, woklerx PR1139, Douglas Colkitt historical parity decoder and prior frame-completion work. Apache-2.0.", + "result": { + "status": "completed structural research note", + "threshold": 9, + "labeled_rectangles_h9": 453600, + "canonical_frames_tested": 59520, + "residual_dimensions": [ + 3, + 3, + 4, + 4 + ], + "new_kappa": false, + "completed_utc": "2026-10-13 19:35:00 UTC", + "link": "https://github.com/ToikY/integer-mult-bounds/tree/codex/decoder-seed48/research/five-subset-shared-node-seed48", + "overlap_refresh": "Open PRs refreshed through1171; PR1139 unchanged at82da1e827c51d94691134c6aec346357d89622bc; distinct constant-weight-five class." + } +} diff --git a/research/five-subset-shared-node-seed48/PROOF.md b/research/five-subset-shared-node-seed48/PROOF.md new file mode 100644 index 0000000000..95b63ee885 --- /dev/null +++ b/research/five-subset-shared-node-seed48/PROOF.md @@ -0,0 +1,89 @@ +# Sharp threshold in the weight-five class + +Use the class defined in README.md, over the standard binary dot product. +The proof combines PR920's residual dimension floor with PR1139's triple +support classification. The eight-coordinate complement step and the +nine-coordinate weight-five fixture are this package's additions. + +## The four-plus-four floor + +For any nondegenerate binary space W, its characteristic w_W uniquely satisfies +w_W dot x = x dot x for all x in W. A norm-one vector s splits W as its line +orthogonally summed with the nondegenerate residual W intersect s-perp. +That residual is alternating exactly when w_W=s: its characteristic vanishes +exactly when the characteristic of W lies in the line spanned by s. +This is the historical criterion used in PR920. + +Distinct norm-one sources with s1 dot s2=1 span a degenerate plane E with +radical r=s1+s2. A nondegenerate U containing E cannot have dimension two. +If dim U=3, then E=r-perp inside U. Since r has norm zero, w_U lies in E. +Pairing w_U with both sources must give one; the only two possibilities +inside E are s1 and s2. At least one incoming residual is therefore an +alternating plane and has no orthonormal basis. Hence dim U>=4. Apply the +same argument to the targets inside U-perp to obtain dim U-perp>=4. +Thus h>=8 for every legal doubly degenerate norm-one rectangle. + +## Eight-coordinate complements preserve the interface + +In F2^8 let w be the all-ones vector and define J(x)=x+(x dot w)w. +The map is linear, w dot w=0, and J is its own inverse. Expanding the two +cross terms shows J(x) dot J(y)=x dot y. It is therefore an isometry and +preserves every containment, orthogonal complement, nondegeneracy and +orthonormal basis condition in the local interface. It also preserves +disjointness of E and T, since it is an invertible linear map. + +Every weight-five label has odd parity, so J sends it to its three-element +complement. For two weight-five supports with intersection size k, +their complements intersect in k-2. Consequently +K(J(s),J(t))=-K(s,t); the entire 2x2 matrix changes by one common sign and +rank one is preserved. Degenerate pairs remain degenerate. A legal weight-five +rectangle at h=8 would therefore give a legal triple rectangle there. + +## Why a doubly degenerate triple rectangle needs ten coordinates + +The following is PR1139's small support classification, included to make the +dependency inspectable without importing pending code. Write source triples +as {c,a,b} and {c,d,e}, and let O be the other coordinates. Every triple +even-orthogonal to both sources has one of four forms: + +| Type | Support | Signed kernel column | +| --- | --- | --- | +| A | three elements of O | (+1,+1) | +| B | {a,b,o}, o in O | (-1,+1) | +| C | {d,e,o}, o in O | (+1,-1) | +| D | {c,x,y}, x in {a,b}, y in {d,e} | (-1,-1) | + +If c is present, parity forces one element from each displayed pair. If c +is absent, each pair contributes zero or two elements. This proves the list +complete. Rank one groups the two targets into A/D or B/C. A/D targets are +disjoint, and two distinct B or two distinct C targets intersect twice, +so those pairs are not degenerate. Two D targets intersect once only when +their x and y both differ; their sum is the nonzero source radical +{a,b,d,e}. Likewise a B/C pair intersects once only with a common o, and +then has the same sum. These possibilities violate E intersect T={0}. +Only A/A remains, requiring five coordinates outside the five source +coordinates. Thus h>=10. In particular no such triple rectangle exists +at h=8, even before checking incident residuals. + +The isometry excludes weight-five rectangles at h=8. The general floor +excludes h<8. Together these prove the lower bound h>=9 in our local class. + +## Nine coordinates attain the bound + +Take sources (31,481), targets (47,87), and U=span(31,481,3,40) in F2^9, +with the masks defined in README.md. The endpoint intersections are one and +three, every cross intersection is even, and the kernel is +[[1,1],[-1,-1]]. Direct span inspection gives E intersect T={0}. +U is nondegenerate, contains E, and is orthogonal to T. The four explicit +residual bases in README.md each span their full residual and have identity +Gram matrix. These exact finite vector identities certify this witness; +both implementations check them. Therefore the minimum ambient dimension +for this weight-five class is exactly nine. + +For h>9 embed these supports and U by zero extension. The complement becomes +the old U-perp orthogonally summed with standard coordinate lines; each +outgoing residual gains those same orthonormal lines. Thus existence holds +for every h>=9. This proves a threshold, not a classification or count of +all weight-five rectangles in larger dimensions. The h=9 exhaustive census +is separate finite evidence. No complete supplier, global simultaneous +frame assignment, cost recurrence or new multiplication exponent follows. diff --git a/research/five-subset-shared-node-seed48/README.md b/research/five-subset-shared-node-seed48/README.md new file mode 100644 index 0000000000..eb62066005 --- /dev/null +++ b/research/five-subset-shared-node-seed48/README.md @@ -0,0 +1,132 @@ +# Five-subset shared nodes: sharp nine-coordinate threshold + +**Structural geometry research note; no new kappa or paid supplier.** In the +historical orthonormal-residual interface, a doubly degenerate two-source, +two-target shared node with constant-weight-five labels first exists at +ambient dimension **nine**. This changes the label alphabet in the triple-only +ten-coordinate classification of [woklerx's PR1139](https://github.com/CrocSwap/integer-mult-bounds/pull/1139). +It does not lower the eight-coordinate floor for unrestricted norm-one labels +already attained in [ArnavSwiggy's PR920](https://github.com/CrocSwap/integer-mult-bounds/pull/920). + +From the repository root, Python 3.9 or later, standard library only: + +```sh +python3 -I -B research/five-subset-shared-node-seed48/verify.py +python3 -I -B research/five-subset-shared-node-seed48/independent.py +``` + +The first command prints +`PASS_FIVE_SUBSET_SHARED_NODE threshold=9 rectangles_h9=453600 canonical_frames=59520 residual_bases=4 no_new_kappa`. +The second independently exhausts all labeled rectangles at h=8,9 and checks +the four residual bases using coordinate sets. Its final lines are +`PASS_INDEPENDENT_FIVE_SUBSET_RECTANGLES h8=0 h9=453600` and +`PASS_INDEPENDENT_RESIDUAL_BASES dimensions=3,3,4,4`. +Both commands are offline, read-only and retain checks under optimized Python. +The optional `verify.py --write-certificate` regenerates only this package's +certificate. See [VALIDATION.md](VALIDATION.md) for completed checks. + +## Precise local class + +Labels are incidence vectors of five-subsets of a labeled h-coordinate ground +set, in the standard dot-product space F2^h. Each side is an unordered pair +of distinct labels; source and target sides are distinguished. Require: + +1. Both endpoint spans E=span(s1,s2) and T=span(t1,t2) are degenerate, so + both pair intersections have odd size (one or three). +2. Every cross dot product is zero, and the 2x2 signed scalar matrix + K(s,t)=Re(i^|s intersection t|) has rank one over Q. +3. E intersects T only in zero. +4. A nondegenerate U satisfies E subset U subset T-perp, and all four + incident residuals U intersect si-perp and U-perp intersect tj-perp + have orthonormal bases. + +The historical side kernel has a common factor 1/2, irrelevant to its rank. +The label lines and target hyperplanes are fixed; no copied carriers, phases, +multiple shared nodes or relaxed residual contract enter this class. +The lower bound is proved in [PROOF.md](PROOF.md), independently of enumeration. + +## Exact nine-coordinate witness + +Masks use zero-based coordinates, with bit i representing coordinate i: + +```text +sources = (31,481) = ({0,1,2,3,4}, {0,5,6,7,8}) +targets = (47,87) = ({0,1,2,3,5}, {0,1,2,4,6}) +K = [[1,1],[-1,-1]] +U = span(31,481,3,40), dimension 4 +w_U = 40, w_(U-perp) = 471 +``` + +U and U-perp have orthonormal bases `(28,55,481,482)` and +`(47,59,67,131,259)`, respectively. The exact incident residual bases are: + +| Endpoint | Orthonormal basis | Dimension | +| --- | --- | ---: | +| Source 31 | 52,457,458 | 3 | +| Source 481 | 28,55,482 | 3 | +| Target 47 | 59,67,131,259 | 4 | +| Target 87 | 131,279,367,379 | 4 | + +Both implementations compare each basis's complete generated vector set with +the actual residual and check every Gram-matrix entry. These dimensions are +local geometry, not a paid recursive profile. + +## Completed finite coverage + +Coordinate permutations reduce source pairs to intersection sizes one and +three. At h=8 only intersection three is possible. At h=9, every valid +rectangle has a dimension-four frame, and each has exactly **48** such legal +frames. The complete canonical frame census tests all 155 two-dimensional +subspaces of T-perp/E for every rectangle: **59,520** candidates total. + +| h | Source intersection | Compatible target labels | Canonical valid rectangles | Labeled source pairs | Labeled rectangles | +| ---: | ---: | ---: | ---: | ---: | ---: | +| 8 | 3 | 11 | 0 | 840 | 0 | +| 9 | 1 | 32 | 288 | 315 | 90,720 | +| 9 | 3 | 30 | 96 | 3,780 | 362,880 | + +The independent implementation visits every labeled source pair and every +cross-compatible target pair, using set intersections, literal integer kernel +values, determinants and explicit nonzero spans. It imports no primary code +and uses no symmetry multiplier. It also checks source/target swap symmetry. +At h=8 all 4,200 degenerate signed-rank-one candidates fail common-span +disjointness. At h=9 there are 511,560 such candidates, of which 57,960 fail +that condition. The survivors total **453,600**. + +The seed is **48**, one fresh OS-random draw. It selects structural decoder +research and the odd-weight-five extension, rather than another triple or +current-frontier search. The fixed domain, three candidate tasks, scope, +stopping rule and local claim are in [CLAIM.json](CLAIM.json). This is complete +finite coverage at h=8,9, not an all-dimension census or a formal proof of the +full multiplication theorem. + +## Cost decision, scope and attribution + +This mechanism changes copied-information geometry by changing the label +alphabet. No complete cost improvement follows. Even setting local operations +optimistically to zero leaves global label coverage, source access, scalar +gates, helper stock, frame changes, copies, compensation, restoration, recursive +children, whole-call hosting, precision/tape and analytic transfer obligations +unresolved. No global decoder is implemented or fed to assembly. The experiment +stops after the sharp local threshold, witness and exact census; it does not +reopen the rejected fixed h=26 parity-DAG repair with more computation. + +Exact base: **ce7ad1b6ab09452c3478723a2e96ed5ff212dc08**. The reviewed selected +result at this base is PR1094 with conditional +kappa=836330098538459/500000000000000000. Its manifest, actual rare-pattern +construction, assembly certificate and maintainer review were followed. +Neither the selected frontier nor upstream/ is changed. [SOURCES.json](SOURCES.json) +records exact source commits and hashes, including pending PR1139's proof. +Our lower-bound proof restates the small triple classification with attribution, +so reproducing the new certificate requires no pending code or network access. + +Credit Douglas Colkitt's historical parity-side kernel and frame obstruction; +ArnavSwiggy's PR920 for the residual criterion, four-plus-four floor and general +norm-one fixtures; woklerx's PR1139 for the triple support classification; and +the seed47 frame-completion note for the distinction between separating frames +and legal incident transfers. No predecessor implementation is imported. + +Prepared for GitHub contributor **ToikY**, with substantial **OpenAI Codex** +assistance in mathematics, implementation, algorithmically independent checks, +review and writing. This is not independent human peer review. New files are +under Apache-2.0, matching the repository. diff --git a/research/five-subset-shared-node-seed48/SOURCES.json b/research/five-subset-shared-node-seed48/SOURCES.json new file mode 100644 index 0000000000..13ef761f0e --- /dev/null +++ b/research/five-subset-shared-node-seed48/SOURCES.json @@ -0,0 +1,32 @@ +{ + "base_commit": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "selected_kappa": "836330098538459/500000000000000000", + "selected_reproduce": "make frontier1094-verify", + "repository_sources_sha256": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/community-frontier1094-audit/SELECTED-SOURCE.json": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "docs/research/community-batch1099-review.md": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "research/complex-t16-rare-pattern-exchanges/README.md": "da542711a6a3eb01ce1ebdf8f28a748e6195512687f61d003b95ac5ff281a7b2", + "research/gauge44-slots-t16/hosting/PROOF.md": "45bb3de8a10298a4cf5a278c3343be22a7d2e735be93a4e9454f24df7275faf0", + "docs/research/parity-side.md": "75de20f8dcd3d1a2e2d19bc087eda50a6cc77027651f48198868426a80cd12f2", + "research/complex-parity-frames-seed35/README.md": "b7d8c49293d770c0c3037fcd5eda36881adb7042c46c0d87dfbe47d9610d104c", + "research/frame-completion-seed47/README.md": "b24cf3ed7cf5b651f4c2c463e10918dc4d1a2323bf268bcd35fbcbb0f79d9253" + }, + "pending_predecessor": { + "pr": 1139, + "author": "woklerx", + "head": "82da1e827c51d94691134c6aec346357d89622bc", + "proof_url": "https://github.com/woklerx/integer-mult-bounds/blob/82da1e827c51d94691134c6aec346357d89622bc/research/triple-shared-frame-threshold46/PROOF.md", + "use": "Triple support classification restated with credit in PROOF.md. No code imports or runtime dependency." + }, + "incorporated_predecessor": { + "pr": 920, + "author": "ArnavSwiggy", + "head": "913817423bbfaf241dec1d6b9edb1c7ded349508", + "use": "Characteristic residual criterion and four-plus-four norm-one floor; existing general-label h8 and triple h10 fixtures credited." + }, + "license": "Apache-2.0", + "attribution": "Prepared for ToikY with substantial OpenAI Codex assistance. Douglas Colkitt historical parity-side kernel and frame obstruction; ArnavSwiggy PR920; woklerx PR1139; ToikY seed47 frame-completion note.", + "imports": "No predecessor implementation is imported; all checks use Python standard library." +} diff --git a/research/five-subset-shared-node-seed48/VALIDATION.md b/research/five-subset-shared-node-seed48/VALIDATION.md new file mode 100644 index 0000000000..43845734df --- /dev/null +++ b/research/five-subset-shared-node-seed48/VALIDATION.md @@ -0,0 +1,53 @@ +# Validation receipt + +Base ce7ad1b6ab09452c3478723a2e96ed5ff212dc08; seed48; macOS arm64, +Python 3.9.6, standard library only. Completed on October 13, 2026. + +```sh +python3 -I -B research/five-subset-shared-node-seed48/verify.py +python3 -I -B research/five-subset-shared-node-seed48/independent.py +python3 -I -O -B research/five-subset-shared-node-seed48/verify.py +python3 -I -O -B research/five-subset-shared-node-seed48/independent.py +make selected-record-check +git diff --cached --check +``` + +All passed. Primary output: threshold=9, 453600 labeled h9 rectangles, +59520 canonical frame candidates, four residual bases. Independent output: +h8=0, h9=453600, residual dimensions=3,3,4,4. The selected-record guard +retains conditional kappa=836330098538459/500000000000000000. + +The primary has six semantic controls: an alternating incoming residual, +a corrupted residual vector, a cross-incompatible endpoint, a signed-rank-two +rectangle despite cross orthogonality and two degenerate pairs, a nonzero +common-span intersection, and a degenerate proposed source frame. It also +checks all 65536 vector pairs for the h8 complement map's linear isometry, +and all 3136 five-subset kernel pairs for its common negative sign. + +Additional checks copied the package to a temporary directory and ran both +programs with isolated optimized Python successfully. Changing the recorded +h9 total by one then caused both programs to exit nonzero. Independently +changing the first incoming residual vector from 52 to 53 caused both to +exit nonzero. Deleting one incoming residual basis causes the independent +checker to reject the endpoint/basis count. These controls changed disposable +copies only. Both default commands compare the committed certificate without +rewriting it. Regeneration is explicit and package-local. + +A separate read-only review confirmed the written h8 isometry lower bound, +all h9 witness residuals, quotient-plane completeness and the characteristic +test. That review identified the missing-basis `zip` failure mode; an explicit +two-bases-per-side check was added and its rejection verified. This is AI +assisted algorithmic review, not independent human peer review. + +Every repository source hash in SOURCES.json was checked against the exact +base. Pending PR1139 was refreshed at unchanged head +82da1e827c51d94691134c6aec346357d89622bc. The open PR queue was refreshed +through PR1171; no matching weight-five shared-node package was found. +The contribution adds a distinct label class and threshold, crediting PR920 +and PR1139 rather than presenting their fixtures or classification as new. + +No root generator, selected source, upstream file, Makefile or workflow is +modified. The expensive repository-wide `make verify` and selected cold +supplier replay were not repeated for this isolated historical-geometry +research package. No hosted CI success or full multiplication theorem +certification is claimed. diff --git a/research/five-subset-shared-node-seed48/independent.py b/research/five-subset-shared-node-seed48/independent.py new file mode 100644 index 0000000000..c45e5d2ba5 --- /dev/null +++ b/research/five-subset-shared-node-seed48/independent.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Independent exhaustive set census for the seed-48 five-subset class. + +Copyright 2026 Eva Ayala. SPDX-License-Identifier: Apache-2.0. +Written with substantial OpenAI Codex assistance. + +This implementation uses coordinate sets, literal real parts of powers of i, +integer 2-by-2 determinants, and explicit nonzero binary-span nodes. It does +not import the primary verifier or use its bit-mask or canonical-frame code. +Source and target sides are distinguished; each side is an unordered pair of +five-element subsets of a labeled h-element coordinate set. The complete +finite domain is h in {8, 9}; this is not a theorem about other dimensions or +other decoder classes. +""" + +import argparse +from collections import Counter, defaultdict +from itertools import combinations +import json +from pathlib import Path + + +def kernel(intersection_size): + """The integer real part of i**intersection_size, without complex floats.""" + return (1, 0, -1, 0)[intersection_size % 4] + + +def census(dimension): + subsets = tuple(frozenset(coords) for coords in combinations(range(dimension), 5)) + # Every cached value is computed directly from coordinate-set intersection. + overlap = tuple(tuple(len(left & right) for right in subsets) for left in subsets) + odd_pairs = tuple( + (i, j, overlap[i][j]) + for i, j in combinations(range(len(subsets)), 2) + if overlap[i][j] % 2 == 1 + ) + spans = { + (i, j): frozenset((subsets[i], subsets[j], subsets[i] ^ subsets[j])) + for i, j, _ in odd_pairs + } + by_source = Counter({str(size): 0 for _, _, size in odd_pairs}) + by_target = Counter({str(size): 0 for _, _, size in odd_pairs}) + by_pair = Counter() + by_cross_overlap = Counter() + by_common_core_overlap = Counter() + source_degrees = defaultdict(Counter) + rank_zero_before_span_check = 0 + rejected_span_overlap = 0 + + for i, j, source_size in odd_pairs: + # This only discards targets that already violate a required cross-even + # condition. Every permissible target pair remains in this list. + compatible = tuple( + k for k in range(len(subsets)) + if overlap[i][k] % 2 == 0 and overlap[j][k] % 2 == 0 + ) + source_span = spans[i, j] + source_core = subsets[i] & subsets[j] + degree = 0 + for k, l in combinations(compatible, 2): + target_size = overlap[k][l] + if target_size % 2 == 0: + continue + crossing = (overlap[i][k], overlap[i][l], overlap[j][k], overlap[j][l]) + matrix = ((kernel(crossing[0]), kernel(crossing[1])), + (kernel(crossing[2]), kernel(crossing[3]))) + if matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0] != 0: + continue + rank_zero_before_span_check += 1 + # Zero is omitted from both spans, so this tests E intersect T = {0} + # directly, without replacing it with a specialized parity shortcut. + if source_span & spans[k, l]: + rejected_span_overlap += 1 + continue + degree += 1 + by_source[str(source_size)] += 1 + by_target[str(target_size)] += 1 + by_pair['{},{}'.format(source_size, target_size)] += 1 + by_cross_overlap[','.join(map(str, sorted(crossing)))] += 1 + by_common_core_overlap[str(len(source_core & (subsets[k] & subsets[l])))] += 1 + source_degrees[str(source_size)][str(degree)] += 1 + + # Reversing the two distinguished sides is a bijection of this same domain. + # Check the stronger pair-stratified symmetry, not only the total count. + if by_source != by_target: + raise ValueError('source/target intersection totals are asymmetric') + for pair, count in by_pair.items(): + source_size, target_size = pair.split(',') + if by_pair['{},{}'.format(target_size, source_size)] != count: + raise ValueError('source/target swap fails for intersection stratum ' + pair) + + return { + 'total': sum(by_source.values()), + 'five_subsets': len(subsets), + 'odd_source_pairs': len(odd_pairs), + 'by_source_intersection': dict(sorted(by_source.items())), + 'by_target_intersection': dict(sorted(by_target.items())), + 'by_intersection_pair': dict(sorted(by_pair.items())), + 'source_pair_target_degree_histograms': { + size: dict(sorted(histogram.items(), key=lambda item: int(item[0]))) + for size, histogram in sorted(source_degrees.items()) + }, + 'by_sorted_cross_intersections': dict(sorted(by_cross_overlap.items())), + 'by_common_core_intersection': dict(sorted(by_common_core_overlap.items())), + 'rank_zero_before_span_check': rank_zero_before_span_check, + 'rejected_nonzero_span_overlap': rejected_span_overlap, + 'source_target_swap_checked': True, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--certificate', type=Path, + default=Path(__file__).with_name('CERTIFICATE.json')) + args = parser.parse_args() + certificate = json.loads(args.certificate.read_text(encoding='utf-8')) + results = {str(dimension): census(dimension) for dimension in (8, 9)} + totals = {dimension: result['total'] for dimension, result in results.items()} + by_source = { + dimension: result['by_source_intersection'] + for dimension, result in results.items() + } + if totals != certificate['labeled_rectangles']: + raise ValueError('labeled rectangle census disagrees with certificate: ' + repr(totals)) + if by_source != certificate['labeled_by_source_intersection']: + raise ValueError('source-intersection census disagrees with certificate: ' + repr(by_source)) + verify_fixture(certificate['fixture']) + print(json.dumps(results, indent=2, sort_keys=True)) + print('PASS_INDEPENDENT_FIVE_SUBSET_RECTANGLES h8={} h9={}'.format(totals['8'], totals['9'])) + print('PASS_INDEPENDENT_RESIDUAL_BASES dimensions=3,3,4,4') + + +def verify_fixture(fixture): + """Check every residual vector by coordinate sets, without Gaussian algebra.""" + h = fixture['h'] + if h != 9 or any(len(fixture[key]) != 2 for key in + ('sources', 'targets', 'incoming_residual_bases', 'outgoing_residual_bases')): + raise ValueError('fixture dimension or endpoint count') + def decode(mask): + if mask < 0 or mask >= 2 ** h: + raise ValueError('fixture coordinate outside ambient space') + return frozenset(i for i in range(h) if (mask // 2 ** i) % 2) + def orthogonal(x, y): + return len(x & y) % 2 == 0 + def generated(rows): + vectors = {frozenset()} + for row in rows: + vectors |= {v ^ row for v in vectors} + return vectors + sources = list(map(decode, fixture['sources'])) + targets = list(map(decode, fixture['targets'])) + U = generated(list(map(decode, fixture['frame_basis']))) + ambient = [frozenset(s) for size in range(h + 1) + for s in combinations(range(h), size)] + W = {v for v in ambient if all(orthogonal(v, u) for u in U)} + if len(U) != 16 or len(W) != 32 or U & W != {frozenset()}: + raise ValueError('fixture orthogonal decomposition') + if not all(s in U for s in sources) or not all(t in W for t in targets): + raise ValueError('fixture endpoint containment') + for space, labels, bases, dimensions in ( + (U, sources, fixture['incoming_residual_bases'], [3, 3]), + (W, targets, fixture['outgoing_residual_bases'], [4, 4])): + for label, masks, dimension in zip(labels, bases, dimensions): + rows = list(map(decode, masks)) + residual = {v for v in space if orthogonal(v, label)} + if len(rows) != dimension or generated(rows) != residual: + raise ValueError('fixture residual basis span') + if any((len(x & y) % 2) != int(i == j) + for i, x in enumerate(rows) for j, y in enumerate(rows)): + raise ValueError('fixture residual basis orthonormality') + + +if __name__ == '__main__': + main() diff --git a/research/five-subset-shared-node-seed48/verify.py b/research/five-subset-shared-node-seed48/verify.py new file mode 100644 index 0000000000..78e198c7b6 --- /dev/null +++ b/research/five-subset-shared-node-seed48/verify.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +"""Five-subset shared-node geometry. Apache-2.0; prepared for ToikY with Codex. +No predecessor implementation imports. Exact local class, not a supplier. +""" +from collections import Counter +import hashlib +from itertools import combinations +import json +from math import comb +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +BASE = 'ce7ad1b6ab09452c3478723a2e96ed5ff212dc08' + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def pc(x): + return bin(x).count('1') + + +def dot(x, y): + return pc(x & y) % 2 + + +def span(basis): + result = {0} + for b in basis: + result |= {x ^ b for x in result} + return result + + +def kernel(a, b): + return (1, 0, -1, 0)[pc(a & b) % 4] + + +def rectangle(a, b, c, d): + return (a != b and c != d and dot(a, b) == dot(c, d) == 1 + and all(dot(s, t) == 0 for s in (a, b) for t in (c, d)) + and kernel(a, c) * kernel(b, d) == kernel(a, d) * kernel(b, c) + and not ({a, b, a ^ b} & {c, d, c ^ d})) + + +def solve_characteristic(basis): + n = len(basis) + rows = [sum(dot(x, y) << j for j, y in enumerate(basis)) + | (dot(x, x) << n) for x in basis] + for j in range(n): + pivot = next((i for i in range(j, n) if rows[i] & (1 << j)), None) + if pivot is None: + return None + rows[j], rows[pivot] = rows[pivot], rows[j] + for i in range(n): + if i != j and rows[i] & (1 << j): + rows[i] ^= rows[j] + w = 0 + for j, x in enumerate(basis): + if rows[j] & (1 << n): + w ^= x + return w + + +def frame_candidates(h, a, b, c, d): + E = span([a, b]) + ambient = [v for v in range(1 << h) if not dot(v, c) and not dot(v, d)] + need(len(ambient) == 1 << (h - 2), 'target annihilator rank') + cosets = sorted({min(v ^ x for x in E) for v in ambient}) + quotient_planes = {} + for u, v in combinations(cosets[1:], 2): + key = tuple(sorted((u, v, min((u ^ v) ^ x for x in E)))) + quotient_planes.setdefault(key, (u, v)) + need(len(quotient_planes) == ((1 << (h - 4)) - 1) * ((1 << (h - 4)) - 2) // 6, + 'complete quotient two-subspace count') + for key in sorted(quotient_planes): + u, v = quotient_planes[key] + yield [a, b, u, v] + + +def inspect_frames(h, a, b, c, d): + total, nondegenerate, legal = 0, 0, 0 + first = None + for basis in frame_candidates(h, a, b, c, d): + total += 1 + w = solve_characteristic(basis) + if w is None: + continue + nondegenerate += 1 + # The ambient characteristic is all ones. Orthogonal splitting gives + # w_(U-perp) = all_ones XOR w_U, avoiding a second elimination engine. + if w not in (a, b) and (((1 << h) - 1) ^ w) not in (c, d): + legal += 1 + if first is None: + first = basis + return total, nondegenerate, legal, first + + +def check_basis(basis, space): + need(span(basis) == space, 'residual basis span') + need(all(dot(x, y) == int(i == j) + for i, x in enumerate(basis) for j, y in enumerate(basis)), + 'residual basis orthonormality') + + +def fixture_check(): + h, sources, targets, basis = 9, [31, 481], [47, 87], [31, 481, 3, 40] + need(all(pc(x) == 5 for x in sources + targets), 'five-subset fixture') + need(rectangle(*sources, *targets), 'fixture rectangle conditions') + U = span(basis) + W = {x for x in range(1 << h) if all(dot(x, y) == 0 for y in basis)} + need(len(U) == 16 and len(W) == 32 and U & W == {0}, 'orthogonal decomposition') + need(solve_characteristic(basis) == 40, 'source characteristic') + need(all(dot(471, x) == dot(x, x) for x in W), 'target characteristic') + incoming = [[52, 457, 458], [28, 55, 482]] + outgoing = [[59, 67, 131, 259], [131, 279, 367, 379]] + for label, rows in zip(sources, incoming): + check_basis(rows, {x for x in U if not dot(x, label)}) + for label, rows in zip(targets, outgoing): + check_basis(rows, {x for x in W if not dot(x, label)}) + check_basis([28, 55, 481, 482], U) + check_basis([47, 59, 67, 131, 259], W) + return {'h': h, 'sources': sources, 'targets': targets, + 'kernel': [[kernel(s, t) for t in targets] for s in sources], + 'frame_basis': basis, 'frame_characteristic': 40, + 'complement_characteristic': 471, + 'incoming_residual_bases': incoming, 'outgoing_residual_bases': outgoing, + 'incident_residual_dimensions': [3, 3, 4, 4]} + + +def canonical_census(): + census, records = {}, [] + labeled, by_source = {}, {} + for h in (8, 9): + labels = [sum(1 << i for i in t) for t in combinations(range(h), 5)] + labeled[str(h)] = 0 + by_source[str(h)] = {} + for overlap in (1, 3): + if 10 - overlap > h: + continue + a = 31 + b = (1 << overlap) - 1 | sum(1 << i for i in range(5, 10 - overlap)) + targets = [t for t in labels if not dot(a, t) and not dot(b, t)] + good = [(c, d) for c, d in combinations(targets, 2) if rectangle(a, b, c, d)] + source_pairs = comb(h, 10 - overlap) * comb(10 - overlap, overlap) * comb(10 - 2 * overlap, 5 - overlap) // 2 + stats = {'target_labels': len(targets), 'target_pairs_tested': comb(len(targets), 2), + 'rectangles': len(good), 'labeled_source_pairs': source_pairs, + 'target_intersection_histogram': dict(sorted(Counter(str(pc(c & d)) for c, d in good).items()))} + if h == 9: + histogram = Counter() + tested = 0 + for c, d in good: + n, nondeg, legal, witness = inspect_frames(h, a, b, c, d) + tested += n + histogram[str(legal)] += 1 + need(legal > 0, 'rectangle lacks a dimension-four legal frame') + records.append([overlap, c, d, n, nondeg, legal, witness]) + stats['dimension_four_frames_tested'] = tested + stats['legal_frame_count_histogram'] = dict(sorted(histogram.items())) + census[str(h) + '_source_intersection_' + str(overlap)] = stats + count = source_pairs * len(good) + labeled[str(h)] += count + by_source[str(h)][str(overlap)] = count + need(labeled == {'8': 0, '9': 453600}, 'rectangle census total') + digest = hashlib.sha256(json.dumps(records, separators=(',', ':')).encode()).hexdigest() + return census, labeled, by_source, digest + + +def controls(): + def reject(fn, name): + try: + fn() + except ValueError: + return + raise ValueError('negative control accepted: ' + name) + # Legal separators can fail the stronger incident-residual contract. + U = span([25, 26, 4]) + bad_residual = {x for x in U if not dot(x, 7)} + need(len(bad_residual) == 4 and all(dot(x, x) == 0 for x in bad_residual), + 'PR920 alternating residual control') + reject(lambda: check_basis([3, 29], bad_residual), 'alternating residual') + reject(lambda: check_basis([52, 457, 459], {x for x in span([31, 481, 3, 40]) if not dot(x, 31)}), + 'corrupted residual vector') + reject(lambda: need(rectangle(31, 481, 47, 31), 'cross orthogonality'), 'wrong endpoint') + need(all(dot(s, t) == 0 for s in (31, 103) for t in (47, 155)) + and dot(31, 103) == dot(47, 155) == 1, 'rank control premises') + need(kernel(31, 47) * kernel(103, 155) != kernel(31, 155) * kernel(103, 47) + and not rectangle(31, 103, 47, 155), 'signed rank-two control') + need({31, 481, 31 ^ 481} & {47, 465, 47 ^ 465} + and not rectangle(31, 481, 47, 465), 'common-span control') + need(solve_characteristic([31, 481]) is None, 'degenerate source-span control') + # Exhaust the complement isometry independently on all 256 vectors. + w = 255 + J = lambda x: x ^ (w if dot(x, w) else 0) + for x in range(256): + need(J(J(x)) == x, 'complement involution') + for y in range(256): + need(J(x ^ y) == J(x) ^ J(y) and dot(J(x), J(y)) == dot(x, y), + 'complement linear isometry') + labels = [x for x in range(256) if pc(x) == 5] + for s in labels: + need(pc(J(s)) == 3, 'five to triple complement') + for t in labels: + need(kernel(J(s), J(t)) == -kernel(s, t), 'kernel complement sign') + return {'semantic_controls': 6, 'isometry_vector_pairs': 65536, 'five_subset_kernel_pairs': 3136} + + +def main(): + need(sys.argv[1:] in ([], ['--write-certificate']), 'arguments') + f = fixture_check() + census, labeled, by_source, digest = canonical_census() + result = {'format': 'five-subset-shared-node-seed48-v1', 'base_commit': BASE, + 'seed': 48, 'new_kappa': False, 'sharp_ambient_threshold': 9, + 'canonical_census': census, 'labeled_rectangles': labeled, + 'labeled_by_source_intersection': by_source, + 'canonical_frame_records_sha256': digest, 'fixture': f, 'controls': controls()} + target = HERE / 'CERTIFICATE.json' + if sys.argv[1:]: + target.write_text(json.dumps(result, indent=2) + '\n') + else: + need(json.loads(target.read_text()) == result, 'certificate mismatch') + print('PASS_FIVE_SUBSET_SHARED_NODE threshold=9 rectangles_h9=453600 canonical_frames=59520 residual_bases=4 no_new_kappa') + + +if __name__ == '__main__': + main()