diff --git a/research/u8-terminal-cone-census/CERTIFICATE.json.gz b/research/u8-terminal-cone-census/CERTIFICATE.json.gz new file mode 100644 index 0000000000..608ae8b1fd Binary files /dev/null and b/research/u8-terminal-cone-census/CERTIFICATE.json.gz differ diff --git a/research/u8-terminal-cone-census/COST.md b/research/u8-terminal-cone-census/COST.md new file mode 100644 index 0000000000..0608e72319 --- /dev/null +++ b/research/u8-terminal-cone-census/COST.md @@ -0,0 +1,85 @@ +# Complete optimistic recurrence and its limits + +Let `d_k` be the literal end-B dimension, `u0_k` the actual old terminal +dimension and `s_k` the entrance dimension. A proposed helper endpoint has +dimension `u_k`, contains its necessary cone, and has width `u_k-s_k`. +Retain all source/target endpoints, the eight ordered centers, A/B frame +assignments, nine calls and 896 live families per replica in ambient rank73. + +The exact old local histogram is +`{1:2548,2:338,3:446,4:162,5:72,8:8}`. Its decomposition is: + +| Bill | Rank histogram | Rank mass | +| --- | --- | ---: | +| Fixed prefix climbs and center descents | `{1:2048,2:288,3:368,4:160,5:16,8:8}` | 4512 | +| Actual old post-B suffix, all728 registers | `{1:500,2:50,3:78,4:2,5:56}` | 1122 | +| Favorable single jump to each old endpoint | `{1:328,2:80,3:86,4:10,6:56}` | 1122 | + +The first two sum to the full old profile of mass5634. The favorable +single-jump relaxation preserves mass, but can reduce its moment. It need +not admit any common-frame cleanup word. This note makes no numerical +exclusion from that relaxation. + +In particular, removing an assumed `H(9-d_k)` and adding `H(u_k-d_k)` is +unsafe as a general rejection test. Old endpoints need not be FULL, and +post-B climbs may be split across early cleanup. If other registers' suffix +climbs may change, retaining their entire old bills is also unsafe. Use the +actual old suffix or replace **all** 728 suffix bills by favorable one-jump +costs, including sources and targets. + +The fixed source/target/center mass is1856. The old helper widths are +`{4:80,5:32,7:54,8:122,9:216}`, of total3778. The capacity mass for idle +stock per replica is48384. For proposed widths set + +``` +D(u) = 48384 - 9 * sum_helpers(u_k-s_k) + = 14382 + 9 * sum_helpers(u0_k-u_k). +``` + +Require `D(u)>=0` for feasible whole-helper placement. Every idle child has +rank at most48. For `0=phi_z(a+b)`. With P_pre the fixed prefix +histogram, a complete **optimistic moment lower bound** is + +``` +L_z(u) = [9 * (sum_r P_pre(r)*phi_z(r) + + sum_all728 phi_z(u_k-d_k)) + + D(u)*phi_z(48)/48] / (73*896). +``` + +It includes every required suffix dimension and charges returned helper +mass as idle work. Ignoring bin integrality, shared-gate compatibility, +chronology and new finite scalar work enlarges the candidate class. A +certified minimum `L_z>=1` would exclude an improved complex endpoint beyond +z for this precise family; `L_z<1` is inconclusive. No such outward-rounded +numerical exclusion is asserted here. The endpoint census alone forces +every reductions-only helper proposal back to its old endpoint. + +For an actual program and T replicas, the exact recurrence must instead use +the freshly recounted local paid histogram L_new and **literal** idle +histogram I from a valid whole-helper owner map: + +``` +H(r) = 9*T*L_new(r) + I(r) +M = 896*T, W = 73 +sum_r r*I(r) = T*D(u) +M*W - sum_r r*H(r) = 320*T +``` + +The last identity follows from local mass `1856+sum_helpers(u_k-s_k)`; +width reduction does not erase the inherited rank deficit. The associated +weighted recurrence uses these children plus a separately charged finite +term. That term must recount compensation, scalar/Horner coefficient +access, frames, copies, wrappers, source restoration, routing, bridges, +shifts, moves, private stock, correction streams, precision, tape and rows. +Keep the bit supplier and its surcharge, analytic guards and seven-step +outer recipe. Zero extra finite work is allowed only in the relaxation, +never in a constructed invoice. + +A positive nomination therefore still needs a literal cleanup, both exact +arbitrary-dirt orientations, native phases and wrappers, changed residual +adapters, complete whole-helper hosting, the full invoice and rational +moment/outer certificates. This contribution changes none of those inputs +and claims no larger kappa. + +Prepared for ToikY with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/u8-terminal-cone-census/MANIFEST.json b/research/u8-terminal-cone-census/MANIFEST.json new file mode 100644 index 0000000000..12f78f6812 --- /dev/null +++ b/research/u8-terminal-cone-census/MANIFEST.json @@ -0,0 +1,25 @@ +{ + "CERTIFICATE.json.gz": "980ce3d07d20a6f1bb1c9d097f91aa38b08d19681160f025653e2019f634a95d", + "COST.md": "4583754502b150ee5593b1fc9295c7c5785e26a179bd5f61013a018487b3dd7c", + "PROOF.md": "a4419c30370ab74cb7c20125a7d166710e368f47a46e4c4fbc710df85bd6e879", + "README.md": "461f01830ade53f779fb4a5fbc871fa90efabda378964bfe2d827bebf78c91c3", + "SOURCES.json": "df52be5641c2310b9bff76c742f8fb420605ab389658227c29e44a16676dfe95", + "audit/COMMAND-1.json": "be259843550ef3110093af0e938bc9dbd790bf17684448cde4f452afbb0d37e2", + "audit/COMMAND-2.json": "c21df59dcdfe4dd380cb065a650fc353749627dd369514c9094929b15e1022db", + "audit/INDEPENDENT-AUDIT.json": "18431a3ca2f0c909f08a851770ce0612d33d9ef625df42ef6ab23fe159ab1acf", + "audit/INDEPENDENT-PROFILE-CHECK.json": "e7698c26e6e7c4a75f228110d42cfed5e4a673ef43c9a8a883e004a94aacdee8", + "audit/LATEST-MAIN-DEPENDENCY-CHECK.json": "9edf16266319115d76165540072342ee8895b3f11294802892637dd7ea0cfb1e", + "audit/NORMAL-PACKAGE-COMMAND.json": "6a0b6faee1128b9d18d754b6623b3de2a1b307e7d4ec4eba86c3875f52c9f853", + "audit/NORMAL-PACKAGE-OUTPUT.txt": "96253cd2a8d6d422269de6dc700861230a2c28dc630385c55fa385fdd4f5a83f", + "audit/PACKAGE-INDEPENDENT-REVIEW.json": "72410a6c7aa154c7debd186b71b201afcda6ed6cb2759b68ed3417677960ebdc", + "audit/PACKAGE-NEGATIVE-CONTROLS.json": "8b22a06da96e0b6ad91316387fb1d3f644c4e41f5e7a8557b95ed67964a9cc4c", + "audit/RELOCATED-OPTIMIZED-COMMAND.json": "bff7f4907ea6f49d31f745a115959558bb0433eb806d7e5d6ea129c111ca8111", + "audit/RELOCATED-OPTIMIZED-OUTPUT.txt": "092cebe53ac9ab45aa5595a87f5a6003a07a162f48b8846ccfa98af38a40b4e7", + "audit/REPORT-FINAL-OVERLAP.md": "e8432806389e1bda8cda13132b6ebe2d35de30cc1e91ad9fa63d451bea028eff", + "audit/SEMANTIC-MUTATION-CONTROLS.json": "0f9bda4894c26975a39c4a64df150d076e86a074da80ede528dc72989253dd41", + "audit/SOURCE-PIN-CONTROL.json": "5a32f2277bc878f56818f289b81b52c083e3dee95e706b7be99b805242412a68", + "census.py": "ccb6d6c4331b5b3a0e3cd0274bb9d0472f6f13c7b6d911a3410ffa6eaa1cc27c", + "independent.py": "12db3de009c6a5fca813ead6f06612abb0fb9172fc244b980c289e1756fdeba0", + "inputs/U8-WORD.json.gz": "5320f56557816b33e9e708f2134156c72bf8c096de7edaef0169f984e5942686", + "verify.py": "d21ce2fe0eff2c748e00765de35cf733d529ce689e255c1dfeb6014a54b57514" +} diff --git a/research/u8-terminal-cone-census/PROOF.md b/research/u8-terminal-cone-census/PROOF.md new file mode 100644 index 0000000000..68e35d99c7 --- /dev/null +++ b/research/u8-terminal-cone-census/PROOF.md @@ -0,0 +1,76 @@ +# Necessary terminal cones under monotone common-frame restoration + +Let `P` be the exact compensated U8 scalar prefix and `B_k` its end-of-B +binary frame on register k. There are 728 independent arbitrary scalar +inputs, including 504 arbitrary helper contents. Fix the prefix, its frame +assignments, entrance frames and end-B frames. The suffix may change its +scalar word and helper endpoints, subject to these restrictions: + +- Only invertible linear ADD and nonzero SCALE primitives on the same registers. +- Each ADD acts on two registers at the same current frame. +- After end B, frames only grow by subspace inclusion. +- No new COPY, ERASE, clean ancilla, frame reset or descent. +- The prescribed final data shear is independent of incoming helper dirt; + each helper is restored identically, without residual scalar helper mixing. + +These are the scalar/common-frame hypotheses of this note. Native lowering, +phases and physical hosting are additional obligations for a construction. + +For helper q, every possible terminal frame `U_q` contains + +``` +C_q = span(B_q, + {B_k : (P^-1)[q,k] != 0}, + {B_k : k != q and P[k,q] != 0}). +``` + +All supports refer to exact rational nonzeros. This joins full subspaces, +not the count of distinct generators. The criterion follows the cold-ended +helper lineage in PR591/604/635; this note applies it to all 504 U8 helpers. + +The first term follows directly from monotonicity. For the inverse-row term, +the suffix scalar map is `C = J P^-1`, where J is the prescribed final shear. +The helper row of J is the q-th identity row, so `C[q,k]=(P^-1)[q,k]`. +Track formal dependencies on end-B coordinates during the suffix. A nonzero +dependency originating at register k can reach q only along ADD edges whose +common frames contain `B_k`; frame growth never removes that subspace. +Thus every nonzero entry of the final row requires `B_k` contained in `U_q`. +Cancellation can remove a dependency, but cannot create an entry without +such a path. + +For the dirty-column term fix a proposed `U_q`. At suffix time t let `H(t)` +be the registers whose current frame is **not** contained in `U_q`. The set +only grows. Equal-common-frame gates never cross from H to its complement: +the two incident frames either both lie in `U_q` or both do not. Scalar +gates within H are invertible on its entire vector of coefficients of the +independent incoming dirt variable q. Promotions append coordinates to that +vector, preserving a preexisting nonzero vector. Hence a nonzero q-column +coefficient in any register initially in H cannot disappear from the entire +H vector. The final q frame is `U_q`, so q is outside H; every other final +register has zero q-column coefficient by the prescribed endpoint. The final +H vector is therefore zero. It follows that initially `P[k,q]=0` for every +k in H, proving the dirty-column clause. + +This promotion argument uses arbitrary independent helper contents and +invertibility. A cleanup with erasure, extra clean storage, a reset, unequal +frame ADD or a nonidentity helper endpoint is outside the statement. + +The exact finite census finds `C_q = U0_q` for **every** current helper +endpoint U0. Therefore any terminal frame strictly contained in U0 is +excluded under these hypotheses. For a dimension-preserving different +orientation, containing C also forces equality to U0. Larger endpoints +remain possible. This does not prove that the present tail has minimum +paid cost: one can seek cheaper climbs or scalar words at the same endpoints. +Changed prefix dirt responses or end-B frames also escape the result. + +The row plus own-monotonicity clause alone closes 496 helpers. Helpers +347, 349, 359, 361, 370, 371, 372 and 373 have a rank-eight row-only minimum +and a rank-nine joined minimum. Their independent dirt columns supply the +missing dimension. All begin in rank one; their residual widths remain +eight. These eight indices are not identified with U8's eight added holders. + +The structural argument above is a written lemma; the programs independently +certify its finite premises and joins. Neither is a formal verification of +the all-size integer-multiplication theorem. + +Prepared for ToikY with substantial OpenAI Codex assistance. Apache-2.0. diff --git a/research/u8-terminal-cone-census/README.md b/research/u8-terminal-cone-census/README.md new file mode 100644 index 0000000000..bf0d626fd1 --- /dev/null +++ b/research/u8-terminal-cone-census/README.md @@ -0,0 +1,108 @@ +# Complete U8 terminal-cone census + +**Independent verification / scoped negative result; no new kappa.** For +the pinned compensated U8 prefix and literal end-B frames, the necessary +inverse-row, dirty-column and own-monotonicity cone equals the present +terminal frame for every one of the 504 helpers. No smaller endpoint is +available under the monotone, equal-common-frame invertible scalar cleanup +contract in [PROOF.md](PROOF.md). + +The criterion is inherited. PR864 already reported this test for all378 +FULL-ending helpers of the immediate X4 ancestor, without packaging it. +This contribution extends the concrete coverage to the changed U8 prefix, +all504 helpers including its126 low endpoints, and independently reconstructs +every support and frame with two different exact implementations. It also +records the eight false admissions from omitting the dirty-column clause. +No new cone method or first X4 endpoint obstruction is claimed. +Adjacent PR974 (`f40cd20a8c257bcfee17508c7de68fee24df0568`) prices favorable +U8 role/phase deletion budgets at fixed idle hosting; it does not recheck +cones or construct a changed restoration interface. Its budget screen is +separate from this complete endpoint census and whole-suffix accounting. + +Run from the repository root with Python3.10 or later: + +```sh +python3 -I -B research/u8-terminal-cone-census/verify.py +``` + +Expected status is `PASS_EXACT_INDEPENDENT_U8_TERMINAL_CONE_CENSUS`, with +504helpers,728arbitrary input columns and no smaller-endpoint candidates. +The package is self-contained: copying this directory to another location +needs only the Python standard library. `--optimized` also checks the child +interpreters with optimization; rejection gates do not rely on assertions. +No optimizer, floating tolerance or supplier auditor is imported. + +`CERTIFICATE.json.gz` contains every helper support and canonical frame; +verification compares its decompressed proof-relevant payload. Container +hashes bind committed inputs, not regenerated compression streams. + +The primary uses chronological sparse `Fraction` rows. The independent +implementation right-composes integer/dyadic columns in the opposite order +and enumerates all512 GF(2)^9 vectors to build subspaces. Each independently +rederives6320 compensation gates, the12913-gate prefix, the exact complete +arbitrary-dirt endpoint and prefix inverse. All504 records are compared, +including their exact supports and canonical subspace bases. The independent +CLI was adapted only to accept additional explanatory primary record fields; +its mathematical algorithm is unchanged from the separately executed audit. + +| Result | Exact census | +| --- | --- | +| Current and necessary helper widths | `{4:80,5:32,7:54,8:122,9:216}` | +| Joined cone strictly below current endpoint | 0of504 | +| Closed by inverse row plus own monotonicity | 496of504 | +| Dirty-column clause closes the remaining dimension | helpers347,349,359,361,370,371,372,373 | +| Complete helper width / idle mass per replica | 3778 /14382 | + +The eight exceptional helpers have entrance rank1 and current terminal rank9, +so their width is8. Their row-only minimum has rank8. They are potential +targets only for a mechanism that escapes the column invariant, not valid +rank-seven residual constructions. + +The reproducible verifier compares the complete committed certificate, +tests every proper one-generator endpoint deletion, checks the eight real +row-only failures, exact width/idle/deficit accounting and four independent +semantic controls (zero cancellation, inverse-row orientation, dirt columns +and GF2 joins). It also executes corrupted-input and existing-output CLI +controls. The separately executed audit in `audit/` preserves six actual +semantic mutation rejections and a failed Python3.9 attempt; public historical +receipts replace local paths with portable markers and retain the hashes of +the complete private originals. They are labeled derivatives, not byte-exact +original receipts; the originals are not runtime dependencies. + +[COST.md](COST.md) gives the complete favorable moment relaxation and exact +recurrence accounting. It corrects the provisional single-final-climb cost +screen: old endpoints are not uniformly FULL, and actual suffix climbs may +be split. This result excludes narrower endpoints. It does not exclude +cheaper tails at unchanged endpoints, changed prefixes/end-B frames, added +storage or a different cleanup/compiler interface. There is no numerical +global optimality, runtime improvement or larger-kappa claim. Native phases, +wrappers, hosting, all-size/compiler realization, precision, tape and +analytic transfer remain separate construction obligations. + +Source base: `007664306fff84fbb1c9a1b4053b69f439764034`. The byte-pinned U8 +input is the PR869/870 RECIPE-U8 payload +`090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a`. +It is included directly and completely checked as a finite scalar/frame +word; this command does not regenerate its supplier ancestry or recertify +the selected construction. [SOURCES.json](SOURCES.json) records context Git +blobs, recipe, inherited criterion, predecessor and AI attribution. + +The sprint's orientation selected PR890; by15:19UTC main +`bbc600db2fc15007b7c914f4f2b2ed55fa909c87` selected merged PR942 at +`1661960547713947/10^18`, matching the independently preserved T37 tie. +This note leaves the selected result and upstream files untouched. Bounded +overlap inspection through PR971 found no complete U8 census in the inspected +new bodies; that is not a comprehensive priority claim. + +Sprint seed51, recursive-interface track, began2026-10-13T14:49:33.985287Z. +Its domain was exactly all504 helpers of this fixed word; the stopping rule +was completion of every exact cone and independent record comparison, +rather than elapsed-time or solver exhaustion. No seed reroll occurred. + +Credits: icekylinx's arbitrary-dirt audit; Jeremy Kothe's PR869/870 U8; +PR591/604/635 cold-ended helper work; @navinor's PR864 X4 frame audit; +Chafik Boukhalfa's PR890 composition; Jonathan Capalbo's PR942 fixed-inventory +bound; and contributors retained by these sources. Prepared for ToikY with +substantial OpenAI Codex assistance, including an independent agent +implementation and review. No independent human review is claimed. +New material is Apache-2.0; the included U8 word retains repository attribution. diff --git a/research/u8-terminal-cone-census/SOURCES.json b/research/u8-terminal-cone-census/SOURCES.json new file mode 100644 index 0000000000..2f23c2f738 --- /dev/null +++ b/research/u8-terminal-cone-census/SOURCES.json @@ -0,0 +1,70 @@ +{ + "base_commit": "007664306fff84fbb1c9a1b4053b69f439764034", + "word_raw_sha256": "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a", + "word_gzip_sha256": "5320f56557816b33e9e708f2134156c72bf8c096de7edaef0169f984e5942686", + "word_origin": "Exact PR869/870 RECIPE-U8 output; same payload as fresh independently replayed T37 U8. Historical report scope is retained and is superseded by executed native/endpoint certification, not changed.", + "context_and_criterion_pins": { + "CONTRIBUTING.md": { + "sha256": "1cae543effcabab91dab7f78423ee9283e60fb504f10848483d153331cd72bc4", + "git_blob": "acda5f534dd9e54eb80479cd15ccc12fafe39792" + }, + "certificates/selected-result.json": { + "sha256": "41fb066ff0f43ce472323195e9088d6d888715c13c54eae7b42e357ed5bfc726", + "git_blob": "5dbfac5424703adbb97f38edbdcaea4627215132" + }, + "docs/research/current-status.md": { + "sha256": "e99d003504e7a26c2b81ddb5c88b621880257096bd1109bc57906fb3f1737fe2", + "git_blob": "a679c83b0a1840037fb152456b528c767af007c3" + }, + "docs/research/pr-ledger.md": { + "sha256": "750591e529c45db5dd09bf727bfaebaab856c4b08a1e48794f51517f75f62d7d", + "git_blob": "65d49139fcacf89972e255e882064912ebfcc7bc" + }, + "docs/research/community-frontier890-review.md": { + "sha256": "cd03b7c2c6c09db2cfa89ae40133ae44e1deb6e32ec5ddd23aacecc9c50f2fea", + "git_blob": "6b65461724ba99a36333cb3a8f443cf5f648ca67" + }, + "research/complex-t21-owners/PROOF.md": { + "sha256": "78721b32fceb34b21b8e77c95381c38c60276e72e6d9c2e9c6262cb347457def", + "git_blob": "64e611cce120e0c3a66af303d9c4a43d7b0cb4d9" + }, + "research/complex-t21-owners/vendor/pr870/construction/barch/RECIPE-U8.json": { + "sha256": "292f0e9f82824c4111728cf4de929bf6e43320fbbdc77658aae9681906b0d652", + "git_blob": "ee215a805a7487c300fe1e2b117bd4b5720d4d24" + }, + "research/complex-t21-owners/vendor/pr870/independent/audit_local.py": { + "sha256": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd", + "git_blob": "4744d8783c25bf7bf5076886169077ca3808309a" + }, + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py": { + "sha256": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "git_blob": "d5d3509d90c01fd91dd00b78743287614b532e48" + }, + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/README.md": { + "sha256": "d74a9499a23a729d3470bde7b06b85c4cf8602d06d10af9bf9991aea2da8ed7e", + "git_blob": "6ee54bcf64a3c5ff39bacc6d6a7ed6ffe23d25cb" + } + }, + "attribution": [ + "icekylinx arbitrary-dirt audit", + "Jeremy Kothe PR869/870 U8", + "PR591/604/635 cold-ended helper and cone criterion lineage", + "PR864 X4 FULL-ending endpoint census, @navinor", + "Chafik Boukhalfa PR890; jon314159 PR942 fixed-owner-family bound" + ], + "substantial_AI_assistance": "OpenAI Codex; independent agent implementation and review; no independent human peer review claimed", + "predecessor_PR864": { + "head": "9b1a55f6d281ae5bd7d691977d38861fcd9bd015", + "path": "research/complex-x4-frame-bound/CLAIM.md", + "git_blob": "70779030fc6522a1d73340b09283f4cd394026d3", + "sha256": "40931140e343a6ce9e63a5d6d4c39da8a1dac9751cbe82b36e0e8585b72dcb84", + "scope": "X4 FULL-ending cone census, 216fresh+162entering, not packaged; inherited criterion, not new method", + "contributor_login": "navinor" + }, + "certificate_raw_sha256": "0dc8e482fd4218a8d2021f77cdb98062e4ef0479a83f7f92fa8303908cdfb7b2", + "certificate_gzip_sha256": "980ce3d07d20a6f1bb1c9d097f91aa38b08d19681160f025653e2019f634a95d", + "adjacent_PR974": { + "head": "f40cd20a8c257bcfee17508c7de68fee24df0568", + "scope": "optimistic role/phase deletion budget at fixed U8 inventory/idle hosting; no cone, compensation, owner or hosting recertification; separate from complete endpoint census" + } +} diff --git a/research/u8-terminal-cone-census/audit/COMMAND-1.json b/research/u8-terminal-cone-census/audit/COMMAND-1.json new file mode 100644 index 0000000000..362f9c422a --- /dev/null +++ b/research/u8-terminal-cone-census/audit/COMMAND-1.json @@ -0,0 +1,33 @@ +{ + "state": "FINISHED", + "logger_pid": 68296, + "child_pid": 68297, + "argv": [ + "/Library/Developer/CommandLineTools/usr/bin/python3", + "-B", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/independent_cones.py", + "--word", + "/kappa-run-20261013/experiments/u8-frames/BASELINE-WORD.json.gz", + "--primary", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/TERMINAL-CONES-1.json", + "--out", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/INDEPENDENT-CONES-1.json" + ], + "cwd": "", + "started_utc": "2026-10-13T15:11:58.732478+00:00", + "timeout_seconds": 30, + "threads": 1, + "log": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/independent-run-1.log", + "exit_code": 1, + "seconds": 0.2877435, + "finished_utc": "2026-10-13T15:11:59.020224+00:00", + "log_sha256": "27dc9208b61588427b0edae5155bff065daf1ce74901370b679d185c4b450f76", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "fe6ca2c7c51218edb2d064a4b082ab06ec5452fb52228be4bda4804d0a224588", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/COMMAND-2.json b/research/u8-terminal-cone-census/audit/COMMAND-2.json new file mode 100644 index 0000000000..e8b0d3877a --- /dev/null +++ b/research/u8-terminal-cone-census/audit/COMMAND-2.json @@ -0,0 +1,35 @@ +{ + "state": "FINISHED", + "logger_pid": 69417, + "child_pid": 69457, + "argv": [ + "/kappa-run-20261013/venv/bin/python", + "-B", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/independent_cones.py", + "--word", + "/kappa-run-20261013/experiments/u8-frames/BASELINE-WORD.json.gz", + "--primary", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/TERMINAL-CONES-1.json", + "--out", + "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/INDEPENDENT-CONES-2.json" + ], + "cwd": "", + "started_utc": "2026-10-13T15:13:01.242742+00:00", + "timeout_seconds": 30, + "threads": 1, + "python_version": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "independent_script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340", + "log": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/independent-cones/independent-run-2.log", + "exit_code": 0, + "seconds": 4.500112832989544, + "finished_utc": "2026-10-13T15:13:05.743033+00:00", + "log_sha256": "a3f13e6574ee1608f4515f79d5f6eed43914616976d9206e3868b10cc5250aa9", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "5b5d8284526c8c85aa281a85ca1b8c1d5752ac8495dc6037e281bf72d8751477", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/INDEPENDENT-AUDIT.json b/research/u8-terminal-cone-census/audit/INDEPENDENT-AUDIT.json new file mode 100644 index 0000000000..a3e61225d8 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/INDEPENDENT-AUDIT.json @@ -0,0 +1,126 @@ +{ + "status": "PASS_INDEPENDENT_EXACT_U8_TERMINAL_CONE_CERTIFICATION", + "recorded_utc": "2026-10-13T15:22:26.029805+00:00", + "main_source_commit": "007664306fff84fbb1c9a1b4053b69f439764034", + "word_content_sha256": "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a", + "primary_first_sha256": "9bc72425478f32bc12d21494ce0831432d7045a16a448b15d2b1039d0914c7ef", + "primary_final_sha256": "a66ee2bbb8ec9147065e9ad839b5374d92ce1769b175f1ee04b212fd71d187d8", + "independent_result_sha256": "64f99ff9ccd2fe906dbe44272653f319cbacfb8382d6484dffbd78e56ecb1e99", + "independent_script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340", + "exact_504_common_records_match_final_primary": true, + "exact_support_not_probabilistic": true, + "arbitrary_input_columns": 728, + "full_endpoint_and_inverse_composition_exact": true, + "width_inventory": { + "4": 80, + "5": 32, + "7": 54, + "8": 122, + "9": 216 + }, + "row_only_closed_count": 496, + "row_only_gap_helpers": [ + 347, + 349, + 359, + 361, + 370, + 371, + 372, + 373 + ], + "joined_cone_closed_count": 504, + "helper_width_sum": 3778, + "idle_mass_per_9_call_replica": 14382, + "profile_receipt_sha256": "e7698c26e6e7c4a75f228110d42cfed5e4a673ef43c9a8a883e004a94aacdee8", + "semantic_mutations_rejected": 6, + "semantic_controls_sha256": "0f9bda4894c26975a39c4a64df150d076e86a074da80ede528dc72989253dd41", + "source_pin_actual_cli_exit": 1, + "source_pin_no_output_created": true, + "source_pin_control_sha256": "5a32f2277bc878f56818f289b81b52c083e3dee95e706b7be99b805242412a68", + "source_and_scope_pins": [ + { + "path": "/kappa-interface-20261013/research/complex-t21-owners/vendor/pr870/construction/barch/RECIPE-U8.json", + "sha256": "292f0e9f82824c4111728cf4de929bf6e43320fbbdc77658aae9681906b0d652", + "bytes": 12031 + }, + { + "path": "/kappa-interface-20261013/research/complex-t21-owners/vendor/pr870/independent/audit_local.py", + "sha256": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd", + "bytes": 9209 + }, + { + "path": "/kappa-interface-20261013/research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/code/hpe_audit_and_transport.py", + "sha256": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "bytes": 16394 + }, + { + "path": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/frontier-interface-audit/source/pr899-README.md", + "sha256": "cbcf1bc5d35c247a42439669e449a592fb52e5094869a232213bf588d7ff00b4", + "bytes": 23964 + }, + { + "path": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/frontier-interface-audit/source/pr892-PROOF.md", + "sha256": "099c41c4f8895fa1d3a2de62b9ed7edc3b53d2142c022d03fd43496d59c75828", + "bytes": 8313 + }, + { + "path": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/frontier-interface-audit/SOURCE-RECEIPTS.json", + "sha256": "3d107eaa3983b22da75e22ddcf54501c740e88a9b38ed34e7a1de1c86953c2a3", + "bytes": 1443 + }, + { + "path": "/kappa-run-20261013/sprints/sprint-20261013T144933Z-seed51/frontier-interface-audit/OVERLAP-RECORDS.json", + "sha256": "413602de6c5c31ec86d13175a6abe5e384cdd5a96fdabf373e5ce4ad8f1cfab5", + "bytes": 77818 + }, + { + "path": "/kappa-run-20261013/evidence/frontier-publication-1308/open-page-3.json", + "sha256": "538861eb90f3afbdf4f650d4395aeff86fee0c27795bcbd7965ede0115f8afed", + "bytes": 2108904 + } + ], + "pr698_scope_evidence": { + "pr": 698, + "head": "ab78f797cffcbeddbb17a7eb069741085ffe3351", + "source_snapshot_path": "/kappa-run-20261013/evidence/frontier-publication-1308/open-page-3.json", + "source_snapshot_sha256": "538861eb90f3afbdf4f650d4395aeff86fee0c27795bcbd7965ede0115f8afed", + "full_package_replayed": false + }, + "execution": { + "first_system_python_attempt_exit": 1, + "successful_census_exit": 0, + "successful_census_elapsed_seconds": 4.500112832989544, + "profile_only_elapsed_seconds": 0.4682181659154594, + "all_commands_finished": true, + "live_jobs_owned": [], + "threads": 1, + "hard_timeout_seconds_each": 30, + "substantial_job_launched": false, + "paid_compute": false, + "failed_receipts_preserved": true, + "census_cpu_seconds": null, + "census_max_rss_bytes": null, + "unrecorded_resource_note": "Census wall time recorded; CPU/RSS were not independently sampled. Tiny controls and frame-only command record child CPU/RSS." + }, + "mathematical_status": { + "finite_census": "EXACT_EXECUTED", + "retained_cone_admission": "ALL504_SATURATED", + "row_monotone_information_flow": "WRITTEN_ARGUMENT", + "column_growing_partition_invariant": "WRITTEN_ARGUMENT_WITH_EXPLICIT_GATE_ENDPOINT_HYPOTHESES", + "formal_proof": false, + "unrestricted_interface_optimality": false, + "new_kappa": null, + "cleanup_gate_count_or_tail_profile_optimality": false + }, + "blockers": [], + "next_experiment_boundary": "Any endpoint-width experiment must change the fixed prefix/end-B frames or restoration/primitive interface and prove why the cone invariant no longer applies. Eight row-only gaps are not constructions.", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "4586ca7dae1259ed2d9716c05a7fbd334401353adf375ea95255d50823b68289", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/INDEPENDENT-PROFILE-CHECK.json b/research/u8-terminal-cone-census/audit/INDEPENDENT-PROFILE-CHECK.json new file mode 100644 index 0000000000..235b01624d --- /dev/null +++ b/research/u8-terminal-cone-census/audit/INDEPENDENT-PROFILE-CHECK.json @@ -0,0 +1,36 @@ +{ + "fixed_prefix_paid_profile": { + "1": 2048, + "2": 288, + "3": 368, + "4": 160, + "5": 16, + "8": 8 + }, + "actual_old_suffix_paid_profile": { + "1": 500, + "2": 50, + "3": 78, + "4": 2, + "5": 56 + }, + "all_register_minimal_one_jump_suffix_profile": { + "1": 328, + "2": 80, + "3": 86, + "4": 10, + "6": 56 + }, + "status": "PASS_INDEPENDENT_FRAME_ONLY_PROFILE_AND_FINAL_PRIMARY_BINDINGS", + "helper_width_sum": 3778, + "idle_mass_per_9_call_replica": 14382, + "all_registers": 728, + "exact_common_record_fields_match_504": true, + "exact_row_only_split_matches": true, + "primary_final_sha256": "a66ee2bbb8ec9147065e9ad839b5374d92ce1769b175f1ee04b212fd71d187d8", + "word_content_sha256": "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a", + "independent_script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340", + "profile_script_sha256": "57f5bbbf37b90800611bac9e3b354e03515f2d8f1ae7999987fc1c013794fe56", + "seconds": 0.17910441709682345, + "scope": "Frame-only reconstruction. The one-jump histogram grants scalar cleanup for free and is not a legal cleanup construction." +} diff --git a/research/u8-terminal-cone-census/audit/LATEST-MAIN-DEPENDENCY-CHECK.json b/research/u8-terminal-cone-census/audit/LATEST-MAIN-DEPENDENCY-CHECK.json new file mode 100644 index 0000000000..9ebf4a6b84 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/LATEST-MAIN-DEPENDENCY-CHECK.json @@ -0,0 +1,30 @@ +{ + "status": "PASS_RETAINED_U8_INPUT_DEPENDENCIES_MATCH_LATEST_MAIN", + "observed_utc": "2026-10-13T15:30:52.358448+00:00", + "base_commit": "007664306fff84fbb1c9a1b4053b69f439764034", + "latest_main": "bbc600db2fc15007b7c914f4f2b2ed55fa909c87", + "matching_paths": { + "research/complex-t21-owners/vendor/pr870/construction/barch/RECIPE-U8.json": "292f0e9f82824c4111728cf4de929bf6e43320fbbdc77658aae9681906b0d652", + "research/complex-t21-owners/vendor/pr870/independent/audit_local.py": "03afcfc9da428b3f6edac81c1fee7f277ab81b64998efae78380b63498dec6cd", + "research/complex-t21-owners/PROOF.md": "78721b32fceb34b21b8e77c95381c38c60276e72e6d9c2e9c6262cb347457def" + }, + "selected_pr_at_latest_main": 942, + "selected_kappa": "1661960547713947/1000000000000000000", + "old_base_selected_record_check": { + "actual_command": "make selected-record-check PYTHON=/kappa-run-20261013/venv/bin/python", + "emitted_recipe": "python3 -B scripts/verify_selected_result.py", + "exit_code": 0, + "stdout": "PASS selected record, exact kappa, original source inventory and proof supplement: 1661957774647029/1000000000000000000", + "full_make_verify_rerun": false, + "cold_selected_replay_rerun": false, + "scope": "new isolated research-only directory; no selected construction/source edits" + }, + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "8e55bb38cece9c7a73c794ee63b20b4b95ac133ee5efc451cb71c5e11bc747f9", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-COMMAND.json b/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-COMMAND.json new file mode 100644 index 0000000000..fd154bef3e --- /dev/null +++ b/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-COMMAND.json @@ -0,0 +1,24 @@ +{ + "command": [ + "kappa-run-20261013/venv/bin/python", + "-I", + "-B", + "kappa-interface-20261013/research/u8-terminal-cone-census/verify.py" + ], + "cwd": "", + "started_utc": "2026-10-13T15:27:24.852327+00:00", + "status": "FINISHED", + "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "thread_limit": 1, + "exit_code": 0, + "seconds": 1.4063814589753747, + "log_sha256": "96253cd2a8d6d422269de6dc700861230a2c28dc630385c55fa385fdd4f5a83f", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "513716ae78710313e4dc58c046e29aadc313ca42aecd9cdccf4c6324f8062d92", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-OUTPUT.txt b/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-OUTPUT.txt new file mode 100644 index 0000000000..18086bc55e --- /dev/null +++ b/research/u8-terminal-cone-census/audit/NORMAL-PACKAGE-OUTPUT.txt @@ -0,0 +1,17 @@ +{ + "status": "PASS_EXACT_INDEPENDENT_U8_TERMINAL_CONE_CENSUS", + "source_files_checked": 15, + "helpers": 504, + "arbitrary_columns": 728, + "independent_semantic_mutations_rejected": 4, + "corrupted_input_cli_rejected": true, + "existing_output_preserved": true, + "controls": { + "old_endpoints_accepted": 504, + "proper_basis_deletions_rejected": 4186, + "row_only_false_admissions_rejected": 8, + "complete_cost_mass_checks": "PASS" + }, + "optimized_children": false, + "scope": "fixed-prefix/end-B monotone common-frame endpoints; no kappa or tail-optimality claim" +} diff --git a/research/u8-terminal-cone-census/audit/PACKAGE-INDEPENDENT-REVIEW.json b/research/u8-terminal-cone-census/audit/PACKAGE-INDEPENDENT-REVIEW.json new file mode 100644 index 0000000000..56cc40dff7 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/PACKAGE-INDEPENDENT-REVIEW.json @@ -0,0 +1,102 @@ +{ + "status": "PASS_BOUNDED_INDEPENDENT_STATIC_PACKAGE_REVIEW", + "recorded_utc": "2026-10-13T15:32:41.549688+00:00", + "scope": "Read-only source/docs/pin review; no matrix replay, heavy job or package edit. The original independent audit remains unchanged.", + "package_path": "/kappa-interface-20261013/research/u8-terminal-cone-census", + "reviewed_file_sha256": { + "census.py": "ccb6d6c4331b5b3a0e3cd0274bb9d0472f6f13c7b6d911a3410ffa6eaa1cc27c", + "independent.py": "12db3de009c6a5fca813ead6f06612abb0fb9172fc244b980c289e1756fdeba0", + "verify.py": "dcd3c12caa5cc7a5ad455144a9697cdbc3630c0635c239a91c398dc7e9d24ab4", + "PROOF.md": "a4419c30370ab74cb7c20125a7d166710e368f47a46e4c4fbc710df85bd6e879", + "COST.md": "4583754502b150ee5593b1fc9295c7c5785e26a179bd5f61013a018487b3dd7c", + "README.md": "ccf875170a7f5af2053848f4b766339f953eacfb50edd648f173098f06ca4dc0", + "SOURCES.json": "be7efdb52020b8319de643ab58a055add17d434a407b97f66ee9edb15b835204", + "CERTIFICATE.json": "0dc8e482fd4218a8d2021f77cdb98062e4ef0479a83f7f92fa8303908cdfb7b2", + "MANIFEST.json": "28175d04f5dc0d0ab33dedcc2732ce2505f27a5f9985d39d99424a72a407b413" + }, + "package_manifest_entries": 17, + "manifest_source_closure_and_hashes_match": true, + "certificate_matches_executed_primary_final_exactly_except_removed_seconds": true, + "independent_algorithm_review": { + "frozen_script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340", + "unchanged_function_names": [ + "need", + "dyadic", + "fraction_pair", + "plus", + "scalar", + "columns", + "canon_columns", + "matrix_sha", + "space", + "basis", + "dimension", + "join", + "touched", + "frames", + "reconstruct", + "controls" + ], + "changed_function_names": [ + "main" + ], + "only_change": "main compares each record after projecting primary extra explanatory fields to every independently derived key; exact record count is also checked. Matrix, compensation, subspace, endpoint and inverse algorithms are unchanged." + }, + "lemma_review": { + "row_information_flow": "VALID_WITH_STATED_FIXED_PREFIX_AND_MONOTONE_COMMON_FRAME_HYPOTHESES", + "column_promotion_invariant": "VALID_WITH_STATED_ARBITRARY_DIRT_IDENTITY_ENDPOINT_AND_INVERTIBLE_SCALAR_HYPOTHESES", + "promotion_case_explicit": true, + "no_claim_of_tail_gatecount_or_global_optimality": true, + "eight_gap_helpers_start_rank1_end_rank9_width8_confirmed": true + }, + "cost_arithmetic": { + "prefix_rank_mass": 4512, + "old_suffix_rank_mass": 1122, + "local_rank_mass": 5634, + "helper_width_sum": 3778, + "idle_mass": 14382, + "rank_deficit_per_replica": 320, + "all_728_register_suffix_relaxation_included": true, + "lower_bound_direction_correct": true, + "outward_rounded_numerical_exclusion_claimed": false + }, + "verification_gates_review": [ + "exact package closure and each SHA", + "gzip and raw word pins", + "full primary recomputation equals committed certificate excluding time", + "independent common-field record and row-only frame comparison", + "proper basis-deletion rejection for all helpers", + "eight row-only dirty-column false-admission checks", + "exact prefix/suffix/idle/deficit arithmetic", + "four independent semantic fixtures", + "real corrupt-word CLI exit and no output", + "existing output preservation", + "need-based rejection remains active under optimized Python" + ], + "verification_execution_scope": "Static gate review only. Coordinator owns normal/relocated/optimized executions; no duplicate execution was launched.", + "predecessor_credit": { + "pr864_login": "navinor", + "head": "9b1a55f6d281ae5bd7d691977d38861fcd9bd015", + "claim_sha256": "40931140e343a6ce9e63a5d6d4c39da8a1dac9751cbe82b36e0e8585b72dcb84", + "same_X4_FULL_cone_method_acknowledged": true, + "no_new_cone_method_claim": true + }, + "new_main_confirmation": { + "commit": "bbc600db2fc15007b7c914f4f2b2ed55fa909c87", + "selected_pr": 942, + "kappa": "1661960547713947/1000000000000000000", + "selected_source_head": "1960cfa919a0945d0ca4cb14ea96237000037903", + "selected_result_git_bytes_sha256": "1d35283cb0ce3f8db1f285683933517f9e87475d295e2b6316399ad9928c81c3" + }, + "correctness_defects": [], + "blockers": [], + "next_step": "Coordinator can finish planned relocation/optimized/source-negative receipts and focused PR packaging. This review does not authenticate past execution or certify the full multiplication theorem.", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "1eeffcce0640353cbd5cc23013f5ce79dd43e2db46ba2db052f8cc172b106eb7", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/PACKAGE-NEGATIVE-CONTROLS.json b/research/u8-terminal-cone-census/audit/PACKAGE-NEGATIVE-CONTROLS.json new file mode 100644 index 0000000000..69580a98fd --- /dev/null +++ b/research/u8-terminal-cone-census/audit/PACKAGE-NEGATIVE-CONTROLS.json @@ -0,0 +1,37 @@ +{ + "status": "PASS_ACTUAL_PACKAGE_NEGATIVE_CONTROLS", + "recorded_utc": "2026-10-13T15:32:17.139402+00:00", + "optimized": true, + "source_root": "/kappa-interface-20261013/research/u8-terminal-cone-census", + "source_manifest_sha256": "28175d04f5dc0d0ab33dedcc2732ce2505f27a5f9985d39d99424a72a407b413", + "cases": [ + { + "mutation": "changed_source", + "exit_code": 1, + "required_rejection": "source hash mismatch: census.py", + "stderr_sha256": "da56a8a0a303160cf29aba0eb138e9853804a3b63decf57255be36c0fa802cbb" + }, + { + "mutation": "missing_manifest_entry", + "exit_code": 1, + "required_rejection": "source closure differs from manifest", + "stderr_sha256": "04c6c82bd94cfdc1c575182d215798ea7bee04cfba3367ba1ee55ea51694a120" + }, + { + "mutation": "rehashed_wrong_certificate", + "exit_code": 1, + "required_rejection": "recomputed exact certificate mismatch", + "stderr_sha256": "0b704ad9ab5c195d493f68f7060398c8d761a46d5cda4af2a049f7e27cec8e1c" + } + ], + "source_changed": false, + "all_children_finished": true, + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "0d9b2cd31b8301f9e3fbac0ff7d30149c34fc4492805913d1e6eca44c4b4313e", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-COMMAND.json b/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-COMMAND.json new file mode 100644 index 0000000000..d5a8a5b28e --- /dev/null +++ b/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-COMMAND.json @@ -0,0 +1,26 @@ +{ + "command": [ + "kappa-run-20261013/venv/bin/python", + "-O", + "-I", + "-B", + "/verify.py", + "--optimized" + ], + "cwd": "", + "started_utc": "2026-10-13T15:30:52.446007+00:00", + "status": "FINISHED", + "python": "3.12.14 (main, Aug 25 2026, 13:50:33) [Clang 22.1.3 ]", + "thread_limit": 1, + "exit_code": 0, + "seconds": 1.6688253749161959, + "log_sha256": "092cebe53ac9ab45aa5595a87f5a6003a07a162f48b8846ccfa98af38a40b4e7", + "public_metadata_redaction": { + "status": "SANITIZED_DERIVATIVE", + "original_receipt_sha256": "bcb72e54ef2cef263e98a66591317e609678d6abef0c753ba5b677073b2f6226", + "absolute_local_paths_replaced_by_portable_markers": true, + "complete_original_preserved_privately": true, + "mathematical_values_and_artifact_hashes_unchanged": true, + "not_byte_identical_to_original": true + } +} diff --git a/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-OUTPUT.txt b/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-OUTPUT.txt new file mode 100644 index 0000000000..51cb864e43 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/RELOCATED-OPTIMIZED-OUTPUT.txt @@ -0,0 +1,17 @@ +{ + "status": "PASS_EXACT_INDEPENDENT_U8_TERMINAL_CONE_CENSUS", + "source_files_checked": 17, + "helpers": 504, + "arbitrary_columns": 728, + "independent_semantic_mutations_rejected": 4, + "corrupted_input_cli_rejected": true, + "existing_output_preserved": true, + "controls": { + "old_endpoints_accepted": 504, + "proper_basis_deletions_rejected": 4186, + "row_only_false_admissions_rejected": 8, + "complete_cost_mass_checks": "PASS" + }, + "optimized_children": true, + "scope": "fixed-prefix/end-B monotone common-frame endpoints; no kappa or tail-optimality claim" +} diff --git a/research/u8-terminal-cone-census/audit/REPORT-FINAL-OVERLAP.md b/research/u8-terminal-cone-census/audit/REPORT-FINAL-OVERLAP.md new file mode 100644 index 0000000000..472f50f514 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/REPORT-FINAL-OVERLAP.md @@ -0,0 +1,99 @@ +# Final bounded overlap refresh for U8 terminal-cone census + +Recommended publication label: +**Independent finite verification / scoped negative result: complete U8 +terminal-cone census (no new kappa).** + +This supplements the earlier orientation REPORT.md; it does not overwrite its +source pins. In particular, the newly inspected PR864 claim requires explicit +credit for the necessary-cone method and the earlier X4 FULL-end closure. + +## Current observed pins and material upstream change + +- Main at both reads: bbc600db2fc15007b7c914f4f2b2ed55fa909c87. +- PR942 head unchanged:1960cfa919a0945d0ca4cb14ea96237000037903. + It merged 2026-10-13T15:06:48Z, merge commit + 3c84be1db6d225d02b239fefc18e8db6e005c9f9. +- Immutable-main current-status.md now selects PR942 at + 1661960547713947/10^18 and names make frontier942-verify. + This is the already known T37 tie, not a stronger value. +- PR962, head50c6ae8151493af21d284afe34fb35f68f6d4934, + independently ties PR942 with the U8 word, widths and bit supplier unchanged. +- Relevant exact predecessor PR864 remains + 9b1a55f6d281ae5bd7d691977d38861fcd9bd015. + Its CLAIM.md exact blob70779030fc6522a1d73340b09283f4cd394026d3 + is retained and independently hashed here. +- Earlier inspected scope pins retained: PR899 + 75e7699a691f321861ab8fe303f8bd8e6a6fc393, PR892 + 9778ba2d891468996b81eb50c389bb4169df0025, PR698 + ab78f797cffcbeddbb17a7eb069741085ffe3351. No repeated source fetch + was performed for those earlier reads. + +## Factual overlap and the defensible contribution + +PR864's local claim already checks every FULL-ending helper of the immediate +X4 ancestor by joining end-B inverse-row and dirt-column supports. It reports +all216 fresh plus162 entering FULL-ending helpers have rank-nine joins and +labels this check “Not packaged.” Thus the elementary join method, and the +earlier X4 no-new-low-end conclusion, are predecessor work. + +The proposed research/u8-terminal-cone-census can still add useful, distinct +evidence if it binds the actual changed U8 compensated prefix/end-B boundary, +covers all504 helpers including126 existing low ends, records exact subspaces +and row/column witnesses, and checks them with separate Fraction-row and +dyadic-column implementations. This provides a durable independently checked +extension to U8 and a stronger complete coverage receipt than the unbundled +FULL-only X4 claim. It should not claim discovery of the cone criterion, first +X4 endpoint closure, broader circuit optimality or a new multiplication result. + +PR899 concerns fixed-op-multiset helper/holder merging under its specified +shipped-frame bounds. PR698 optimizes CK B frames while fixing exact end-B +frames. PR892 applies early rank-eight restoration to one new coded helper in +four PR626 embeddings, then closes those fixed-geometry mixtures. Their +specified programs/domains differ from the actual all504 U8 census. PR864 is +the closest method/result predecessor and should be cited prominently, +alongside the existing auditor's cone predicates. + +The negative claim must remain exactly scoped: fixed compensated scalar +prefix, fixed end-B frames, arbitrary independent dirty inputs and retained +monotone common-frame/native wrapper interface. It does not exclude changed +scalar programs, frames, compensation, noncoordinate primitives, cross-call +restoration contracts or different paid helper inventories. This overlap audit +has not run or certified either implementation or the candidate's result. + +## Changes since orientation and coverage boundaries + +Conservative cutoff14:49:00Z predates the saved orientation requests at +14:51:07–10UTC. Initial and confirming updated-open/closed pages each contain100 +entries and cross that cutoff; no second page is required for this bounded +interval under the API's updated-descending order. The created-descending +first page confirms new arrivals through969 at its read. A later open +confirmation adds970/971 and changes969's head from52275a6 to d1ee3f4. +The closed confirmation captures871's subsequent closure. These serial changes +are preserved rather than treated as an atomic snapshot. + +The union contains31 updated PRs, including ten new numbers962–971. +Their bodies concern the T37 tie, P111 receiver minimality, CK weighted forests, +R439 helper triples/stars, prescribed-target decoder thresholds, complex +frame-pair decoder copy costs, historical scalar swap runs, bit-compression +provenance and a targetwise audit of PR966. None inspected describes this +complete fixed-U8 helper terminal-cone census. The changed older items are +metadata/status, finite circuit or verifier updates in their earlier scopes. + +Four all-state GitHub title/body queries return: +- U8 + terminal:0. +- dirt-column:28. +- cold-ended + cone:1. +- 504 + census:5. + +Each response has incomplete_results=false and is shorter than100. Relevant +hits include864,604,617 and717. Search result count is not proof of priority: +indexing, synonyms, comments and source-only claims can escape those queries. +New-arrival exclusions are body/scope review, not whole-source absence checks. +This is a bounded overlap refresh, not a comprehensive frontier or literature +novelty assertion; events after each response remain outside that response. + +COMPACT-COVERAGE.json records exact heads, source files, boundaries and drift. +Raw serial responses and immutable-main status are retained. FETCH-RECEIPTS-FINAL +and the local manifest bind the evidence. No publication, claim, source edit, +compute job or native/search verifier was performed. diff --git a/research/u8-terminal-cone-census/audit/SEMANTIC-MUTATION-CONTROLS.json b/research/u8-terminal-cone-census/audit/SEMANTIC-MUTATION-CONTROLS.json new file mode 100644 index 0000000000..6ba2c34b86 --- /dev/null +++ b/research/u8-terminal-cone-census/audit/SEMANTIC-MUTATION-CONTROLS.json @@ -0,0 +1,41 @@ +{ + "status": "PASS_SEMANTIC_MUTATION_CONTROLS", + "positive_cases": 6, + "negative_cases": 6, + "negative_controls": [ + { + "name": "retain_exactly_cancelled_zero_in_support", + "status": "REJECTED", + "reason": "cancelled zero must be absent from exact column support" + }, + { + "name": "substitute_forward_for_inverse_row", + "status": "REJECTED", + "reason": "noncommuting example requires the inverse-row support" + }, + { + "name": "omit_dirty_column_constraint", + "status": "REJECTED", + "reason": "omission loses a genuinely independent frame direction" + }, + { + "name": "use_deduplicated_generator_count_as_GF2_rank", + "status": "REJECTED", + "reason": "three different generators span only two GF2 dimensions" + }, + { + "name": "use_intersection_as_GF2_join", + "status": "REJECTED", + "reason": "frame join must include both one-dimensional subspaces" + }, + { + "name": "omit_dirty_column_on_actual_gap_helper347", + "status": "REJECTED", + "reason": "actual helper347 row-only mutant differs from certified joined cone" + } + ], + "actual_result_sha256": "64f99ff9ccd2fe906dbe44272653f319cbacfb8382d6484dffbd78e56ecb1e99", + "control_script_sha256": "8aa369b49bf4e31008d1733afaed4e7bec975ee2b59e8a9695609d4a4baedb0d", + "independent_script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340", + "seconds": 0.010039166081696749 +} diff --git a/research/u8-terminal-cone-census/audit/SOURCE-PIN-CONTROL.json b/research/u8-terminal-cone-census/audit/SOURCE-PIN-CONTROL.json new file mode 100644 index 0000000000..9324edbccf --- /dev/null +++ b/research/u8-terminal-cone-census/audit/SOURCE-PIN-CONTROL.json @@ -0,0 +1,12 @@ +{ + "status": "PASS_ACTUAL_PUBLIC_CLI_SOURCE_PIN_CONTROL", + "expected_exit_code": 1, + "actual_exit_code": 1, + "no_result_created": true, + "changed_bytes": 1, + "original_content_sha256": "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a", + "mutated_content_sha256": "e4b32bc9166e29dacb11a71167d6d7fbff9f6c3f197fe697d45d10f59f7b3cae", + "mutated_gzip_sha256": "ec7d57751f2102ed087025619eea0a026399db2b11fee5ca9bc04b42279a2a63", + "log_sha256": "85cccb121156512a4da5c9a83e24e8515d2ba91688dbb3cc81b82c96cbb8713c", + "script_sha256": "4e86d2b14ea4321e542f099264b070fc4f7a1056911fa449b807961d970f5340" +} diff --git a/research/u8-terminal-cone-census/census.py b/research/u8-terminal-cone-census/census.py new file mode 100644 index 0000000000..57a5360954 --- /dev/null +++ b/research/u8-terminal-cone-census/census.py @@ -0,0 +1,218 @@ +"""Exact necessary terminal cones for the frozen U8 scalar prefix. + +Standalone diagnostic; no supplier construction or exponent certificate. +Credits icekylinx's arbitrary-dirt auditor and the PR591/604/635 cold-end +criterion retained by Jeremy Kothe's PR869/870 U8. Apache-2.0. +Prepared for ToikY with substantial OpenAI Codex assistance. +""" +import argparse +from collections import Counter +from fractions import Fraction +import gzip +import hashlib +import json +from pathlib import Path +import time + +WORD_SHA = "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a" +FULL = (256, 128, 64, 32, 16, 8, 4, 2, 1) + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def span(vectors): + pivots = {} + for vector in vectors: + while vector: + bit = vector.bit_length() - 1 + if bit in pivots: + vector ^= pivots[bit] + else: + pivots[bit] = vector + break + for bit in sorted(pivots): + for high in pivots: + if high > bit and (pivots[high] >> bit) & 1: + pivots[high] ^= pivots[bit] + return tuple(pivots[bit] for bit in sorted(pivots, reverse=True)) + + +def included(small, large): + return span(small + large) == large + + +def touched(gate): + return gate[1:3] if gate[0] == "add" else gate[1:2] + + +def execute(gates, rows, inverse=False): + sequence = reversed(gates) if inverse else gates + for gate in sequence: + kind = gate[0] + if kind == "add": + target, source = gate[1:3] + require(target != source, "self addition") + coefficient = Fraction(gate[3], gate[4]) * (-1 if inverse else 1) + for column, value in list(rows[source].items()): + total = rows[target].get(column, 0) + coefficient * value + if total: + rows[target][column] = total + else: + rows[target].pop(column, None) + elif kind == "scale": + coefficient = Fraction(gate[2], gate[3]) + require(coefficient != 0, "zero scale") + if inverse: + coefficient = 1 / coefficient + rows[gate[1]] = {k: coefficient * v for k, v in rows[gate[1]].items()} + else: + raise ValueError("unknown primitive") + return rows + + +def identity(size): + return [{i: Fraction(1)} for i in range(size)] + + +def compute(word): + v, h, helpers = (word["report"][k] for k in ("v", "h", "R")) + require((v, h, helpers) == (112, 9, 504), "wrong U8 geometry") + size = 2 * v + helpers + core = word["A"] + word["cut"] + word["B"] + raw = execute(core, identity(size)) + response = [{} for _ in range(size)] + for target in range(v, 2 * v): + response[target] = {k: a for k, a in raw[target].items() if k >= 2 * v} + execute(word["precondition"], response) + compensation = [ + ["add", target, helper, -value.numerator, value.denominator, []] + for target in range(v, 2 * v) + for helper, value in sorted(response[target].items()) + ] + prefix = word["precondition"] + compensation + core + forward = execute(prefix, identity(size)) + inverse = execute(prefix, identity(size), inverse=True) + # Replaying the inverse on the actual forward state checks all columns. + require(execute(prefix, [dict(row) for row in forward], inverse=True) == identity(size), + "prefix inverse does not restore every arbitrary input") + start = [(port,) for port in word["ports"]] + [()] * (v + helpers) + for q, frame in word.get("start_extra", {}).items(): + start[int(q)] = span(frame) + end = [FULL] * v + [ + span(x for x in range(1, 512) if (x & port).bit_count() % 2 == 0) + for port in word["ports"] + ] + [FULL] * helpers + for q, frame in word.get("helper_final", {}).items(): + end[int(q)] = span(frame) + current = list(start) + paid = Counter() + + def climb(q, frame): + frame = span(frame) + require(included(current[q], frame), "nonmonotone frame") + delta = len(frame) - len(current[q]) + if delta: + paid[delta] += 1 + current[q] = frame + + for section in ("A", "B"): + if section == "B": + levels = {int(q): span(frame) for q, frame in word.get("target_levels", {}).items()} + require(all(current[v + q] == levels.get(q, ()) for q in range(v)), "target boundary") + for carrier, frame in zip(word["centers"], word["center_frames"]): + frame = span(frame) + require(current[carrier] == frame, "center boundary") + served = {levels.get(g[1] - v, ()) for g in word["cut"] if g[2] == carrier} + for target_frame in sorted(served, key=lambda f: -len(f)): + require(included(target_frame, frame), "center nesting") + if frame != target_frame: + paid[len(frame) - len(target_frame)] += 1 + frame = target_frame + for gate in word[section]: + for q in touched(gate): + climb(q, gate[-1]) + end_b = list(current) + prefix_paid = paid.copy() + early = word.get("early_cleanup", []) + early_indices = {i for i, _ in early} + require(len(early_indices) == len(early), "duplicate early cleanup") + tail = [word["cleanup"][i][:-1] + [frame] for i, frame in early] + cleanup = [g for i, g in enumerate(word["cleanup"]) if i not in early_indices] + for gate in tail: + for q in touched(gate): + climb(q, gate[-1]) + for q, frame in enumerate(end): + climb(q, frame) + require(dict(paid) == {int(k): n for k, n in word["report"]["local_profile"].items()}, "paid profile") + require(all(end[q] == FULL for g in cleanup for q in touched(g)), "FULL cleanup access") + complete = execute(tail + cleanup, [dict(row) for row in forward]) + expected = identity(size) + for q in range(v): + expected[v + q][q] = Fraction(1) + require(complete == expected, "complete arbitrary-dirt endpoint") + records = [] + dirt_rows = {q: [] for q in range(2 * v, size)} + for row, coefficients in enumerate(forward): + for q in coefficients: + if q >= 2 * v and row != q: + dirt_rows[q].append(row) + for q in range(2 * v, size): + required = sorted(set(inverse[q]) | set(dirt_rows[q]) | {q}) + row_frame = span(vector for k in set(inverse[q]) | {q} for vector in end_b[k]) + minimal = span(vector for k in required for vector in end_b[k]) + require(included(minimal, end[q]), "current endpoint violates necessary cones") + records.append({ + "helper": q - 2 * v, "register": q, + "start_frame": list(start[q]), "end_b_frame": list(end_b[q]), + "current_terminal_frame": list(end[q]), "minimal_necessary_terminal_frame": list(minimal), + "row_and_monotonicity_minimum": list(row_frame), + "row_only_dimension_slack": len(end[q]) - len(row_frame), + "inverse_row_support": sorted(inverse[q]), "dirt_column_support": dirt_rows[q], + "current_width": len(end[q]) - len(start[q]), + "minimal_necessary_width": len(minimal) - len(start[q]), + "terminal_dimension_slack": len(end[q]) - len(minimal), + "full_cleanup_incidence": sum(q in touched(g) for g in cleanup), + "column_blockers_for_row_minimum": [k for k in dirt_rows[q] if not included(end_b[k], row_frame)], + }) + return { + "status": "PASS_EXACT_NECESSARY_U8_TERMINAL_CONE_CENSUS", + "helper_count": helpers, "arbitrary_input_columns": size, + "compensation_gates": len(compensation), "prefix_gates": len(prefix), + "local_profile": dict(sorted(paid.items())), + "fixed_prefix_paid_profile": dict(sorted(prefix_paid.items())), + "actual_old_suffix_paid_profile": dict(sorted((paid - prefix_paid).items())), + "all_register_minimal_one_jump_suffix_profile": dict(sorted(Counter( + len(end[q]) - len(end_b[q]) for q in range(size) if end[q] != end_b[q] + ).items())), + "current_width_inventory": dict(sorted(Counter(r["current_width"] for r in records).items())), + "necessary_width_inventory": dict(sorted(Counter(r["minimal_necessary_width"] for r in records).items())), + "dimension_slack_histogram": dict(sorted(Counter(r["terminal_dimension_slack"] for r in records).items())), + "row_only_dimension_slack_histogram": dict(sorted(Counter(r["row_only_dimension_slack"] for r in records).items())), + "row_only_candidates": [r["helper"] for r in records if r["row_only_dimension_slack"]], + "candidates": [r["helper"] for r in records if r["terminal_dimension_slack"]], + "records": records, + "scope": "Necessary cones for the fixed compensated scalar prefix and end-B frames under monotone equal-common-frame invertible ADD/nonzero SCALE cleanup on the same arbitrary dirty registers. No added COPY/ERASE/clean scratch or frame reset. This excludes smaller helper endpoints; it does not exclude cheaper tails at unchanged endpoints, changed prefix/end-B or other interfaces. No new exponent or full theorem claim.", + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--word", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + require(not args.out.exists(), "refusing to overwrite output") + start = time.monotonic() + raw = gzip.decompress(args.word.read_bytes()) + require(hashlib.sha256(raw).hexdigest() == WORD_SHA, "frozen word pin") + result = compute(json.loads(raw)) + result["word_content_sha256"] = WORD_SHA + result["seconds"] = time.monotonic() - start + args.out.write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({k: v for k, v in result.items() if k != "records"}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/u8-terminal-cone-census/independent.py b/research/u8-terminal-cone-census/independent.py new file mode 100644 index 0000000000..d72cbce1ad --- /dev/null +++ b/research/u8-terminal-cone-census/independent.py @@ -0,0 +1,359 @@ +"""Independent exact terminal-cone census, using dyadic matrix columns. + +No imports from the primary census or supplier verifiers. GF(2) spaces are +enumerated as sets of all their vectors, rather than Gaussian rank tests. +Prepared with OpenAI Codex assistance for ToikY. Apache-2.0. +""" +import argparse +from collections import Counter +from datetime import datetime, timezone +from functools import lru_cache +import gzip +import hashlib +import json +from pathlib import Path +import time + +WORD_SHA = "090fd574747fbf9628e70cb9beb792732914cfa52e1df147579fe4dbccc68c5a" + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def dyadic(num, den): + need(den != 0, "zero denominator") + if den < 0: + num, den = -num, -den + need(den & (den - 1) == 0, "non-dyadic coefficient") + exponent = den.bit_length() - 1 + if num: + factor = (abs(num) & -abs(num)).bit_length() - 1 + num >>= factor + exponent -= factor + return num, exponent + + +def fraction_pair(num, exponent): + if not num: + return 0, 1 + factor = (abs(num) & -abs(num)).bit_length() - 1 + num >>= factor + exponent -= factor + return (num << -exponent, 1) if exponent < 0 else (num, 1 << exponent) + + +def plus(left, right, num=1, exponent=0): + """Column vectors are (integer dictionary, shared denominator exponent).""" + ld, le = left + rd, re = right + re += exponent + e = max(le, re) + out = {k: a << (e - le) for k, a in ld.items()} + for k, b in rd.items(): + a = out.get(k, 0) + num * (b << (e - re)) + if a: + out[k] = a + else: + out.pop(k, None) + return out, e + + +def scalar(g, inverse=False): + n, d = g[3:5] if g[0] == "add" else g[2:4] + if inverse: + if g[0] == "add": + n = -n + else: + n, d = d, n + n, e = dyadic(n, d) + need(n != 0, "zero scalar primitive") + return n, e + + +def columns(gates, size, inverse=False): + """Right-multiply elementary matrices: chronological gates go in reverse. + + For a shear t += c*s, M*G changes column s, by c times column t. + Inverse factors are right-multiplied in original chronological order. + """ + result = [({q: 1}, 0) for q in range(size)] + seq = gates if inverse else reversed(gates) + for g in seq: + n, e = scalar(g, inverse) + if g[0] == "add": + t, s = g[1:3] + need(t != s and 0 <= t < size and 0 <= s < size, "invalid shear") + result[s] = plus(result[s], result[t], n, e) + elif g[0] == "scale": + q = g[1] + vals, old_e = result[q] + result[q] = ({k: n * a for k, a in vals.items()}, old_e + e) + else: + raise ValueError("unknown primitive") + return result + + +def canon_columns(matrix): + return [{q: fraction_pair(n, e) for q, n in col.items()} for col, e in matrix] + + +def matrix_sha(matrix): + return hashlib.sha256(json.dumps(canon_columns(matrix), sort_keys=True, + separators=(",", ":")).encode()).hexdigest() + + +@lru_cache(maxsize=None) +def space(generators): + members = {0} + for g in generators: + need(isinstance(g, int) and 0 <= g < 512, "GF2 vector out of range") + members |= {x ^ g for x in members} + return frozenset(members) + + +@lru_cache(maxsize=None) +def basis(members): + # The smallest vector of each leading-bit class is its reduced pivot. + return tuple(min(x for x in members if x.bit_length() == b) + for b in range(9, 0, -1) + if any(x.bit_length() == b for x in members)) + + +def dimension(members): + need(len(members) & (len(members) - 1) == 0, "not a subspace cardinality") + return len(members).bit_length() - 1 + + +def join(spaces): + out = space(()) + for s in spaces: + if not s <= out: + out = space(tuple(basis(out)) + tuple(basis(s))) + return out + + +def touched(g): + return g[1:3] if g[0] == "add" else g[1:2] + + +def frames(word, v, helpers): + full = space(tuple(1 << b for b in range(9))) + start = [space((q,)) for q in word["ports"]] + [space(())] * (v + helpers) + for q, f in word.get("start_extra", {}).items(): + start[int(q)] = space(tuple(f)) + end = [full] * v + [frozenset(x for x in range(512) + if (x & port).bit_count() % 2 == 0) + for port in word["ports"]] + [full] * helpers + for q, f in word.get("helper_final", {}).items(): + end[int(q)] = space(tuple(f)) + cur, paid = list(start), Counter() + + def ascend(q, f): + need(cur[q] <= f, "nonmonotone frame") + d = dimension(f) - dimension(cur[q]) + if d: + paid[d] += 1 + cur[q] = f + + for section in ("A", "B"): + if section == "B": + levels = {int(q): space(tuple(f)) for q, f in word.get("target_levels", {}).items()} + need(all(cur[v + q] == levels.get(q, space(())) for q in range(v)), "target boundary") + for q, raw in zip(word["centers"], word["center_frames"]): + f = space(tuple(raw)) + need(cur[q] == f, "center boundary") + children = {levels.get(g[1] - v, space(())) for g in word["cut"] if g[2] == q} + for child in sorted(children, key=lambda x: -dimension(x)): + need(child <= f, "non-nested center child") + if child != f: + paid[dimension(f) - dimension(child)] += 1 + f = child + for g in word[section]: + for q in touched(g): + ascend(q, space(tuple(g[-1]))) + end_b = list(cur) + early = word.get("early_cleanup", []) + early_ids = {i for i, _ in early} + need(len(early_ids) == len(early), "repeated early cleanup index") + tail = [word["cleanup"][i][:-1] + [f] for i, f in early] + cleanup = [g for i, g in enumerate(word["cleanup"]) if i not in early_ids] + for g in tail: + for q in touched(g): + ascend(q, space(tuple(g[-1]))) + for q, f in enumerate(end): + ascend(q, f) + need(dict(paid) == {int(k): n for k, n in word["report"]["local_profile"].items()}, "profile mismatch") + need(all(end[q] == full for g in cleanup for q in touched(g)), "cleanup beyond endpoint") + return start, end_b, end, tail, cleanup, paid + + +def reconstruct(word): + v, h, helpers = [word["report"][k] for k in ("v", "h", "R")] + need((v, h, helpers) == (112, 9, 504), "wrong pinned geometry") + size = 2 * v + helpers + core = word["A"] + word["cut"] + word["B"] + core_m = columns(core, size) + pre_m = columns(word["precondition"], size) + compensation = [] + # Compose the target-only response with the precondition as matrix columns. + for helper in range(2 * v, size): + response = ({}, 0) + vals, exponent = core_m[helper] + for q, n in vals.items(): + if v <= q < 2 * v: + response = plus(response, pre_m[q], n, exponent) + vals, exponent = response + need(all(v <= q < 2 * v for q in vals), "compensation left target chart") + for q, n in vals.items(): + a, b = fraction_pair(-n, exponent) + compensation.append(["add", q, helper, a, b, []]) + compensation.sort(key=lambda g: (g[1], g[2])) + prefix = word["precondition"] + compensation + core + p, inv = columns(prefix, size), columns(prefix, size, True) + start, end_b, end, tail, cleanup, paid = frames(word, v, helpers) + complete = canon_columns(columns(prefix + tail + cleanup, size)) + expected = [{q: (1, 1), **({v + q: (1, 1)} if q < v else {})} for q in range(size)] + need(complete == expected, "complete endpoint not exact on arbitrary columns") + undo = [] + for g in reversed(prefix): + n, e = scalar(g, True) + a, b = fraction_pair(n, e) + undo.append(["add", g[1], g[2], a, b, []] if g[0] == "add" + else ["scale", g[1], a, b, []]) + need(canon_columns(columns(prefix + undo, size)) == [{q: (1, 1)} for q in range(size)], + "exact inverse composition failed") + inv_rows = [[] for _ in range(size)] + p_rows = [[] for _ in range(size)] + for k, (col, _) in enumerate(inv): + for q in col: + inv_rows[q].append(k) + for k, (col, _) in enumerate(p): + for q in col: + p_rows[q].append(k) + records, row_records = [], [] + for q in range(2 * v, size): + inverse_support = inv_rows[q] + dirty_support = sorted(k for k in p[q][0] if k != q) + row_cone = join(end_b[k] for k in [q] + inverse_support) + both_cone = join([row_cone] + [end_b[k] for k in dirty_support]) + need(both_cone <= end[q], "existing endpoint fails joined admission cone") + records.append({ + "helper": q - 2 * v, "register": q, + "start_frame": list(basis(start[q])), "end_b_frame": list(basis(end_b[q])), + "current_terminal_frame": list(basis(end[q])), + "minimal_necessary_terminal_frame": list(basis(both_cone)), + "inverse_row_support": inverse_support, "dirt_column_support": dirty_support, + "current_width": dimension(end[q]) - dimension(start[q]), + "minimal_necessary_width": dimension(both_cone) - dimension(start[q]), + "terminal_dimension_slack": dimension(end[q]) - dimension(both_cone), + "full_cleanup_incidence": sum(q in touched(g) for g in cleanup), + }) + row_records.append({"helper": q - 2 * v, "register": q, + "row_only_frame": list(basis(row_cone)), + "row_only_dimension": dimension(row_cone), + "row_only_terminal_gap": dimension(end[q]) - dimension(row_cone)}) + return { + "status": "PASS_INDEPENDENT_EXACT_COLUMN_CONE_CENSUS", + "algorithm": "Right-composed sparse integer dyadic columns; all-vector GF2 subspaces; no primary or supplier code imports", + "helper_count": helpers, "arbitrary_input_columns": size, + "compensation_gates": len(compensation), "prefix_gates": len(prefix), + "compensation_sha256": hashlib.sha256(json.dumps(compensation, separators=(",", ":")).encode()).hexdigest(), + "forward_matrix_sha256": matrix_sha(p), "inverse_matrix_sha256": matrix_sha(inv), + "exact_full_endpoint_identity": True, "exact_prefix_inverse_identity": True, + "local_profile": dict(sorted(paid.items())), + "current_width_inventory": dict(sorted(Counter(r["current_width"] for r in records).items())), + "necessary_width_inventory": dict(sorted(Counter(r["minimal_necessary_width"] for r in records).items())), + "dimension_slack_histogram": dict(sorted(Counter(r["terminal_dimension_slack"] for r in records).items())), + "candidates": [r["helper"] for r in records if r["terminal_dimension_slack"]], + "row_only_gap_histogram": dict(sorted(Counter(r["row_only_terminal_gap"] for r in row_records).items())), + "row_only_gap_helpers": [r["helper"] for r in row_records if r["row_only_terminal_gap"]], + "records": records, "row_only_records": row_records, + "scope": "Exact finite census. Joined cone excludes smaller endpoints under retained row/column admission contract. Row-only information-flow claim and separately argued column invariant are documented in AUDIT.md; no sufficient cleanup or exponent claim.", + } + + +def controls(): + out = [] + gates = [["add", 0, 1, 1, 2, []], ["add", 0, 1, -1, 2, []]] + exact = canon_columns(columns(gates, 2)) + need(exact == [{0: (1, 1)}, {1: (1, 1)}], "cancellation positive control") + # A support-only union mutant retains the cancelled (row0,column1) term. + support_mutant = [{0}, {0, 1}] + need(support_mutant != [set(c) for c in exact], "zero-union mutant escaped") + out.append({"name": "exact_zero_cancellation", "positive": True, "negative_rejected": True, + "cancelled_entry": [0, 1]}) + noncommuting = [["add", 0, 1, 1, 1, []], ["add", 1, 2, 1, 1, []]] + forward, inverse = columns(noncommuting, 3), columns(noncommuting, 3, True) + frow = [k for k, (col, _) in enumerate(forward) if 0 in col] + irow = [k for k, (col, _) in enumerate(inverse) if 0 in col] + need(frow == [0, 1] and irow == [0, 1, 2], "inverse-row orientation positive control") + need(frow != irow, "forward-row substitution escaped") + out.append({"name": "inverse_not_forward_row", "positive": True, "negative_rejected": True, + "forward_support": frow, "inverse_support": irow}) + f = [space((1,)), space((2,))] + shear = columns([["add", 1, 0, 1, 1, []]], 2) + dirty = sorted(k for k in shear[0][0] if k != 0) + row_only = f[0] + joined = join([row_only] + [f[k] for k in dirty]) + need(dirty == [1] and dimension(row_only) == 1 and dimension(joined) == 2, + "dirty-column positive control") + need(row_only != joined, "omitted dirty-column mutant escaped") + out.append({"name": "dirty_column_not_optional_in_contract", "positive": True, + "negative_rejected": True, "row_only_dimension": 1, "joined_dimension": 2}) + correct = join([space((1,)), space((2,)), space((3,))]) + need(correct == frozenset({0, 1, 2, 3}) and basis(correct) == (2, 1), "GF2 join positive control") + wrong = (3, 2, 1) + need(wrong != basis(correct), "deduplicated-generator-rank mutant escaped") + out.append({"name": "GF2_join_is_span_not_generator_count", "positive": True, + "negative_rejected": True, "rank": 2, "dependent_generator_count": 3}) + return out + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--word", type=Path, required=True) + parser.add_argument("--primary", type=Path, required=True) + parser.add_argument("--out", type=Path, required=True) + args = parser.parse_args() + need(not args.out.exists(), "refusing overwrite of a receipt") + started = time.monotonic() + compressed = args.word.read_bytes() + raw = gzip.decompress(compressed) + need(hashlib.sha256(raw).hexdigest() == WORD_SHA, "raw word content pin mismatch") + result = reconstruct(json.loads(raw)) + primary_raw = args.primary.read_bytes() + primary = json.loads(primary_raw) + fields = ["helper_count", "arbitrary_input_columns", "compensation_gates", "prefix_gates", + "local_profile", "current_width_inventory", "necessary_width_inventory", + "dimension_slack_histogram", "candidates", "records"] + # JSON roundtrip normalizes integer dictionary keys for the independent result. + normalized = json.loads(json.dumps(result)) + # Primary adds explanatory fields; compare every independently derived field. + primary_common = dict(primary) + primary_common["records"] = [{k: row[k] for k in expected} + for row, expected in zip(primary["records"], normalized["records"])] + need(len(primary["records"]) == len(normalized["records"]), "record count mismatch") + mismatches = [k for k in fields if normalized[k] != primary_common[k]] + need(not mismatches, "primary comparison mismatch: " + repr(mismatches)) + result["compared_primary_fields"] = fields + result["all_504_records_match_primary"] = True + result["semantic_controls"] = controls() + changed = bytearray(raw) + changed[-2] ^= 1 + need(hashlib.sha256(changed).hexdigest() != WORD_SHA, "source corruption control escaped") + result["source_pin_control"] = {"one_byte_content_change_rejected_before_parse": True} + result["pins"] = {"word_path": str(args.word.resolve()), "word_content_sha256": WORD_SHA, + "word_gzip_sha256": hashlib.sha256(compressed).hexdigest(), + "primary_path": str(args.primary.resolve()), + "primary_result_sha256": hashlib.sha256(primary_raw).hexdigest(), + "independent_script_sha256": hashlib.sha256(Path(__file__).read_bytes()).hexdigest()} + result["recorded_utc"] = datetime.now(timezone.utc).isoformat() + result["seconds"] = time.monotonic() - started + args.out.write_text(json.dumps(result, indent=2) + "\n") + print(json.dumps({k: v for k, v in result.items() if k not in ("records", "row_only_records")}, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/u8-terminal-cone-census/inputs/U8-WORD.json.gz b/research/u8-terminal-cone-census/inputs/U8-WORD.json.gz new file mode 100644 index 0000000000..2671d8c3dc Binary files /dev/null and b/research/u8-terminal-cone-census/inputs/U8-WORD.json.gz differ diff --git a/research/u8-terminal-cone-census/verify.py b/research/u8-terminal-cone-census/verify.py new file mode 100644 index 0000000000..c11bdb3b4a --- /dev/null +++ b/research/u8-terminal-cone-census/verify.py @@ -0,0 +1,153 @@ +"""Reproduce the exact U8 census and controls, using two independent methods. + +Standard library only, Python >=3.10. Apache-2.0. +Prepared with substantial OpenAI Codex assistance for ToikY. +""" +import argparse +from collections import Counter +import gzip +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def check_sources(root): + manifest = json.loads((root / "MANIFEST.json").read_text()) + actual = {p.relative_to(root).as_posix() for p in root.rglob("*") + if p.is_file() and p.name != "MANIFEST.json" and "__pycache__" not in p.parts} + need(actual == set(manifest), "source closure differs from manifest") + for name, expected in manifest.items(): + path = root / name + need(path.resolve().is_relative_to(root.resolve()), "manifest path escapes package") + need(digest(path) == expected, "source hash mismatch: " + name) + sources = json.loads((root / "SOURCES.json").read_text()) + word = root / "inputs/U8-WORD.json.gz" + need(digest(word) == sources["word_gzip_sha256"], "immutable input container mismatch") + need(hashlib.sha256(gzip.decompress(word.read_bytes())).hexdigest() + == sources["word_raw_sha256"], "word content mismatch") + return len(manifest) + + +def load_census(root): + spec = importlib.util.spec_from_file_location("u8_cone_primary", root / "census.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def run(script, arguments, optimized=False): + flags = ["-I", "-B"] + (["-O"] if optimized else []) + env = dict(os.environ, OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", MKL_NUM_THREADS="1") + return subprocess.run([sys.executable, *flags, str(script), *map(str, arguments)], + env=env, capture_output=True, text=True, timeout=30) + + +def record_controls(module, certificate): + records = certificate["records"] + need(len(records) == 504 and [r["helper"] for r in records] == list(range(504)), + "not a complete unique helper census") + current_ok, smaller_rejected = 0, 0 + for row in records: + cone = tuple(row["minimal_necessary_terminal_frame"]) + old = tuple(row["current_terminal_frame"]) + need(module.included(cone, old), "old endpoint control rejected") + current_ok += 1 + # Every deletion from the literal independent basis is a proper subspace. + for index in range(len(old)): + proposed = module.span(old[:index] + old[index + 1:]) + need(not module.included(cone, proposed), "proper endpoint deletion escaped") + smaller_rejected += 1 + exceptions = [r for r in records if r["row_only_dimension_slack"]] + need([r["helper"] for r in exceptions] == [347, 349, 359, 361, 370, 371, 372, 373], + "row-only exception control") + need(all(len(r["row_and_monotonicity_minimum"]) == 8 + and len(r["minimal_necessary_terminal_frame"]) == 9 + and r["column_blockers_for_row_minimum"] for r in exceptions), + "omitted dirty-column control escaped") + for row in exceptions: + need(not module.included(tuple(row["minimal_necessary_terminal_frame"]), + tuple(row["row_and_monotonicity_minimum"])), + "row-only endpoint accepted") + prefix = Counter({int(k): n for k, n in certificate["fixed_prefix_paid_profile"].items()}) + suffix = Counter({int(k): n for k, n in certificate["actual_old_suffix_paid_profile"].items()}) + local = Counter({int(k): n for k, n in certificate["local_profile"].items()}) + jump = Counter({int(k): n for k, n in certificate["all_register_minimal_one_jump_suffix_profile"].items()}) + mass = lambda counts: sum(r * n for r, n in counts.items()) + need(prefix + suffix == local and (mass(prefix), mass(suffix), mass(local)) == (4512, 1122, 5634), + "prefix/suffix reconstruction or mass") + need(mass(jump) == mass(suffix), "one-jump mass mismatch") + width = sum(r["current_width"] for r in records) + need(width == 3778 and 48384 - 9 * width == 14382, "complete width/idle bill") + need(73 * 896 - (9 * mass(local) + 14382) == 320, "rank deficit") + return {"old_endpoints_accepted": current_ok, + "proper_basis_deletions_rejected": smaller_rejected, + "row_only_false_admissions_rejected": len(exceptions), + "complete_cost_mass_checks": "PASS"} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--optimized", action="store_true", help="also optimize child interpreters") + args = parser.parse_args() + root = Path(__file__).resolve().parent + source_count = check_sources(root) + expected = json.loads(gzip.decompress((root / "CERTIFICATE.json.gz").read_bytes())) + module = load_census(root) + controls = record_controls(module, expected) + with tempfile.TemporaryDirectory(prefix="u8-terminal-cones-") as directory: + tmp = Path(directory) + primary = tmp / "primary.json" + result = run(root / "census.py", ["--word", root / "inputs/U8-WORD.json.gz", "--out", primary], + args.optimized) + need(result.returncode == 0, "primary failed: " + result.stderr) + observed = json.loads(primary.read_text()) + observed.pop("seconds") + need(observed == expected, "recomputed exact certificate mismatch") + independent = tmp / "independent.json" + result = run(root / "independent.py", ["--word", root / "inputs/U8-WORD.json.gz", + "--primary", primary, "--out", independent], args.optimized) + need(result.returncode == 0, "independent failed: " + result.stderr) + audit = json.loads(independent.read_text()) + need(audit["all_504_records_match_primary"] and all( + r["positive"] and r["negative_rejected"] for r in audit["semantic_controls"]), + "independent controls incomplete") + row_frames = {r["helper"]: r["row_only_frame"] for r in audit["row_only_records"]} + need(all(r["row_and_monotonicity_minimum"] == row_frames[r["helper"]] + for r in expected["records"]), "independent row-only frame mismatch") + corrupt = tmp / "corrupt.json.gz" + raw = bytearray(gzip.decompress((root / "inputs/U8-WORD.json.gz").read_bytes())) + raw[-2] ^= 1 + corrupt.write_bytes(gzip.compress(raw, mtime=0)) + absent = tmp / "must-not-exist.json" + result = run(root / "census.py", ["--word", corrupt, "--out", absent], args.optimized) + need(result.returncode != 0 and "frozen word pin" in result.stderr and not absent.exists(), + "corrupted input CLI control escaped") + before = primary.read_bytes() + result = run(root / "census.py", ["--word", root / "inputs/U8-WORD.json.gz", "--out", primary], + args.optimized) + need(result.returncode != 0 and "refusing to overwrite" in result.stderr + and primary.read_bytes() == before, "output-preservation control escaped") + print(json.dumps({"status": "PASS_EXACT_INDEPENDENT_U8_TERMINAL_CONE_CENSUS", + "source_files_checked": source_count, "helpers": 504, "arbitrary_columns": 728, + "independent_semantic_mutations_rejected": len(audit["semantic_controls"]), + "corrupted_input_cli_rejected": True, "existing_output_preserved": True, + "controls": controls, "optimized_children": args.optimized, + "scope": "fixed-prefix/end-B monotone common-frame endpoints; no kappa or tail-optimality claim"}, indent=2)) + + +if __name__ == "__main__": + main()