diff --git a/research/k492-emitter-independent-controls/INPUT-PINS.json b/research/k492-emitter-independent-controls/INPUT-PINS.json new file mode 100644 index 0000000000..47b599a4b0 --- /dev/null +++ b/research/k492-emitter-independent-controls/INPUT-PINS.json @@ -0,0 +1,108 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": { + "research/community-k492-audit/pr626/replay/mixed-global/PLAN.json": { + "bytes": 474252, + "sha256": "2956331d3ba73c564ac757c6667bba5dea7d19207582341d7c829d8401049c04" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CANONICAL-WORD.json.gz": { + "bytes": 92137, + "payload_sha256": "9bbc75dede090cfd7a0a0252424ea9d9f6211e2350d2a801d4e4f2f0784167c7", + "sha256": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CLIFFORD-RECIPES.json": { + "bytes": 1044060, + "sha256": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CLIFFORD-REVIEW.json": { + "bytes": 655, + "sha256": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/INDEPENDENT-LOCAL-REPLAY.json": { + "bytes": 2309, + "sha256": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-CHECKS.json": { + "bytes": 920, + "sha256": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-PROGRAMS.json.gz": { + "bytes": 227308, + "payload_sha256": "854f17274092263dc25e60367f4cd0d29f60a8446becd17cc1883ebed7a97900", + "sha256": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/RESIDUAL-ADAPTERS.json": { + "bytes": 21482, + "sha256": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CANONICAL-WORD.json.gz": { + "bytes": 94957, + "payload_sha256": "fb4a8d14ed2a8048698bea6ae16f86163a1aa6c80f2eb622222eee5cdbce9b3b", + "sha256": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CLIFFORD-RECIPES.json": { + "bytes": 1015814, + "sha256": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CLIFFORD-REVIEW.json": { + "bytes": 655, + "sha256": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": { + "bytes": 2370, + "sha256": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-CHECKS.json": { + "bytes": 920, + "sha256": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-PROGRAMS.json.gz": { + "bytes": 233037, + "payload_sha256": "efe45ce7fb025a6f53cc9eb54e951ac2211a5ed927e689a049e4f68ca680654b", + "sha256": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/RESIDUAL-ADAPTERS.json": { + "bytes": 15417, + "sha256": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/split-centres/CANONICAL-WORD.json.gz": { + "bytes": 70587, + "payload_sha256": "62684fd4d4ffabf3b2f2ce4bc8ccdad07bcc7f2685aec86761cfebe1c39e7a0c", + "sha256": "66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/work/complex-nine-native/DATA-PHASES.json": { + "bytes": 814141, + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "research/community-k492-audit/pr626/replay/mixed-global/hosted/HOSTED.json": { + "bytes": 2904, + "sha256": "29073870df4e5e2b15fa51624599a1a30a5accb93e6d4557a77b86cfbfb8cbbc" + }, + "research/complex-k492-owner-repair/PROOF-NOTE-R.md": { + "bytes": 9555, + "sha256": "22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed" + }, + "research/complex-k492-owner-repair/code/emit_allcold.py": { + "bytes": 13090, + "sha256": "fe26f10fe5d30ed407a37540a45ef94f44576dd241d09e19aef5db1efb072746" + }, + "research/complex-k492-owner-repair/code/witness.py": { + "bytes": 2102, + "sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "research/complex-k492-owner-repair/data/OWNERS.json.gz": { + "bytes": 415526, + "payload_sha256": "cacbaa6b27e0d612b77f2d6fed40eb99a6245f690eb771ffbf76655484866201", + "sha256": "251e82cec1f40e6c1289703667f403104b957f1254dc4f6baa6df9a3d0c751de" + }, + "research/complex-k492-owner-repair/data/SPEC.json": { + "bytes": 47328, + "sha256": "2a2577ac526535826fed9d5f7f83f6e2e0ec058a146c64f7286720b995fa2323" + }, + "research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz": { + "bytes": 398090, + "payload_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "sha256": "ab8448de2036a23d9b55a196a8846512dc24fdf09855c1e0f0caa5b7a6965f7b" + } + } +} diff --git a/research/k492-emitter-independent-controls/MANIFEST.json b/research/k492-emitter-independent-controls/MANIFEST.json new file mode 100644 index 0000000000..695a2217c7 --- /dev/null +++ b/research/k492-emitter-independent-controls/MANIFEST.json @@ -0,0 +1,72 @@ +{ + "algorithm": "sha256", + "files": { + "INPUT-PINS.json": "22292db50241f5a8865dd20a7b67903635a93d0460a55f4998e633833d627dea", + "OVERLAP.md": "57b6d02bda5a975709eeb05f013d2dfcfd6b3534d540c772bfd1612413f079f4", + "PUBLICATION.md": "68b7279a8fc124f54253220a0580790efcb25c334d055b1cbe275f1fa2b2da33", + "README.md": "4943c75fd3ce8f7e385795f264ba27e11c978ec6e1af1ec5eb37dc8295b9343b", + "REVIEW.md": "b36e60b09f0441bea764b4623bbb4ef8ef426e8cde93697c57b1a96088f7d774", + "evidence/BASELINE.json": "648cf66e67fe6bb92676ae2d1aa780afe62858336478a034e54e1587879f4c1c", + "evidence/ENVIRONMENT.json": "f295be1c3457a2fe4730a5cb664ae7327a14c47a0e8fafb56ac48614124858a0", + "evidence/INPUT-PINS.json": "22292db50241f5a8865dd20a7b67903635a93d0460a55f4998e633833d627dea", + "evidence/PUBLICATION-NORMALIZATION.json": "88975cbb024076910ec5790f5c15d854ffafd4b65bd94aaa9c0f9da568368efd", + "evidence/PUBLICATION-OVERLAP.json": "ae77eee0e280f37fcaf07899d8e749242e40e6b830e293cced36d04633021d9b", + "evidence/RESULT.json": "2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9", + "evidence/SEMANTIC-CONTROLS.json": "963ce82ddb5baa4c1c8555ceab60a2bccbbbc11bd72c553e3b15520b45062337", + "evidence/SOURCE-REVERTS.json": "89af5468f28d22f99d4f10b30c95864e546b332c8b4d2e66225d714602c2dadf", + "evidence/astra-receipt-review.json": "3cf4f94e784d1288018649c4d9f1d79e7bba52907e1bf3e732b55641d21b90b0", + "evidence/astra-run-command.json": "6a05dba263a2c45d8d65a91d8e9be9d4f1ae139b3612a1a7608cb6015eb18eae", + "evidence/astra-run-stdout.txt": "b00f16b4c6384da6bcb26fa07a5b8c35c7ba58cba793d3098c3f3b6e7c969d8a", + "evidence/baseline-preservation.json": "98ad0da20ba01f5e2220d3755846c9320f9ed0e42300cd67f80c68fe332b6a81", + "evidence/baseline/COMMAND.json": "b29c0936243036305b94cf28db4c777ff0dba22455a935a2dc00a0ec94be8f7c", + "evidence/baseline/emitted/ACTUAL-SIGMAS.json.gz": "422568f2ccb849b36a1ae5440edfdee6c53b0a1501e77132ad352e6296fa4b5d", + "evidence/baseline/emitted/GLOBAL-TEMPLATE.json.gz": "e9b0432d25980181c2168869baaa469e8849d16aa0b9af6c3c6ea28d04fc5a13", + "evidence/baseline/emitted/HOSTED.json": "29073870df4e5e2b15fa51624599a1a30a5accb93e6d4557a77b86cfbfb8cbbc", + "evidence/baseline/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/baseline/stdout.txt": "29073870df4e5e2b15fa51624599a1a30a5accb93e6d4557a77b86cfbfb8cbbc", + "evidence/emit.R_from_providers/COMMAND.json": "6ef62d77423ff46b3c723ce43e70f7002d1fa21786441afe49d0a2a3d624c620", + "evidence/emit.R_from_providers/source.patch": "7e3ab5b75e822f0fc682175797b29e9501d01bd81851b2cc6a0596686c926196", + "evidence/emit.R_from_providers/stderr.txt": "da6603310b6fb689386abcf980e1bee487947deaed52811adb92a5ee3b0919ae", + "evidence/emit.R_from_providers/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.all_helpers_owned/COMMAND.json": "334c7c891dbfdef09072d116aa276aaa3352ac7793dcbd2e76914fc622f47b8e", + "evidence/emit.all_helpers_owned/source.patch": "a7e77a0870253a572cbdfaa98b91659806542e19e6b7f7ba63b11786c5e4deb3", + "evidence/emit.all_helpers_owned/stderr.txt": "0044b1a6d4f16f2c524815647ca95a6316f9ffc9edac7deb9dc8ec2d75263af5", + "evidence/emit.all_helpers_owned/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.parent_R0/COMMAND.json": "ff9c68bce1850a4c7903a4a9484c557ed63fc8e8eb09e47e0d793d382af1d0af", + "evidence/emit.parent_R0/source.patch": "857a3cb1b7b41f5b20559ccdc87eef6871f9ea04c6bcdaed505274f15030199a", + "evidence/emit.parent_R0/stderr.txt": "2e55da1811367dd65a0c4820ddc413355ef329daa88241e62b9b2a1a9492415b", + "evidence/emit.parent_R0/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.physical/COMMAND.json": "e3dcdd9f7873f1f3a2caeadbeab90daf0c5bb0bc93721307e6546bfec7a5dede", + "evidence/emit.physical/emitted/ACTUAL-SIGMAS.json.gz": "422568f2ccb849b36a1ae5440edfdee6c53b0a1501e77132ad352e6296fa4b5d", + "evidence/emit.physical/emitted/GLOBAL-TEMPLATE.json.gz": "0e44480276f3c5f2fefaf606c86cc27065503055e6fa4075cc08df3acabf1f7c", + "evidence/emit.physical/emitted/HOSTED.json": "fdbf2adc8e75ef0b867fceef7ce67f341dc90d9ff078ea7c1c9fb514fe4dafac", + "evidence/emit.physical/source.patch": "5aee9de2b1eca3e094e991fd4db471151b96216fa2f999889d47fedcba5110a9", + "evidence/emit.physical/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.physical/stdout.txt": "fdbf2adc8e75ef0b867fceef7ce67f341dc90d9ff078ea7c1c9fb514fe4dafac", + "evidence/emit.reserved_tableau/COMMAND.json": "193ec9005755acdcf369aeb00324a376adf5ae4e56cdf5e5d62c69921abef351", + "evidence/emit.reserved_tableau/emitted/ACTUAL-SIGMAS.json.gz": "422568f2ccb849b36a1ae5440edfdee6c53b0a1501e77132ad352e6296fa4b5d", + "evidence/emit.reserved_tableau/emitted/GLOBAL-TEMPLATE.json.gz": "8353644263c4143ccf177994ad9cb682991ac0285eebe51964e058cd8b035977", + "evidence/emit.reserved_tableau/emitted/HOSTED.json": "7c7c6b20c48e6f301ad48666443c7f71728285552a63fc146d8c300165258b09", + "evidence/emit.reserved_tableau/source.patch": "301c6ce54d528fd7d5cb764cc136c6c7b5eb46c7453ece8d3d0be6e0e78f98d8", + "evidence/emit.reserved_tableau/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.reserved_tableau/stdout.txt": "7c7c6b20c48e6f301ad48666443c7f71728285552a63fc146d8c300165258b09", + "evidence/emit.roles_72R/COMMAND.json": "7822e3b9916b38329eba7b6389c4fa00a075ee867a631cfe8f3b24e5a93125c4", + "evidence/emit.roles_72R/source.patch": "5d2116d58e86c99d55ae572fd80160c664ae47d3831a52b5b5fa1678d253e904", + "evidence/emit.roles_72R/stderr.txt": "cc2b024bae007f75c2a0c8d542166f8f615297a04281485d76899d14fb8821cc", + "evidence/emit.roles_72R/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.version_label/COMMAND.json": "00ab2a1976da007d0554f36cf998bd04a2d6ea4b259f249b89f0a638b21f2506", + "evidence/emit.version_label/emitted/ACTUAL-SIGMAS.json.gz": "422568f2ccb849b36a1ae5440edfdee6c53b0a1501e77132ad352e6296fa4b5d", + "evidence/emit.version_label/emitted/GLOBAL-TEMPLATE.json.gz": "6c51fc435fb42e1216c9a41c70ee3f70c1bb168b47b44df8bf13bd4ce2bb9a61", + "evidence/emit.version_label/emitted/HOSTED.json": "62a2e8722535f3f34acda6843516b1601272832be17d2917577fb9d1491e06c7", + "evidence/emit.version_label/source.patch": "6f6cb22a3e7f0c3e451eda198ce23d4223abf360bf911068838bbae11510d1cf", + "evidence/emit.version_label/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/emit.version_label/stdout.txt": "62a2e8722535f3f34acda6843516b1601272832be17d2917577fb9d1491e06c7", + "evidence/emit.widths_range/COMMAND.json": "dab77d88e1d0786660dfa754a272e615b0945bafefe27982f414d7250a900af3", + "evidence/emit.widths_range/source.patch": "1d7d20404d5e9e36f8fc3b7e448fa737e5bd75c334ea074b291e8e47337bd3ff", + "evidence/emit.widths_range/stderr.txt": "f1c096f9dd9b4732a2ec254b351e5fc74e27eac881cb8466875979bbbe2d9476", + "evidence/emit.widths_range/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/overlap-summary.json": "f740780fbfec7af0a512af96f3a7b443074219ae2955c727a434f6456c04701f", + "independent.py": "755f2c39697d33f2f2c431605dcdc59c7753e4cfae497d40482ab40b7d0f9016", + "run.py": "fbb04bc8c097b82db4a09af69ae62c1b7ab07f522a9726ff573ea64e485a9aa8" + } +} diff --git a/research/k492-emitter-independent-controls/OVERLAP.md b/research/k492-emitter-independent-controls/OVERLAP.md new file mode 100644 index 0000000000..aad4700fbe --- /dev/null +++ b/research/k492-emitter-independent-controls/OVERLAP.md @@ -0,0 +1,89 @@ +# K492 overlap and control-slice audit + +Packaging note: the summary named below is retained at +[`evidence/overlap-summary.json`](evidence/overlap-summary.json). Original source +acquisition hashes and snapshot details are preserved in that summary. + +## Publication refresh, 2026-10-13 19:18 UTC + +The publication review at integration base +`ce7ad1b6ab09452c3478723a2e96ed5ff212dc08` searched 767 unique open and 383 unique +closed PR titles/bodies, including 323 merged PRs, and searched current main for +the exact eight emitter-site names. No equivalent eight-site emitter replay was +identified. The later issue inventory contained an additional unrelated #1153; +these independently paginated snapshots are non-atomic. Exact source heads, +timestamps, acquisition hashes, evidence levels and limitations are recorded in +[`evidence/PUBLICATION-OVERLAP.json`](evidence/PUBLICATION-OVERLAP.json). + +#766 and #724 remain open at the heads below. Newly identified partial overlap +includes [#780](https://github.com/CrocSwap/integer-mult-bounds/pull/780), an open +independent sorted-interval endpoint check of the same owner footprints, and +merged [#727](https://github.com/CrocSwap/integer-mult-bounds/pull/727), its related +bitmask optimization. Merged [#819](https://github.com/CrocSwap/integer-mult-bounds/pull/819) +addresses gzip-portable native-owner input binding. This package claims no new +R/R0 distinction, interval method or gzip-insensitive comparison technique. +Its distinct scope is execution of the eight emitter sites with the stated +independent output contract. #675's owner-window work has also merged. + +Merged [#806](https://github.com/CrocSwap/integer-mult-bounds/pull/806) supplies +a related digest-propagation diagnostic. Its maintainer note expressly limits +that result: whole-file digest substitution does not prove that only timing +changed, and unavailable historical CI payloads remain unverified. + +The current selected record is #1094. References to selected #626 in the original +audit below describe the historical baseline; its source tree and maintainer +review are unchanged at the integration base. No global novelty guarantee follows +from this scoped screening, and no pending contributor code was executed. + +## Original source and control-slice audit + +Audit completed 2026-10-13 UTC against repository HEAD `66849e1475c930fd7732b1a0067ffee7e1e95f60`. The selected source remains PR626 `660de893d27bb7abd1d5b01b1640207528a5c851`, conditional κ `51110230636731/31250000000000000`. This is a read-only source/claim audit, not execution of the pending contributions. + +**Recommendation:** independently exercise the complete eight `emit.*` rows of `research/complex-k492-owner-repair/PROOF-NOTE-R.md`. No inspected public contribution claims that source-control slice. It is a coherent addition covering provider cardinality, complete ownership, output stock/tableau geometry, parent-template separation, and a cosmetic positive control. + +## Public overlap evidence + +The saved open-PR response was last written at `2026-10-13T06:01:28.508101Z`; the issues response at `2026-10-13T06:01:38.693470Z`. These are local acquisition-file timestamps, not an atomic GitHub snapshot. The PR response has 624 rows but **623 unique PRs**: #29 appears twice with the same head. The issues response contains those same 623 PRs plus issue #650, “Can we turn on Discussions?”. No sprint coordination issue appears in this open-issue snapshot. Highest PR number is 804. Source-byte hashes and the deduplicated scanned inventory are in `overlap-summary.json`. + +Titles and bodies of the complete saved open queue were searched for K492/helper-count/R504/revert/source-file terms. The closest three contributions also received file-list and patch inspection; their saved issue-comment and review arrays are empty. + +| Contribution | Pinned head | Relevant coverage and separation | +|---|---|---| +| [#766](https://github.com/CrocSwap/integer-mult-bounds/pull/766), Gabriel Roa | `56bac6775e8882f4c3bfa0cef9bcc9a61da9ba06` | All 14 documented **assembly** source sites; 13 intended rejections and one equivalent parent-bank control. Explicitly excludes the other 18 scratch controls and original R504 fixture. Do not reproduce this package's assembly recount. | +| [#724](https://github.com/CrocSwap/integer-mult-bounds/pull/724), Sagar Thakrar | `624ccfe44b1c5816f0279481d91cca6a5a2290ab` | Independent selected-invoice recount and seven rejected mutations of **assemble.py lines 118–153**. Already resolves the contradictory R/R0 prose. It mentions `emit.parent_R0`, but does not execute `emit_allcold.py` or reproduce its eight sites. Credit the conceptual R/R0 overlap; do not claim a new discovery of that discrepancy. | +| [#729](https://github.com/CrocSwap/integer-mult-bounds/pull/729) | `deaed262cebc50bdb0c27c6ba132b8f8289b3eef` | Persistent helper-frame lifetimes and a scalar-preserving monotonicity regression in the standalone interface. Different obligation. | +| [#675](https://github.com/CrocSwap/integer-mult-bounds/pull/675) | `f011d03633f0570257b653e7aa1e869b1b06d06a` | Independently audits the same 35,424 roles and event windows; bridge omission leaves timing intact but changes scalar control. Different from cardinality/source-reversion testing, though it is related selected-owner evidence. | +| [#659](https://github.com/CrocSwap/integer-mult-bounds/pull/659) | `4982f0ca66ffe0960b5a6451deb5b66b1039326b` | A changed R504 no-triangle construction. It is not the original `GlobalR/run504b` compatibility fixture. | +| [#655](https://github.com/CrocSwap/integer-mult-bounds/pull/655), [#641](https://github.com/CrocSwap/integer-mult-bounds/pull/641) | Heads recorded in JSON | Changed pivot/end constructions and spot-width controls. They neither claim nor replace the unchanged PR626 emitter reversion slice. | + +The maintainer review expressly declines to reproduce the author's unavailable 32-site scratch suite. It separately records a full R504 compatibility replay, including admission and identity controls. Those facts are compatible: **generalized R504 execution has maintainer evidence; the original scratch suite's 32-for-32 R504 reversion claim remains distinct and unreproduced.** The review ledger classifies #622–#626 as incorporated; later open claims do not supersede the selected certificate. + +## Eight-site reviewer checklist + +All locations below refer to the pinned `code/emit_allcold.py`. A mutation must match exactly one intended source expression, keep the other inputs fixed, and fail at its intended stage. Unexpected exceptions, absent fixture files, source-pin failures, or test-harness failures do not count as successful rejection controls. + +| Site | Source line | Expected behavior for the selected R492 fixture | +|---|---:|---| +| `emit.R_from_providers` | 39 | Replacing provider R by 504 reaches invalid provider helper indexing at line 42. Baseline must also require positive integer R and agreement across both providers. | +| `emit.roles_72R` | 48 | `35424 == 72*504` fails; the correct count is 72×492, versus 36,288 for R504. | +| `emit.widths_range` | 42 | Extending the helper-width loop from 492 to 504 indexes beyond the 716-column native word. Use exactly this loop, not a global replacement of every `range(R)`. | +| `emit.all_helpers_owned` | 77 | Each call owns exactly helper indices 0–491. Comparing its helper set to 0–503 fails. A total-count-only oracle is insufficient to establish per-call coverage. | +| `emit.physical` | 92 | Replacing R by 504 emits physical stock 7,682 rather than 7,670. **The emitter can emit this output.** Rejection comes from independent output geometry, corresponding to production `audit_allcold.py:85`. | +| `emit.reserved_tableau` | 96 | Correct namespace: centers `[7168,7176]`, tableau `[7176,7668]`, coefficients `[7668,7670]`. Replacing tableau R by 504 sets its end to 7,680 and violates the exact namespace. **This is a downstream output rejection**, corresponding to `audit_allcold.py:124`. | +| `emit.parent_R0` | 93 | Parent stock difference remains `12218−11704=514=8+504+2`. Replacing R0 by R492 demands 502 and fails. Despite the note's introductory sentence, this control must fail at R492; #724 already explains why. | +| `emit.version_label` | 96 | The stale `round20-R504-…` label is accepted with changed metadata. All mathematical output remains identical. The template digest and directly derived hash references change legitimately; do not hide unrelated source/artifact hash differences by normalizing all hashes. | + +Additional review checks: + +- Confirm the full eight-row list against the proof note; do not count extra harness controls as replacements for original rows. +- Keep geometry identities independent of the mutated output: R from native providers, R0 from the parent canonical word, data stock from 8×8×112, and two coefficient columns. Inherit or independently validate native frame ranks explicitly; the emitter's basis-list length calculation alone does not establish those ranks. +- Distinguish a complete emitter execution from extracted source-statement replay. The original PR626 archive omits parent/hosted `GLOBAL-TEMPLATE.json.gz`, but the parent was located at `research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz`. Its decompressed SHA-256 `7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3` exactly matches the parent digest in the archived PR626 `HOSTED.json`; this reviewer independently checked that equality. This is an exact retained parent payload, not a synthetic reconstruction. Record the donor path and semantic digest, and distinguish any remaining omitted physical/controller checks. +- A synthetic R504 positive fixture can test parameter behavior but cannot be called a reproduction of the unavailable original `GlobalR/run504b` scratch fixture. If used, describe its provenance and limited scope. +- Prove baseline acceptance first, then seven precise failing controls and the changed-label positive control. If production assertions execute, refuse optimized Python or demonstrate equivalent explicit checks. +- Compare decompressed or documented canonical payloads; do not treat gzip-container variation as a mathematical difference. Bound normalization to documented non-proof fields. + +## Scope and handoff + +The documented table has 32 sites: 14 assembly sites covered by #766's submitted claim, eight emitter sites recommended here, and ten other nonassembly sites outside this recommendation (three binder, one audit spot, four invoice, one admission-control spot, one generated-identity register). #724 supplies overlapping invoice/accounting evidence, but does **not** execute those original four invoice source-site reversions. This inventory distinguishes source-site replay from related conceptual evidence. + +The duplicate check is limited to saved public open titles/bodies, the three closest file/patch sets, the pinned repository review/ledger, and the saved sprint gist. It does not exclude private/local work, unmentioned controls buried in other PR files, closed PRs absent from the repository ledger, unqueried review-comment threads, or changes after acquisition. No external code was executed; no source, public issue, PR, claim, or selected record was changed. No source defect, new κ, complete scalar/phase/restoration replay, original scratch-suite reproduction, or full multiplication theorem is claimed. diff --git a/research/k492-emitter-independent-controls/PUBLICATION.md b/research/k492-emitter-independent-controls/PUBLICATION.md new file mode 100644 index 0000000000..641236ab07 --- /dev/null +++ b/research/k492-emitter-independent-controls/PUBLICATION.md @@ -0,0 +1,70 @@ +# Publication preparation and receipt provenance + +The scientific source baseline remains +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The integration base checked during +publication preparation is `ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`. +All 24 paths in `INPUT-PINS.json` have the same committed raw bytes at that +integration base and the pinned baseline; their decompressed payload pins also +match. The #626/R492 fixture was selected at the historical baseline. This +package makes no claim to replace or audit the current selected frontier. + +## Receipt path normalization + +An exact copy of all 65 original package files and a SHA-256 inventory were +preserved locally outside the repository before preparation. The public receipts +replace personal checkout-directory prefixes with `` and the +original external evidence-directory prefix with ``. + +Twenty execution-provenance fields in twelve JSON files were normalized: + +- `cwd` in each of the nine per-case `COMMAND.json` receipts; +- each of the eight `/command/cwd` values in `SOURCE-REVERTS.json`; +- `/argv/2` and `/cwd` in `astra-run-command.json`; +- `/run_command_receipt` in `astra-receipt-review.json`. + +The last reference names the original local receipt; its packaged copy is +[`evidence/astra-run-command.json`](evidence/astra-run-command.json). +[`evidence/PUBLICATION-NORMALIZATION.json`](evidence/PUBLICATION-NORMALIZATION.json) +records each affected JSON pointer and each file's original and published hash. +The original private prefixes are not included there. + +All preexisting hash values inside receipts remain unchanged. In particular, +the historical `comparison` and `receipt_hashes` values in +`astra-receipt-review.json` identify the original raw execution receipts. +`MANIFEST.json` supplies hashes for the current published package. Neither +`run.py` nor `independent.py`, either input-pin inventory, source patches, +stdout/stderr, emitted artifacts, mathematical results, or timestamps were +changed by normalization. Generic temporary output paths and Python/platform +details are retained as execution provenance. + +## Additional publication validation + +After reviewing the harness, independent checker, pinned emitter and witness +loader, the publication reviewer executed: + +```sh +python3 -B research/k492-emitter-independent-controls/run.py --out /tmp/k492-emitter-publication-review-20261013 +``` + +On 2026-10-13, 19:14:22–19:15:01 UTC, CPython 3.13.2 completed with exit 0 in +38.96 seconds and printed `PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE`. Both verifier +source files retained their reviewed SHA-256 values. All 24 pinned input blobs +were then checked against the integration commit above and matched exactly. +The raw validation receipts remain outside the submitted package. + +The complete baseline `HOSTED.json` equals the retained #626 receipt. Five source +controls fail at their required line and exception class, two emit artifacts +rejected by the independent geometry checks, and the changed-label control +passes. Eighteen semantic corruptions are rejected after digest refresh; the +cosmetic and actual recompression positive controls pass. + +`BASELINE.json`, `RESULT.json`, `SEMANTIC-CONTROLS.json` and `INPUT-PINS.json` from +this additional run are byte-identical to the retained package receipts. +Every non-command field in `SOURCE-REVERTS.json` is identical. Its command fields +differ only in execution metadata: paths, timing and path-dependent stderr hashes. +The unchanged `RESULT.json` SHA-256 is +`2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9`. + +This is an additional finite replay and publication check, not a new mathematical +claim, cold provider rebuild, full theorem audit or human peer review. The scope +limits and source attributions in `README.md` and `REVIEW.md` continue to apply. diff --git a/research/k492-emitter-independent-controls/README.md b/research/k492-emitter-independent-controls/README.md new file mode 100644 index 0000000000..abf18db5fd --- /dev/null +++ b/research/k492-emitter-independent-controls/README.md @@ -0,0 +1,229 @@ +# Independent reconstruction of the eight K492 emitter controls + +This package reconstructs and executes **all eight `emit.*` source-site controls** +listed in [`PROOF-NOTE-R.md`](../complex-k492-owner-repair/PROOF-NOTE-R.md), on the +retained #626 fixture selected at the historical source baseline. The fresh +unmodified emitter reproduces the retained `HOSTED.json` exactly. Five source reversions fail at their intended +emitter statements, two produce artifacts that the independent checker rejects, +and the cosmetic label reversion passes with only its label and directly derived +template digest changed. Eighteen additional semantic corruptions are rejected +after refreshing output hashes; two positive controls pass. + +The scientific source baseline is `66849e1475c930fd7732b1a0067ffee7e1e95f60`. +Publication preparation uses integration base +`ce7ad1b6ab09452c3478723a2e96ed5ff212dc08`; all 24 pinned inputs are identical at +both commits. #626 is a historical checkpoint, not the current selected frontier. +Existing construction code, input data and selected records are unchanged. +This is a finite verification contribution with no new multiplication bound. + +## Exact obligation and boundaries + +The provider count is `R=492`; the fixed parent's count is `R0=504`. The checked +contract connects those distinct quantities to the serialized emitter output: + +1. The two native provider words have 224 data columns and 492 helper columns. + Each residual width is the exact binary rank of the terminal frame minus the + entrance rank. Both frames are independent, and the entrance is contained in + the terminal span. +2. The literal allocation has one role for every element of + `{0,…,8} × {0,…,7} × {0,…,491}`. Each invocation owns 716 distinct live + families, with its first 224 data owners preserved. +3. Each helper's family, width, offset, residual coordinates and spectator + coordinates match the independently reconstructed source allocation and + frames. Sorted occupied intervals partition each consumed idle prefix. +4. Physical storage and its disjoint namespace use the provider count: + `7168+8+492+2=7670`. The parent remains at 11,704 live and 12,218 physical + rows, with stock gap `8+504+2=514`. +5. The output preserves the pinned parent's unchanged fields, expands its event + blocks in the selected complete-call order, binds every provider artifact and + source file, and contains the exact remaining idle suffixes and paid profile. + +`independent.py` imports **only Python's standard library**, not the primary +emitter, audit, invoice, assembly, witness or generated-identity modules. Binary +Gaussian elimination and sorted interval endpoints supply independent checks of +the rank and partition statements. Exact orthogonality uses integer bit parity. +The primary emitter still runs as the implementation under test, in a separate +process; its only local import is the pinned `witness.py` loader. + +This contract checks unchanged controller expansion and allocation structure. +It **does not re-prove** source owner-window feasibility, bridge timing, local +scalar identities, Clifford phases, normalization wrappers, or the validity of +the retained source native receipts. Those are inherited inputs. Informational +prose such as the version, loop-order description, helper-route description, +provider-dispatch description and receipt scope is not treated as executable +proof data. The code checks the underlying structures stated above. + +The unavailable original `Stack492/revert_controls.py`, `REVERT-492.json`, +`REVERT-504.json` and `GlobalR/run504b` fixture are not claimed to be recovered. +This is a new reconstruction on the retained selected R492 fixture. It does not +execute the other 24 source rows, the R504 suite, invoice/assembly inequalities, +or a full cold provider rebuild. All-size compilation, mutable-basis realization, +whole-call hosting, precision/tape/exact recovery and analytic transfer remain +outside this finite check. No optimality, practical speedup or full theorem proof +follows from these results. + +## Reproduce + +From the pinned repository root, with Python 3.10 or later and no third-party +packages: + +```sh +python3 -B research/k492-emitter-independent-controls/run.py --out /tmp/k492-emitter-review +``` + +The output directory must not already exist. Expected final line: + +```text +PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE +``` + +The command checks all 24 input pins before copying the fixture into the output +directory. It runs nine local emitter processes: the baseline and eight exact +single-site reversions. A reversion anchor must occur exactly once. Expected +primary failures must have the specified exception class **and terminal emitter +source line**; missing files or unrelated assertions do not count as rejections. +No network, solver, paid API or external executable is needed beyond Python. + +`INPUT-PINS.json` records immutable raw hashes and decompressed payload hashes. +Each run writes Python/platform/zlib details, checker and harness hashes, actual +commands, exit statuses, stdout/stderr digests, exact source patches, baseline +artifacts, semantic mutation recipes, and machine-readable results. Seconds and +absolute command paths are execution metadata; exact mathematical equality uses +the full decompressed JSON or explicitly identified semantic fields. Regenerated +gzip container hashes are not cross-environment acceptance criteria. + +## Fixture provenance + +The selected emitter and witness loader come from +[`complex-k492-owner-repair/code`](../complex-k492-owner-repair/code). `SPEC.json` +and `OWNERS.json.gz` are that package's unchanged selected data. The rebound plan, +two seven-artifact provider sets, parent canonical word and data-phase file come +from the retained [`community-k492-audit/pr626/replay/mixed-global`](../community-k492-audit/pr626/replay/mixed-global). + +That retained directory omits its large parent global-template container. The +identical payload is present at +[`structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz`](../structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz). +Its decompressed SHA-256 is +`7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3`, exactly the +`parent_template_sha256` in the selected retained `HOSTED.json`. This is an +identified retained payload, not a synthetic parent. The raw container is also +pinned. The baseline then reproduces the **entire** retained `HOSTED.json`. + +## Exact results + +| Quantity | Independently reconstructed value | +|---|---:| +| Provider helper count / fixed parent helper count | 492 / 504 | +| Provider helper frame pairs checked | 984 | +| Call/helper roles | 35,424 | +| Owners per invocation | 716 | +| Live / physical rows | 7,168 / 7,670 | +| Parent live / physical rows | 11,704 / 12,218 | +| Entering helper roles | 16,368 | +| Cross-replica helper roles | 28,404 | +| Idle remainder children | 2,339 | +| Actual 73-column charts | 7,672 | +| Binary Gram-matrix entries checked | 596,848 | +| Rank mass / deficit | 520,704 / 2,560 | + +The exact private intervals are centres `[7168,7176)`, helper tableau +`[7176,7668)`, and coefficients `[7668,7670)`. + +The paid profile is +`{1:181659, 2:30016, 3:31104, 4:11520, 5:5040, 6:576, 8:576, 37:1, 48:2215}`. +It is recounted from literal local-program events and the reconstructed idle +suffixes, rather than accepted from a printed total. Native width histograms are +`ck={4:30,5:48,7:68,8:92,9:254}` and +`jp8={4:30,5:48,7:36,8:112,9:266}`. + +The fresh template's canonical JSON SHA-256 is +`22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0`. + +| Source control | Observed outcome | +|---|---| +| `emit.R_from_providers` | `IndexError`, emitter line 42: a 504-helper range indexes the 492-helper word | +| `emit.roles_72R` | `AssertionError`, line 48: 35,424 roles do not equal 36,288 | +| `emit.widths_range` | `IndexError`, line 42: stale width range indexes past the word | +| `emit.all_helpers_owned` | `AssertionError`, line 77: helper domain 0–491 differs from 0–503 | +| `emit.physical` | Emitter succeeds; independent `emit.physical` rejects 7,682 instead of 7,670 | +| `emit.reserved_tableau` | Emitter succeeds; independent `emit.reserved_tableau` rejects endpoint 7,680 instead of 7,668 | +| `emit.parent_R0` | `AssertionError`, line 93: parent gap 514 differs from `8+492+2=502` | +| `emit.version_label` | Accepted; only `GLOBAL-TEMPLATE.version` and `HOSTED.template_sha256` differ | + +The proof note's general sentence saying R0 controls should pass is imprecise +for `emit.parent_R0`: that particular mutation replaces the required R0 with R. +Its table and evidence correctly expect rejection, which this run reproduces. +The separate `assemble.parent_banks` identity control is outside this slice. + +The eighteen semantic mutations cover wrong physical/tableau sizes, truncated +helper domain, family aliasing, a private family used as a live owner, false +provider R or widths, wrong residual width or spectator, omitted role or idle +remainder, changed source-event order, provider artifact link corruption, changed +retained recipe/call window, erased async parent schedule, an empty input-binding +inventory, and a false input digest. Each template-changing control recomputes +the template digest and summary digest before checking. Summary-only binding +controls retain the correct template digest and refresh the summary digest. +Source inputs remain fixed and pinned. Rejection obligations are recorded, so a +digest mismatch or unrelated exception cannot substitute for the intended check. + +The positive controls accept a cosmetic label change and actual gzip +recompression with a different timestamp/compression level. The source label +reversion is additionally compared after normalizing **only two exact fields**; +there is no blanket removal of hash or metadata fields. + +## Evidence and independent review + +[`evidence/RESULT.json`](evidence/RESULT.json) is the machine-readable outcome. +[`evidence/BASELINE.json`](evidence/BASELINE.json), +[`evidence/SOURCE-REVERTS.json`](evidence/SOURCE-REVERTS.json), and +[`evidence/SEMANTIC-CONTROLS.json`](evidence/SEMANTIC-CONTROLS.json) contain the +exact counts, eight source receipts, and twenty semantic/positive control +recipes. Each source case retains its command, stdout/stderr and exact patch; +successful emitters retain their generated artifacts. Input fixtures and copied +source files can be regenerated from the pinned source inventory. The separate +review and fresh rerun are recorded in [`REVIEW.md`](REVIEW.md). +Publication path normalization and the additional validation run are documented +in [`PUBLICATION.md`](PUBLICATION.md). + +## Prior work and attribution + +This adds the eight non-assembly emitter sites excluded by +[#766](https://github.com/CrocSwap/integer-mult-bounds/pull/766). It does not repeat +that PR's all-fourteen assembly-site suite. +[#724](https://github.com/CrocSwap/integer-mult-bounds/pull/724) already supplies +related invoice/assembly R/R0 accounting evidence and identifies the parent-R0 +conceptual distinction; the contribution here is execution of the actual emitter +sites with an independent output oracle. +[#675](https://github.com/CrocSwap/integer-mult-bounds/pull/675) concerns source +controller windows and bridge timing, which remain inherited here. The overlap +review originally screened 623 unique open PRs in 624 raw inventory rows; that +historical snapshot is retained in `OVERLAP.md`. +[#780](https://github.com/CrocSwap/integer-mult-bounds/pull/780) independently checks +the same checkpoint's owner footprints with sorted interval endpoints, and +[#727](https://github.com/CrocSwap/integer-mult-bounds/pull/727) optimizes the related +occupancy check with bitmasks. The interval technique is not claimed as new here; +the contribution is the complete eight-emitter source-control reconstruction and +its separately expressed output contract. Overlap screening is a scoped snapshot, +not a guarantee against concurrent or unpublished work. +[#819](https://github.com/CrocSwap/integer-mult-bounds/pull/819) supplies related +gzip-portable native-owner binding; gzip-insensitive comparison is likewise not +claimed as a new technique. The publication refresh screened 767 open and 383 +closed PR titles/bodies and is recorded alongside the original overlap audit. +The source heads and precise overlap boundaries are in [`OVERLAP.md`](OVERLAP.md). + +K492 suppliers and the R generalization retain Jeremy Kothe / `jeremykothe2` and +the GlobalR, AtomReviewer, AtomScout, Stack492, Port480 and ColdBeyond credits. +The selected owner allocation retains Chafik Boukhalfa / `chafreaky`'s #626 credit, +the #623 dispatch/seed-map credit, GamingPuzzled's owner-headroom lead, and all +DreamingOfClouds / earlier-source attributions in the original +[`NOTICE.md`](../complex-k492-owner-repair/NOTICE.md). No source notice is replaced. + +The independent reconstruction and adversarial-hash methodology was informed by +the pinned [Krenn independent verifier](https://github.com/brianross93/Krenn/blob/ab446724a61a293a3268c63b9e9e721c6a360561/experiments/krenn_quantum_graph/independent_verifier.py) +and [ThetaTwist exact derivation](https://github.com/brianross93/thetatwist/blob/b4ec6c13088b89961834cc675b44b81372199b02/PROOF.md). +No theorem or result from those unrelated systems is imported into this check. + +Prepared for Brian Ross with substantial OpenAI Codex / GPT-6 Astra assistance, +including a separate Astra code review and rerun. This is AI-assisted independent +implementation evidence, not a claim of human peer review. New files use the +repository's Apache-2.0 license. diff --git a/research/k492-emitter-independent-controls/REVIEW.md b/research/k492-emitter-independent-controls/REVIEW.md new file mode 100644 index 0000000000..6158f9092f --- /dev/null +++ b/research/k492-emitter-independent-controls/REVIEW.md @@ -0,0 +1,79 @@ +# Astra independent review — K492 emitter controls + +Packaging note: the supporting `astra-*.json` and `astra-run-stdout.txt` files +named below are retained in this package's [`evidence/`](evidence/) directory. +The successful baseline/source-control emissions, command receipts, logs and +patches have also been copied there from the reviewer's temporary output. +References to the original temporary locations remain as execution provenance. +Personal checkout and local evidence directory prefixes in packaged JSON receipts +are normalized as documented in [`PUBLICATION.md`](PUBLICATION.md). Historical +receipt hash values below still identify the original bytes; the package manifest +identifies the published bytes. This review's selected #626 references are relative +to the historical source baseline, not the current upstream frontier. + +Independent review on 2026-10-13, repository base `66849e1475c930fd7732b1a0067ffee7e1e95f60`. This reviews the locally authored `research/k492-emitter-independent-controls/independent.py` and `run.py`; it does not endorse any downloaded PR implementation. **Final repaired-code review and a separate harness rerun passed. No remaining blocking finding was identified within the stated eight-site finite structural scope.** The preliminary findings below are retained with their resolution. + +## Positive findings + +- The eight mutation anchors match exactly once in the pinned original emitter at the expected source lines. They reproduce the eight `emit.*` rows of `PROOF-NOTE-R.md` without duplicating #766's 14 assembly controls. +- Native helper widths are independently calculated by exact integer XOR elimination, checking basis independence and entrance containment. No floating-point arithmetic or production rank function is used. +- Owner families use a separately expressed coordinate formula. Complete `(stage,replica,helper)` coverage, whole-family uniqueness, route/spectator reconstruction, and endpoint-sorted occupied intervals supply useful independent structural evidence. +- Paid profiles are recounted from literal local-program climb/center events and exact idle remainders; scalar, Clifford, phase and theorem proofs remain inherited. +- The selected allocation's serialization order exactly equals call-order then helper-order. Thus the checker's independently generated sigma-stream order agrees with the emitter's allocation-stream order on this fixture. This was verified by directly reading JSON, without executing repository source. +- The donor parent `research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz` has decompressed SHA-256 `7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3`, independently verified equal to PR626's archived `HOSTED.json.parent_template_sha256`. It is an exact retained payload, not a synthetic parent. +- The harness's cosmetic control compares the complete template and receipt after normalizing only `GLOBAL-TEMPLATE.version` and its directly derived `HOSTED.template_sha256`. It also compares the sigma artifact. This normalization is appropriately narrow. + +## Findings requiring repair or explicit scope limits + +1. **Missing proof-input bindings.** In the initially read 305-line checker, `all(...)` over `summary['source_artifacts']` accepts an empty object. Require the exact expected key set (one data-phase file plus seven files per provider), then require each digest. The registry's canonical/program/Clifford/adapter digest fields also need explicit checks. Merely comparing the embedded program does not bind every receipt's claimed input identity. + +2. **Incomplete serialized-output coverage.** Initially, changing `recipe`, `exact_data_phase_recipe_sha256`, `adapter_policy`, retained per-call `pair`/`window` fields, async source schedule/call-order/plan links, or hosting limits/banks could survive a refreshed template digest. Compare all retained parent/call fields against their pinned originals, and check explicitly rewritten metadata. Otherwise narrow any “complete emitter semantics” description to the checked contract. Source window feasibility is distinct from checking unchanged expanded event order; it may remain an explicitly inherited obligation. + +3. **Overly broad source-failure acceptance.** Initially, the harness accepted any terminal `AssertionError`/`IndexError` mentioning `emit_allcold.py`. This can mistake a different failure for the intended source control. Require the terminal emitter frame, exact source line and exception class, and save the failed source statement. Missing files, import failures, pin failures, or failures at another assertion must never count. + +All three findings were repaired and independently re-read before the final run. Exact input inventory/provider links, retained parent/call fields, hosting/async links, and exact failure line/class are now enforced. New regression controls reject erased source inventory, changed input/artifact hashes, a changed retained recipe, an erased call window, and an erased async source schedule. The final version also checks summary call-order digest and bank counts, and validates all 112 port charts before reporting their Gram-entry count. + +## Final review checklist + +| Control | Intended observed outcome | +|---|---| +| `emit.R_from_providers` | `IndexError`, original emitter line 42 | +| `emit.roles_72R` | `AssertionError`, line 48; 35,424 differs from 36,288 | +| `emit.widths_range` | `IndexError`, line 42 | +| `emit.all_helpers_owned` | `AssertionError`, line 77 | +| `emit.physical` | Emitter succeeds; independent `emit.physical` rejection of 7,682 vs 7,670 | +| `emit.reserved_tableau` | Emitter succeeds; independent `emit.reserved_tableau` rejection of end 7,680 vs 7,668 | +| `emit.parent_R0` | `AssertionError`, line 93; retained parent stock gap 514 differs from 502 | +| `emit.version_label` | Accepted; only label and derived template digest differ | + +The final review pinned repaired checker/harness hashes, reviewed exact input inventory and donor provenance, ran the final harness once into a fresh separate directory, and compared deterministic mathematical receipts with the implementation agent's run. The baseline `HOSTED.json` equals its archived counterpart; all eight original source mutations reach their intended result; the added semantic corruptions are rejected after output hashes are refreshed; cosmetic/recompression positives pass. + +## Final execution and comparison + +Command: `python3 -B research/k492-emitter-independent-controls/run.py --out /tmp/k492-emitter-astra-review-20261013`. + +Observed UTC interval: `2026-10-13T06:14:35.026077+00:00` through `2026-10-13T06:15:18.676077+00:00`; wall time 43.65 seconds; CPython 3.13; exit 0; output `PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE`. + +Reviewed and executed source SHA-256 values, checked unchanged after execution: + +- `run.py`: `fbb04bc8c097b82db4a09af69ae62c1b7ab07f522a9726ff573ea64e485a9aa8` +- `independent.py`: `755f2c39697d33f2f2c431605dcdc59c7753e4cfae497d40482ab40b7d0f9016` + +Results: + +- Eight documented source controls: five failures at the exact original source line/class, two successful emissions rejected by the independent output-geometry oracle, one accepted changed-label control. +- Twenty additional semantic controls: 18 intended rejections after hash refresh, one accepted cosmetic label, and one accepted actual gzip recompression with identical payload semantics. +- Selected structural recount: 984 provider helper-frame pairs, 35,424 roles, 7,670 physical rows, 7,672 sigma charts, 596,848 exact Gram entries, 2,339 idle remainders, rank mass 520,704 and deficit 2,560. +- Fresh complete `HOSTED.json` equals the archived receipt as JSON. The template decompressed SHA-256 is `22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0`, matching its receipt. +- Against `/tmp/k492-emitter-final`, `BASELINE.json`, `RESULT.json`, `SEMANTIC-CONTROLS.json`, and `INPUT-PINS.json` are byte-identical. `SOURCE-REVERTS.json` mathematical records are identical after excluding only each run's command object, which contains different absolute output paths, wall times and path-dependent stderr hashes. + +Supporting evidence: `astra-run-command.json`, `astra-run-stdout.txt`, and `astra-receipt-review.json` in this directory; complete command, mutation patches, stderr/stdout and emitted outputs remain in `/tmp/k492-emitter-astra-review-20261013` for packaging by the implementation agent. `RESULT.json` SHA-256: `2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9`. + +Keep these distinctions in the handoff: + +- The maintainer already recorded a generalized R504 compatibility replay. This contribution does not reproduce the unavailable original `GlobalR/run504b` scratch fixture or its full 32-site reversion report. +- Eight emitter controls do not discharge the other 24 documented source sites. Related invoice/accounting evidence from #724 is credited; the R/R0 prose discrepancy is not new here. +- Complete source emission and finite structural checking do not independently re-prove native scalar/Clifford/phase identities, source allocation window feasibility, invoice/assembly inequalities, all-size compilation, physical hosting, precision/tape or analytic transfer. +- No selected-record change, new κ, full theorem proof, or human peer review is claimed. + +No verifier source was edited by this reviewer. The final rerun executed the reviewed local harness, the pinned primary repository emitter and witness loader in temporary copies, and the separate independent checker. No pending-PR code was executed. No external publication, PR, issue, claim, or message to contributors was made. diff --git a/research/k492-emitter-independent-controls/evidence/BASELINE.json b/research/k492-emitter-independent-controls/evidence/BASELINE.json new file mode 100644 index 0000000000..58e1babd89 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/BASELINE.json @@ -0,0 +1,46 @@ +{ + "R": 492, + "R0": 504, + "actual_sigmas": 7672, + "cross_replica_helper_roles": 28404, + "deficit": 2560, + "entering_helper_roles": 16368, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "idle_remainders": 2339, + "orthogonal_basis_gram_entries": 596848, + "owners_per_call": 716, + "parent_live": 11704, + "parent_physical": 12218, + "physical": 7670, + "provider_helper_frames_checked": 984, + "provider_width_histograms": { + "ck": { + "4": 30, + "5": 48, + "7": 68, + "8": 92, + "9": 254 + }, + "jp8": { + "4": 30, + "5": 48, + "7": 36, + "8": 112, + "9": 266 + } + }, + "rank_mass": 520704, + "role_domain_size": 35424, + "status": "PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT", + "template_semantic_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0" +} diff --git a/research/k492-emitter-independent-controls/evidence/ENVIRONMENT.json b/research/k492-emitter-independent-controls/evidence/ENVIRONMENT.json new file mode 100644 index 0000000000..bf0dd4784c --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/ENVIRONMENT.json @@ -0,0 +1,11 @@ +{ + "assertions_enabled": true, + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "checker_sha256": "755f2c39697d33f2f2c431605dcdc59c7753e4cfae497d40482ab40b7d0f9016", + "executable": "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "harness_sha256": "fbb04bc8c097b82db4a09af69ae62c1b7ab07f522a9726ff573ea64e485a9aa8", + "platform": "macOS-26.5.2-arm64-arm-64bit-Mach-O", + "python": "3.13.2 (v3.13.2:4f8bb3947cf, Feb 4 2025, 11:51:10) [Clang 15.0.0 (clang-1500.3.9.4)]", + "zlib_compile": "1.2.12", + "zlib_runtime": "1.2.12" +} diff --git a/research/k492-emitter-independent-controls/evidence/INPUT-PINS.json b/research/k492-emitter-independent-controls/evidence/INPUT-PINS.json new file mode 100644 index 0000000000..47b599a4b0 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/INPUT-PINS.json @@ -0,0 +1,108 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "files": { + "research/community-k492-audit/pr626/replay/mixed-global/PLAN.json": { + "bytes": 474252, + "sha256": "2956331d3ba73c564ac757c6667bba5dea7d19207582341d7c829d8401049c04" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CANONICAL-WORD.json.gz": { + "bytes": 92137, + "payload_sha256": "9bbc75dede090cfd7a0a0252424ea9d9f6211e2350d2a801d4e4f2f0784167c7", + "sha256": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CLIFFORD-RECIPES.json": { + "bytes": 1044060, + "sha256": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/CLIFFORD-REVIEW.json": { + "bytes": 655, + "sha256": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/INDEPENDENT-LOCAL-REPLAY.json": { + "bytes": 2309, + "sha256": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-CHECKS.json": { + "bytes": 920, + "sha256": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/LOCAL-PROGRAMS.json.gz": { + "bytes": 227308, + "payload_sha256": "854f17274092263dc25e60367f4cd0d29f60a8446becd17cc1883ebed7a97900", + "sha256": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/ck/RESIDUAL-ADAPTERS.json": { + "bytes": 21482, + "sha256": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CANONICAL-WORD.json.gz": { + "bytes": 94957, + "payload_sha256": "fb4a8d14ed2a8048698bea6ae16f86163a1aa6c80f2eb622222eee5cdbce9b3b", + "sha256": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CLIFFORD-RECIPES.json": { + "bytes": 1015814, + "sha256": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/CLIFFORD-REVIEW.json": { + "bytes": 655, + "sha256": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": { + "bytes": 2370, + "sha256": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-CHECKS.json": { + "bytes": 920, + "sha256": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/LOCAL-PROGRAMS.json.gz": { + "bytes": 233037, + "payload_sha256": "efe45ce7fb025a6f53cc9eb54e951ac2211a5ed927e689a049e4f68ca680654b", + "sha256": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/providers/jp8/RESIDUAL-ADAPTERS.json": { + "bytes": 15417, + "sha256": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/split-centres/CANONICAL-WORD.json.gz": { + "bytes": 70587, + "payload_sha256": "62684fd4d4ffabf3b2f2ce4bc8ccdad07bcc7f2685aec86761cfebe1c39e7a0c", + "sha256": "66d3c3c70983224650643a0a05a21ac6c6959f84d0f4528650601016f5a76844" + }, + "research/community-k492-audit/pr626/replay/mixed-global/base/work/complex-nine-native/DATA-PHASES.json": { + "bytes": 814141, + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "research/community-k492-audit/pr626/replay/mixed-global/hosted/HOSTED.json": { + "bytes": 2904, + "sha256": "29073870df4e5e2b15fa51624599a1a30a5accb93e6d4557a77b86cfbfb8cbbc" + }, + "research/complex-k492-owner-repair/PROOF-NOTE-R.md": { + "bytes": 9555, + "sha256": "22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed" + }, + "research/complex-k492-owner-repair/code/emit_allcold.py": { + "bytes": 13090, + "sha256": "fe26f10fe5d30ed407a37540a45ef94f44576dd241d09e19aef5db1efb072746" + }, + "research/complex-k492-owner-repair/code/witness.py": { + "bytes": 2102, + "sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "research/complex-k492-owner-repair/data/OWNERS.json.gz": { + "bytes": 415526, + "payload_sha256": "cacbaa6b27e0d612b77f2d6fed40eb99a6245f690eb771ffbf76655484866201", + "sha256": "251e82cec1f40e6c1289703667f403104b957f1254dc4f6baa6df9a3d0c751de" + }, + "research/complex-k492-owner-repair/data/SPEC.json": { + "bytes": 47328, + "sha256": "2a2577ac526535826fed9d5f7f83f6e2e0ec058a146c64f7286720b995fa2323" + }, + "research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz": { + "bytes": 398090, + "payload_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "sha256": "ab8448de2036a23d9b55a196a8846512dc24fdf09855c1e0f0caa5b7a6965f7b" + } + } +} diff --git a/research/k492-emitter-independent-controls/evidence/PUBLICATION-NORMALIZATION.json b/research/k492-emitter-independent-controls/evidence/PUBLICATION-NORMALIZATION.json new file mode 100644 index 0000000000..04b1ade34f --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/PUBLICATION-NORMALIZATION.json @@ -0,0 +1,176 @@ +{ + "files": [ + { + "normalized_fields": [ + { + "json_pointer": "/0/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/1/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/2/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/3/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/4/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/5/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/6/command/cwd", + "published_value": "" + }, + { + "json_pointer": "/7/command/cwd", + "published_value": "" + } + ], + "path": "evidence/SOURCE-REVERTS.json", + "published_receipt_sha256": "89af5468f28d22f99d4f10b30c95864e546b332c8b4d2e66225d714602c2dadf", + "raw_receipt_sha256": "e1c4cc9de856c6b527f420aa17db063335458cb150ecd314d3c8ce91a0e9e2ba" + }, + { + "normalized_fields": [ + { + "json_pointer": "/run_command_receipt", + "published_value": "/astra-run-command.json" + } + ], + "path": "evidence/astra-receipt-review.json", + "published_receipt_sha256": "3cf4f94e784d1288018649c4d9f1d79e7bba52907e1bf3e732b55641d21b90b0", + "raw_receipt_sha256": "fedab01a871512d9e6dde6826b4bd22e675f968e8fcc7893cbd14e02455dbffc" + }, + { + "normalized_fields": [ + { + "json_pointer": "/argv/2", + "published_value": "/research/k492-emitter-independent-controls/run.py" + }, + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/astra-run-command.json", + "published_receipt_sha256": "6a05dba263a2c45d8d65a91d8e9be9d4f1ae139b3612a1a7608cb6015eb18eae", + "raw_receipt_sha256": "0a9e311dc33bf2dcfd79db437c3460714f571579a9116a5087bea05ff7666477" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/baseline/COMMAND.json", + "published_receipt_sha256": "b29c0936243036305b94cf28db4c777ff0dba22455a935a2dc00a0ec94be8f7c", + "raw_receipt_sha256": "ef8336986e94e2bf3175456b771d3be74a689844c214f32f68fe048fa17bb6ee" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.R_from_providers/COMMAND.json", + "published_receipt_sha256": "6ef62d77423ff46b3c723ce43e70f7002d1fa21786441afe49d0a2a3d624c620", + "raw_receipt_sha256": "3d66df04f4979e492b6371b72a5d819d5626c248a70d08fc4d2174d34e3849ba" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.all_helpers_owned/COMMAND.json", + "published_receipt_sha256": "334c7c891dbfdef09072d116aa276aaa3352ac7793dcbd2e76914fc622f47b8e", + "raw_receipt_sha256": "57ab5730d8946524971817262be967a3c92ae6673c941f4a2e8813b28cb5cf9f" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.parent_R0/COMMAND.json", + "published_receipt_sha256": "ff9c68bce1850a4c7903a4a9484c557ed63fc8e8eb09e47e0d793d382af1d0af", + "raw_receipt_sha256": "d1bec798e209cdf7a0014892397624412e24be0270e690a58d6468d839fb9b69" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.physical/COMMAND.json", + "published_receipt_sha256": "e3dcdd9f7873f1f3a2caeadbeab90daf0c5bb0bc93721307e6546bfec7a5dede", + "raw_receipt_sha256": "0e46fc80b8b2be50234f428c491537018339d957f616cce3f4d54c08c76bbc77" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.reserved_tableau/COMMAND.json", + "published_receipt_sha256": "193ec9005755acdcf369aeb00324a376adf5ae4e56cdf5e5d62c69921abef351", + "raw_receipt_sha256": "f03327ff0760eb6aa9afb98d0d241d1ac33cfaad169063b04508f0e26a1cf2aa" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.roles_72R/COMMAND.json", + "published_receipt_sha256": "7822e3b9916b38329eba7b6389c4fa00a075ee867a631cfe8f3b24e5a93125c4", + "raw_receipt_sha256": "4ce2c808941a87e410ec540c9da058a8297f84421621bfd690cb4ea6936cb52f" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.version_label/COMMAND.json", + "published_receipt_sha256": "00ab2a1976da007d0554f36cf998bd04a2d6ea4b259f249b89f0a638b21f2506", + "raw_receipt_sha256": "c2d462dc769538c815dfcf17960492c06c3219c46c4debc890cd096ec773890e" + }, + { + "normalized_fields": [ + { + "json_pointer": "/cwd", + "published_value": "" + } + ], + "path": "evidence/emit.widths_range/COMMAND.json", + "published_receipt_sha256": "dab77d88e1d0786660dfa754a272e615b0945bafefe27982f414d7250a900af3", + "raw_receipt_sha256": "039ff0ce568ff9b899db3354750b5aff0a6e4e0531f2d04a986cddc5dc4a32dd" + } + ], + "historical_receipt_hash_policy": "Existing SHA-256 values in the historical review receipt continue to identify the original raw receipts. Use MANIFEST.json for current publication-file hashes.", + "placeholders": { + "": "Original local evidence directory outside the repository; the referenced astra-run-command.json is also packaged in evidence/.", + "": "Absolute checkout directory of the pinned source repository." + }, + "raw_package_manifest_sha256": "a5f7cf5572e13e987df5204380ed38259c7a2501bd1af434bc11a2f6f67f09c6", + "schema": "k492-publication-path-normalization-v1", + "scope": "Only personal checkout and local evidence directory prefixes in execution-provenance fields. No proof data, source code, source hashes, emitted artifacts, stderr, outcomes, or pins changed." +} diff --git a/research/k492-emitter-independent-controls/evidence/PUBLICATION-OVERLAP.json b/research/k492-emitter-independent-controls/evidence/PUBLICATION-OVERLAP.json new file mode 100644 index 0000000000..5a5efcc377 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/PUBLICATION-OVERLAP.json @@ -0,0 +1,261 @@ +{ + "baseline": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "completed_at_utc": "2026-10-13T19:18:30.097624+00:00", + "current_main": "ce7ad1b6ab09452c3478723a2e96ed5ff212dc08", + "decision": { + "equivalent_eight_emitter_suite_identified": false, + "publication_recommendation": "Proceed with a scoped draft for the retained historical PR626 checkpoint, credit adjacent work, and avoid claiming novelty for the R/R0 distinction or interval-endpoint/gzip methodology.", + "scope": "All eight emit.* source controls: five original emitter failures, two downstream independent-output rejections, one cosmetic acceptance; eighteen refreshed-hash semantic negatives and two positive controls.", + "stop_publication_for_duplication": false + }, + "evidence_files": [ + { + "mtime_utc": "2026-10-13T19:13:33.443705+00:00", + "path": "evidence/publication/open-pulls.json", + "sha256": "2d6003a4b775afa58522bce2ec9e67a5c849dc1e302adfb1c96ffda5b5f778bb" + }, + { + "mtime_utc": "2026-10-13T19:13:56.610249+00:00", + "path": "evidence/publication/closed-pulls.json", + "sha256": "3a20e12706ae149c019fab233757a2a66ea5db9178f949e1bfad8aa07f9547bb" + }, + { + "mtime_utc": "2026-10-13T19:14:06.509318+00:00", + "path": "evidence/publication/open-issues.json", + "sha256": "90d6f33de36723302ec64a1f69fb0921fbdc04ff57ad5ac532ea8c57f692fc52" + }, + { + "mtime_utc": "2026-10-13T19:12:57.378764+00:00", + "path": "evidence/publication/upstream-head.json", + "sha256": "15ca3dd31b83d1538f17b103fa7ce0426464921b6f422cf747ca29f337d9ba7d" + }, + { + "mtime_utc": "2026-10-13T19:16:18.891752+00:00", + "path": "evidence/publication/current-main-exact-control-search.txt", + "sha256": "220e22b9432bb4c87c3a58bfe999ce10130dbc8bc9acd9be5ffac1afb4fcf8d1" + }, + { + "mtime_utc": "2026-10-13T19:16:18.998296+00:00", + "path": "evidence/publication/current-main-related-paths.json", + "sha256": "9fc6733f58eee107d49755c731dca1c50d6f7ce1217b99e5b2e0104f9cbf8824" + }, + { + "mtime_utc": "2026-10-13T19:16:52.004879+00:00", + "path": "evidence/publication/main-owner-boundary-audit-README.md", + "sha256": "1984701154e38bd96b8bd83d297898d36b02aa0a3975450bb83dff1f84720340" + }, + { + "mtime_utc": "2026-10-13T19:16:51.994137+00:00", + "path": "evidence/publication/main-pr695-digest-audit-README.md", + "sha256": "e531c24dc59c6c8ad8f0a30a7c30569ce77ac25d73656e73c0631798f26de935" + }, + { + "mtime_utc": "2026-10-13T19:16:51.983294+00:00", + "path": "evidence/publication/main-pr626-native-payload-binding-README.md", + "sha256": "f0e4521786a22ebf22f971d0de226e27bb9994ed35179b2e647c1714ed437125" + } + ], + "limitations": [ + "Titles and bodies were searched across every supplied current open and closed/merged PR row; not every file in every pending PR was inspected.", + "The three closest pending package file/patch audits are reused only because their current heads are unchanged. Other related pending work is assessed from current title/body; current main exact-site search and three related merged READMEs were read.", + "Pagination is non-atomic; the later issue snapshot already includes PR1153 missing from the pull inventory. Its full body was inspected and is unrelated. Subsequent/private/local work remains outside the snapshot.", + "This audit did not execute contributors code, reproduce claimed validation, inspect all comments/reviews, or establish global novelty." + ], + "main_inspection": { + "current_selected_not_PR626": true, + "exact_site_name_paths": [ + "research/complex-571-cold14-k492-repacked624/PROOF-NOTE-R.md", + "research/complex-571-cold14-k492/PROOF-NOTE-R.md", + "research/complex-571-cold14-k492b/PROOF-NOTE-R.md", + "research/complex-571-cold14-k492c/PROOF-NOTE-R.md", + "research/complex-k492-owner-repair/PROOF-NOTE-R.md", + "research/complex-sw4-frame8/vendor/pr635/research/complex-571-cold14-st2/PROOF-NOTE-R.md" + ], + "exact_site_result": "All exact emit.* names occur in inherited PROOF-NOTE-R.md copies, not a new executable reversion suite.", + "exact_source_control_search": "current-main-exact-control-search.txt", + "historical_checkpoint": "certificates/checkpoints/k492626.json", + "main_related_paths": "current-main-related-paths.json", + "retained_primary_tree_and_review_changed_files": [], + "selected_certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "selected_source_pr": 1094 + }, + "nearest_contributions": [ + { + "author": "gaboroa14", + "closed_at": null, + "created_at": "2026-10-13T05:18:38Z", + "evidence_level": "current title/body and prior exact file/patch inspection at unchanged head", + "head": "56bac6775e8882f4c3bfa0cef9bcc9a61da9ba06", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/766", + "merged_at": null, + "number": 766, + "overlap_and_distinction": "All 14 assembly-side source sites; explicitly excludes the other 18 scratch sites. Same native ranks/helper-role facts partially overlap, but no eight-site emitter replay.", + "state": "open", + "title": "Research audit: replay all 14 K492 assembly helper-count reversions", + "updated_at": "2026-10-13T05:19:10Z" + }, + { + "author": "thakrarsagar", + "closed_at": null, + "created_at": "2026-10-13T04:51:02Z", + "evidence_level": "current title/body and prior exact file/patch inspection at unchanged head", + "head": "624ccfe44b1c5816f0279481d91cca6a5a2290ab", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/724", + "merged_at": null, + "number": 724, + "overlap_and_distinction": "Independent invoice/accounting recount and seven assemble.py source changes (lines 118\u2013153). Already explains R versus parent R0, including the emit.parent_R0 prose issue; does not execute emitter sites.", + "state": "open", + "title": "Research audit: resolve R/R0 revert expectations with exact PR626 accounting", + "updated_at": "2026-10-13T04:51:19Z" + }, + { + "author": "sk1-j", + "closed_at": null, + "created_at": "2026-10-13T04:56:24Z", + "evidence_level": "current title/body and prior exact file/patch inspection at unchanged head", + "head": "deaed262cebc50bdb0c27c6ba132b8f8289b3eef", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/729", + "merged_at": null, + "number": 729, + "overlap_and_distinction": "Persistent helper-frame lifetime verification and scalar-preserving regression; native-word obligation rather than serialized emitter/source-reversion suite.", + "state": "open", + "title": "Independent verification: audit helper-frame lifetimes with a scalar-preserving regression", + "updated_at": "2026-10-13T04:56:24Z" + }, + { + "author": "tekuuu", + "closed_at": "2026-10-13T06:10:35Z", + "created_at": "2026-10-13T03:42:31Z", + "evidence_level": "current main README plus PR metadata", + "head": "f011d03633f0570257b653e7aa1e869b1b06d06a", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/675", + "merged_at": "2026-10-13T06:10:35Z", + "number": 675, + "overlap_and_distinction": "Merged independent owner-window/bridge-omission audit: 10,368 decisions and 35,424 roles. This checks controller timing inherited by our package; no emitter reversion suite.", + "state": "closed", + "title": "Research audit: PR626 owner boundaries and bridge-omission blind spot", + "updated_at": "2026-10-13T06:10:35Z" + }, + { + "author": "TMM2009", + "closed_at": "2026-10-13T06:44:20Z", + "created_at": "2026-10-13T04:55:01Z", + "evidence_level": "current title/body", + "head": "71ba94c981477b3527ef21dd0f8140e795a7664d", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/727", + "merged_at": "2026-10-13T06:44:20Z", + "number": 727, + "overlap_and_distinction": "Merged optional integer-bitmask adapter for original owner checker with 19 complete-check rejection controls; common owner-footprint data and corruption ideas, no emitter reversion suite.", + "state": "closed", + "title": "Tooling: exact owner footprint masks reduce checker wall time by 13\u201319%", + "updated_at": "2026-10-13T06:44:21Z" + }, + { + "author": "JoyboyBrian", + "closed_at": null, + "created_at": "2026-10-13T05:31:24Z", + "evidence_level": "current title/body", + "head": "9f68dff1e1cccad2bd5b3b51f4ced0bba9765862", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/780", + "merged_at": null, + "number": 780, + "overlap_and_distinction": "Open independent endpoint-sweep oracle for the same 35,424 helper roles and complete idle histogram. Sorted interval endpoint methodology overlaps our independent footprint check; no priority claim for that method. Its target is PR727 masks/checker, not the eight emitter mutations.", + "state": "open", + "title": "Independent verification: endpoint-sweep audit of PR727 owner masks", + "updated_at": "2026-10-13T05:31:24Z" + }, + { + "author": "jsnider3", + "closed_at": "2026-10-13T06:10:35Z", + "created_at": "2026-10-13T04:20:14Z", + "evidence_level": "current title/body", + "head": "e322f2f1d9cc0f830cb3a50c6e928e0a1a32383c", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/695", + "merged_at": "2026-10-13T06:10:35Z", + "number": 695, + "overlap_and_distinction": "Merged preservation/reconciliation of completed historical PR626 Linux replay and its differing provenance digests; not an independent emitter implementation.", + "state": "closed", + "title": "Research consolidation: reconcile selected #626 Linux replay evidence", + "updated_at": "2026-10-13T06:10:36Z" + }, + { + "author": "Rohansguliani", + "closed_at": "2026-10-13T06:44:20Z", + "created_at": "2026-10-13T06:01:58Z", + "evidence_level": "current main README plus PR metadata", + "head": "4189f39ec022b7d1f8adb6c394f80b2c31a3f9c5", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/806", + "merged_at": "2026-10-13T06:44:20Z", + "number": 806, + "overlap_and_distinction": "Merged digest-propagation diagnostic. Current main adds a maintainer warning: whole-file digest substitution does not establish that only timing changed, and a non-timing change passes when propagated. Unavailable historical CI payloads remain unverified. No emitter mutation suite.", + "state": "closed", + "title": "Audit #695: selected #626 provenance digest differences are timing and directory order, reproduced byte for byte", + "updated_at": "2026-10-13T06:44:21Z" + }, + { + "author": "MrPink604", + "closed_at": "2026-10-13T15:39:43Z", + "created_at": "2026-10-13T06:21:58Z", + "evidence_level": "current main README plus PR metadata", + "head": "0c17b5c2e9563c1973da73d3ec103d0587957e88", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/819", + "merged_at": "2026-10-13T15:39:43Z", + "number": 819, + "overlap_and_distinction": "Merged opt-in native-owner checker adapter accepts identical decompressed native payloads despite gzip metadata changes; 38 controls. Shared recompression/provenance concerns, but no serialized emitter source-site replay.", + "state": "closed", + "title": "Tooling: make PR626 native owner binding gzip-portable", + "updated_at": "2026-10-13T15:39:44Z" + }, + { + "author": "woklerx", + "closed_at": null, + "created_at": "2026-10-13T18:50:31Z", + "evidence_level": "current title/body", + "head": "36a82dd551cd18b8b32c2013ba928f59ad52678c", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1132", + "merged_at": null, + "number": 1132, + "overlap_and_distinction": "Open reconciliation distinguishes retained R492 ancestor data from selected-at-its-base PR1042 R480 archive inputs. Related historical/current provenance discipline; different inputs and target.", + "state": "open", + "title": "Research consolidation: distinguish selected R480 replay from retained R492 evidence", + "updated_at": "2026-10-13T18:50:31Z" + } + ], + "provenance": "Excerpt of the publication reviewer audit. Complete scanned PR inventory and raw acquisition files remain in the local evidence archive; source hashes and inventory counts are retained here.", + "repository": "CrocSwap/integer-mult-bounds", + "schema": "k492-publication-overlap-excerpt-v1", + "snapshot": { + "actual_open_issues": [ + { + "number": 913, + "title": "All size/compiler is retained" + }, + { + "number": 650, + "title": "Can we turn on Discussions?" + } + ], + "additional_prs_in_later_issue_snapshot": [ + { + "assessment": "Inspected title/body: R480 scalar sign-normalization construction, no K492 emitter suite.", + "body_sha256": "bb216d04c08549b76022ac055d2cd643b696572e779cd884fb5c1c1188345fba", + "created_at": "2026-10-13T19:13:50Z", + "number": 1153, + "title": "Finite construction: PR1042 R480 sign normalization saves 408 primitives per orientation (no new kappa)", + "updated_at": "2026-10-13T19:13:50Z" + } + ], + "closed_rows": 383, + "highest_pull_number": 1152, + "latest_pr_update": "2026-10-13T19:10:53Z", + "merged_in_closed": 323, + "open_closed_intersection": [], + "open_issue_rows": 770, + "open_rows": 767, + "timestamp_kind": "Local acquisition mtimes and GitHub item timestamps; independently paginated, non-atomic snapshots.", + "unique_closed": 383, + "unique_open": 767, + "unique_pull_inventory": 1150 + }, + "source_audit_sha256": "6b09560fbc93926b597378299408d0911ca9dcbc6ad4915ba35d257998bdb26f" +} diff --git a/research/k492-emitter-independent-controls/evidence/RESULT.json b/research/k492-emitter-independent-controls/evidence/RESULT.json new file mode 100644 index 0000000000..ba265c82ee --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/RESULT.json @@ -0,0 +1,67 @@ +{ + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "baseline": { + "R": 492, + "R0": 504, + "actual_sigmas": 7672, + "cross_replica_helper_roles": 28404, + "deficit": 2560, + "entering_helper_roles": 16368, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "idle_remainders": 2339, + "orthogonal_basis_gram_entries": 596848, + "owners_per_call": 716, + "parent_live": 11704, + "parent_physical": 12218, + "physical": 7670, + "provider_helper_frames_checked": 984, + "provider_width_histograms": { + "ck": { + "4": 30, + "5": 48, + "7": 68, + "8": 92, + "9": 254 + }, + "jp8": { + "4": 30, + "5": 48, + "7": 36, + "8": 112, + "9": 266 + } + }, + "rank_mass": 520704, + "role_domain_size": 35424, + "status": "PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT", + "template_semantic_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0" + }, + "scope": "R492 emitter structural contract only, with retained native inputs and hash-matched parent", + "semantic_controls": { + "positive": 2, + "rejected": 18, + "total": 20 + }, + "source_reverts": { + "independent_rejected": 2, + "pass_changed": 1, + "primary_rejected": 5, + "total": 8 + }, + "status": "PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE", + "unresolved": [ + "Unavailable original scratch suite and original R504 fixture are not reproduced", + "Other 24 source sites are not claimed by this contribution", + "No local scalar/Clifford/phase reconstruction, invoice, assembly, or all-size theorem proof" + ] +} diff --git a/research/k492-emitter-independent-controls/evidence/SEMANTIC-CONTROLS.json b/research/k492-emitter-independent-controls/evidence/SEMANTIC-CONTROLS.json new file mode 100644 index 0000000000..e5775328f5 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/SEMANTIC-CONTROLS.json @@ -0,0 +1,886 @@ +[ + { + "detail": "expected 7168+8+492+2=7670, got 7682", + "expected_obligation": "emit.physical", + "json_replacement": { + "after": 7682, + "before": 7670, + "path": [ + "physical" + ] + }, + "name": "R0-in-provider-stock", + "obligation": "emit.physical", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "d36544f1b31713c3a5963f060cbd5aca5f8fae7a7afec5889da61fd3be9095f1", + "refreshed_template_sha256": "b1d820f78e4806c998e4407633ee6a6583805a0bd8dff1bc63456d42f08d12ff", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": { + "physical": 7682 + } + }, + { + "detail": "{'centers': [7168, 7176], 'coefficient': [7668, 7670], 'reserved_tableau': [7176, 7680]}", + "expected_obligation": "emit.reserved_tableau", + "json_replacement": { + "after": 7680, + "before": 7668, + "path": [ + "private_namespace", + "reserved_tableau", + 1 + ] + }, + "name": "R0-in-private-tableau", + "obligation": "emit.reserved_tableau", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "d06057ba3f46001443b95ba11d9ca4f1c82d0281524550c68d959006749f7b07", + "refreshed_template_sha256": "0fe077c438088adebd0ecd3de887774e1ffc28e336e8e79e7022b2bc10edcf46", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0): expected 716 owners, got 715", + "expected_obligation": "emit.all_helpers_owned", + "json_replacement": { + "before": [ + 2240, + [ + 4, + 4, + 0, + 5, + [ + 0, + 6, + 7, + 8 + ] + ] + ], + "operation": "remove", + "path": [ + "calls", + 0, + "owners", + 715 + ] + }, + "name": "truncated-helper-domain", + "obligation": "emit.all_helpers_owned", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "81fa8b2aa6a2a183e81cc01e62bda180ad98aea81ecc690a306b0a3c329dda95", + "refreshed_template_sha256": "4e1a72dd277cdaee57fe85d9cc3ccfbff98fdd0e7661a1cdc0525b44d573f8d5", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0)", + "expected_obligation": "emit.owner_family_uniqueness", + "json_replacement": { + "after": [ + 3265, + [ + 3, + 6, + 0 + ] + ], + "before": [ + 2351, + [ + 3, + 4, + 0 + ] + ], + "path": [ + "calls", + 0, + "owners", + 225 + ] + }, + "name": "aliased-helper-families", + "obligation": "emit.owner_family_uniqueness", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "a72b942db3224e1755df6ab437fdd5c140c575351c10da39745608dcdc8d3083", + "refreshed_template_sha256": "48bfa3b4fbbc5754fa59756a88a808473671a93dc821b32535f09ffd258c7c23", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0)", + "expected_obligation": "emit.owner_family_uniqueness", + "json_replacement": { + "after": 7168, + "before": 3265, + "path": [ + "calls", + 0, + "owners", + 224, + 0 + ] + }, + "name": "private-family-used-as-owner", + "obligation": "emit.owner_family_uniqueness", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "dfc9d4da3fd2431e86c214df19a4659cdf61446b0411dc7e2bc732112cd910ab", + "refreshed_template_sha256": "a1f4b420b14168106bcf25a9c7de7d4a8d6b0e9bae47ab2b8cfac32404d1a623", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "ck", + "expected_obligation": "emit.provider_semantics", + "json_replacement": { + "after": 504, + "before": 492, + "path": [ + "local_providers", + "ck", + "R" + ] + }, + "name": "provider-R-restored-to-504", + "obligation": "emit.provider_semantics", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "09ec72f555982742a29a0a7338decf89a46be3d77657cb0f0a9cbc623adb401f", + "refreshed_template_sha256": "8a72cb5d3701a9a3cf4e27993e7de9134d2bbf9cb9e5cab2ccf6e634d740c7ab", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "ck", + "expected_obligation": "emit.provider_semantics", + "json_replacement": { + "after": 8, + "before": 9, + "path": [ + "local_providers", + "ck", + "widths", + 0 + ] + }, + "name": "provider-width-spoof", + "obligation": "emit.provider_semantics", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "6b62e67ba864b6b69aedbcfaeeba171e64ffd646de17f3853a753fa12d2b454b", + "refreshed_template_sha256": "018ffe3d4a0b2a444700517486ac4bd354bb9a737fbbdd2d9508821183541c19", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0, 10)", + "expected_obligation": "emit.residual_chart", + "json_replacement": { + "after": 3, + "before": 4, + "path": [ + "calls", + 0, + "owners", + 234, + 1, + 3 + ] + }, + "name": "narrow-helper-width-changed", + "obligation": "emit.residual_chart", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "7f1cf60bc5a18094051d16ceb86f1c9903989c770d172d21a5758867ed4343e7", + "refreshed_template_sha256": "6b5d012fe3887f60bbab6c63564a046e0c6636698b9beed2d006a85b8f53b9e5", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0, 10)", + "expected_obligation": "emit.residual_chart", + "json_replacement": { + "after": 72, + "before": 0, + "path": [ + "calls", + 0, + "owners", + 234, + 1, + 4, + 0 + ] + }, + "name": "spectator-axis-changed", + "obligation": "emit.residual_chart", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "e6032bf95381e35f94fbacad78d34521621106d370533931c6d75077ef230744", + "refreshed_template_sha256": "5925851c6db4f943f4664ead0164e61f0eb9280fd6da4ea0cdfddaf4ed5d2666", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "serialized role metadata must be the complete literal allocation", + "expected_obligation": "emit.role_metadata", + "json_replacement": { + "before": { + "child": 14, + "copy": 787, + "family": 6499, + "helper": 491, + "offset": 27, + "owner_replica": 7, + "port": 3, + "replica": 7, + "stage": 8, + "time": 71, + "width": 5 + }, + "operation": "remove", + "path": [ + "hosting", + "pooled_slots", + 35423 + ] + }, + "name": "one-literal-role-omitted", + "obligation": "emit.role_metadata", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "d9c2b60a8e3054ceb5b67729699ab44c91b4952619297e47b9026aefdea02aef", + "refreshed_template_sha256": "0c8e58167af5d32762685f6e0793261bf3b99889acb7c05f7b13624eb0999460", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": { + "hosted_residuals": 35423 + } + }, + { + "detail": "literal remainder list differs", + "expected_obligation": "emit.idle_remainders", + "json_replacement": { + "before": { + "child": 13, + "family": 3807, + "hosted": 0, + "pending_offset": 0, + "port": 111, + "rank": 48, + "replica": 4, + "replicas": 1 + }, + "operation": "remove", + "path": [ + "idle_children", + 2338 + ] + }, + "name": "remainder-omitted", + "obligation": "emit.idle_remainders", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "76d6a387aa270067c36facaab7b282152239786a13c43842fd011485129a5d49", + "refreshed_template_sha256": "dda146255c7d88d63a3facbdbd601a1bfab76e8df9f57feaead574c7f7c19dea", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "source event blocks or complete invocation order differ", + "expected_obligation": "emit.controller_expansion", + "json_replacement": { + "after": 1, + "before": 0, + "path": [ + "execution_schedule", + 0, + "source_event" + ] + }, + "name": "source-event-order-changed", + "obligation": "emit.controller_expansion", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "ac5f39ddb512d41510cf4a40970c66301a6a0aa1e49e1e6dc45d565015683bf3", + "refreshed_template_sha256": "209dc7257aea62b836bffbe1abd408bf7aced6b1e9b866f2e74bc126c544c264", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "ck", + "expected_obligation": "emit.provider_artifact_binding", + "json_replacement": { + "after": "0000000000000000000000000000000000000000000000000000000000000000", + "before": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "path": [ + "local_providers", + "ck", + "residual_adapter_sha256" + ] + }, + "name": "provider-artifact-link-changed", + "obligation": "emit.provider_artifact_binding", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "bb824a47a4c0d636ee30fa01906c6989a19182ed3c99b78e78e12c21639733d5", + "refreshed_template_sha256": "1d04f182786135dc51b7c9423f82e5b1c31f70107ff3f0e8468e14536b3c0d48", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "recipe", + "expected_obligation": "emit.retained_parent_field", + "json_replacement": { + "after": -1, + "before": 1, + "path": [ + "recipe", + 2, + "coefficient" + ] + }, + "name": "retained-recipe-changed", + "obligation": "emit.retained_parent_field", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "69ee35bb425e98f4f5b497120c91f52a4f96543c895e66719b960e26706725b4", + "refreshed_template_sha256": "7c06cc1c2d2441f984c28d69f3e0b49abbc82e75c98e8e4e90e904698c200c8b", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "(0, 0)", + "expected_obligation": "emit.retained_call_fields", + "json_replacement": { + "after": [], + "before": { + "local_axes": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8 + ], + "prefix_axes": [] + }, + "path": [ + "calls", + 0, + "window" + ] + }, + "name": "retained-call-window-changed", + "obligation": "emit.retained_call_fields", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "b3345363b18be837c433192707ca9684ff2f357578ba8081eca0a8aa4a3520ed", + "refreshed_template_sha256": "88a7e0dc282793b75a781920354becaa6a758736af1c56131d2254dc062bb305", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "parent schedule/calls or source PLAN changed", + "expected_obligation": "emit.async_source_binding", + "json_replacement": { + "after": [], + "before": [ + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 0 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 1 + }, + { + "child_indices": [ + 0, + 2 + ], + "from_level": -1, + "kind": "idle_cover_sweep", + "pair": 1, + "to_level": 1 + }, + { + "coefficient": 1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 2 + }, + { + "child_indices": [ + 1, + 3 + ], + "from_level": 1, + "kind": "idle_cover_sweep", + "pair": 1, + "to_level": 2 + }, + { + "coefficient": -1, + "dst": 0, + "kind": "bridge", + "src": 1 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 3 + }, + { + "child_indices": [ + 4, + 6 + ], + "from_level": -1, + "kind": "idle_cover_sweep", + "pair": 2, + "to_level": 3 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 4 + }, + { + "child_indices": [ + 5, + 7 + ], + "from_level": 3, + "kind": "idle_cover_sweep", + "pair": 2, + "to_level": 4 + }, + { + "coefficient": -1, + "dst": 1, + "kind": "bridge", + "src": 2 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 5 + }, + { + "child_indices": [ + 8, + 10 + ], + "from_level": -1, + "kind": "idle_cover_sweep", + "pair": 3, + "to_level": 5 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 6 + }, + { + "child_indices": [ + 9, + 11 + ], + "from_level": 5, + "kind": "idle_cover_sweep", + "pair": 3, + "to_level": 6 + }, + { + "coefficient": -1, + "dst": 2, + "kind": "bridge", + "src": 3 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 7 + }, + { + "entry_exit_phase_adapters": "DATA-PHASES.recipes[port].stage_alignment[stage]", + "kind": "local_cover_sweep", + "replicas": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7 + ], + "stage": 8 + }, + { + "child_indices": [ + 12, + 13 + ], + "from_level": 2, + "kind": "idle_cover_sweep", + "pair": 0, + "to_level": 8 + }, + { + "child_indices": [ + 14, + 15 + ], + "from_level": 4, + "kind": "idle_cover_sweep", + "pair": 1, + "to_level": 8 + }, + { + "child_indices": [ + 16, + 17 + ], + "from_level": 6, + "kind": "idle_cover_sweep", + "pair": 2, + "to_level": 8 + }, + { + "child_indices": [ + 18, + 19 + ], + "from_level": 8, + "kind": "idle_cover_sweep", + "pair": 3, + "to_level": 8 + }, + { + "coefficient": 1, + "dst": 3, + "kind": "bridge", + "src": 2 + }, + { + "coefficient": 1, + "dst": 2, + "kind": "bridge", + "src": 1 + }, + { + "coefficient": 1, + "dst": 1, + "kind": "bridge", + "src": 0 + }, + { + "kind": "terminal_Y_translations", + "pairs": [ + 0, + 1, + 2, + 3 + ], + "vector": "port q transported by its cover matrix g" + }, + { + "kind": "terminal", + "pairs": 4 + }, + { + "children_source": "bank_padding.children", + "families": [ + 7168, + 11704 + ], + "kind": "bank_padding_cover_sweep" + }, + { + "charged_calls_per_cover": 11704, + "families": [ + 0, + 11704 + ], + "formula": "delta_i=(weight(row_i(g))-1)/2 mod 2", + "kind": "translate_every_live_family", + "must_follow_bank_padding_and_data_signed_exchange": true + } + ], + "path": [ + "async_schedule", + "source_schedule" + ] + }, + "name": "async-parent-schedule-erased", + "obligation": "emit.async_source_binding", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "292121b70a456f39607afd8229d2ce6114489cb03d7f135ba17de30e5b03c175", + "refreshed_template_sha256": "c4467e08006d48f5418b7a3bbe208d980f2e9b77b0c9321b155c59a9818fce4b", + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "expected_obligation": null, + "json_replacement": { + "after": "independent-emitter-cosmetic-control", + "before": "round20-R492-asynchronous-whole-owner-v1", + "path": [ + "version" + ] + }, + "name": "cosmetic-label", + "outcome": "pass_changed", + "refreshed_summary_sha256": "b3ff4de86b7d5f0dba8ff4c7dc80bc9da36e1d8295b5681df146a279826ba500", + "refreshed_template_sha256": "772d904b4d5df50b8a7d68bc00c5206e675afc7c48530983d5060951dff3ee12", + "result": { + "R": 492, + "R0": 504, + "actual_sigmas": 7672, + "cross_replica_helper_roles": 28404, + "deficit": 2560, + "entering_helper_roles": 16368, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "idle_remainders": 2339, + "orthogonal_basis_gram_entries": 596848, + "owners_per_call": 716, + "parent_live": 11704, + "parent_physical": 12218, + "physical": 7670, + "provider_helper_frames_checked": 984, + "provider_width_histograms": { + "ck": { + "4": 30, + "5": 48, + "7": 68, + "8": 92, + "9": 254 + }, + "jp8": { + "4": 30, + "5": 48, + "7": 36, + "8": 112, + "9": 266 + } + }, + "rank_mass": 520704, + "role_domain_size": 35424, + "status": "PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT", + "template_semantic_sha256": "772d904b4d5df50b8a7d68bc00c5206e675afc7c48530983d5060951dff3ee12" + }, + "sigmas_semantic_sha256": "7e6feeb22afb3b108af89f790d2da2a7a91e0e961aafd41ad8e8dadb2a65d13d", + "source_pins_unchanged": true, + "summary_claim_changes": {} + }, + { + "detail": "exact data-phase plus seven-artifact-per-provider set required", + "name": "source-inventory-erased", + "obligation": "links.input_inventory", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "7aaf50e35fe60ac966709dc2496dc1ff865dd71def1f36d263e03cecce9de1be", + "refreshed_template_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0", + "source_pins_unchanged": true, + "summary_source_artifacts": {} + }, + { + "detail": "input byte digest mismatch", + "name": "source-artifact-hash-changed", + "obligation": "links.inputs", + "outcome": "semantic_rejected_after_hash_refresh", + "refreshed_summary_sha256": "8536faa6b3c740bf026066c4133197b5a71aa98b251137b3f250342e9f21e881", + "refreshed_template_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0", + "source_pins_unchanged": true, + "summary_source_artifacts": { + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/RESIDUAL-ADAPTERS.json": "0000000000000000000000000000000000000000000000000000000000000000", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + } + }, + { + "changed_raw_sha256": "4b9062fa64260597d846410c8d025b58d970fcf1128ea025ba9dccb751be7301", + "name": "actual-gzip-recompression", + "original_raw_sha256": "e9b0432d25980181c2168869baaa469e8849d16aa0b9af6c3c6ea28d04fc5a13", + "outcome": "pass_identical_semantics", + "result": { + "R": 492, + "R0": 504, + "actual_sigmas": 7672, + "cross_replica_helper_roles": 28404, + "deficit": 2560, + "entering_helper_roles": 16368, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "idle_remainders": 2339, + "orthogonal_basis_gram_entries": 596848, + "owners_per_call": 716, + "parent_live": 11704, + "parent_physical": 12218, + "physical": 7670, + "provider_helper_frames_checked": 984, + "provider_width_histograms": { + "ck": { + "4": 30, + "5": 48, + "7": 68, + "8": 92, + "9": 254 + }, + "jp8": { + "4": 30, + "5": 48, + "7": 36, + "8": 112, + "9": 266 + } + }, + "rank_mass": 520704, + "role_domain_size": 35424, + "status": "PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT", + "template_semantic_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0" + }, + "unchanged_payload_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0" + } +] diff --git a/research/k492-emitter-independent-controls/evidence/SOURCE-REVERTS.json b/research/k492-emitter-independent-controls/evidence/SOURCE-REVERTS.json new file mode 100644 index 0000000000..4365bd4ba1 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/SOURCE-REVERTS.json @@ -0,0 +1,369 @@ +[ + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.R_from_providers/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.R_from_providers/emitted" + ], + "cwd": "", + "emitter_source_sha256": "56c02b1f9bd024824398923774fbde188a5cfbe271ab7b7fadc2bd22e96d5f3e", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 1.001981, + "stderr_sha256": "da6603310b6fb689386abcf980e1bee487947deaed52811adb92a5ee3b0919ae", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "primary_rejected", + "failing_emitter_line": 42, + "failing_source_statement": " widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(R)] # HPE: residual width |final|-|start|", + "last_error": "IndexError: list index out of range", + "outcome": "primary_rejected", + "patch_sha256": "7e3ab5b75e822f0fc682175797b29e9501d01bd81851b2cc6a0596686c926196", + "site": "emit.R_from_providers" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.roles_72R/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.roles_72R/emitted" + ], + "cwd": "", + "emitter_source_sha256": "8537a142444cf6bc2fef2c8eb92a0e24593aa901650a69a97d627dfd68be0d9b", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 1.232351, + "stderr_sha256": "cc2b024bae007f75c2a0c8d542166f8f615297a04281485d76899d14fb8821cc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "primary_rejected", + "failing_emitter_line": 48, + "failing_source_statement": "assert len(roles)==72*504 # one whole-owner role per (call, provider helper)", + "last_error": "AssertionError", + "outcome": "primary_rejected", + "patch_sha256": "5d2116d58e86c99d55ae572fd80160c664ae47d3831a52b5b5fa1678d253e904", + "site": "emit.roles_72R" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.widths_range/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.widths_range/emitted" + ], + "cwd": "", + "emitter_source_sha256": "c25d0a8d4d857f9cd78320ae719d7e2e2d535ca0c5567d3d94aea21275cd2eb2", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 0.997683, + "stderr_sha256": "f1c096f9dd9b4732a2ec254b351e5fc74e27eac881cb8466875979bbbe2d9476", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "primary_rejected", + "failing_emitter_line": 42, + "failing_source_statement": " widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(504)] # HPE: residual width |final|-|start|", + "last_error": "IndexError: list index out of range", + "outcome": "primary_rejected", + "patch_sha256": "1d7d20404d5e9e36f8fc3b7e448fa737e5bd75c334ea074b291e8e47337bd3ff", + "site": "emit.widths_range" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.all_helpers_owned/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.all_helpers_owned/emitted" + ], + "cwd": "", + "emitter_source_sha256": "a8baced1545b409569b5111a97b2c0dc2e4fd17a15c775562d1367d4c796d399", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 2.063202, + "stderr_sha256": "0044b1a6d4f16f2c524815647ca95a6316f9ffc9edac7deb9dc8ec2d75263af5", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "primary_rejected", + "failing_emitter_line": 77, + "failing_source_statement": " k=(c['stage'],c['replica']);assert set(bycall[k])==set(range(504))", + "last_error": "AssertionError", + "outcome": "primary_rejected", + "patch_sha256": "a7e77a0870253a572cbdfaa98b91659806542e19e6b7f7ba63b11786c5e4deb3", + "site": "emit.all_helpers_owned" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.physical/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.physical/emitted" + ], + "cwd": "", + "emitter_source_sha256": "468dd48a649b58e3cb26899b3f4f4cfaa8136f338590c06ad8d3e92191b926f9", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.750823, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fdbf2adc8e75ef0b867fceef7ce67f341dc90d9ff078ea7c1c9fb514fe4dafac", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "detail": "expected 7168+8+492+2=7670, got 7682", + "expected": "independent_rejected", + "obligation": "emit.physical", + "outcome": "independent_rejected", + "patch_sha256": "5aee9de2b1eca3e094e991fd4db471151b96216fa2f999889d47fedcba5110a9", + "refreshed_template_sha256": "5a5e948cde3e0293779d2259e90b3baa82a525679a21b7fb2b54355d29662948", + "site": "emit.physical" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.reserved_tableau/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.reserved_tableau/emitted" + ], + "cwd": "", + "emitter_source_sha256": "3d2e8f5e95cdcc870fa8988882cd4a5ba372cf88c1d6ebc4d7361749634be4e0", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.722604, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7c7c6b20c48e6f301ad48666443c7f71728285552a63fc146d8c300165258b09", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "detail": "{'centers': [7168, 7176], 'coefficient': [7668, 7670], 'reserved_tableau': [7176, 7680]}", + "expected": "independent_rejected", + "obligation": "emit.reserved_tableau", + "outcome": "independent_rejected", + "patch_sha256": "301c6ce54d528fd7d5cb764cc136c6c7b5eb46c7453ece8d3d0be6e0e78f98d8", + "refreshed_template_sha256": "0fe077c438088adebd0ecd3de887774e1ffc28e336e8e79e7022b2bc10edcf46", + "site": "emit.reserved_tableau" + }, + { + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.parent_R0/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.parent_R0/emitted" + ], + "cwd": "", + "emitter_source_sha256": "0cd96348b9c591cd8dca0596fa9c2c2a51281a83da420b4156f8dde3fef8a347", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 2.056735, + "stderr_sha256": "2e55da1811367dd65a0c4820ddc413355ef329daa88241e62b9b2a1a9492415b", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "primary_rejected", + "failing_emitter_line": 93, + "failing_source_statement": "assert parent['physical']-parent['live']==C+R+2", + "last_error": "AssertionError", + "outcome": "primary_rejected", + "patch_sha256": "857a3cb1b7b41f5b20559ccdc87eef6871f9ea04c6bcdaed505274f15030199a", + "site": "emit.parent_R0" + }, + { + "changed_fields": [ + "GLOBAL-TEMPLATE.version", + "HOSTED.template_sha256" + ], + "command": { + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.version_label/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.version_label/emitted" + ], + "cwd": "", + "emitter_source_sha256": "182f044875f7b9584b81b5bab09ec4f2d1e04483042c5b2c8f7e2c87c44fcc56", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.727284, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "62a2e8722535f3f34acda6843516b1601272832be17d2917577fb9d1491e06c7", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" + }, + "expected": "pass_changed", + "outcome": "pass_changed", + "patch_sha256": "6f6cb22a3e7f0c3e451eda198ce23d4223abf360bf911068838bbae11510d1cf", + "result": { + "R": 492, + "R0": 504, + "actual_sigmas": 7672, + "cross_replica_helper_roles": 28404, + "deficit": 2560, + "entering_helper_roles": 16368, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "idle_remainders": 2339, + "orthogonal_basis_gram_entries": 596848, + "owners_per_call": 716, + "parent_live": 11704, + "parent_physical": 12218, + "physical": 7670, + "provider_helper_frames_checked": 984, + "provider_width_histograms": { + "ck": { + "4": 30, + "5": 48, + "7": 68, + "8": 92, + "9": 254 + }, + "jp8": { + "4": 30, + "5": 48, + "7": 36, + "8": 112, + "9": 266 + } + }, + "rank_mass": 520704, + "role_domain_size": 35424, + "status": "PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT", + "template_semantic_sha256": "b2a5ee0dfd84dd039492ebe8ca20e70b18686b7ebe16c3544084b5e62629b318" + }, + "site": "emit.version_label" + } +] diff --git a/research/k492-emitter-independent-controls/evidence/astra-receipt-review.json b/research/k492-emitter-independent-controls/evidence/astra-receipt-review.json new file mode 100644 index 0000000000..02f953a46b --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/astra-receipt-review.json @@ -0,0 +1,71 @@ +{ + "status": "PASS_INDEPENDENT_REVIEWER_REPLAY_AND_RECEIPT_COMPARISON", + "reviewed_at_utc": "2026-10-13T06:16:04.555842+00:00", + "review_output": "/tmp/k492-emitter-astra-review-20261013", + "implementation_output": "/tmp/k492-emitter-final", + "run_command_receipt": "/astra-run-command.json", + "reviewed_source_sha256": { + "run.py": "fbb04bc8c097b82db4a09af69ae62c1b7ab07f522a9726ff573ea64e485a9aa8", + "independent.py": "755f2c39697d33f2f2c431605dcdc59c7753e4cfae497d40482ab40b7d0f9016" + }, + "checks": { + "exact_retained_HOSTED": true, + "template_payload_matches_HOSTED_sha": true, + "source_outcomes": { + "primary_rejected": 5, + "independent_rejected": 2, + "pass_changed": 1 + }, + "semantic_outcomes": { + "semantic_rejected_after_hash_refresh": 18, + "pass_changed": 1, + "pass_identical_semantics": 1 + }, + "source_site_count": 8, + "source_site_names_unique": true, + "semantic_count": 20, + "source_unchanged": true + }, + "comparison": { + "BASELINE.json": { + "semantic_equal": true, + "byte_equal": true, + "review_run_sha256": "648cf66e67fe6bb92676ae2d1aa780afe62858336478a034e54e1587879f4c1c", + "verifier_run_sha256": "648cf66e67fe6bb92676ae2d1aa780afe62858336478a034e54e1587879f4c1c" + }, + "RESULT.json": { + "semantic_equal": true, + "byte_equal": true, + "review_run_sha256": "2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9", + "verifier_run_sha256": "2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9" + }, + "SEMANTIC-CONTROLS.json": { + "semantic_equal": true, + "byte_equal": true, + "review_run_sha256": "963ce82ddb5baa4c1c8555ceab60a2bccbbbc11bd72c553e3b15520b45062337", + "verifier_run_sha256": "963ce82ddb5baa4c1c8555ceab60a2bccbbbc11bd72c553e3b15520b45062337" + }, + "INPUT-PINS.json": { + "semantic_equal": true, + "byte_equal": true, + "review_run_sha256": "22292db50241f5a8865dd20a7b67903635a93d0460a55f4998e633833d627dea", + "verifier_run_sha256": "22292db50241f5a8865dd20a7b67903635a93d0460a55f4998e633833d627dea" + }, + "SOURCE-REVERTS.json": { + "mathematical_records_equal": true, + "excluded_fields": [ + "command (absolute output paths, wall time, and path-dependent stderr hashes)" + ], + "review_run_sha256": "e1c4cc9de856c6b527f420aa17db063335458cb150ecd314d3c8ce91a0e9e2ba", + "verifier_run_sha256": "8b21615501801f6a2bfe8babd88a73f31bd9a8c177e51e5702d445a93c5e4cc8" + } + }, + "receipt_hashes": { + "RESULT.json": "2ece1e706252c810df6e8a73d09dd66ae6c9b2b940c83049a7c7767aec6856e9", + "BASELINE.json": "648cf66e67fe6bb92676ae2d1aa780afe62858336478a034e54e1587879f4c1c", + "SOURCE-REVERTS.json": "e1c4cc9de856c6b527f420aa17db063335458cb150ecd314d3c8ce91a0e9e2ba", + "SEMANTIC-CONTROLS.json": "963ce82ddb5baa4c1c8555ceab60a2bccbbbc11bd72c553e3b15520b45062337", + "INPUT-PINS.json": "22292db50241f5a8865dd20a7b67903635a93d0460a55f4998e633833d627dea", + "ENVIRONMENT.json": "f295be1c3457a2fe4730a5cb664ae7327a14c47a0e8fafb56ac48614124858a0" + } +} diff --git a/research/k492-emitter-independent-controls/evidence/astra-run-command.json b/research/k492-emitter-independent-controls/evidence/astra-run-command.json new file mode 100644 index 0000000000..da65b9a39c --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/astra-run-command.json @@ -0,0 +1,21 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/research/k492-emitter-independent-controls/run.py", + "--out", + "/tmp/k492-emitter-astra-review-20261013" + ], + "cwd": "", + "started_at_utc": "2026-10-13T06:14:35.026077+00:00", + "finished_at_utc": "2026-10-13T06:15:18.676077+00:00", + "elapsed_seconds": 43.649371459148824, + "exit_code": 0, + "output_directory": "/tmp/k492-emitter-astra-review-20261013", + "source_sha256": { + "run.py": "fbb04bc8c097b82db4a09af69ae62c1b7ab07f522a9726ff573ea64e485a9aa8", + "independent.py": "755f2c39697d33f2f2c431605dcdc59c7753e4cfae497d40482ab40b7d0f9016" + }, + "source_unchanged": true, + "stdout_sha256": "b00f16b4c6384da6bcb26fa07a5b8c35c7ba58cba793d3098c3f3b6e7c969d8a" +} diff --git a/research/k492-emitter-independent-controls/evidence/astra-run-stdout.txt b/research/k492-emitter-independent-controls/evidence/astra-run-stdout.txt new file mode 100644 index 0000000000..121667716d --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/astra-run-stdout.txt @@ -0,0 +1,10 @@ +PASS baseline: R=492, R0=504, 35,424 roles, 7,670 physical rows +PASS emit.R_from_providers: primary_rejected +PASS emit.roles_72R: primary_rejected +PASS emit.widths_range: primary_rejected +PASS emit.all_helpers_owned: primary_rejected +PASS emit.physical: independent_rejected +PASS emit.reserved_tableau: independent_rejected +PASS emit.parent_R0: primary_rejected +PASS emit.version_label: pass_changed +PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE diff --git a/research/k492-emitter-independent-controls/evidence/baseline-preservation.json b/research/k492-emitter-independent-controls/evidence/baseline-preservation.json new file mode 100644 index 0000000000..8981692702 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/baseline-preservation.json @@ -0,0 +1,46 @@ +{ + "captured_at_utc": "2026-10-13T06:18:03.782907+00:00", + "checks": [ + { + "command": [ + "git", + "rev-parse", + "HEAD" + ], + "exit_code": 0, + "stdout": "66849e1475c930fd7732b1a0067ffee7e1e95f60\n", + "stderr": "" + }, + { + "command": [ + "git", + "diff", + "--exit-code" + ], + "exit_code": 0, + "stdout": "", + "stderr": "" + }, + { + "command": [ + "git", + "diff", + "--cached", + "--exit-code" + ], + "exit_code": 0, + "stdout": "", + "stderr": "" + }, + { + "command": [ + "git", + "status", + "--short" + ], + "exit_code": 0, + "stdout": "?? research/k492-emitter-independent-controls/\n", + "stderr": "" + } + ] +} diff --git a/research/k492-emitter-independent-controls/evidence/baseline/COMMAND.json b/research/k492-emitter-independent-controls/evidence/baseline/COMMAND.json new file mode 100644 index 0000000000..c11d15db44 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/baseline/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/baseline/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/baseline/emitted" + ], + "cwd": "", + "emitter_source_sha256": "fe26f10fe5d30ed407a37540a45ef94f44576dd241d09e19aef5db1efb072746", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.747111, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "29073870df4e5e2b15fa51624599a1a30a5accb93e6d4557a77b86cfbfb8cbbc", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/baseline/emitted/ACTUAL-SIGMAS.json.gz b/research/k492-emitter-independent-controls/evidence/baseline/emitted/ACTUAL-SIGMAS.json.gz new file mode 100644 index 0000000000..c438815fc5 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/baseline/emitted/ACTUAL-SIGMAS.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/baseline/emitted/GLOBAL-TEMPLATE.json.gz b/research/k492-emitter-independent-controls/evidence/baseline/emitted/GLOBAL-TEMPLATE.json.gz new file mode 100644 index 0000000000..7fed7d5880 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/baseline/emitted/GLOBAL-TEMPLATE.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/baseline/emitted/HOSTED.json b/research/k492-emitter-independent-controls/evidence/baseline/emitted/HOSTED.json new file mode 100644 index 0000000000..db58972e0c --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/baseline/emitted/HOSTED.json @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/baseline/stderr.txt b/research/k492-emitter-independent-controls/evidence/baseline/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/baseline/stdout.txt b/research/k492-emitter-independent-controls/evidence/baseline/stdout.txt new file mode 100644 index 0000000000..db58972e0c --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/baseline/stdout.txt @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "22b41c45fdac1dcc7495311fe701f4697219654843558785ed72fae91df531b0", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/COMMAND.json new file mode 100644 index 0000000000..92d9a6acc4 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.R_from_providers/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.R_from_providers/emitted" + ], + "cwd": "", + "emitter_source_sha256": "56c02b1f9bd024824398923774fbde188a5cfbe271ab7b7fadc2bd22e96d5f3e", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 1.001981, + "stderr_sha256": "da6603310b6fb689386abcf980e1bee487947deaed52811adb92a5ee3b0919ae", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/source.patch b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/source.patch new file mode 100644 index 0000000000..ea8a01803f --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.R_from_providers/emit_allcold.py +@@ -36,7 +36,7 @@ + assert all((directory/f).is_file()for f in provider_files) + pc=read(directory/'CANONICAL-WORD.json.gz');checks=read(directory/'LOCAL-CHECKS.json');programs=read(directory/'LOCAL-PROGRAMS.json.gz');replay=read(directory/'INDEPENDENT-LOCAL-REPLAY.json') + assert(pc['v'],pc['h'],pc['ports'],pc['centers'])==(V,9,canon['ports'],canon['centers']) +- R=pc['R'];assert type(R)is int and R>0 and all(x['R']==R for x in registry.values()),'providers disagree on helper count R' ++ R=504;assert type(R)is int and R>0 and all(x['R']==R for x in registry.values()),'providers disagree on helper count R' + assert replay['status']=='PASS_INDEPENDENT_LOCAL_SCALAR_FRAME_AND_WRAPPER_REPLAY' + assert replay['canonical_word_sha256']==sha(directory/'CANONICAL-WORD.json.gz')and replay['local_programs_sha256']==sha(directory/'LOCAL-PROGRAMS.json.gz') + widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(R)] # HPE: residual width |final|-|start| diff --git a/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/stderr.txt new file mode 100644 index 0000000000..1988ea433f --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/stderr.txt @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/private/tmp/k492-emitter-astra-review-20261013/emit.R_from_providers/source/emit_allcold.py", line 42, in + widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(R)] # HPE: residual width |final|-|start| + ~~~~~~~~~~~^^^^^^^ +IndexError: list index out of range diff --git a/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.R_from_providers/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/COMMAND.json new file mode 100644 index 0000000000..6557d31b81 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.all_helpers_owned/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.all_helpers_owned/emitted" + ], + "cwd": "", + "emitter_source_sha256": "a8baced1545b409569b5111a97b2c0dc2e4fd17a15c775562d1367d4c796d399", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 2.063202, + "stderr_sha256": "0044b1a6d4f16f2c524815647ca95a6316f9ffc9edac7deb9dc8ec2d75263af5", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/source.patch b/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/source.patch new file mode 100644 index 0000000000..0a6da2d041 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.all_helpers_owned/emit_allcold.py +@@ -74,7 +74,7 @@ + cells=set(range(off,off+w));assert not used[i,orp,port]&cells;used[i,orp,port]|=cells + digest.update(json.dumps([s,rep,h,f,sigmahash],separators=(',',':')).encode()+b'\n') + for c in t['calls']: +- k=(c['stage'],c['replica']);assert set(bycall[k])==set(range(R)) ++ k=(c['stage'],c['replica']);assert set(bycall[k])==set(range(504)) + c['owners']=c['owners'][:(2*V)]+[bycall[k][h]for h in range(R)];assert len({f for f,r in c['owners']})==2*V+R and all(f + k=(c['stage'],c['replica']);assert set(bycall[k])==set(range(504)) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.all_helpers_owned/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.parent_R0/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/COMMAND.json new file mode 100644 index 0000000000..671c769371 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.parent_R0/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.parent_R0/emitted" + ], + "cwd": "", + "emitter_source_sha256": "0cd96348b9c591cd8dca0596fa9c2c2a51281a83da420b4156f8dde3fef8a347", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 2.056735, + "stderr_sha256": "2e55da1811367dd65a0c4820ddc413355ef329daa88241e62b9b2a1a9492415b", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.parent_R0/source.patch b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/source.patch new file mode 100644 index 0000000000..d977f6643a --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.parent_R0/emit_allcold.py +@@ -90,7 +90,7 @@ + f=rep*(8*V)+(2*pairs[i]+side[i])*V+port;newidle.append(dict(child=i,port=port,replica=rep,replicas=1,family=f,rank=left,hosted=len(u),pending_offset=len(u)));paid[left]+=1 + assert M*DATA-sum(r*n for r,n in paid.items())==2560 + C=len(canon['centers']);physical=DATA+C+R+2 +-assert parent['physical']-parent['live']==C+R0+2 ++assert parent['physical']-parent['live']==C+R+2 + # Local circuits, exact phase recipes, normalized wrappers and data routes stay + # byte-identical; only full-family helper placement and idle remainders change. + t.update(version='round20-R%d-asynchronous-whole-owner-v1'%R,live=DATA,physical=physical,idle_children=newidle,private_namespace={'centers':[DATA,DATA+C],'reserved_tableau':[DATA+C,DATA+C+R],'coefficient':[physical-2,physical]}) diff --git a/research/k492-emitter-independent-controls/evidence/emit.parent_R0/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/stderr.txt new file mode 100644 index 0000000000..baf5e0c6f2 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/stderr.txt @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/private/tmp/k492-emitter-astra-review-20261013/emit.parent_R0/source/emit_allcold.py", line 93, in + assert parent['physical']-parent['live']==C+R+2 + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/research/k492-emitter-independent-controls/evidence/emit.parent_R0/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.parent_R0/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.physical/COMMAND.json new file mode 100644 index 0000000000..7feabd4619 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.physical/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.physical/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.physical/emitted" + ], + "cwd": "", + "emitter_source_sha256": "468dd48a649b58e3cb26899b3f4f4cfaa8136f338590c06ad8d3e92191b926f9", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.750823, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "fdbf2adc8e75ef0b867fceef7ce67f341dc90d9ff078ea7c1c9fb514fe4dafac", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/ACTUAL-SIGMAS.json.gz b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/ACTUAL-SIGMAS.json.gz new file mode 100644 index 0000000000..c438815fc5 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/ACTUAL-SIGMAS.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/GLOBAL-TEMPLATE.json.gz b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/GLOBAL-TEMPLATE.json.gz new file mode 100644 index 0000000000..89ae86a296 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/GLOBAL-TEMPLATE.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/HOSTED.json b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/HOSTED.json new file mode 100644 index 0000000000..8a048b5b66 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.physical/emitted/HOSTED.json @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "5a5e948cde3e0293779d2259e90b3baa82a525679a21b7fb2b54355d29662948", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7682, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/source.patch b/research/k492-emitter-independent-controls/evidence/emit.physical/source.patch new file mode 100644 index 0000000000..3acdba8ce0 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.physical/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.physical/emit_allcold.py +@@ -89,7 +89,7 @@ + if left: + f=rep*(8*V)+(2*pairs[i]+side[i])*V+port;newidle.append(dict(child=i,port=port,replica=rep,replicas=1,family=f,rank=left,hosted=len(u),pending_offset=len(u)));paid[left]+=1 + assert M*DATA-sum(r*n for r,n in paid.items())==2560 +-C=len(canon['centers']);physical=DATA+C+R+2 ++C=len(canon['centers']);physical=DATA+C+504+2 + assert parent['physical']-parent['live']==C+R0+2 + # Local circuits, exact phase recipes, normalized wrappers and data routes stay + # byte-identical; only full-family helper placement and idle remainders change. diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.physical/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.physical/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.physical/stdout.txt new file mode 100644 index 0000000000..8a048b5b66 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.physical/stdout.txt @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "5a5e948cde3e0293779d2259e90b3baa82a525679a21b7fb2b54355d29662948", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7682, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/COMMAND.json new file mode 100644 index 0000000000..0e81e76f13 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.reserved_tableau/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.reserved_tableau/emitted" + ], + "cwd": "", + "emitter_source_sha256": "3d2e8f5e95cdcc870fa8988882cd4a5ba372cf88c1d6ebc4d7361749634be4e0", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.722604, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "7c7c6b20c48e6f301ad48666443c7f71728285552a63fc146d8c300165258b09", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/ACTUAL-SIGMAS.json.gz b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/ACTUAL-SIGMAS.json.gz new file mode 100644 index 0000000000..c438815fc5 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/ACTUAL-SIGMAS.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/GLOBAL-TEMPLATE.json.gz b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/GLOBAL-TEMPLATE.json.gz new file mode 100644 index 0000000000..69e028a46a Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/GLOBAL-TEMPLATE.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/HOSTED.json b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/HOSTED.json new file mode 100644 index 0000000000..785e623291 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/emitted/HOSTED.json @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "0fe077c438088adebd0ecd3de887774e1ffc28e336e8e79e7022b2bc10edcf46", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/source.patch b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/source.patch new file mode 100644 index 0000000000..2e48987a63 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.reserved_tableau/emit_allcold.py +@@ -93,7 +93,7 @@ + assert parent['physical']-parent['live']==C+R0+2 + # Local circuits, exact phase recipes, normalized wrappers and data routes stay + # byte-identical; only full-family helper placement and idle remainders change. +-t.update(version='round20-R%d-asynchronous-whole-owner-v1'%R,live=DATA,physical=physical,idle_children=newidle,private_namespace={'centers':[DATA,DATA+C],'reserved_tableau':[DATA+C,DATA+C+R],'coefficient':[physical-2,physical]}) ++t.update(version='round20-R%d-asynchronous-whole-owner-v1'%R,live=DATA,physical=physical,idle_children=newidle,private_namespace={'centers':[DATA,DATA+C],'reserved_tableau':[DATA+C,DATA+C+504],'coefficient':[physical-2,physical]}) + t['hosting']=dict(rule='one-helper-per-physical-family-per-complete-invocation',max_helpers_per_physical_family_per_call=1,scope='asynchronously interleaved data replicas; each whole helper occurs once per(stage,invocation replica)',pooled_slots=roles,banks=[0]*9,owner_map_sha256=hashlib.sha256(MAP.read_bytes()).hexdigest(),idle_remainder_semantics='Each idle_children item acts once, on its explicit replica/family, at pending_offset with the stated rank; replicas=1.') + t['route_semantics']['helper']='Whole physical family may belong to another replica; actual orthogonal port basis followed by residual/spectator coordinate permutation. Entering helpers have paid wrappers around the complete invocation; at most one helper and no active data wire uses that family in that invocation. Route[4,child,offset,width,spectators], width9 route[3,child,offset].' + t['bank_padding']['families']=[];t['bank_padding']['children']=[];t['cover_final_correction']['families']=[0,DATA];t['cover_final_correction']['charged_calls_per_cover']=DATA diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/stdout.txt new file mode 100644 index 0000000000..785e623291 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.reserved_tableau/stdout.txt @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "0fe077c438088adebd0ecd3de887774e1ffc28e336e8e79e7022b2bc10edcf46", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.roles_72R/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/COMMAND.json new file mode 100644 index 0000000000..3cf3d32659 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.roles_72R/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.roles_72R/emitted" + ], + "cwd": "", + "emitter_source_sha256": "8537a142444cf6bc2fef2c8eb92a0e24593aa901650a69a97d627dfd68be0d9b", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 1.232351, + "stderr_sha256": "cc2b024bae007f75c2a0c8d542166f8f615297a04281485d76899d14fb8821cc", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.roles_72R/source.patch b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/source.patch new file mode 100644 index 0000000000..2bedd81ad8 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.roles_72R/emit_allcold.py +@@ -45,7 +45,7 @@ + value=sha(directory/name);assert value==plan['provider_registry'][provider_id]['artifact_sha256'][name] + source_artifacts[f'providers/{provider_id}/{name}']=value + registry[provider_id]=dict(local_programs=programs,canonical_word_sha256=sha(directory/'CANONICAL-WORD.json.gz'),local_programs_sha256=sha(directory/'LOCAL-PROGRAMS.json.gz'),local_program_checks=checks,exact_local_clifford_recipe_sha256=sha(directory/'CLIFFORD-RECIPES.json'),residual_adapter_sha256=sha(directory/'RESIDUAL-ADAPTERS.json'),v=V,h=9,R=R,ports=pc['ports'],centers=pc['centers'],widths=widths) +-assert len(roles)==72*R # one whole-owner role per (call, provider helper) ++assert len(roles)==72*504 # one whole-owner role per (call, provider helper) + selected={(c['stage'],c['replica']):c for c in plan['provider_calls']} + assert len(selected)==72 and set(selected)==set(call_order) + assert Counter(c['provider']for c in selected.values())==COUNTS diff --git a/research/k492-emitter-independent-controls/evidence/emit.roles_72R/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/stderr.txt new file mode 100644 index 0000000000..01be4e989d --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/stderr.txt @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/private/tmp/k492-emitter-astra-review-20261013/emit.roles_72R/source/emit_allcold.py", line 48, in + assert len(roles)==72*504 # one whole-owner role per (call, provider helper) + ^^^^^^^^^^^^^^^^^^ +AssertionError diff --git a/research/k492-emitter-independent-controls/evidence/emit.roles_72R/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.roles_72R/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.version_label/COMMAND.json new file mode 100644 index 0000000000..6c96b81ec2 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.version_label/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.version_label/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.version_label/emitted" + ], + "cwd": "", + "emitter_source_sha256": "182f044875f7b9584b81b5bab09ec4f2d1e04483042c5b2c8f7e2c87c44fcc56", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 0, + "seconds": 2.727284, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_sha256": "62a2e8722535f3f34acda6843516b1601272832be17d2917577fb9d1491e06c7", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/ACTUAL-SIGMAS.json.gz b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/ACTUAL-SIGMAS.json.gz new file mode 100644 index 0000000000..c438815fc5 Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/ACTUAL-SIGMAS.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/GLOBAL-TEMPLATE.json.gz b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/GLOBAL-TEMPLATE.json.gz new file mode 100644 index 0000000000..be24109c7f Binary files /dev/null and b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/GLOBAL-TEMPLATE.json.gz differ diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/HOSTED.json b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/HOSTED.json new file mode 100644 index 0000000000..99eb424eb8 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.version_label/emitted/HOSTED.json @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "b2a5ee0dfd84dd039492ebe8ca20e70b18686b7ebe16c3544084b5e62629b318", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/source.patch b/research/k492-emitter-independent-controls/evidence/emit.version_label/source.patch new file mode 100644 index 0000000000..d4590a0d23 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.version_label/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.version_label/emit_allcold.py +@@ -93,7 +93,7 @@ + assert parent['physical']-parent['live']==C+R0+2 + # Local circuits, exact phase recipes, normalized wrappers and data routes stay + # byte-identical; only full-family helper placement and idle remainders change. +-t.update(version='round20-R%d-asynchronous-whole-owner-v1'%R,live=DATA,physical=physical,idle_children=newidle,private_namespace={'centers':[DATA,DATA+C],'reserved_tableau':[DATA+C,DATA+C+R],'coefficient':[physical-2,physical]}) ++t.update(version='round20-R504-asynchronous-whole-owner-v1',live=DATA,physical=physical,idle_children=newidle,private_namespace={'centers':[DATA,DATA+C],'reserved_tableau':[DATA+C,DATA+C+R],'coefficient':[physical-2,physical]}) + t['hosting']=dict(rule='one-helper-per-physical-family-per-complete-invocation',max_helpers_per_physical_family_per_call=1,scope='asynchronously interleaved data replicas; each whole helper occurs once per(stage,invocation replica)',pooled_slots=roles,banks=[0]*9,owner_map_sha256=hashlib.sha256(MAP.read_bytes()).hexdigest(),idle_remainder_semantics='Each idle_children item acts once, on its explicit replica/family, at pending_offset with the stated rank; replicas=1.') + t['route_semantics']['helper']='Whole physical family may belong to another replica; actual orthogonal port basis followed by residual/spectator coordinate permutation. Entering helpers have paid wrappers around the complete invocation; at most one helper and no active data wire uses that family in that invocation. Route[4,child,offset,width,spectators], width9 route[3,child,offset].' + t['bank_padding']['families']=[];t['bank_padding']['children']=[];t['cover_final_correction']['families']=[0,DATA];t['cover_final_correction']['charged_calls_per_cover']=DATA diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.version_label/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/emit.version_label/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.version_label/stdout.txt new file mode 100644 index 0000000000..99eb424eb8 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.version_label/stdout.txt @@ -0,0 +1,60 @@ +{ + "status": "EMITTED_MIXED_PROVIDER_ASYNCHRONOUS_WHOLE_OWNER_COMPLEX_TEMPLATE", + "template_sha256": "b2a5ee0dfd84dd039492ebe8ca20e70b18686b7ebe16c3544084b5e62629b318", + "parent_template_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "live": 7168, + "physical": 7670, + "global_profile": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + }, + "rank_mass": 520704, + "deficit": 2560, + "maxchild": 48, + "hosted_residuals": 35424, + "banks_per_stage": [ + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0 + ], + "entering_helper_roles": 16368, + "unique_actual_73column_sigmas": 7672, + "sigma_stream_sha256": "96831caea559aaa2427050c88cf03c0cd3a657af422edc72ecaca5960c0690c3", + "cross_replica_helper_roles": 28404, + "asynchronous_order_sha256": "2acd6b2004be3d3ef6645f3c968feb22b5167c400bb49eb446821e5cb7af6eee", + "source_artifacts": { + "work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "providers/ck/CANONICAL-WORD.json.gz": "ae3018c0646be06f47d345bb8baf0e6ea9220096a949fa30a8f7656aa4ad6f45", + "providers/ck/LOCAL-PROGRAMS.json.gz": "b5da54e049cc127a1065190a647cb71cac0c6ba03d9ccdb71719f4fcbfa886f3", + "providers/ck/LOCAL-CHECKS.json": "059c4e59142bdf5c19dc7c0afebcddfec28e6e60cbc7299b8bdcc624afbc0cbe", + "providers/ck/INDEPENDENT-LOCAL-REPLAY.json": "ecefb9e661301d8081522be68bbe6640e175c011eb1177f643383d193c6fb2f0", + "providers/ck/RESIDUAL-ADAPTERS.json": "4697965c1b466fd3eaf37fa1fbbd45bb06c78cb0fe0b3a253744efb4013581b9", + "providers/ck/CLIFFORD-RECIPES.json": "dfb64e71409a395f9375d9cc2258365d462bab2d28b707dcfba38994dd5aa0b9", + "providers/ck/CLIFFORD-REVIEW.json": "35591083acb26fad551358b9fd1efc3a3a825fff02b1b51403bc2b8934b09faf", + "providers/jp8/CANONICAL-WORD.json.gz": "7a3fec1022d3b2b1bd986302a327735ec521d17b043f4a5acb96253a56f6193c", + "providers/jp8/LOCAL-PROGRAMS.json.gz": "fa0c196f65bd6ec1424fdf7d789f6972075c7bb02bf43f573ea85eafab31be98", + "providers/jp8/LOCAL-CHECKS.json": "0fad744aa863eedb288a9f87b1c23225a36b316b6275cc3b1bcedd42afe28a67", + "providers/jp8/INDEPENDENT-LOCAL-REPLAY.json": "cb2f99ed351925dd35434b73de16f4085884fe81a35a69e1c7ce2d5e96cb975b", + "providers/jp8/RESIDUAL-ADAPTERS.json": "bdb44cf523636f307ebb3617da548f2e3a8af74321eabe24aef40186e280a917", + "providers/jp8/CLIFFORD-RECIPES.json": "2799d73dd08c4435e5900ff2ae6ebc7f34535c153e173ab88d66d1f0b5e6dcde", + "providers/jp8/CLIFFORD-REVIEW.json": "c134b7ce364791051d755c4d91e1c594215302b3ebffb807fdb41aff325f97a1" + }, + "provider_counts": { + "ck": 8, + "jp8": 64 + }, + "scope": "Two actual verified plain/width-seven providers dispatched per complete invocation; independent controller/spectator/normalization and complete finite invoice admission required." +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.widths_range/COMMAND.json b/research/k492-emitter-independent-controls/evidence/emit.widths_range/COMMAND.json new file mode 100644 index 0000000000..f06f41af0a --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.widths_range/COMMAND.json @@ -0,0 +1,31 @@ +{ + "argv": [ + "/Library/Frameworks/Python.framework/Versions/3.13/bin/python3", + "-B", + "/private/tmp/k492-emitter-astra-review-20261013/emit.widths_range/source/emit_allcold.py", + "--base", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/base", + "--owners", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/OWNERS.json.gz", + "--plan", + "/private/tmp/k492-emitter-astra-review-20261013/fixture/PLAN.json", + "--out", + "/private/tmp/k492-emitter-astra-review-20261013/emit.widths_range/emitted" + ], + "cwd": "", + "emitter_source_sha256": "c25d0a8d4d857f9cd78320ae719d7e2e2d535ca0c5567d3d94aea21275cd2eb2", + "environment_overrides": { + "PYTHONDONTWRITEBYTECODE": "1", + "WITNESS_SPEC": "/private/tmp/k492-emitter-astra-review-20261013/fixture/SPEC.json" + }, + "environment_removed": [ + "PYTHONOPTIMIZE", + "WITNESS_DISCOVER", + "WITNESS_RECORD" + ], + "exit_code": 1, + "seconds": 0.997683, + "stderr_sha256": "f1c096f9dd9b4732a2ec254b351e5fc74e27eac881cb8466875979bbbe2d9476", + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "witness_source_sha256": "00789c911a8f32cfe9d52207c7aa78305dc3fce4a8b6305ba402b7e74117103d" +} diff --git a/research/k492-emitter-independent-controls/evidence/emit.widths_range/source.patch b/research/k492-emitter-independent-controls/evidence/emit.widths_range/source.patch new file mode 100644 index 0000000000..3262a53242 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.widths_range/source.patch @@ -0,0 +1,11 @@ +--- original/emit_allcold.py ++++ emit.widths_range/emit_allcold.py +@@ -39,7 +39,7 @@ + R=pc['R'];assert type(R)is int and R>0 and all(x['R']==R for x in registry.values()),'providers disagree on helper count R' + assert replay['status']=='PASS_INDEPENDENT_LOCAL_SCALAR_FRAME_AND_WRAPPER_REPLAY' + assert replay['canonical_word_sha256']==sha(directory/'CANONICAL-WORD.json.gz')and replay['local_programs_sha256']==sha(directory/'LOCAL-PROGRAMS.json.gz') +- widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(R)] # HPE: residual width |final|-|start| ++ widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(504)] # HPE: residual width |final|-|start| + assert widths==plan['provider_registry'][provider_id]['widths'] + for name in provider_files: + value=sha(directory/name);assert value==plan['provider_registry'][provider_id]['artifact_sha256'][name] diff --git a/research/k492-emitter-independent-controls/evidence/emit.widths_range/stderr.txt b/research/k492-emitter-independent-controls/evidence/emit.widths_range/stderr.txt new file mode 100644 index 0000000000..a6be1b1e97 --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/emit.widths_range/stderr.txt @@ -0,0 +1,5 @@ +Traceback (most recent call last): + File "/private/tmp/k492-emitter-astra-review-20261013/emit.widths_range/source/emit_allcold.py", line 42, in + widths=[len(pc['frames'][pc['final'][2*V+h]])-len(pc['frames'][pc['start'][2*V+h]])for h in range(504)] # HPE: residual width |final|-|start| + ~~~~~~~~~~~^^^^^^^ +IndexError: list index out of range diff --git a/research/k492-emitter-independent-controls/evidence/emit.widths_range/stdout.txt b/research/k492-emitter-independent-controls/evidence/emit.widths_range/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/k492-emitter-independent-controls/evidence/overlap-summary.json b/research/k492-emitter-independent-controls/evidence/overlap-summary.json new file mode 100644 index 0000000000..a263d4b43e --- /dev/null +++ b/research/k492-emitter-independent-controls/evidence/overlap-summary.json @@ -0,0 +1,5931 @@ +{ + "schema": "k492-overlap-obligation-audit-v1", + "audit_completed_at_utc": "2026-10-13T06:08:42.694855Z", + "repository": "CrocSwap/integer-mult-bounds", + "base_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "selected_source_head": "660de893d27bb7abd1d5b01b1640207528a5c851", + "selected_kappa": "51110230636731/31250000000000000", + "reviewed_dependency_heads": { + "622": "f69477f4f6d3c7eb1f740b166881bffed4ffa9f6", + "623": "e39a615ca601ce5d62abeb24f3fcdb8644ca1005", + "626": "660de893d27bb7abd1d5b01b1640207528a5c851", + "543": "2065fe4f72a914d907f1046603f5a36f17018535" + }, + "snapshot": { + "timestamp_kind": "local_acquisition_file_mtime; not atomic GitHub server snapshot", + "open_pull_file_mtime_utc": "2026-10-13T06:01:28.508101Z", + "open_issue_file_mtime_utc": "2026-10-13T06:01:38.693470Z", + "pull_rows": 624, + "unique_pull_numbers": 623, + "duplicate_pull_numbers": [ + 29 + ], + "issue_rows": 624, + "real_issues": [ + { + "number": 650, + "title": "Can we turn on Discussions?", + "url": "https://github.com/CrocSwap/integer-mult-bounds/issues/650" + } + ], + "issue_PR_number_set_equals_pull_number_set": true, + "highest_pull_number": 804, + "latest_pull_updated_at": "2026-10-13T06:00:56Z" + }, + "search_patterns": [ + "revert|non.?assembly|scratch.{0,60}control|32.{0,25}(control|site)|R.?504.{0,40}compat", + "(492|generalised|generalized|helper.map).{0,60}(control|audit|verif)|control.{0,60}(492|helper.map)", + "helper-map|helper map|helper.index|width_spot|width-8|mapped-index|R\\s*=\\s*504|identity\\.start|swap_spot|bind_providers|emit_allcold|audit_allcold|generated_identity_controls|assembly_controls" + ], + "scanned_pull_inventory": [ + { + "number": 1, + "title": "Refine paired parameters and derive the fixed-exponent supremum", + "head": "bfb168a5611c9eb219d04cf7d551edf1517ecd78", + "updated_at": "2026-10-07T20:58:44Z", + "body_sha256": "8afeb14967b845ed6fb93e681954d77568e3d3bc738647cb8633513ad94c3992", + "matched_searches": [] + }, + { + "number": 2, + "title": "Preserve aligned pairing and its conditional 17*2^-63 witness", + "head": "8bb07d55f6898bc8ec919222cf7596e987e9b69f", + "updated_at": "2026-10-08T16:19:03Z", + "body_sha256": "bc3b321c571a353485e9b7a5b076a1569e3e8d03f76f07b0e634b759267fe898", + "matched_searches": [] + }, + { + "number": 3, + "title": "Compress the complex network for a conditional 59/10^11 > 2^-31 bound", + "head": "dfe5b818aad4d386cb5dd7d76df108088107765d", + "updated_at": "2026-10-08T02:28:12Z", + "body_sha256": "197965d5ca5e21b324fa42b60d43caf426c7825c4be7284d0dfecea45ebf577d", + "matched_searches": [] + }, + { + "number": 4, + "title": "Combine PR #3 shared exclusions with retained totals and stage sharing", + "head": "8c225e619168c0141dcfcba3b68a65bbed6a8729", + "updated_at": "2026-10-08T03:45:41Z", + "body_sha256": "88e2f5d8ff1b00967bb3537187628f8a8729ae5111f3968a284e520157da3809", + "matched_searches": [] + }, + { + "number": 5, + "title": "Faster Gaussian resampling for a conditional 1479/10^12 > 2^-30 bound", + "head": "d3d370c34937503bd3fa63c83d505a05e8e50893", + "updated_at": "2026-10-08T04:09:10Z", + "body_sha256": "03d9baf2e7f079ce086b0ba092e27e97032c8828b99174b8369ae0146231f8fa", + "matched_searches": [] + }, + { + "number": 6, + "title": "Aligned bit circuit with cheaper centers for a conditional 1624/10^12 bound", + "head": "5015011bd9a655da038910171eee9f431f4590ff", + "updated_at": "2026-10-08T05:23:30Z", + "body_sha256": "e53c12e3f418b6138ca2dd57523f51887c514d686f9d95d87b94e64d6dcf5b9f", + "matched_searches": [] + }, + { + "number": 7, + "title": "Ternary five-subset networks for a conditional 373/10^11 > 2^-28 bound", + "head": "6725c6a17b17871a35353fd29157f4ed851bc114", + "updated_at": "2026-10-08T06:12:04Z", + "body_sha256": "6fcfe027068c969f15b0d1323ed0154f835a70e77aa0e60781adb3ddbadbaec3", + "matched_searches": [] + }, + { + "number": 8, + "title": "Review conditional geometric complex-network candidate with kappa = 5.9e-10", + "head": "4920e44843512014f742d685e01341f6787bbd5f", + "updated_at": "2026-10-09T00:43:18Z", + "body_sha256": "0d298013826b3c1bb901ad7b251283b2ed6c630d0f8adb8f6f593f4fbe894dc8", + "matched_searches": [] + }, + { + "number": 9, + "title": "Refine PR #7 ternary star templates for conditional kappa = 3.8e-9", + "head": "cfd6a2baded9dba990b987934474a7721d6ca3fb", + "updated_at": "2026-10-08T08:22:26Z", + "body_sha256": "a308f07a3e9f2761e4b774d502c43e144e9a11aa7154391848999e21994e7814", + "matched_searches": [] + }, + { + "number": 12, + "title": "Use dimension-30 geometry for conditional kappa = 1.2649e-7", + "head": "35d31e30f28bc5da0ae6a88e7b03d75ebc855534", + "updated_at": "2026-10-08T08:47:03Z", + "body_sha256": "cb5250617ddc827e2679e3ee7d86bedbf92943f730defcb8ab08ef356aa30a4e", + "matched_searches": [] + }, + { + "number": 13, + "title": "Auxiliary source frames for a conditional kappa = 7699/10^10 > 2^-21 bound", + "head": "3ef246fa4f69c87ebfed78376418afa9ffcad145", + "updated_at": "2026-10-08T09:01:22Z", + "body_sha256": "655fa55842cecd2411f6d779f46c032c5a1d861023b08d67f498139553a73f40", + "matched_searches": [] + }, + { + "number": 14, + "title": "Combine source frames and data corners for conditional kappa = 9.0799e-7", + "head": "1fa5b9a9aaccbebb3eb29ac7ea55811f46464eee", + "updated_at": "2026-10-08T09:19:26Z", + "body_sha256": "9fd9c330a403d54e4d777d96f0cddfb46646ccbf28054f5b4643d56aa731e961", + "matched_searches": [] + }, + { + "number": 15, + "title": "Smaller h30 producer and full complex batching for conditional κ > 2^-20", + "head": "a17cab396ce1c79c288bde9d06002cefdc0af8e6", + "updated_at": "2026-10-08T09:26:21Z", + "body_sha256": "65a9cbf04b2978bc36ee596b216a91afc1d9db440fb4bcf9060a4ab95fec2318", + "matched_searches": [ + 0 + ] + }, + { + "number": 16, + "title": "Nested controlled bases for a conditional 9799/10^10 > 2^-20 bound", + "head": "a80f5e676c84b59def9791495df0655efe89a04f", + "updated_at": "2026-10-08T09:36:26Z", + "body_sha256": "65185bf269ebe21d9789c36420de4c6f9fe2cd62c09687e96d8b8c3755da65eb", + "matched_searches": [] + }, + { + "number": 17, + "title": "Compose nested geometry and smaller h30 producer for conditional κ = 1.248342e-6 > 2^-20", + "head": "c915b4117626a512dd470adbdbd76963108f5cb3", + "updated_at": "2026-10-08T10:04:07Z", + "body_sha256": "254a82a104d976eb5ea2518068ee891fb85c81c3388df394ed08958e5fc9cad6", + "matched_searches": [] + }, + { + "number": 19, + "title": "Partial-swap ternary geometry for conditional κ = 2.093495e-6 > 2^-19", + "head": "817aeb7b1225717d1b784d507570bf02ed89294c", + "updated_at": "2026-10-08T10:36:20Z", + "body_sha256": "802972685cfe10d44414ff24deb35d5ab4a0322ae2460ec8d41914bf3bb5f07d", + "matched_searches": [] + }, + { + "number": 20, + "title": "Source-framed h53 conditional witness above 2^-20: attributed research record", + "head": "4f8d6c8272b5ff307a0da51df545ec3cd96a8b6e", + "updated_at": "2026-10-08T10:57:04Z", + "body_sha256": "2e3942c200ba7c901207fecd9ca4eea53b8bb6bfba9f7b03e7d956981a2f6566", + "matched_searches": [ + 0 + ] + }, + { + "number": 21, + "title": "Translated partial-swap frames for a conditional 5499/10^9 > 2^-18 bound", + "head": "5ba6cf0bfb68f2be8d15610e7972207c50254d6a", + "updated_at": "2026-10-08T10:24:48Z", + "body_sha256": "6d6fe492fe210a06fcfd26f04a013aa74e440a38330c3e12865bb30613b9469b", + "matched_searches": [] + }, + { + "number": 22, + "title": "Refine translated parameters to conditional κ = 5.7114918e-6", + "head": "c2f03ed48637fbe69803b6cecdcd50686e3274af", + "updated_at": "2026-10-08T11:46:40Z", + "body_sha256": "39dab279b00d8c98474d366c338fed6908562bd257676d696ea82b5680bbc797", + "matched_searches": [] + }, + { + "number": 23, + "title": "Semantic precision and bulk resampling for a conditional 1099/10^8 > 2^-17 bound", + "head": "661ebabc1076c9f525d7ce4967c876b203fa9827", + "updated_at": "2026-10-08T10:43:55Z", + "body_sha256": "9537b86cd710cec8e4ff83eb2f6747de35925449c6440c16e8061a191dcff1c7", + "matched_searches": [] + }, + { + "number": 25, + "title": "Expose an A5 block for conditional κ = 1.1447067e-5 > 2^-17", + "head": "003f366cfa99e19fbeacd9300a219f2d44c8cff0", + "updated_at": "2026-10-08T10:57:42Z", + "body_sha256": "5764c2e5a78a7b7d31ffb90528b16827aa56b4c8c1c436ea5d80bb8ee717789a", + "matched_searches": [] + }, + { + "number": 27, + "title": "Compose endpoint bit and semantic bulk interfaces for conditional κ = 1.19720853e-5", + "head": "c297233e788a23e9833ad1ee07fc8517accd0f42", + "updated_at": "2026-10-08T11:44:43Z", + "body_sha256": "45f7decd08d688770a51b14d04d2e17951e4fa7731ef4fd5bf61b1464261ca08", + "matched_searches": [] + }, + { + "number": 28, + "title": "Rectangular geometry for conditional κ = 1.2260937e-5 > 2^-17", + "head": "bb1143d0714bf315a0043cebeabe96b987af935e", + "updated_at": "2026-10-08T11:16:18Z", + "body_sha256": "09e14e5b11c3c7f805aa03894d3f9512e3a6b22f9ac6055e639755ef015301f5", + "matched_searches": [] + }, + { + "number": 29, + "title": "Two-stage controlled corners for a conditional 15536/10^9 > 2^-16 bound", + "head": "9d963275075fa98f1da821e27757b238dafd6b3c", + "updated_at": "2026-10-08T11:20:11Z", + "body_sha256": "e953987672e1d4abd0846e158d076442c6e5db25c3ef6d13c3d6bc7e17fb3f6f", + "matched_searches": [] + }, + { + "number": 31, + "title": "Exact data-corner certificates for conditional κ = 1.5878574e-5 > 2^-16", + "head": "122e6453e80330633af701eabd1a6a72dfefd286", + "updated_at": "2026-10-08T11:37:30Z", + "body_sha256": "d54619e29cb47b4fdb831077d31fdc6da78326f640135e8a8723e361327653fd", + "matched_searches": [] + }, + { + "number": 33, + "title": "Compose smaller two-stage dimensions and data blocks for conditional κ = 1.638103206e-5", + "head": "a499a345c040aa15b68e984a0904eadc485c7a7e", + "updated_at": "2026-10-08T11:49:21Z", + "body_sha256": "e1769a8b92e34df7ed0bcd6070e28faf9b5864b2046230af190b2128f0329d63", + "matched_searches": [] + }, + { + "number": 34, + "title": "Reversed two-stage basis and balanced assembly for conditional κ = 1.639226629e-5", + "head": "7fecbe3651e095fb0f450756afdeefd2a9ee80a2", + "updated_at": "2026-10-08T12:10:06Z", + "body_sha256": "eb6af92c20873ef7bec76926d726afa869ef481ce00f7ebaab91a6b69e26e19d", + "matched_searches": [] + }, + { + "number": 35, + "title": "Fixed local bases in two stages for conditional κ = 1.6631776e-5", + "head": "9c345a2a11e5f4f3649f7c68214bf9a2a0a3fe9c", + "updated_at": "2026-10-08T12:37:15Z", + "body_sha256": "d94719f92c0d200a050d5bb57ab21c6b7426e7a232fb083f317012fefcccea2a", + "matched_searches": [] + }, + { + "number": 38, + "title": "Copied centers with fixed local bases for conditional κ = 3.886224e-5", + "head": "605323bab4ba330de3d1785dc5b3ecb14e8ab747", + "updated_at": "2026-10-08T13:01:24Z", + "body_sha256": "3b7857eb146f7f624996a923a11a97c3f31f7d08a318c4787d63206a2213a29e", + "matched_searches": [] + }, + { + "number": 40, + "title": "Both fixed bases and copied reversed corners: conditional κ = 3.918734894e-5 > 2^-15", + "head": "e3bf3ab0cb1ec48588e279b31a97e7a49c72f99e", + "updated_at": "2026-10-08T13:36:03Z", + "body_sha256": "4053b803d7b9200e85768243be98986d39dd8a83c6b493d0a4132f417ad99744", + "matched_searches": [] + }, + { + "number": 41, + "title": "Alternating pair-block networks for conditional κ = 4.034168124 × 10⁻⁵ > 2⁻¹⁵", + "head": "03bde70c0c2a453f1ceae20c619b602841405467", + "updated_at": "2026-10-08T13:46:27Z", + "body_sha256": "6e4e51f71f0686ecfcf7e9a4b99144f237df34f4ada922d5b8f80df4d271b95f", + "matched_searches": [] + }, + { + "number": 42, + "title": "RaD producers with fixed reversed geometry: conditional κ = 4.099494519e-5 > 2^-15", + "head": "a92fc98c456f6c8863b8bba90079ba71b97d2dc0", + "updated_at": "2026-10-08T14:04:50Z", + "body_sha256": "e957cd67c834c18915981dce97af6cf04e0834e9f3b1f13ebf5c2c35f7a42f43", + "matched_searches": [] + }, + { + "number": 44, + "title": "Weighted carrier matching: conditional κ = 4.100629254e-5 > 2^-15", + "head": "1a21794eb5384db0e96d7bc2b11aa6f28cff7a85", + "updated_at": "2026-10-08T14:35:23Z", + "body_sha256": "9e6cf4cc2d3d45702b54ddd1c00ac5a1f4d055505cde9ba943292ef9b799d0c5", + "matched_searches": [] + }, + { + "number": 47, + "title": "Hill-climbed producers for a conditional κ = 4.105106623e-5 bound", + "head": "117caf164e3b235ef20188aa2dc1b49617e9255c", + "updated_at": "2026-10-08T15:05:44Z", + "body_sha256": "3794c686863763a99251cfba8ce177db7b9e62b99fbe4bb48d1ad1ffede79004", + "matched_searches": [] + }, + { + "number": 63, + "title": "Rank-first pair assembly: conditional κ = 5.102757e-5", + "head": "5e42f913e827990f30d0f0918e54a803d830f13e", + "updated_at": "2026-10-08T19:27:20Z", + "body_sha256": "78462df5cbccb6510183e46d4c0869b2a4576a77d3d651192319022c4dfb3db2", + "matched_searches": [] + }, + { + "number": 65, + "title": "Reordered rank-pair regions: conditional κ = 5.1028985071975e-5", + "head": "b0cea06d7fd5ac10f76169b01d3114f208fc7448", + "updated_at": "2026-10-08T19:12:43Z", + "body_sha256": "a3cc1e4f7ff2350971a1b32d0bd2c80e874fa959050e2f200d3b33c137a59a7d", + "matched_searches": [] + }, + { + "number": 66, + "title": "Split-pair dual-suffix frames: conditional κ = 4.83109396e-5", + "head": "701b1246e2def8b022a14309b5171138f2b12a52", + "updated_at": "2026-10-08T19:53:10Z", + "body_sha256": "b2f5d8ea28b1ac11e869004de1bb1f9a14f2fd24c69f44a836030094ec3f1a04", + "matched_searches": [] + }, + { + "number": 67, + "title": "Cost-aware retired-slot selection: conditional κ = 5.1033760584215e-5", + "head": "46991a21d13f37faf2350591de7d794cfaa4455e", + "updated_at": "2026-10-08T19:34:27Z", + "body_sha256": "6633c6c0bb6a99ed99dccbd8befef9e2f457232d457c50baa7617a848a592107", + "matched_searches": [] + }, + { + "number": 68, + "title": "Cost-aware live controls: conditional κ = 5.103512721785e-5", + "head": "b1b2af3415ecb494a0552b16c18045bf3ee05e95", + "updated_at": "2026-10-08T19:25:57Z", + "body_sha256": "09fbd14cb226858a4df56947940e5c49b40bc6cd48d661e28ffca589814cdb45", + "matched_searches": [] + }, + { + "number": 69, + "title": "Balanced coarse sums: conditional κ = 5.136837484e-5", + "head": "6817afefcf0e42fb378f29f36945f4ae551b493d", + "updated_at": "2026-10-09T00:19:00Z", + "body_sha256": "1cd3e6d9ad541dcbdfc5790c2bdb913c42164cb2b8c10e0b6b9b8b90e0004d6a", + "matched_searches": [] + }, + { + "number": 70, + "title": "Profile-aware frame compilation: conditional kappa = 5.10403292611078e-5 above frozen #62", + "head": "11a4e3176511ece840d57b7db045772945d9703c", + "updated_at": "2026-10-08T19:05:16Z", + "body_sha256": "529191e8e900be64913291a9123681f54a3ad2ad1b0904f52edd7341d2ab4884", + "matched_searches": [] + }, + { + "number": 71, + "title": "Anchored split frames with profile-cost live reclamation: κ = 5.1414646104039e-5", + "head": "f59cb9f54d12a2a02b665afef24a9bb5061ae011", + "updated_at": "2026-10-08T19:58:33Z", + "body_sha256": "5a23b9e231aaeb51d863e92a91ec66a67c28ef95d0abf7915ea13419f11ce813", + "matched_searches": [] + }, + { + "number": 74, + "title": "Stopped pair-star trees: conditional κ = 7.808981744031e-5", + "head": "ecb79f2c56b1b08efad21a6b087f0b95fb121a71", + "updated_at": "2026-10-09T00:56:37Z", + "body_sha256": "164e00220dcc2e0ccfdb1b790ec0d4d0e579b175a7ea0fbe2774582a3a25a7bb", + "matched_searches": [] + }, + { + "number": 75, + "title": "Zero-circuit live clearing: conditional kappa = 5.14154245470094e-5 above #71", + "head": "da9b6cbebb33e8b8293a604dde0eace9de53406b", + "updated_at": "2026-10-08T19:34:43Z", + "body_sha256": "1d7823a3b9f5c72407211dab3c2612b804109224a17ef6169f001da15b4b555f", + "matched_searches": [] + }, + { + "number": 76, + "title": "Envelope-ordered carry exchanges: conditional κ = 5.1738676045141e-5", + "head": "2333abcea79793fe301b479a7c971cc2be45596c", + "updated_at": "2026-10-08T19:55:26Z", + "body_sha256": "5c68aba57175e93638ea4a77bc4fe08ca7febff59b0cb9910f3e75a97ef3046b", + "matched_searches": [] + }, + { + "number": 77, + "title": "Coarse-threshold and coordinate refinement: conditional κ = 5.2062354654791e-5", + "head": "17c979eb6dcd4c300e6263c66111f220a9e926e7", + "updated_at": "2026-10-08T22:27:12Z", + "body_sha256": "722cd9a037a8928ff6baa5c7a3ceab21a8622fe8c2c84cada2a0d8f367fd651d", + "matched_searches": [] + }, + { + "number": 78, + "title": "Geometric coordinate flags: conditional κ = 5.1428783626028e-5", + "head": "7c3793131155fa5795920eff35057672be38833a", + "updated_at": "2026-10-08T20:50:18Z", + "body_sha256": "a7d8f5bc9320d3d9d9e05e4b2c016556190e9daff6dbb2f93e953604189f2b24", + "matched_searches": [] + }, + { + "number": 79, + "title": "Balanced coarse split frames: conditional κ = 5.1745625472866e-5", + "head": "79dd6e134855bc8a7b8950c3aa0eb279fe148ceb", + "updated_at": "2026-10-08T20:33:40Z", + "body_sha256": "46d32de3012f6b5d5dbe909ebb99a708a8732aa6d29c577375bb021973b8fd68", + "matched_searches": [] + }, + { + "number": 80, + "title": "Combined envelope/balanced axes and geometric flags: conditional κ = 5.1778825456819e-5", + "head": "4fb50b65e3542592bb1674a0211b0b5faa3ed920", + "updated_at": "2026-10-08T20:50:24Z", + "body_sha256": "31a51148c07e00e1c4b27e357d5f0e8ff0215b9e87c322aa7900635437ae77cd", + "matched_searches": [] + }, + { + "number": 81, + "title": "Balanced-column carry exchanges: conditional κ = 5.1915547765237e-5", + "head": "acae4964aef41c69f3c57e72a45e76afc4d4934d", + "updated_at": "2026-10-08T20:18:40Z", + "body_sha256": "af438d45d31192f85f8527f4bce407f3f12e6da78aed7653048d12e7450c52b6", + "matched_searches": [] + }, + { + "number": 82, + "title": "Envelope ordering on balanced frames with geometric pricing: conditional κ = 5.203279888519e-5", + "head": "67b446ccdb9d23cae9683f6059fb607b52285004", + "updated_at": "2026-10-08T21:00:34Z", + "body_sha256": "a2c6ac910cda9815f9adccc5c731046fea5ee57ebf40d54fca0c39ef8ef441c0", + "matched_searches": [] + }, + { + "number": 83, + "title": "Certify 64 depth-coarse profiles and an adaptive-recursion limit", + "head": "183077b7b3ae12e96eb3a87c1dc08023e6494dca", + "updated_at": "2026-10-08T20:33:46Z", + "body_sha256": "8c6422f70d1fee0a5273592051f26378e5bb5dae95f2278b9588001f03a80a43", + "matched_searches": [] + }, + { + "number": 84, + "title": "Indexed carry two-cycles and coordinate flags: conditional κ = 5.22712890914e-5", + "head": "424ef44609eda377250b2985a5210cb336ade19e", + "updated_at": "2026-10-08T21:22:07Z", + "body_sha256": "6041bc7ba3c0dba9d7e9f2ffacd37efc0a42a827c887210c65d00d8368ec1968", + "matched_searches": [] + }, + { + "number": 85, + "title": "Coordinate refinement of indexed two-cycles: conditional κ = 5.2272192668365e-5", + "head": "dd7690a5a7a3027afcb002aa8ef41d0e29bde58f", + "updated_at": "2026-10-08T21:33:52Z", + "body_sha256": "b902e38ad25e90dd3e051ca3c1bdf7c1ecaffd7eba0dd6c4f280f0eb3f286847", + "matched_searches": [] + }, + { + "number": 86, + "title": "Coordinate-aware indexed compilation: conditional κ = 5.2275423755251e-5", + "head": "f0fe4453a088c62af3ee795691fa92c502ed8b57", + "updated_at": "2026-10-08T22:01:34Z", + "body_sha256": "7555535bb9ea6d6c7d60f4deb8f801480d6cf3f1864f2f1a30d3cd98326b7b86", + "matched_searches": [] + }, + { + "number": 87, + "title": "Congruent balanced multi-splits and indexed two-cycles: conditional κ = 5.2431959054651e-5", + "head": "466fc99e67d872831d1d192394f346a28e909e09", + "updated_at": "2026-10-08T21:23:40Z", + "body_sha256": "55f1e15dcdd987872dbf25af8d46ab5afc08863a97c12057af6a78e4a0071db1", + "matched_searches": [] + }, + { + "number": 88, + "title": "Certify ordered-frame composition at κ = 5.2514124198891e-5", + "head": "d5a5b936844104db18c5bdd871f89da2fbf99551", + "updated_at": "2026-10-08T22:02:07Z", + "body_sha256": "db10c95b867a8d208b7abdfe50859cf9e372227fbdcaadc3244d4800d143842c", + "matched_searches": [] + }, + { + "number": 89, + "title": "Congruent splits with geometric prices and null-circuit clearing: conditional κ = 5.2445080818074e-5", + "head": "6e3d667ee119cc630eb5ffc69ea4c222f967ce2d", + "updated_at": "2026-10-08T22:22:55Z", + "body_sha256": "f272d93bfa89533fc3111468bc7183f4a594b1ed80e02091a27b5d08d4c98277", + "matched_searches": [] + }, + { + "number": 90, + "title": "Clarify current review checkpoint and published release", + "head": "8e0442641696b4c284bf7fbb4f2c97dccf24ea6c", + "updated_at": "2026-10-08T21:24:49Z", + "body_sha256": "b3c7ef7e17f22854f174192e7931ab6e3ac8cb50c1a95fe05583420aa4f7b4ef", + "matched_searches": [] + }, + { + "number": 91, + "title": "Aligned frame composition: κ=5.2789616935221e-5 with Lean arithmetic certificate", + "head": "8d1a0838f3e906d372818df02b3564c8b36495cc", + "updated_at": "2026-10-08T22:30:33Z", + "body_sha256": "46191ca2ce663f70ac437997a0f40913a4117fe644f4aef1a4c2931e9ad16378", + "matched_searches": [] + }, + { + "number": 92, + "title": "Scheduled region orders on balanced frames: conditional κ = 5.2111890493145e-5", + "head": "2b4dca843b7a719512595896aab29de28bc4ea1f", + "updated_at": "2026-10-10T00:25:17Z", + "body_sha256": "b3a6e620ea62901b394e95b3fb745191b79b1b12cb16f71a7afbcba05a7b1cdf", + "matched_searches": [] + }, + { + "number": 93, + "title": "Coordinate refinement of aligned composition: conditional κ = 5.2790906739644e-5", + "head": "f5f5ebdfc92fa6001d209aafba432a36ff9d86f5", + "updated_at": "2026-10-08T23:05:52Z", + "body_sha256": "88c706f95bdd2681e17fb4fe3ae6756c226253dd72d650f8700b3fc0220d8723", + "matched_searches": [] + }, + { + "number": 94, + "title": "Adjacent coordinate refinement beyond PR93: conditional κ = 5.2790937858556e-5", + "head": "0c440e40c9d4a5a02ca5bd028a2ebb5ebbca55d7", + "updated_at": "2026-10-08T22:00:47Z", + "body_sha256": "faf540634fe45f43e57738ff2c9c51583c60785de29e85aad85a383da00b8ee1", + "matched_searches": [] + }, + { + "number": 95, + "title": "Coordinate descent beyond PR94: conditional κ = 5.279109590448e-5", + "head": "641aae7baf14ae21b69145d54e8232bf20076fce", + "updated_at": "2026-10-08T23:19:19Z", + "body_sha256": "afc80e512123950859f2a0b023981850a80a9b8f2dd82a6870202c126e02eb2e", + "matched_searches": [] + }, + { + "number": 97, + "title": "Deferred endpoints and signed phase correction for a conditional 63965813/10^12 > 2^-14 bound", + "head": "e15350b66e4bf796153a68c240a6cc1b788abe3e", + "updated_at": "2026-10-08T23:01:29Z", + "body_sha256": "a09526f2d23275336894cecefd9b90226ad2ac3c7bc5432506758b2efba39eaa", + "matched_searches": [] + }, + { + "number": 98, + "title": "Final-coordinate carrier pricing: conditional κ = 5.2791461623702e-5", + "head": "6862c47f5fcb69dfb424e1bb7f32f415d8659063", + "updated_at": "2026-10-09T00:37:23Z", + "body_sha256": "fe69e1b84d13d7880ae87542f38fc6d62585664b138dd5016e9798cab5617a77", + "matched_searches": [] + }, + { + "number": 99, + "title": "Nondegenerate readout saturation: conditional κ = 6.3978725e-5", + "head": "0622dcce6a897567e4eb6bdfedc7def66ab21346", + "updated_at": "2026-10-08T23:01:12Z", + "body_sha256": "7825eaaaa953b094c6a6fd18e2ce884bbdd71fa6198481add99579ada1ad271d", + "matched_searches": [] + }, + { + "number": 100, + "title": "Balanced transfer of deferred signed networks: conditional κ = 6.3978919675787e-5", + "head": "22dc19dd7123dd582110a912a6ca687e31e2243f", + "updated_at": "2026-10-09T00:09:25Z", + "body_sha256": "5e6f07b6e038bb75327788bffd3c9c77009eba5236270d8c091688498ee11098", + "matched_searches": [] + }, + { + "number": 102, + "title": "Sharpen the deferred signed bit moment: conditional kappa 6.3974824e-5", + "head": "3fc54ebacb1fbbd1f0e0e66f9dbd32202934661c", + "updated_at": "2026-10-08T22:58:51Z", + "body_sha256": "a6ed95cb9c53d2fe0484e5540b91d6eac8d97f715b8c547ebdf20a4bc91cc594", + "matched_searches": [] + }, + { + "number": 103, + "title": "Saturated readouts with complete signed/balanced integration: conditional κ = 6.398282083297e-5", + "head": "75ab1f70d146c21c7611ce0df9eb5f645f51ac0e", + "updated_at": "2026-10-09T00:14:57Z", + "body_sha256": "50a04cbd3987d348104a5ad4a7892f7123cd16f4d2c621c03a2e514999b780fb", + "matched_searches": [] + }, + { + "number": 106, + "title": "Contiguous-pair coordinate pricing and two-round circuit exchange: conditional κ = 5.2805219274162e-5", + "head": "34c066390b9b0026789d8ce9b0e044bc30253b2b", + "updated_at": "2026-10-08T23:21:31Z", + "body_sha256": "0605a58291281daef5f178510b467051e34e10f02fadb9dbc5e2ff040b4dee69", + "matched_searches": [] + }, + { + "number": 107, + "title": "Reversed rational-center orders: conditional κ = 7.798412662809e-5", + "head": "eb231b7b63f7fc99d51ffc16e0356831c3af1c22", + "updated_at": "2026-10-09T00:15:02Z", + "body_sha256": "cbaa64bebc1f3f3a048aab4775edb586a53eb672294aa9ebf2d08e9daec54838", + "matched_searches": [] + }, + { + "number": 108, + "title": "Dual-suffix pair stars in the rational-center producer: conditional κ = 7.988289348441e-5", + "head": "4974895daf92b51d2cc4a954bc6b77be2d7ff4c4", + "updated_at": "2026-10-09T00:38:26Z", + "body_sha256": "e76147c6e44ce596b92049ccaaf1df15b26a7938a5858b9cf10131e6bd25dc9d", + "matched_searches": [] + }, + { + "number": 109, + "title": "Weighted dual-suffix carriers: conditional κ = 7.9961717358e-5", + "head": "45389b383b31092d83d19007dd6faaa8543db961", + "updated_at": "2026-10-09T00:42:36Z", + "body_sha256": "1cd920844f641eb53900a3f6571650b5438495fd972b16f3e78893be5c2bfe05", + "matched_searches": [] + }, + { + "number": 110, + "title": "Deferred readouts on both stopped networks: conditional κ = 8.58478e-5", + "head": "09775e9f3fbf1900175010bcd0c3d6d1dbf65ffe", + "updated_at": "2026-10-09T00:02:51Z", + "body_sha256": "e3fae61dcea350a1c519cae16914c94bb959f58ed43465c6dc57c0c607fac768", + "matched_searches": [] + }, + { + "number": 111, + "title": "Cyclic interval strips on both axes: conditional κ = 8.578151200855e-5", + "head": "5b3add9415bf7ef19e1dfe739903d09d66c1d9ca", + "updated_at": "2026-10-09T00:48:42Z", + "body_sha256": "ece0f9bb4036cba74048c014e43792b0f7a54ee6df394ba9377538876ae1f9e8", + "matched_searches": [] + }, + { + "number": 113, + "title": "Deferred readouts on the cyclic-strip complex network: conditional κ = 9.39074e-5", + "head": "502761e7e02e25c737f61be718e29bca3f391d19", + "updated_at": "2026-10-09T01:22:20Z", + "body_sha256": "682a58caf32ac2982d21fffdfe9cd6536413c09e7bdeba898c34789e690490a8", + "matched_searches": [] + }, + { + "number": 114, + "title": "Shared completed cores and physical frames: conditional κ = 1.23988197806e-4", + "head": "77227550987a49eec5f335b61ab233fc5c93dbe8", + "updated_at": "2026-10-09T02:04:56Z", + "body_sha256": "454a1031dadaec5c63d780aaaa4508d4d61ff6a932ddf32fab0e34e9039844f1", + "matched_searches": [] + }, + { + "number": 116, + "title": "Cube recurrence with balanced deferred frames: conditional κ = 9.8699350338e-5", + "head": "295a48a3b966428896057a98c6b4834c0b4b7416", + "updated_at": "2026-10-09T11:12:02Z", + "body_sha256": "0cb8cf1a1bb94d90482a11e615da38f424a8068ff68f01e75b34bbbb447805aa", + "matched_searches": [] + }, + { + "number": 117, + "title": "Deferred bit word and a 28,705-role complex producer under stopped-product accounting: conditional κ = 1.044939e-4", + "head": "cbb05ce504d571546d9b7794c186a613c659c3bf", + "updated_at": "2026-10-09T00:39:23Z", + "body_sha256": "f40fdf09ea4358bee16bfd8eeb670cfb4f3dd0a0f3fcd805d39ad21476bbb994", + "matched_searches": [] + }, + { + "number": 118, + "title": "Deferred readouts on PR117’s complex producer: conditional κ = 1.085428e-4", + "head": "51fd1bbff9b73e3ad6e8bc6d53318909c3785484", + "updated_at": "2026-10-09T11:12:07Z", + "body_sha256": "20857bf205b8fc15f98db196d1229691c83329cac9a6fcee9749277977fbb7b3", + "matched_searches": [] + }, + { + "number": 121, + "title": "Add staggered dual-paired rational-center and bit producers (κ = 8.032517e-5 complex-only / 8.800233e-5 joint)", + "head": "446dd07dbe14f6dcfcca629f3a9cb01cb148f003", + "updated_at": "2026-10-09T01:05:29Z", + "body_sha256": "cee288430a1f262a85ff320f04d56a2ee2e9fe9b72d0fd94cc969d0e65fd8d46", + "matched_searches": [] + }, + { + "number": 122, + "title": "Terminal accumulator elimination with exact majorization audit", + "head": "b1a6f24e57141637b3ff040d6f2ce9d896ffb9bb", + "updated_at": "2026-10-09T01:11:36Z", + "body_sha256": "5f4c54dd9afa22c6083e5e087844bbc6c0c52c77906852bbd9bba7994a4847d6", + "matched_searches": [] + }, + { + "number": 123, + "title": "Seeded saturated-frame tie order: conditional κ = 1.09285663466e-4", + "head": "4634e11162691478556c1ef88fa6a369c2622abf", + "updated_at": "2026-10-09T11:12:12Z", + "body_sha256": "c3fd492fce6ef9d79d063dfc33539e3a19a2d547aadd5f0a0dfebb037647c91d", + "matched_searches": [] + }, + { + "number": 124, + "title": "Birth-read slot recycling: conditional kappa 1.1038332094346e-4", + "head": "3657b5d62fabc0bd2b1c596ad86b97002e437ea8", + "updated_at": "2026-10-09T02:06:04Z", + "body_sha256": "6e5f718b9e9402d4c81910036d852b140314b1de1eec471ecca294e47ff402be", + "matched_searches": [] + }, + { + "number": 125, + "title": "Shrunk lifted frames with saturated deferral: conditional κ = 1.10591581647e-4", + "head": "dda535bdcfc321a13a1ebd3c2d70e2b5bb72368e", + "updated_at": "2026-10-09T01:30:32Z", + "body_sha256": "0b76c572600139e91ab1e337e8310481310fda3955ee0718271d655a3b88e249", + "matched_searches": [] + }, + { + "number": 126, + "title": "Physical operation frames with deferred readouts: conditional κ = 1.11192082577e-4", + "head": "31ceb5ead3055ea780e13654b05b546d26c3d6ed", + "updated_at": "2026-10-09T01:58:09Z", + "body_sha256": "a0342e0692ef730ea4a9556ac64d7713f40d631f663946239b199cf3da925b26", + "matched_searches": [] + }, + { + "number": 127, + "title": "Birth-read reuse on shrunk saturated frames: conditional κ = 1.1239534209971e-4", + "head": "ca8725485a822769f24c2e4e9b8955b31a42b044", + "updated_at": "2026-10-09T01:34:34Z", + "body_sha256": "ef9977867ff09452bf19e4fe23980c51498acaeeff6fcc85a0570e0f7961b151", + "matched_searches": [] + }, + { + "number": 128, + "title": "Completed-core sharing: conditional kappa > 2^-13", + "head": "530588a019b4a74f09180680c9e3961bf649ec89", + "updated_at": "2026-10-09T01:36:24Z", + "body_sha256": "4d8addc6a43badbd8241d348af327613f04c163b13f86a41daf2271b556fcb81", + "matched_searches": [] + }, + { + "number": 129, + "title": "Shared bit cores and gauged scratch reuse: conditional κ = 1.29186205798e-4", + "head": "59fade1f7790db61a56b69e0d3974c0a97b41f4d", + "updated_at": "2026-10-09T02:50:37Z", + "body_sha256": "307044e3706ae87e7383d348d23ca97989bba396884e77961cc67db304887438", + "matched_searches": [ + 1 + ] + }, + { + "number": 131, + "title": "Physical frames and scratch reuse on Cayley covers: conditional κ = 3.32205398986e-4", + "head": "3acf2f944abd069301600ce468f16f1dd8f1f9e4", + "updated_at": "2026-10-09T02:52:20Z", + "body_sha256": "a19904e13bd0e679762b303ab404ec49b46401b0cdd68167b901b2ffb75e4a0b", + "matched_searches": [] + }, + { + "number": 133, + "title": "Optimize cyclic-deferred frames and phase-aware role compilation (kappa = 1.11513943837e-4)", + "head": "2c97e8ab1578d05d0aacf03903f458b088c7dd50", + "updated_at": "2026-10-09T02:51:02Z", + "body_sha256": "78e7a2adb41b99ad897d8feb665ba5ca9432662db6e9b6fa2dddde7344194cdb", + "matched_searches": [] + }, + { + "number": 135, + "title": "Paired physical scratch reuse: candidate conditional κ = 3.62108222954e-4 (+4.02% vs #134)", + "head": "2bb675bba25771ae1cafd4ff7804b9bc094dd415", + "updated_at": "2026-10-09T03:15:24Z", + "body_sha256": "2919d7ec3f90c80cb6118a9fea7fb68836c49f79972089a413c1e876669ec504", + "matched_searches": [] + }, + { + "number": 137, + "title": "Padded triple covers with sequential dirty reuse: conditional κ = 4.13596233702e-4", + "head": "c205b7d9df0ab933c4b7392ea6625c05dbd5e4c0", + "updated_at": "2026-10-09T03:48:25Z", + "body_sha256": "8622696d660a93971fd1792d1250e6854f074fcf86f54c336a9426b8f5c26e77", + "matched_searches": [] + }, + { + "number": 138, + "title": "Tightened slack constants on paid padded triple covers: conditional κ = 4.13596659368e-4", + "head": "c5a48c3ed0b1f16cdda7601ea0555b9998e9e734", + "updated_at": "2026-10-09T05:04:18Z", + "body_sha256": "d7af1c8fce4db3210f659fbaf1220545d32b26fe37705481027682c1ef147502", + "matched_searches": [] + }, + { + "number": 141, + "title": "Shrunk-frame birth and terminal composition: conditional kappa = 1.12802185097556e-4", + "head": "3ddc4dcf7312ec5ab3bff843fd3e8c10cce041dc", + "updated_at": "2026-10-09T03:49:54Z", + "body_sha256": "052f7fbb3517e1023063ae4f32258bee47bc1cd0cdc0ec7bc327fb03f350b661", + "matched_searches": [] + }, + { + "number": 142, + "title": "Restricted h22 padded triple covers: conditional κ = 4.20151003347e-4", + "head": "2fc6cf548523fb22bba1d88aaadc367fd0a0b499", + "updated_at": "2026-10-09T04:16:03Z", + "body_sha256": "40fa8119e8db91427eb7c98c7e672e58193cae47b9f9cf5e923893755123640f", + "matched_searches": [] + }, + { + "number": 143, + "title": "Late compensation and joint frame refinement: conditional κ = 4.24830828577e-4", + "head": "803b28a5e373442974385396e9d4d3f6e75fd5e7", + "updated_at": "2026-10-09T06:45:22Z", + "body_sha256": "96ca45c40ee0775a885d8cab2f94a1287e4baad7c2b39338adc6ef1fac8256c3", + "matched_searches": [] + }, + { + "number": 145, + "title": "Optimize physical local reuse under three-stage cover for kappa = 3.37546392004e-4", + "head": "ce7a86f674c6f83a0fe33348c0a046064fefe901", + "updated_at": "2026-10-09T04:50:38Z", + "body_sha256": "d8f4eb4ffdea3d2044b0b857331de52f948513fda46fa3fc6bf1d506b4bffb94", + "matched_searches": [] + }, + { + "number": 146, + "title": "Use exact telescoping min-cut bit subset on paired-cube shared cores for kappa = 4.61028508707e-4 (4.61239827139e-4 at atom=1/2000)", + "head": "70355a3192028852598e96624ae29b389e664451", + "updated_at": "2026-10-09T04:59:22Z", + "body_sha256": "a409c8394d43f3b615426ae4885446aec8821a420fb3a98dd1347b1884023e30", + "matched_searches": [] + }, + { + "number": 148, + "title": "Raise conditional kappa to 4.611281e-4 with tightened adapter toll", + "head": "975c3cf5d4ee0c90d5a76500d431bfc59102bb72", + "updated_at": "2026-10-09T05:05:50Z", + "body_sha256": "106db0c01c577083d88c860b7cdef030937affacb90e20a0aeb82110ee58f526", + "matched_searches": [] + }, + { + "number": 153, + "title": "Re-instantiated phase-stop on the p = 11 paired cubes: conditional κ = 5.108294e-4", + "head": "4ead11e6e10cc7f13a340563990f50f86cc2668b", + "updated_at": "2026-10-09T06:23:28Z", + "body_sha256": "144d6d645b57cfbf7be2075ed92b2803a275f4c17673af30325717be042cfb6e", + "matched_searches": [] + }, + { + "number": 154, + "title": "Faster verification: concurrent checks, make verify-parallel, faster paired-cube frames, no joint-dual re-pins", + "head": "f571bcbd6e06618aeae0b8279da48060032dc74b", + "updated_at": "2026-10-09T07:37:04Z", + "body_sha256": "63872c16c51b0ad996aa843fb1fc74123caee6a20d1aee8f3eb475851b186d9c", + "matched_searches": [] + }, + { + "number": 158, + "title": "Re-instantiated atom exponent at the toll edge on the searched pair module: conditional κ = 5.557315e-4", + "head": "6e086603f936dbb95c6d7171132ed943cc024db9", + "updated_at": "2026-10-09T07:07:00Z", + "body_sha256": "13918a7818ea99af8fea6c4e847b8dac73c4d5f950777eb260371d69e3d0b07f", + "matched_searches": [] + }, + { + "number": 160, + "title": "Searched pair module in the paired-cube bit word at p = 11: conditional κ = 5.616446e-4", + "head": "da3385314d935e57f8129c8734c27104b125e572", + "updated_at": "2026-10-10T14:00:08Z", + "body_sha256": "026d0186ff1da18efb0599d0b93bfc520a6922d7250d9e08511b90c3d57ed012", + "matched_searches": [] + }, + { + "number": 162, + "title": "Extended carrier matching on #161's complex word: conditional κ = 5.901881e-4", + "head": "279b2ff6d3f0a1abe4a61c1f2ea4944bca7cf3dd", + "updated_at": "2026-10-09T13:39:29Z", + "body_sha256": "6ded55199feda236aa449b45bf63614f81e8b67204a36c284ecd992d0346f265", + "matched_searches": [] + }, + { + "number": 163, + "title": "Fused paired cubes and paid balanced transfer: conditional κ = 5.93970203079492e-4", + "head": "e1813796ef5c3ca38c5dd7b9e8d81b3908ff5997", + "updated_at": "2026-10-09T08:02:58Z", + "body_sha256": "72c5da1ff1703ebc87181e5586d3e81e3579ee681b6969624738b985e3c2f12f", + "matched_searches": [] + }, + { + "number": 164, + "title": "Connected bit-frame descents on #163: conditional κ = 5.94035602295411e-4", + "head": "4391a60bb26f75ea47a4c55c508c88a036b5a2b8", + "updated_at": "2026-10-09T08:04:53Z", + "body_sha256": "be1f48a1cdefcfbe84361607c0dbd544f5761d7640a004608af56a3e03ef57cf", + "matched_searches": [] + }, + { + "number": 165, + "title": "Certify extended paired cubes and bit frames (κ=5.94272360424954e-4)", + "head": "7518fed2688baf25c7c32bae32674f3334b517da", + "updated_at": "2026-10-09T08:24:48Z", + "body_sha256": "3ad0f905660a47515bae157237412e490ea73a18fa4493bb5024fbd50aac54d3", + "matched_searches": [] + }, + { + "number": 166, + "title": "Add exact dirty-target terminal compiler and 67-sink witness", + "head": "4dbc2af5f223a0fbf22542c9d6c3f71442b6a3a6", + "updated_at": "2026-10-10T00:01:50Z", + "body_sha256": "8acf9b97f053fa2c8d2633e12de0f76a8d0cd6ac807c721d750b0b1715e52104", + "matched_searches": [] + }, + { + "number": 167, + "title": "Open search tooling for paired-cube complex words (no κ claim)", + "head": "3540326866af459ef28ee23252e3c54d2ac49017", + "updated_at": "2026-10-09T08:15:25Z", + "body_sha256": "858ce79fafdde3c4e7a2ab67635ac70cb74088f31fec7c40391246e8d656c929", + "matched_searches": [] + }, + { + "number": 169, + "title": "Bit operation-frame descent on #168's bit word: conditional κ = 6.105562e-4", + "head": "4895ba1104cedc7908b6d6ba64fdd6290e0ed7ae", + "updated_at": "2026-10-09T08:36:30Z", + "body_sha256": "45011a3e4071fcfbc839b8e51f7ed3fb4d1c368f8c9a79e34830c5e06617a670", + "matched_searches": [] + }, + { + "number": 170, + "title": "Paired bit-output fusion and verified lifetime reuse: conditional κ = 5.96818007e-4", + "head": "29892e2fe8a90714ef61bd8cbfb1a74bec6f8fd4", + "updated_at": "2026-10-09T08:47:18Z", + "body_sha256": "053655cd48dd0d9b9cc2d84b9c82b941e79567d3c0dce84bb34c5ec2cec21284", + "matched_searches": [] + }, + { + "number": 171, + "title": "Causal bit-frame refinement of #169: conditional kappa = 6.11068410271618e-4", + "head": "89d0c75f8bf97131db21bc610e7546b699afcb9a", + "updated_at": "2026-10-09T09:03:10Z", + "body_sha256": "ea4a27afe5c59487b1d5fb55169a323b6123a695453ca2ae19f2fea5d9098791", + "matched_searches": [] + }, + { + "number": 172, + "title": "Boolean-lattice (zeta) finite networks: compiler-level construction, in-tree assembly projection 15x-48x, obligations named (research record, draft)", + "head": "427b23bc79489e7b2b7548bfd434dd9670fd5c47", + "updated_at": "2026-10-09T09:29:09Z", + "body_sha256": "63b991a05415b1aba1ce4197c9c6cf8ce97082db71b8f902d927ad355fea0710", + "matched_searches": [ + 0 + ] + }, + { + "number": 173, + "title": "Mixed-gap bit all-but-one module on #168: conditional κ = 6.129700e-4", + "head": "55d19073972c9a334203228e3af8f84997a1c2ad", + "updated_at": "2026-10-09T09:18:08Z", + "body_sha256": "b70ed9e9e021776abad89d33de049c07e5501572fb15c38e135978fca847a55c", + "matched_searches": [] + }, + { + "number": 174, + "title": "Research/atom exponent 169", + "head": "12963ebca6f0be5b28e135bba94cd8f17010cd16", + "updated_at": "2026-10-09T09:38:53Z", + "body_sha256": "8585cd6f0442cdaddd26061f5b09502743a9806f182027ab908f9b8ad426920d", + "matched_searches": [] + }, + { + "number": 177, + "title": "Refine reviewed paired-cube stopping parameters to conditional κ = 0.000461144586716", + "head": "855a1c9488f60d7295d61cc088bfa82f62bbacc5", + "updated_at": "2026-10-09T22:07:57Z", + "body_sha256": "3f444a43470f65a6f46674108f2f056538302efe727cdfa7ca453414f7845956", + "matched_searches": [] + }, + { + "number": 178, + "title": "Refine PR168 operation frames: conditional κ = 0.00065591780345", + "head": "0bffdfa5aafdc23e668e035ae2b179212b4b3d9a", + "updated_at": "2026-10-09T12:21:11Z", + "body_sha256": "89d2e16fdf9c4062bd8e2f8806272e1efe191c56ebae12e0f1105fec7af4379b", + "matched_searches": [] + }, + { + "number": 179, + "title": "Refine paired-cube frames on PR168 v4 with retained terminal sinks (κ = 6.55920176686219e-4)", + "head": "15e21dca486b4deacb07608d65021962e5e6086a", + "updated_at": "2026-10-09T10:58:10Z", + "body_sha256": "483b607b7bac86c408af20c340204287e280b64cba912b560246005853cecd28", + "matched_searches": [] + }, + { + "number": 180, + "title": "Independently audit PR #186 and refine its conditional exponent", + "head": "33f3f1e3eba2797caf9c355bcca1cbdb800bfd24", + "updated_at": "2026-10-09T13:06:18Z", + "body_sha256": "e33fd36fa2337a667b410520fc1583cc34e2f43d9d8e4f3c93e6d8365fc2d9e8", + "matched_searches": [] + }, + { + "number": 182, + "title": "Shared-edge local circuit, refined bit frames and bit terminal sinks on PR168 v4 (κ = 6.60216552061722e-4)", + "head": "af90b94783f7d104a0be75c762ade758bec75855", + "updated_at": "2026-10-09T11:38:10Z", + "body_sha256": "f7ead6744106caf3bb8b6dfcf55cebc902a0f748049aa161fbea1418bea0b788", + "matched_searches": [] + }, + { + "number": 183, + "title": "Add an exact κ-ceiling check for the exponent assembly (no new κ)", + "head": "1f22094b12bdae7759124e6c51ab44d3ea2a10ab", + "updated_at": "2026-10-09T11:40:14Z", + "body_sha256": "ac6f4e6bb6eb2a3f50a4cfe9ba91deaa09666c0c1d14d4ed14e2ac001e872a02", + "matched_searches": [] + }, + { + "number": 185, + "title": "Finite leaf bootstrap above PR182: conditional kappa = 0.000660627334074291", + "head": "561d6ecbbeb94a11b67862ccedd32bfcbad2cae0", + "updated_at": "2026-10-09T11:53:29Z", + "body_sha256": "43cb392ad739d4815578d93b6d29c7be919f7be8e3260fac31d98827e0a360e8", + "matched_searches": [] + }, + { + "number": 187, + "title": "Globally replayed source-assisted bit word: conditional kappa = 0.000661755179959122", + "head": "201737a1ec4f936e166e2481fb9e88104cb2ccc7", + "updated_at": "2026-10-09T12:14:27Z", + "body_sha256": "a302f07ffac8c36fa295758562d3c793f3c61e6cc43a8cfa96437f65860e4e88", + "matched_searches": [] + }, + { + "number": 188, + "title": "Executed terminal accumulation and bit reuse: conditional κ = 6.16027622e-4", + "head": "c6eea3e8a46bf122878b512590f9f91a20260800", + "updated_at": "2026-10-09T13:36:09Z", + "body_sha256": "c8aaf75fb4300a691dda25f3b96fa1e0a3c0dc7bd46a6e123e93f7702466b826", + "matched_searches": [] + }, + { + "number": 189, + "title": "Shared-edge complex and face-diagonal bit local circuits on PR168 v4 (κ = 6.61755179959122e-4)", + "head": "0a4091175b3981267a97a62ab7492cb9ba528916", + "updated_at": "2026-10-09T12:17:21Z", + "body_sha256": "468fdb1f54c110feea53bb60a207d00a124187fae6458cdb52a3b1f64caf4e39", + "matched_searches": [] + }, + { + "number": 191, + "title": "Source-assisted complex word on PR168 v4 modules: conditional κ = 6.626307e-4", + "head": "15fa62d52bd7d08f29fd09fffe33dfc7a15ba8a0", + "updated_at": "2026-10-09T12:16:23Z", + "body_sha256": "7cd6abf556efed247dc8d15a76fd92c3b2a5d545d19622f2374dbeaa642b16b9", + "matched_searches": [] + }, + { + "number": 192, + "title": "A κ ceiling of 7.010e-4 for every frame layout of #168's word (no new κ)", + "head": "ba52fac95ebc7cd25d284888aefee2284b670fd6", + "updated_at": "2026-10-09T13:25:21Z", + "body_sha256": "9542d91b5f22200e08edcaea47a235a371bbb92c0cb929e97a915e1edafb71cd", + "matched_searches": [] + }, + { + "number": 193, + "title": "Pair donors to avoid parity erasure on the source-assisted v4 word: conditional κ = 6.647872e-4", + "head": "187e1010ac8b259af8e9b5166f68b64bc27b4b47", + "updated_at": "2026-10-09T19:17:30Z", + "body_sha256": "b60d63147c501ee3278906c7ef0f4932bf588df4f8f5cca4a418d7a708b53059", + "matched_searches": [] + }, + { + "number": 194, + "title": "Source-assisted v4 complex word with PR189's bit supplier: conditional κ = 6.674324e-4", + "head": "a8c87783785be6fe20c4a8bb2ac4b3eec295a179", + "updated_at": "2026-10-09T12:43:44Z", + "body_sha256": "9cca33aade8c8fb1446e04369474c62931d236c296831f49fdeeda46d9d83052", + "matched_searches": [] + }, + { + "number": 195, + "title": "Further coordinated frame cuts on #186: conditional κ = 6.62651985348746e-4", + "head": "d3e6b83af33c3aad940e737776937706e25b0b19", + "updated_at": "2026-10-09T13:00:17Z", + "body_sha256": "778a1940a46ba3598a7d9709b72f73d055a7dc325aa6ac1c6bf7954b667de0b4", + "matched_searches": [] + }, + { + "number": 196, + "title": "Face-diagonal local circuits on both suppliers of PR168 v4 (κ = 6.65046903615388e-4)", + "head": "5b09c35ee837e0157342a7cd1fbd933467cfe90b", + "updated_at": "2026-10-09T14:19:26Z", + "body_sha256": "ca5d774f98f5ed48aad76404949eeea8b1a8ef3bc6e84e28c1553f0ccfdb299b", + "matched_searches": [] + }, + { + "number": 197, + "title": "Pack #187's bit residuals: conditional κ = 0.000676080316519385", + "head": "8c5e1cf07c23d843642bf2d4c76f882669edc43f", + "updated_at": "2026-10-09T17:34:24Z", + "body_sha256": "eb86697ec6e8bb424f846bc305c0de3c58d7742fcb471b823f9818d46001091b", + "matched_searches": [] + }, + { + "number": 199, + "title": "Bit leaf bootstrap: queue standing + the deferred #200 composition at conditional κ = 6.773148e-4", + "head": "5c1fb8346615968844bc182a5376c399109670ca", + "updated_at": "2026-10-10T00:25:19Z", + "body_sha256": "26cbd8d41c346b44df4833d400744afd64d0f2b35627f3782584571639096090", + "matched_searches": [] + }, + { + "number": 200, + "title": "A stronger bit supplier: fixed-coordinate and face-diagonal bit local circuit on PR168 v4 (effective bit saving 6.7734e-4)", + "head": "a1175449f34d39ff933d9d8ab23ced1f32b290ec", + "updated_at": "2026-10-11T15:29:55Z", + "body_sha256": "a2b0b2106ae45aa0657df03126e0cb57cacf14954f719e239a585b3b0f9fd97b", + "matched_searches": [] + }, + { + "number": 201, + "title": "A κ ceiling of 2.5592e-3 for every word on #144's paired-cube design (no new κ)", + "head": "b3c128ec4c3a4ac1a095f45a8d86e387bbda05ec", + "updated_at": "2026-10-09T14:27:52Z", + "body_sha256": "d80e5cabff216974078215ac7d46bc7cf662b78f8a1fbbae7067feda168c1c89", + "matched_searches": [] + }, + { + "number": 202, + "title": "Compose the v4 source-assisted complex word with the PR200 bit supplier: conditional κ = 6.768823e-4", + "head": "8d8d67bcf69c5ea67d3a29dbc64ba588156d6e8d", + "updated_at": "2026-10-09T14:40:09Z", + "body_sha256": "32afe40f7cb60e95dc2f61df8b64107c7768ec62ae97a84e98742613fb0292d2", + "matched_searches": [] + }, + { + "number": 203, + "title": "Research: structural barriers for kappa = 0.01 (no new exponent)", + "head": "d2873e20750d0949d2ad75cbc4cd82b5b1a74e84", + "updated_at": "2026-10-09T15:05:12Z", + "body_sha256": "3a06285f570823215bf3222d71c51abe490e0fc8ba10ddb5bcf03be8b5ea6599", + "matched_searches": [] + }, + { + "number": 204, + "title": "Composed diagonal-bit bootstrap: the pricing model that called PR205's banked row, audits the queue, and prices the next ladder of κ gains", + "head": "525ed356ec4928f4c31c7668ecb547f575278f4e", + "updated_at": "2026-10-10T00:25:21Z", + "body_sha256": "240ebf24ab5e0e1878e9be801cd8b7f740e742373f864cd3e8b8d043ac46fac5", + "matched_searches": [] + }, + { + "number": 205, + "title": "Pack PR200 diagonal bit residuals into completed banks (conditional κ = 0.000683061299399923)", + "head": "95c58706ad231d532bd7038308946a0344d08186", + "updated_at": "2026-10-09T21:01:10Z", + "body_sha256": "a8ca0d2644cb05cfbf3a264a7d34481bdbb5d6ee986be6396ec220b99c300983", + "matched_searches": [] + }, + { + "number": 207, + "title": "Conditional kappa 6.831904550365e-4: coordinated frame optimization and completed entrance banks", + "head": "cd14825023b75af4f5919a30e5e6d548b6ade5bc", + "updated_at": "2026-10-09T16:00:16Z", + "body_sha256": "6cb95c22b1dc8ab18cd681bd96df467675376d95f38f1dadd816c51d2c362c5b", + "matched_searches": [] + }, + { + "number": 208, + "title": "Price the bank-absorption ladder against the suppliers' own allocation rules: +2.17% needs a new residual type this word does not have (target, not built)", + "head": "2352ffee98179a14af9059be316fb282711000fe", + "updated_at": "2026-10-09T18:53:54Z", + "body_sha256": "c6c22d7429a3a20393c17170b3da1ea5920fb1fc4cfcf28e43fdbf42f49a197b", + "matched_searches": [] + }, + { + "number": 210, + "title": "κ = 7.10069340338651e-4: five-stage banks and F₂ movement fusion", + "head": "b0c058ba979c748bb3a8604bfb6502e9fac9b84d", + "updated_at": "2026-10-09T23:14:11Z", + "body_sha256": "155bfe85110a7e7786f8b76af7d94d4f3dccae3fe199bab8c25b447306bc345b", + "matched_searches": [] + }, + { + "number": 211, + "title": "Conditional kappa 6.838479e-4: cascade-optimized frames on PR200's banked bit word", + "head": "c63e50a5dde96fe1459d6b29e55e47f42f104347", + "updated_at": "2026-10-09T17:14:57Z", + "body_sha256": "87e107c76ccfc77a6d2b6be7df0aa5a4fbdb90995a27923aa84c331f2c2643e4", + "matched_searches": [] + }, + { + "number": 212, + "title": "A frame-layout ceiling for #200's bit word: coarse < 6.964e-4 under the banked ledger, so κ < 6.959e-4 on #205–#207's word (no new κ)", + "head": "9b6ad038f8690206c14ed8f28fb90ec6b3a79ae1", + "updated_at": "2026-10-09T17:46:15Z", + "body_sha256": "a576d25dafb8da3de902248e64126d5dc9530c5bb3514eb7cc5f89126f27534b", + "matched_searches": [] + }, + { + "number": 214, + "title": "Replays of the verifiers of #207, #202, #197 and #199 (no new κ)", + "head": "0d584fad684b7999ae94edc6a1914901bdc9efa7", + "updated_at": "2026-10-09T18:10:34Z", + "body_sha256": "3b9b946619b87b2aefa16ab16f4354f5cbc31d6670234b019c24dcad7b0c4721", + "matched_searches": [] + }, + { + "number": 215, + "title": "What entrance gauges and completed banks can absorb (no new κ)", + "head": "1afe68ea9a03e62306796e882acfd4a99f8b3d8c", + "updated_at": "2026-10-09T18:09:14Z", + "body_sha256": "e2473df7b23950e8fdcb7b65a48c3d8894888f1192e39cf83c35a27338f71575", + "matched_searches": [] + }, + { + "number": 216, + "title": "Conditional kappa 6.838643131376e-4: composed cascade frames, global cuts and four finite bootstraps", + "head": "34abdc58ed77329c8bf9af5634531fc41939ba3c", + "updated_at": "2026-10-09T18:28:00Z", + "body_sha256": "25f21984132c0879e8d489543a01fa12e948cb40f5f616cffb747d9d050df9e7", + "matched_searches": [] + }, + { + "number": 217, + "title": "Conditional κ = 6.84696826673891e-4: paid XOR butterflies with cascade-optimized frames", + "head": "b739fc226a54a4a507989aa1bef092d491287451", + "updated_at": "2026-10-09T18:50:03Z", + "body_sha256": "e97736e3e2780af31aa073bdca00842d68cf42a059a2ecfb91b21ebdbfda7397", + "matched_searches": [] + }, + { + "number": 221, + "title": "PR212's frame floor on PR217's butterfly word: κ < 6.968e-4 banked, +1.77% of frame room left (no new κ)", + "head": "aa947f2f0fb624e17c027a463286b42fc810fdeb", + "updated_at": "2026-10-09T19:28:23Z", + "body_sha256": "8c47be4f459ddc79b805a3c49830de860a1bf6eff7a632e2939dfccea9bd9fdb", + "matched_searches": [] + }, + { + "number": 223, + "title": "Conditional κ = 6.92144604250060e-4: served diagonal operations on PR200's bit word (+1.09% over #217)", + "head": "8786fec0148a41409874cad133123da227d93751", + "updated_at": "2026-10-09T20:38:37Z", + "body_sha256": "f085651e7c5c09f697f4af80d9cb0ced365cba154fe8337bc78547cdc4e1d53c", + "matched_searches": [] + }, + { + "number": 224, + "title": "Rung 2 above #219: a complex-side bank ledger that raises κ to 7.0829157e-4, blocked on C1/C5", + "head": "a60c9505284908edbac52f7c2f167feca75de546", + "updated_at": "2026-10-10T00:25:23Z", + "body_sha256": "75f7ef414cd05425cf6683dd34da99a274ce5e611d9768bdfb3d95d644e6b535", + "matched_searches": [] + }, + { + "number": 225, + "title": "The complex suppliers transfer to the exact DFT: θ = 1 − 7009/10⁷ (7.009·10⁻⁴) for the exact discrete Fourier transform (no new κ)", + "head": "830971b6b157374ebf941d0ca0b73fd2b956e3e0", + "updated_at": "2026-10-10T01:45:09Z", + "body_sha256": "ff2c496ba6bda9f6f4df9ad50c9831efd2f2360f8a79af6c3457737ad48e8c85", + "matched_searches": [] + }, + { + "number": 226, + "title": "Bipartite carrier compression: -377,890 wires, kappa = 826215307/20000000000000 (~4.1310765e-5)", + "head": "7be337efa887c53d167cf8f480b3822ce111d8a3", + "updated_at": "2026-10-12T08:39:35Z", + "body_sha256": "a0a26d87f772d89e51249964b3a3c38a28cae72685f101a79e75c0c5219bd450", + "matched_searches": [] + }, + { + "number": 227, + "title": "κ = 6.947753951612e-4: independent native replay of coordinated source-gauge construction", + "head": "418bd6a80f3190d1998780a2fb7f66a073367de1", + "updated_at": "2026-10-09T20:33:33Z", + "body_sha256": "77bd18d70570c6bc161cb4995568c60e292affa233945f876ae00e31b41ebf01", + "matched_searches": [] + }, + { + "number": 228, + "title": "Refine PR195 frame witness to κ = 0.000662832575455842015647", + "head": "ffa872f4d8ad3e9ab46a7a1a97b02a1250b2c925", + "updated_at": "2026-10-09T20:36:33Z", + "body_sha256": "4b33920de8bdb4d3fc2a9bab40c38eb938e2176da26f9cb5507806011106b3e7", + "matched_searches": [] + }, + { + "number": 229, + "title": "Six families per word: where the bank ladder tops out, and what the bit rank-6 rung would need (model, no new κ)", + "head": "cf64f1cb29f7af951db375f460ad683ec6d16419", + "updated_at": "2026-10-10T00:25:25Z", + "body_sha256": "911816e1c8065b5fde8e95a8abcda5c2c5d17fcb55541ff071ecb04904d4f351", + "matched_searches": [] + }, + { + "number": 233, + "title": "A stronger complex supplier: PR200's reuse pairing on the source-assisted v4 word, complex saving 7.0991·10⁻⁴ (+1.28% over #194; no new κ, bit binds)", + "head": "109a857a329d18ed5552d5573f17ddfa886ae57f", + "updated_at": "2026-10-10T01:45:07Z", + "body_sha256": "0d2af7c49b3e595d42fcb47c1ae8671438a5a3b8f272f23303bf25101df4bb2a", + "matched_searches": [] + }, + { + "number": 234, + "title": "Conditional κ ≈ 7.037017435 × 10⁻⁴ > 2⁻¹¹: five-stage bit and complex suppliers", + "head": "af3fe331ca60c936229e060681ffccbc1c208678", + "updated_at": "2026-10-09T22:17:15Z", + "body_sha256": "19977d8bb613932cc6e9ae70f1f864dedf2b93255476e282ed218633c514a4e7", + "matched_searches": [] + }, + { + "number": 235, + "title": "Conditional κ = 7.08582414684555347682e-4: fixed prime and finite leaves on PR237 banks", + "head": "63e3e9e2f852c72634d4b09d0bbb8fcf1081481d", + "updated_at": "2026-10-09T22:47:08Z", + "body_sha256": "4634fcba604a9697b1fe580b24778a8f6a3dd13415e9847f708d804d6d242b47", + "matched_searches": [] + }, + { + "number": 236, + "title": "[Lean] Verification of paired-cube finite identities and arithmetic — κ = 0.0004609169", + "head": "f825b6fdfd763f189db3aa1c02fdd5d604c85a01", + "updated_at": "2026-10-09T22:34:50Z", + "body_sha256": "e814d45e30a58eef46064b38826d6ea1d99c9968ce86bc4c4aeddbd186af4ce6", + "matched_searches": [] + }, + { + "number": 237, + "title": "Conditional κ = 7.08582410781108e-4: completed width-120 entrance banks on #234's five-stage bit supplier", + "head": "a8b0ce212bc9f09353a8161bf8a5cee9cefd600c", + "updated_at": "2026-10-09T22:23:19Z", + "body_sha256": "53f259ba24437865352c17586e3298c0ca8a9e59c550c32aafa292a1c60e160a", + "matched_searches": [] + }, + { + "number": 240, + "title": "Conditional κ = 7.09424406659975e-4: five-stage completed banks with #210’s 493-source helper", + "head": "1068237fdb977f45e68107d118d0eaf0c7a4b516", + "updated_at": "2026-10-09T23:00:35Z", + "body_sha256": "489c2bb747c79fe93c07cf7d7258752895111cbe2388815e45a3dd6f515c308b", + "matched_searches": [] + }, + { + "number": 241, + "title": "Publish the bodies behind the pinned digests: the bit twin's gate now decides A2 and A3 on real exports (no new κ)", + "head": "33d23ec65a1022ecc10ccefe7fc4b277761e6900", + "updated_at": "2026-10-10T14:57:04Z", + "body_sha256": "422b82a24361e077cbd6e67985376fae1517bea0df64d930976dac41dfc636b6", + "matched_searches": [] + }, + { + "number": 242, + "title": "Independent native source527 audits and four finite leaf levels: conditional kappa = 7.10046193592262e-4", + "head": "ef47efc3256a57bacf4273c35faf4b5148be5014", + "updated_at": "2026-10-09T23:29:16Z", + "body_sha256": "67c2ce7e19257d1e794417a78912cdc162bcbc9d88927a2e18f6bb5aa5d0c234", + "matched_searches": [] + }, + { + "number": 243, + "title": "Conditional κ = 7.09424410568126e-4: fixed prime, seven finite levels and η = 10⁻²⁴ on #240's five-stage banks", + "head": "ab482ea45dd73f0cb80796641528f0ab930c13b5", + "updated_at": "2026-10-09T23:33:36Z", + "body_sha256": "3bb6012af5bbf5faccbb28b5e3831bc912bc6c79052f9e8bde3d2d7bfae1391c", + "matched_searches": [] + }, + { + "number": 244, + "title": "κ = 7.10346589668175e-4: retime source-pair additions to their delivery frames", + "head": "a568d94f941929232ab393c7d33dc5a30e017892", + "updated_at": "2026-10-09T23:43:37Z", + "body_sha256": "5e1ebe9f126d795a3ef943c5e963e2af15d25be5edc26786ac04dd7208e523b6", + "matched_searches": [] + }, + { + "number": 245, + "title": "Compose PR223 with cascade frames and 67 compatible butterflies", + "head": "e347f31c5960323f6dca8bfb5a1f529ebac4537e", + "updated_at": "2026-10-09T23:51:21Z", + "body_sha256": "84de7846a2164de4da0b35580ca7f0611ba759f8fca59ef3fcdc11f268d12893", + "matched_searches": [] + }, + { + "number": 248, + "title": "Conditional κ = 7.10346593569666e-4: fixed prime, seven finite levels and η = 10⁻²⁴ on #244's retimed source527 banks", + "head": "e56591cbf0b18b6d0f959f3742c05c7d8cc41f75", + "updated_at": "2026-10-10T00:05:19Z", + "body_sha256": "2bf7d12d32cfc0ec6be59432930185ece6d06e6591584a4c9cd590b7b2d6d6ba", + "matched_searches": [] + }, + { + "number": 249, + "title": "κ = 7.10392186446856e-4: transport dirty compensations to 21 entrance frames", + "head": "96495746c786d6d0339dbb38c7f553d4af3f88ed", + "updated_at": "2026-10-10T00:06:20Z", + "body_sha256": "65b250a8e1542f9e25f196118cd429094a7e19bfb35c92b712b95cb1b798b3b0", + "matched_searches": [] + }, + { + "number": 250, + "title": "Compose terminal query retention into the five-stage complex supplier", + "head": "c5aedbe94158adf04e97800e713517eaa711a267", + "updated_at": "2026-10-10T01:45:05Z", + "body_sha256": "2a64c35272055ae619549bcadfa9a1a2f3a3801aaeddcf36e5277060fa1530a8", + "matched_searches": [] + }, + { + "number": 251, + "title": "κ = 7.10433687047883e-4: expand transported entrances with shared frame intersections", + "head": "2b030c06a811473ae8ed49dce07bc7ea50b72e9e", + "updated_at": "2026-10-10T00:27:52Z", + "body_sha256": "153e39ea99e75ea5d1bac12dd42740ef46eb4e786abed888636d88d12336f46c", + "matched_searches": [] + }, + { + "number": 252, + "title": "Conditional κ = 7.10392190350878e-4: fixed prime, seven finite levels and η = 10⁻²⁴ on #249's source527 banks", + "head": "45121f754db92f91d1e105061125e6b1fa4c2dc0", + "updated_at": "2026-10-10T01:38:03Z", + "body_sha256": "8047d647fdeff9990a2943a57507269fb9ec25a5e48f95c21c003eb8fbcaab80", + "matched_searches": [] + }, + { + "number": 254, + "title": "Response-kernel entrance gauges: 132 helper-pair rewrites, κ = 7.1046520063283e-4", + "head": "9ce32efb421132420242cfdb91ddd9eabe2c3795", + "updated_at": "2026-10-10T01:14:01Z", + "body_sha256": "8b60a4acadebf66f5c32b34225e57d197ed3bebc84fdeacbf5db041cca952327", + "matched_searches": [] + }, + { + "number": 255, + "title": "Conditional κ = 7.10465204542247e-4: fixed prime, seven finite levels and η = 10⁻²⁴ on #254", + "head": "3ba1c146c523c0305fe5f1a7bc4d3c5aebb9192c", + "updated_at": "2026-10-10T01:35:33Z", + "body_sha256": "eadc16dc39f287aa6f180852176152b303b68ef3aac2f880cdf497fa6cea32b5", + "matched_searches": [] + }, + { + "number": 256, + "title": "The source-assisted complex word of #233 as one explicit numbered program (gcert/1): reference-checked, 7.547361·10⁻⁴ in the Lean-checked five-stage layout (no new κ)", + "head": "db3f75cdc5f03f3131d48fb220f6bf1958404ff3", + "updated_at": "2026-10-10T02:29:24Z", + "body_sha256": "3d95508bb346595e17ede347301976003cb53c92be92f960d49dea904f68e32c", + "matched_searches": [] + }, + { + "number": 258, + "title": "Compose 25 exact frame retimings with PR254 (conditional κ = 7.1046804825911e-4)", + "head": "cf82ca09322d1327ab887cfd1cce97591b8d3cfa", + "updated_at": "2026-10-10T02:17:47Z", + "body_sha256": "3adf168a88f895a9c8b69a8abf7bb536f7db3619376b3324cd0e4e8b7a844794", + "matched_searches": [] + }, + { + "number": 259, + "title": "Multi-cut kernel condensation: 518 entrances, kappa = 7.11029386054035e-4", + "head": "a53ec0ca4d59634f16630dd16adf035c9f12595c", + "updated_at": "2026-10-10T03:27:51Z", + "body_sha256": "025218cfd061d599a49babb4a1d622cb3d600026560494ce53505c4c6b0e83de", + "matched_searches": [] + }, + { + "number": 260, + "title": "Draft: Conditional κ = 7.10436534421701e-4: concave-descent frame retiming of 25 gates on #251's source527 banks", + "head": "87aa555a455cca84a3e3296ced2440623d39fc4d", + "updated_at": "2026-10-10T02:11:27Z", + "body_sha256": "42278fb8e7100d5ba0713e2673514605fb7e55c403391e05225b46b1be91ba97", + "matched_searches": [] + }, + { + "number": 261, + "title": "Fixed-prime refinement of PR259 (kappa = 0.000711029389987426878345881)", + "head": "d2c63486d895860a65f25b80a51f4b2ec4f3c6ef", + "updated_at": "2026-10-10T02:54:02Z", + "body_sha256": "8c9f5ec335106b37f8a9581df42d82a4e0c277bb15e5add056f0c02b73fdfb74", + "matched_searches": [] + }, + { + "number": 262, + "title": "Conditional κ = 8.339545889388e-4 on #233's row: the bit word's own retained ledger banked a second time (B1 open, not a witness)", + "head": "dd3bec29abd124b94e8642d84a3552f2459a3faa", + "updated_at": "2026-10-10T02:45:37Z", + "body_sha256": "083bb13182a5544c911acb84731a19b9c6e3894ada2bb7933cf7438cd8ca8334", + "matched_searches": [] + }, + { + "number": 263, + "title": "Conditional κ = 7.11032238200698e-4: concave-descent frame retiming of 25 gates on #259's multi-cut condensation", + "head": "87129308f762f86a9d8e9a60f5d6c8ef23ce1f6e", + "updated_at": "2026-10-10T02:34:06Z", + "body_sha256": "7e3dc53feb180a5203c72f4cd0debd100ee0d9cb3a677912f1ffdafc744d9bf5", + "matched_searches": [] + }, + { + "number": 264, + "title": "Global majorant frame contractions: conditional κ = 0.000662502871668435", + "head": "a64076340dcfd6d77ebe3dc3a1eb30a6a4c74793", + "updated_at": "2026-10-10T02:40:55Z", + "body_sha256": "de358dea03b1290e75521b9b98fe611f5a146b179e4e234edf35f06c9ff2dbcd", + "matched_searches": [] + }, + { + "number": 265, + "title": "Conditional κ = 7.11032242134072e-4: fixed prime, eight finite levels and η = 10⁻²⁴ on #263's descent-retimed multicut word", + "head": "fc00fcf07a554ff6847b2a8764ecc26f5a99542a", + "updated_at": "2026-10-10T02:47:20Z", + "body_sha256": "5b7a342ff7b53894271b4258c707d3c3e9419450a5fe9a3378d17da7d3bbe89e", + "matched_searches": [] + }, + { + "number": 266, + "title": "Conditional κ = 7.14026746429965·10⁻⁴ on #249's word: 890 kernel families, #263/#270 retimings, #273's target-prefix squares and 126 cleanup sandwiches (#271), composed (+0.42% over #259; above #271/#275)", + "head": "8cff894317648ae8d4f170b3d33456a76a7822c7", + "updated_at": "2026-10-10T04:42:46Z", + "body_sha256": "4195077c7035423322bc0540be7d0ebf7121cb5c19dbd8f3ad34ed9bb26f6a57", + "matched_searches": [] + }, + { + "number": 267, + "title": "Chronological donor sharing: 545 entrances, kappa = 0.000711074913688782665281379", + "head": "4f849bd0c08787d588d211ef5f5dbe60f32542b2", + "updated_at": "2026-10-10T03:00:59Z", + "body_sha256": "266014aea6fd98278bfb053e2789f7fbe39b895af1323ab6658138fa471608ed", + "matched_searches": [] + }, + { + "number": 268, + "title": "κ = 7.11191385398487e-4: compose kernel entrances with 217 target-prefix groups", + "head": "dbb653bb249e0087f9aa32e77149cc9043ac72c1", + "updated_at": "2026-10-10T03:01:58Z", + "body_sha256": "4b3452eaf72fb80a10a653c93ccaf9e4c1c80e17de2cd27e372b79a8b9675fe6", + "matched_searches": [] + }, + { + "number": 269, + "title": "Conditional κ = 7.11426001276118e-4: 365 net-positive supplementary equal-response pivot families on #259's multi-cut condensation", + "head": "d4ca9aacd885375e6b6ce555bfb2d228ca71e1c7", + "updated_at": "2026-10-10T03:51:07Z", + "body_sha256": "96e80b8892bc436b404017d1b4bff72835eff9b9d61ac497fd07737234125a29", + "matched_searches": [] + }, + { + "number": 270, + "title": "Conditional κ = 0.000711457853376510: 887 entrances and connected-block retiming", + "head": "9b48fd73531eaf09ebbbd5acb0f7a3eb338d9a2a", + "updated_at": "2026-10-10T03:25:42Z", + "body_sha256": "6e73fbde5575bad44819e8ed083ebbc1d2b4602aaf4ffcfeebb6093f6dc5bc8f", + "matched_searches": [] + }, + { + "number": 271, + "title": "Cancel cleanup sandwiches of 99 helpers on #272: conditional κ = 7.1366215638961e-4", + "head": "ebc1defe8c13f39f86e5901c3437c1be52886a2b", + "updated_at": "2026-10-10T04:13:01Z", + "body_sha256": "e94ce8ef2892bd078aaf47a27b6a24bdddafb64f9a5f8ef9889a1afe12448fea", + "matched_searches": [] + }, + { + "number": 272, + "title": "Frame-filtered collective kernels + target-prefix sharing: kappa = 0.000712074434532274423885827", + "head": "65768f62d4fde0d1fa7fc84f71678522a84aaa6c", + "updated_at": "2026-10-10T05:30:04Z", + "body_sha256": "59db0e1776282dd60afa330f470d6b15db47b6a581c9ce476559cf3351306e5e", + "matched_searches": [] + }, + { + "number": 273, + "title": "Conditional κ = 7.11948953756315e-4: target-prefix compression (209 square groups) composed with the multi-cut kernel condensation", + "head": "45f13d0568033c3c27a96abc99f65a50a3a9133f", + "updated_at": "2026-10-10T03:57:56Z", + "body_sha256": "30369e180f742839fd00b51c9dc36353b4852caaa2d2f395d6a9b39e9b8cf7e3", + "matched_searches": [] + }, + { + "number": 274, + "title": "Audit PR256’s complex program against its pinned Lean proof (no new κ)", + "head": "947726d431438fd73ee4c96231eb88aba2692360", + "updated_at": "2026-10-10T04:54:00Z", + "body_sha256": "1e000c62e6aacb71bdf445d57d977296140c59540ad7046712e1e85579663f3e", + "matched_searches": [] + }, + { + "number": 275, + "title": "Finite assembly, source-basis cost reduction, and E8 verification", + "head": "e819106ee098953be69cdac9aff47bdece567bc4", + "updated_at": "2026-10-12T22:37:57Z", + "body_sha256": "4737d9dbb59f9efca035b564c792dfdb1c0b54c0c3b7aad9765e1a97e14e7d7d", + "matched_searches": [] + }, + { + "number": 277, + "title": "Verified construction checkpoint: conditional κ = 7.110455476244e-4", + "head": "c2f07d311bfdad0d89bf961e4da133ee97bb78de", + "updated_at": "2026-10-10T04:22:16Z", + "body_sha256": "2e88759a1965192c1d1b75f7d8da48db1d4562e3b2e69df530bbe3603180566c", + "matched_searches": [] + }, + { + "number": 278, + "title": "[Info Docs] Architecture Reference and Workflow Diagrams for PR #277", + "head": "8ddcabe87b874c0cb6d7ece0bd58a6f7d969bd3e", + "updated_at": "2026-10-10T04:40:19Z", + "body_sha256": "9f1ff3b0d9a6fb0732f162b832c777d8c46facf7560ce3e745638b66d3b25def", + "matched_searches": [] + }, + { + "number": 279, + "title": "Conditional κ = 7.24098741932703e-4: 880-gate concave-descent retiming and 220 target-prefix squares on #276's gen4 five-stage banks", + "head": "913ccc48a0bc1173709ea92280b96252256b7754", + "updated_at": "2026-10-10T05:21:07Z", + "body_sha256": "8db99c4ca700a17ac95212c1b955feec07f13a797d0dc635f9cf650e7b020ea5", + "matched_searches": [] + }, + { + "number": 280, + "title": "Conditional κ = 0.000724189082265949: gen4 retiming, 440 early restorations and 60 dirty entrances", + "head": "f063aab8d6e514188e53db57218515df9cdd186e", + "updated_at": "2026-10-10T04:56:20Z", + "body_sha256": "da68f6beefe550652a454478384ca08816ca675ab855388cf54aec65da512561", + "matched_searches": [] + }, + { + "number": 281, + "title": "Conditional κ = 7.25113717934416e-4: target-prefix compression (280 groups) composed with #280's gen4 retiming, early restorations and dirty entrances", + "head": "7542b215a7ff49d264e2b4691ca7fa9bc3be82d9", + "updated_at": "2026-10-10T05:40:08Z", + "body_sha256": "160fa0a9f79fd7e2120cf2a22e84759cdaf3263b899bd223f037760840e9031f", + "matched_searches": [] + }, + { + "number": 282, + "title": "Conditional κ = 7.24733001963261·10⁻⁴: 695 collective response-kernel entries (per-entry cuts, entrances of any dimension) on #276's gen4 word, composed with #279's descent retiming (+0.258% over #276)", + "head": "841a99b8cf0609ce461b208ed6367463459dd7f5", + "updated_at": "2026-10-10T07:08:41Z", + "body_sha256": "5cb508371cd6f5f1c7f50353c037d0fb7613820074bf12fdd08275ed2bc2d72c", + "matched_searches": [] + }, + { + "number": 283, + "title": "Conditional κ = 7.26111344123732762670617e-4: gen4 response kernels and endpoint-aware composition of #279/#280", + "head": "19d148bd7aa199378816cf1fb9ff746eb4d815da", + "updated_at": "2026-10-10T13:27:05Z", + "body_sha256": "5aeb1bb38ac8747a3233027a85b1feca312ca3d9e306c04e807645f15d995c89", + "matched_searches": [] + }, + { + "number": 284, + "title": "Conditional κ = 7.26291692225845·10⁻⁴: 91 collective response-kernel families on helpers untouched by #283, at its own cut (+0.0248% over #283)", + "head": "2c991a3ac400057059145c837e8b32bba9128346", + "updated_at": "2026-10-10T06:55:04Z", + "body_sha256": "a16df8dbb9e28676d126e5ab999c70f3a3df9e9ed3d742c45ee419bccd772c37", + "matched_searches": [] + }, + { + "number": 285, + "title": "Conditional κ = 7.42785663120535e-4: gen5 — compile-cost-annealed pair and all-but-one modules on #276's gen4 bit word, five-stage completed banks", + "head": "b40c1a3d8f40ee3764b9f13fe850f663f2d8c834", + "updated_at": "2026-10-10T21:35:48Z", + "body_sha256": "556b96b937b33f032f4522e429eed24d22a67e87c193d904c09beec2158721a3", + "matched_searches": [] + }, + { + "number": 286, + "title": "Extreme-frame retiming on #284's gen4 word: conditional κ = 7.26319877913759e-4 (+0.0039% over #284; below #285)", + "head": "13a523a250f471e7cc880e8a24060d654ba9c78b", + "updated_at": "2026-10-10T07:33:51Z", + "body_sha256": "1016ea7193169a510dc241e38eaadaa0f13ce0b560f3fcc5de9c0934ea4afbd8", + "matched_searches": [] + }, + { + "number": 287, + "title": "Conditional κ = 7.44136146100942e-4: two concave-descent retimings (904 + 111 gates) and 220 target-prefix squares on #285's gen5 five-stage banks", + "head": "9f85de891c5eec5de4e33a9185157c9e573bb315", + "updated_at": "2026-10-10T08:59:56Z", + "body_sha256": "3955e701bd61b055215f4e70b2a5fad41db7ebd8835afdb67acada5800a1c734", + "matched_searches": [] + }, + { + "number": 288, + "title": "Negative results from a search for a new coding mechanism: m = 2 closed on both sides, flag theorems, closed routes (no new κ)", + "head": "475a088b5862f75f0b10596cfd6842d19531a5ec", + "updated_at": "2026-10-10T07:55:12Z", + "body_sha256": "e1e91d902af32f818ac56b007c4207f677948fd5845e116e1c260e6a3d8a1d43", + "matched_searches": [] + }, + { + "number": 289, + "title": "Extreme-meet frame retiming (87 gates) on target-compressed gen5 word: kappa = 7.44127392470948e-4", + "head": "04e14102a36a33b9f9eef4e4c76119fd6e54b445", + "updated_at": "2026-10-10T08:45:46Z", + "body_sha256": "e9d4ca632a8b5f8bd775aa058ce928381e4b127aa7a952fa12d2820e2e3297a9", + "matched_searches": [] + }, + { + "number": 290, + "title": "Conditional κ = 7.44714499357628·10⁻⁴: 450 collective response-kernel entries on #285's gen5 word, after #287's descent and target squares (+0.080% over #287)", + "head": "739c3bb0ad0596f427e0a72a2ebeca23277217a3", + "updated_at": "2026-10-10T08:48:14Z", + "body_sha256": "7446d1df818f774706fa15b300f78edc0ae37528ffab3143e8eb1366f43e0f68", + "matched_searches": [] + }, + { + "number": 291, + "title": "Conditional κ = 7.44728650221677e-4: second concave-descent retiming (89 gates, constructed frames) after #290's kernel entries on the gen5 word", + "head": "5c296797e06101c74d15b0162dfe372c186ec330", + "updated_at": "2026-10-10T12:53:32Z", + "body_sha256": "8fe30713cd7ea75cf7eca66c875a6293e2e496449eb86e4996bb499821e0e201", + "matched_searches": [] + }, + { + "number": 292, + "title": "Conditional κ = 0.000744719882668682: 65 compatible retimings on PR290 kernels", + "head": "0687febc3a57c580b1b8cbee83a82d0bfb29fcbe", + "updated_at": "2026-10-10T09:21:22Z", + "body_sha256": "7ea3559e525bd8ab61ce90d592a2e6c4dbfa113e58771223fa3f12022f159ef4", + "matched_searches": [] + }, + { + "number": 293, + "title": "Fixed-prime eight-level gen5 descent: conditional κ = 744728654228590183370616/10^27", + "head": "e65a690f87bdade17b361f9c66554861bb85a5c1", + "updated_at": "2026-10-10T09:33:29Z", + "body_sha256": "a5ec6d696ce211bb350b3cbeed84e959bbd39040ed0bd2cf37581a97fb7921c9", + "matched_searches": [] + }, + { + "number": 294, + "title": "Prove constructive sufficient region for assembly arithmetic", + "head": "55233c38b90edbb0e34ea728b4ed98b366184bb1", + "updated_at": "2026-10-10T09:38:56Z", + "body_sha256": "8585cd6f0442cdaddd26061f5b09502743a9806f182027ab908f9b8ad426920d", + "matched_searches": [] + }, + { + "number": 295, + "title": "Conditional κ = 7.45513573133379·10⁻⁴: early restorations and terminal sinks on the gen5 kernel word, with #233's complex word as supplier (+0.107% over #290)", + "head": "a41781bb9bb45c368046e4e387c6ffeb041c8208", + "updated_at": "2026-10-10T09:56:15Z", + "body_sha256": "6070b3d876368d36d6a891f1c5cf2dd400ccde3366830bdec6f3aaf0e0d5c9e1", + "matched_searches": [] + }, + { + "number": 296, + "title": "Conditional κ = 7.46709720962478·10⁻⁴: gen5b — exactly optimal local design and a debt-10 all-but-one module on #285's word, #287's stages re-derived, #233's complex supplier (+0.348% over #287)", + "head": "b15a33ce4f0e31379be685139f78b9c1e7ffa77b", + "updated_at": "2026-10-10T10:02:56Z", + "body_sha256": "c540c787314a8caa7455c5bea498a72e8e4a1e44e3daf599dee00d8ca87262e2", + "matched_searches": [] + }, + { + "number": 297, + "title": "Conditional κ = 7.45287034630032e-4: PR280's early restoration of 440 cleanup helpers on the gen5 word, after #291's stages", + "head": "2006a8f9288fd7222ae3dc3aeb2e817bbb403be0", + "updated_at": "2026-10-10T16:46:06Z", + "body_sha256": "c42ffe02519e03312d3f62226f778f0d95c88a958d2348f7fa8970b6ecb4386f", + "matched_searches": [] + }, + { + "number": 298, + "title": "Conditional κ = 7.44714499649771e-4: eight completed bootstrap levels on #290", + "head": "7e7a6d796bf9dbc51d1d6d0855cc67bcf0668fbe", + "updated_at": "2026-10-10T11:01:27Z", + "body_sha256": "8f7059ffd588431f15705bb58e3116ece2e6d7a67c823ecaa1c4f14c64c34d35", + "matched_searches": [] + }, + { + "number": 299, + "title": "Conditional κ = 7.50237961741364·10⁻⁴: kernels, early restorations, terminal sinks, a post-sink retiming and addition reordering on the gen5b word (+0.473% over #296)", + "head": "11b69525c7b2bb116cf29b17f976781003ef33b4", + "updated_at": "2026-10-10T12:19:15Z", + "body_sha256": "f9736871a8dbc136ce4547a328224e9d82b1ae6026808e0a549ce0a2f28f509f", + "matched_searches": [] + }, + { + "number": 300, + "title": "Conditional κ = 7.49982567267028e-4: 1,734 kernel entries (restart-packed), second descent, 440 restorations and 8 sinks on #296's gen5b word", + "head": "56eb64125a76b3427986f4a3fcfc4b6f4cf55591", + "updated_at": "2026-10-10T12:53:37Z", + "body_sha256": "6cf412dd6f8a07ddc7d19c74a772055bfe258973f579483e05df03c6eb58d4ce", + "matched_searches": [] + }, + { + "number": 301, + "title": "Verify a 12-helper co-retiming improvement on pinned PR #299", + "head": "ebd6a08ed7d517387794c066490aa02aadcc78d4", + "updated_at": "2026-10-10T11:14:19Z", + "body_sha256": "9c278bbd05b2fa6477cdfff71599dc23132af1d6c7bc04930c0c89ba4b1cff7c", + "matched_searches": [] + }, + { + "number": 302, + "title": "Verify shared-donor kernel improvements on pinned weighted and reordered words", + "head": "9bb199dedb3ecdd9c40c31eac79459dc81154ad3", + "updated_at": "2026-10-10T20:05:33Z", + "body_sha256": "5be76cc668e9b066fd3ef4c43a58d26d218c591ddc88bc3c2c1381e8b043ed73", + "matched_searches": [] + }, + { + "number": 303, + "title": "Conditional κ = 7.49982571369270e-4: fixed-prime eight-level transfer on #300's gen5b-full package (+4.1e-12)", + "head": "363134af67f7aa2e0f887e79c6c22963280682d0", + "updated_at": "2026-10-10T12:53:38Z", + "body_sha256": "f129b57743a15e9ac55b845bd77483f676d2d22e7c8dd247b381b858f1795aa6", + "matched_searches": [] + }, + { + "number": 304, + "title": "A stronger complex supplier: compile-cost-annealed complex modules, five-stage complex saving 7635/10⁷ (+1.17% over #233; no new κ)", + "head": "7ac169c58c96cebdb5cd490842331dff3610af62", + "updated_at": "2026-10-10T21:35:50Z", + "body_sha256": "54646dfecdaad2ccdb031a1f76e826d95dee3091a8b3f2adf5a85585af8f4bf4", + "matched_searches": [] + }, + { + "number": 305, + "title": "κ = 7.51140529238897e-4: restart-packed kernels on weighted gen5b matching", + "head": "a17c42903bbe8d9d26c4bc712d7216a7176237e9", + "updated_at": "2026-10-10T12:17:44Z", + "body_sha256": "02cb33fa61f0060efd541ad731138a62bcbe7ea54fc9cabc78e867433ab35668", + "matched_searches": [] + }, + { + "number": 306, + "title": "Conditional κ = 7.51458925311258·10⁻⁴: addition reordering on #305's weighted gen5b composition (+0.0424% over #305)", + "head": "0314371983b8837f01723f5af2c70217f75b01cc", + "updated_at": "2026-10-10T13:21:52Z", + "body_sha256": "ba6fac45aebaa6cd829843cb507f8bc67a0529ad24f04b0f5caae85350290039", + "matched_searches": [] + }, + { + "number": 307, + "title": "Conditional κ = 7.51154847341386e-4: 1,738 kernel entries, 90-gate second descent, restorations and sinks re-derived fresh on #275's weighted gen5b word", + "head": "b4f85afd6a54a2d593519c59690586a34fac2dfc", + "updated_at": "2026-10-10T13:16:21Z", + "body_sha256": "bdbaa84c5dda1bb31a9bd7689673276c67b0eb689f25ac0051f488b49e5943bf", + "matched_searches": [] + }, + { + "number": 308, + "title": "Conditional κ = 7.51472114011902e-4: #307's fresh selections on the weighted gen5b word with #306's reorder stages", + "head": "02d769b6a4dc1ac351bab06f4e9afd74d9c3995e", + "updated_at": "2026-10-10T13:32:25Z", + "body_sha256": "480a262cfcc4d9ef59e1cbfff1778395c324d472e1b9c982c9f05a59c2b08ccd", + "matched_searches": [] + }, + { + "number": 309, + "title": "Conditional κ = 7.51499335697560e-4: local dirty-response transport, commuting schedules and37 additional gauges on weighted gen5b", + "head": "aeb4808af1392e565e7071cbeb2c29608201cf24", + "updated_at": "2026-10-10T17:58:12Z", + "body_sha256": "0354c1a95f40e68a91542de593bdb044850591ae53f6873800cf112215b338c2", + "matched_searches": [] + }, + { + "number": 310, + "title": "Conditional κ = 0.000752893499605334868002344: source-bound w3 word and complete finite admission (+0.1855% over #309)", + "head": "484b85f1d1fada27fda2ddab3ec952c1314d84c7", + "updated_at": "2026-10-10T14:13:47Z", + "body_sha256": "ab71cf0c5bed2cf36e4156555dfb554f7e5ceb4e1a004b6bfd6629e0988ea10c", + "matched_searches": [] + }, + { + "number": 311, + "title": "Conditional κ = 7.53508664880762e-4: 209 exact F₂ target-prefix squares on #310's w3 word (+0.082% over #310)", + "head": "298f9baf71c261a326e54eb8407ee414c1109f79", + "updated_at": "2026-10-10T16:45:57Z", + "body_sha256": "c3f9ad1ae37b5a89be635cab7ebe44d9f709932ff3c795910c6fa202abfea75b", + "matched_searches": [] + }, + { + "number": 312, + "title": "Conditional κ = 7.54549816771013·10⁻⁴: kernel, target-prefix, plateau and reorder stages on #310's w3 word, priced against #304's complex supplier (+0.138% over #311)", + "head": "328086061dc09499039a7a33fa6510c37e796522", + "updated_at": "2026-10-11T09:15:33Z", + "body_sha256": "cec6d9c9cdd3c9e5820daf812082bdc255abd50ee131f980e3c2b40605eb1b4d", + "matched_searches": [] + }, + { + "number": 313, + "title": "Conditional κ = 7.54077687633330e-4: 438 early restorations (endpoint-aware banks) after the squares on #310's w3 word (+0.0755% over #311)", + "head": "9646345a82f7858e266f71a005a06aaf2c30eba9", + "updated_at": "2026-10-10T16:45:59Z", + "body_sha256": "40222eed3d010521ed388ee6a57d2389044a8428a82b504e13aaee00e40f5fef", + "matched_searches": [] + }, + { + "number": 314, + "title": "Conditional κ = 7.55120411314104e-4: 438 early restorations after #312's kernel/target/plateau/reorder stages on the w3 word (+0.0756% over #312)", + "head": "3984049ab4658f8126475aa1860367bdb79b40cc", + "updated_at": "2026-10-10T16:46:02Z", + "body_sha256": "47929e4e055f2ffc8e08774d3dba231b3c56fc1e71ca4c643d6a4648c364e1e6", + "matched_searches": [] + }, + { + "number": 315, + "title": "Conditional κ = 7.64230861320245e-4: the paired-cube bit word at cube size p = 10 (h = 20, m = 100), with a new centre-sharing complex supplier (+1.21% over #314)", + "head": "64bccfb67494f7c4549bfb2f186b400a3cfefb42", + "updated_at": "2026-10-10T21:35:53Z", + "body_sha256": "c4981dc24031943f41d6306075bd3e35aee33c052436a65daf80c60de805483e", + "matched_searches": [] + }, + { + "number": 316, + "title": "Conditional κ = 7.65146115390441e-4: 480-gate concave-descent retiming on #315's p = 10 word (+0.120% over #315)", + "head": "9e7200bc7b87bde52568b56ec8e2b96af8303d6c", + "updated_at": "2026-10-10T16:46:04Z", + "body_sha256": "276ff21143b2a3f40088bc7f6cb94a60f071d11fe6bfad6b57d8e7b76e76958d", + "matched_searches": [] + }, + { + "number": 317, + "title": "κ = 7.6817007781759e-4: composed p10 stages with full source-bound admission", + "head": "0a0b61a7f4601a96036af8bb6a6338c58f035d2e", + "updated_at": "2026-10-10T16:26:45Z", + "body_sha256": "5a6f491170c9945137ba32b42ed32209f0f487acf66a2e2468eb5d945fccc629", + "matched_searches": [] + }, + { + "number": 318, + "title": "Re-pin the root Makefile/README in research/joint-dual/SOURCE.json (fixes the failing 'Verify research artifacts' job on main and all PRs)", + "head": "a45747d2559141a594916475f52642e4fab86e02", + "updated_at": "2026-10-10T16:39:36Z", + "body_sha256": "c64327370f956a629399846f319b8bc8b29dfe65190f5e089033e8e7095c8d99", + "matched_searches": [] + }, + { + "number": 319, + "title": "κ = 7.68257328708259e-4: shared-donor kernels after frozen PR317", + "head": "14af8e5cd27d8024cbdcbc3273ef183d2db1c65c", + "updated_at": "2026-10-10T16:43:10Z", + "body_sha256": "02df811be4be41d68dfda1322f0e5463e2f80f5e20e86a137878a6e567b19bcc", + "matched_searches": [] + }, + { + "number": 320, + "title": "Conditional κ = 7.69553898621543·10⁻⁴: the full transcript stage stack on #315's p = 10 word, with a shared-donor closure kernel (+0.697% over #315)", + "head": "e912cbdd649fcbd292293c70511882b06266b276", + "updated_at": "2026-10-11T09:15:30Z", + "body_sha256": "90b40da4deaf84230b2adf96d8d608b4f38e7c4a8463f11cab12b3510e356b6f", + "matched_searches": [] + }, + { + "number": 321, + "title": "Conditional kappa 7.692096978795988679e-4: five new p10 response kernels and source-bound finite assembly", + "head": "c76247701762feb2c5bea5bcf302b010eb7d1bc3", + "updated_at": "2026-10-10T18:02:16Z", + "body_sha256": "f1d025f3db1c7c43de8cc3e3e407d8a310cc7b06044fcdc9cd12e56ccfe3559f", + "matched_searches": [] + }, + { + "number": 322, + "title": "κ = 7.69556690340075e-4: four frame retimings after PR320 restoration", + "head": "8ce22e5e487e9d1017c26702adc09d5646565d0c", + "updated_at": "2026-10-10T18:05:01Z", + "body_sha256": "ccbc0774ae53711ab9813407ad5b726e27fa844a2d6d1826ff9a12c9a1ae44b2", + "matched_searches": [] + }, + { + "number": 323, + "title": "κ = 7.69557449978832e-4: three rank-two kernels after frozen PR322", + "head": "e51f5ffee8ab574e5b8249a4612411b2ca5f100d", + "updated_at": "2026-10-10T18:10:24Z", + "body_sha256": "c33d4c706e10bdaa85945a772d487b7dc598de53379c843e10724b0ccb78208f", + "matched_searches": [] + }, + { + "number": 324, + "title": "Fix CI dependency path for frozen PR323; construction unchanged", + "head": "6bc86cb3ddeb2c39e64035a4e657ae892aab61a0", + "updated_at": "2026-10-10T18:14:36Z", + "body_sha256": "718b7580f67d4bd2c7900e22a1dede087421953c2df132633dd9a571e310729f", + "matched_searches": [] + }, + { + "number": 325, + "title": "Conditional κ = 7.696840393833340e-4: a stronger p = 10 bit word — re-annealed pair module, p = 10 local design, balanced cube orientation, tiered reuse matching (+0.71% over #315's word)", + "head": "0eca9340a3df6141b8e71a41638c3937b3522888", + "updated_at": "2026-10-10T21:35:55Z", + "body_sha256": "0f04d2e4690f06d26540d55674a3f1f6e72649385420fb1ffa665015623804d6", + "matched_searches": [] + }, + { + "number": 327, + "title": "A p = 10 complex supplier: five-stage complex saving 7795/10⁷ (centre-sharing) and 7737/10⁷ (#304 recipe), both kernel-checked in Lean (no new κ; raises the complex cap above 7727)", + "head": "40ed0456ab1990beb3440e61bb883ccf95fdcea4", + "updated_at": "2026-10-10T21:35:58Z", + "body_sha256": "c63fbfa652358218f1b70f423f77d0e0251ac13b6ece36a3d0fa9638d4efe939", + "matched_searches": [] + }, + { + "number": 328, + "title": "κ = 7.72285110892838493685197e-4: source-bound p10b stages and retimed complex supplier", + "head": "34af22b4f972f46870ba6b8c9dfaae1d0bb1b25d", + "updated_at": "2026-10-10T19:11:14Z", + "body_sha256": "7b59a14dc1078d6fe2b76284a93ef4afaa9540e4a4f1971fcfed7cf2c19c0984", + "matched_searches": [] + }, + { + "number": 329, + "title": "Conditional κ = 7.76518649004426·10⁻⁴: the full transcript stage stack on #325's p10b word, priced against #327's p = 10 complex supplier (+0.888% over #325)", + "head": "60ca7b5eeedf45301bcf3326b65f3b6a3ca9bf35", + "updated_at": "2026-10-11T09:15:27Z", + "body_sha256": "58a082c7d82a1ff364297f4ebacfcf98bb66f463ef7db8d135c2d43565e0b7ec", + "matched_searches": [] + }, + { + "number": 330, + "title": "κ = 7.7652200910342944936985e-4: cross-entrance retiming and operational PR327 supplier", + "head": "6d1faafc1ac58adb885349b2b08813467a938563", + "updated_at": "2026-10-10T19:39:14Z", + "body_sha256": "875889008a84a7b97b3ce84cf8c6ba5391c59c5a856cb827ec6d9cbcb63d58a3", + "matched_searches": [] + }, + { + "number": 331, + "title": "κ = 7.76523967665819025774905e-4: nested donor entrances on the p10b word", + "head": "c0fa7e1be9e5f9f2316bb1f88e4c77298014492e", + "updated_at": "2026-10-10T19:56:21Z", + "body_sha256": "aa4247d742538d5a669d6ab210ad32fdf6edc304856f46db687d61e18e5e8be9", + "matched_searches": [ + 0 + ] + }, + { + "number": 332, + "title": "κ = 7.77268259042371640048112e-4: oriented p10b source and 42 constructed-frame retimings", + "head": "f9136e76568100034aa37337251f93d684496c13", + "updated_at": "2026-10-10T20:17:54Z", + "body_sha256": "759e484f59413b19df6baf8f60e85845444795ab6b85230c40d95aafd2f71589", + "matched_searches": [ + 0 + ] + }, + { + "number": 333, + "title": "Repair gzip portability for frozen #332; conditional κ unchanged", + "head": "f04a11279fe1eedb54ac97c80d5a71ddc0275b13", + "updated_at": "2026-10-10T21:03:08Z", + "body_sha256": "ab8eea28e4948b38dbfe02ac7ea47cb73bec6ad74d400cdd651c5717b3840b60", + "matched_searches": [] + }, + { + "number": 334, + "title": "κ = 7.77596191161693861459874e-4: all-rank donor flow and 52 final retimings", + "head": "367f55f22e5f5e3aff47e6437bf0dfbf743bacec", + "updated_at": "2026-10-10T21:15:26Z", + "body_sha256": "73e0d0a892cb83531a7e07b77737c4a8f7a5b08744eb2486b02257f9f145286e", + "matched_searches": [ + 0 + ] + }, + { + "number": 335, + "title": "κ = 7.77607473791708458474546e-4: refreshed donors and 54 final retimings", + "head": "fa693bff1fc171a3be18fdaddaf1e196ecef9463", + "updated_at": "2026-10-10T21:34:52Z", + "body_sha256": "55a923f77f622f7ea41f0df4cd374686c5f60d1a5eba86a7b174325d528e54e3", + "matched_searches": [ + 0 + ] + }, + { + "number": 336, + "title": "κ = 7.776299656948249002253e-4: exact-subspace grouping and sixteen carrier switches", + "head": "f566fe33384cd295fc1416cf3ed882500135a1f2", + "updated_at": "2026-10-10T22:14:48Z", + "body_sha256": "75e0e675c5781c6ff8e7798f4e77202f015f722ad9e9d3df2c68a92fbbe1d657", + "matched_searches": [] + }, + { + "number": 337, + "title": "κ = 7.77646134698096194171091e-4: source orientations preserving fifteen sinks", + "head": "bc97a6e8ddd3150f7533fdf119c2a6b5df0e57ea", + "updated_at": "2026-10-10T22:19:08Z", + "body_sha256": "3f8fe869687a69d19b9f0e8482f314858c2af7926c7ae8067e649a4af8b7f615", + "matched_searches": [] + }, + { + "number": 338, + "title": "κ = 7.77667758368047375562422e-4: three source orientations preserve fifteen sinks", + "head": "0faf57c8c7530d866bfed2d208e7a8dcf62b8292", + "updated_at": "2026-10-10T22:41:23Z", + "body_sha256": "2ac063ffa7b13d92b7b79c2aaa1bf2b358c7aba875d1bb219d650b37df2069d0", + "matched_searches": [] + }, + { + "number": 339, + "title": "κ = 7.77699286748588506644032e-4: combine sink-preserving orientations and carrier switches", + "head": "56964cfb850d37c6c7f35810b71552dfc18508f4", + "updated_at": "2026-10-10T22:42:41Z", + "body_sha256": "6f88a0f2924e77322b4f9c1e3850ee729a77c1a745dc4fb8c6c9232fbf9b7afb", + "matched_searches": [] + }, + { + "number": 340, + "title": "Conditional κ ≈ 7.7766181e-4: exact-objective free-form final retiming (490 gates, φ −85.9) replacing #337's 52-gate descent on the same word", + "head": "05a4ee7fdb97607de3e151e774ba93cb1967fb6e", + "updated_at": "2026-10-10T23:06:38Z", + "body_sha256": "05cd829a8a8d72d156b5fdf4dff061b4a162dac4487a87dae6b4a8c12c37504a", + "matched_searches": [] + }, + { + "number": 341, + "title": "κ = 7.77709755852032951391533e-4: selected carrier switches preserve fifteen sinks", + "head": "6ee2d78d7773b2406762d35e41a5636231310ed9", + "updated_at": "2026-10-10T23:04:27Z", + "body_sha256": "617da2823a792f63650bac5d3f5bac05808029ebfea93de164ab6a1d17812b42", + "matched_searches": [] + }, + { + "number": 342, + "title": "κ = 7.77733996775530073717409e-4: selected carriers preserve sixteen sinks", + "head": "69cdb327d3c7cf93f711c983cb51606856dc3f07", + "updated_at": "2026-10-10T23:13:00Z", + "body_sha256": "9a4b318d6ea6b6b9f5105c85da2cd27d13692380d0822cf9206d8885c06372b4", + "matched_searches": [] + }, + { + "number": 343, + "title": "κ = 7.77751087387777005145646e-4: refreshed sixteen-sink carriers", + "head": "1d9c3b64b07395912877f103dc1d0f3214f662f1", + "updated_at": "2026-10-10T23:20:18Z", + "body_sha256": "71e835bba4cc7e8e824611b89a3f506b72f44782a1eeba1a8f63f45a3a85cb87", + "matched_searches": [] + }, + { + "number": 344, + "title": "κ = 7.77947425336102317479703e-4: restore ten terminal caches in original registers", + "head": "da0c805eab7e88d8b9fcce112ff8ed4b720bea8a", + "updated_at": "2026-10-10T23:28:33Z", + "body_sha256": "42128f3bb7a64b04327a4086b0282f34d2e158a717c3545eb853b9229f9c4eab", + "matched_searches": [] + }, + { + "number": 345, + "title": "κ = 7.7809154371141892133459e-4: transfer compatible PR340 frame components", + "head": "9e15e4d5ed41f8df20bd8393ece9f62e910cd49c", + "updated_at": "2026-10-10T23:43:59Z", + "body_sha256": "0a225b7302f30fa0d31c3827c6e5bfe1e126004163bd15928665f0d70be3f413", + "matched_searches": [] + }, + { + "number": 346, + "title": "κ = 7.92580093369946e-4: w3 cube layer on #325's p10b word with a stronger p = 10 complex supplier", + "head": "11b4de5ff8ed5fccf55d4af1043358d257308e8e", + "updated_at": "2026-10-10T23:45:40Z", + "body_sha256": "8c034179d31ac8def4454334dee41170fe894ddeeb48cfa691b402d3d98aed5e", + "matched_searches": [] + }, + { + "number": 347, + "title": "κ = 7.78097715735654505738899e-4: coherent component frame retimings", + "head": "db6a9a004f2d3a1f9281b7e75dfc671189a9ccdb", + "updated_at": "2026-10-10T23:46:17Z", + "body_sha256": "70ec2114b656cb7a26abb9291f4181244fcd63f6f8fb98f1910fba8ef8e5759a", + "matched_searches": [] + }, + { + "number": 348, + "title": "Conditional κ = 7.93392809291691·10⁻⁴: #346's w3 bit word with a per-point p = 10 complex supplier (+0.1025 % over #346)", + "head": "2b8b3d87870f68e646d295bb2d32c6dd918dee9d", + "updated_at": "2026-10-11T09:15:24Z", + "body_sha256": "a55067af7b9bbc8a85a7e0c07ea938a3c5f33b7ccb5edae6c0cc4a9222ceab46", + "matched_searches": [] + }, + { + "number": 349, + "title": "Certify PR288's restricted sign-gauge obstruction with four constraints (no new κ)", + "head": "3e8d8c2b83387930499423ee46b94c5546f11b19", + "updated_at": "2026-10-11T00:33:01Z", + "body_sha256": "ee51e562135d5c17fd96dec2c491ab610eaf2188c7deeb01c47e712f74f03eee", + "matched_searches": [] + }, + { + "number": 350, + "title": "κ = 7.93469326753735e-4: #348 with a frame-retimed complex program (+7.65e-8)", + "head": "a1793b04e2a02ad494c0c4acd2988e8c125ddc99", + "updated_at": "2026-10-11T00:56:09Z", + "body_sha256": "444661d2267fbdd13ee27b2ba33335358bfa84b66ac43a8f835a7563cb75e79f", + "matched_searches": [] + }, + { + "number": 351, + "title": "κ = 7.93392809671713586967588e-4: complete native admission for #346/#348", + "head": "c0f9f480440a25f89a8a00e1b2076467cf484754", + "updated_at": "2026-10-11T00:41:47Z", + "body_sha256": "8da218d2e9eb580539a6973fc29c9bc39aea4368c13cea4af65e2baf091a309d", + "matched_searches": [] + }, + { + "number": 352, + "title": "κ = 8.01083628465007e-4: #346's w3 bit word with Sussman's Lean-checked E8 unit as the complex supplier (+0.96 % over #350)", + "head": "04b4c3c478b5bd8797d2663d89d8db4dfd0ad9f2", + "updated_at": "2026-10-11T11:38:38Z", + "body_sha256": "dd512c80c1d605406d46c9ef68516dd3c6dd2876ee26848c9af7b9580cde80ce", + "matched_searches": [] + }, + { + "number": 353, + "title": "κ = 8.01598358635541e-4: #352 with Design T + twins on a reordered-design p10b base word (+0.064%)", + "head": "3901d29f07d3953438779a2c9d58b15522cfed7d", + "updated_at": "2026-10-11T01:31:18Z", + "body_sha256": "daeb6a92351e80eb0c01cdd0c27accf66794dee742f50a0e3de8547b200f1653", + "matched_searches": [] + }, + { + "number": 354, + "title": "Conditional κ = 8.03137165163490·10⁻⁴: w3 Design T + twins on #329's transcript-staged p10b word with Sussman's E8 complex unit (+0.256 % over #352)", + "head": "2e3f3cf37d2d53d902cf78200c5d59668280cf5b", + "updated_at": "2026-10-11T09:15:21Z", + "body_sha256": "f1c466a5f82cd585a39fc65f44752e8170cfcd9699f95b13f4b9a1f7be58ded3", + "matched_searches": [] + }, + { + "number": 355, + "title": "Conditional κ = 8.01967436473393e-4: exact integer-lifted shared donors with E8 (+0.1103% over #352)", + "head": "e59117a865452b4562891d80c3d2b154b60cb5cf", + "updated_at": "2026-10-11T01:51:48Z", + "body_sha256": "c5f59b64f085777c3314272500bf6f4a20ab30c597d425e38c955f07ddfd013c", + "matched_searches": [] + }, + { + "number": 356, + "title": "κ = 8.03161884970454053300282e-4: staged signed twins with complete native admission", + "head": "c3d16f4249d07274fe234bd57ab9354779b97fbc", + "updated_at": "2026-10-11T01:57:54Z", + "body_sha256": "59ab9d1a56d77f07e3c2abd62fb4d27e0861ae2412063707b1d9ab591bed38eb", + "matched_searches": [] + }, + { + "number": 357, + "title": "κ = 8.03654539036015e-4: #354's staged Design T + twins on a reordered-design p10b base word (+0.064%)", + "head": "0866809c02f30d6e12244a4e69670a323351858b", + "updated_at": "2026-10-11T02:06:59Z", + "body_sha256": "99417c298f4db22fabc19c028a5ff98eef141e0b544641adf6c309eeea642fb7", + "matched_searches": [] + }, + { + "number": 358, + "title": "κ = 8.0367971186626189473809e-4: reordered stages with 471 twins and signed18", + "head": "e76d7a94e6ad819e2aa9dc99083ecfa3e7842e0b", + "updated_at": "2026-10-11T02:14:43Z", + "body_sha256": "14deba5532a3a3335abbfe3bf984d4aea9014d5c25e89df67c81eee22fa4a69e", + "matched_searches": [] + }, + { + "number": 359, + "title": "Conditional κ = 8.04303459176812·10⁻⁴: kernel, retiming and reorders re-derived on #354's Design T word (+0.0776 % over #358)", + "head": "e428efc9bea88c06ab3df89cb3b48eca13757813", + "updated_at": "2026-10-11T09:15:18Z", + "body_sha256": "c3a2d96d3bdfbf069af02f38f56eccc09179a3873b389c0fdb3ce2b9cba4ca44", + "matched_searches": [] + }, + { + "number": 360, + "title": "Conditional κ = 8.03512980550910e-4: paid-aware integer donor-basis exchange on #354 (+0.0468%)", + "head": "edef1a7d6da2c628d1adecda234a711e6fff8152", + "updated_at": "2026-10-11T02:29:06Z", + "body_sha256": "fc4a406b0fb38c7ee5588f534e470a94c4fe02ae735f0a07a8443188c5f30e97", + "matched_searches": [ + 1 + ] + }, + { + "number": 361, + "title": "Conditional κ = 8.04849251275843·10⁻⁴: post-Design-T kernel, retiming and reorders on #357's reordered base word with all 471 twins (+0.0679 % over #359)", + "head": "d7b59136fa7dc6e2abfcd9fe41c6be6e886382f7", + "updated_at": "2026-10-11T09:15:15Z", + "body_sha256": "f8495f5752b4d141b098d88750693867e765c6af2dcf887bf18254b812535a8a", + "matched_searches": [] + }, + { + "number": 362, + "title": "κ = 8.04849251275843e-4: #359's post-Design-T kernel/retime/reorders on our reordered-design base (+0.068%)", + "head": "f46ddb51f66381a1668da3801bb1632aacebe224", + "updated_at": "2026-10-11T03:46:51Z", + "body_sha256": "44ed09566082dae87d65b15c82a6ea680641b8cd048db830d3d2f42ca312afd0", + "matched_searches": [] + }, + { + "number": 363, + "title": "Complex supplier b = 9.32783e-4: E8 in a seven-stage bridged word (+6.45 % over #352; no new κ, raises the complex cap)", + "head": "9df55dad6ddd05c3458793dfd82d1c2fe0ddbbb4", + "updated_at": "2026-10-11T03:24:58Z", + "body_sha256": "5c6132316cb395a545aaf50240a8107e4de3963803916cc792ec36b83891bb2f", + "matched_searches": [] + }, + { + "number": 364, + "title": "κ = 8.04879370798932e-4: #362 with κ-exact min-cost carrier matching in the base producer (+3.0e-8)", + "head": "f8c6a47abfec24b87cb1eb0a138dd73dfce2abe4", + "updated_at": "2026-10-11T03:46:49Z", + "body_sha256": "7d94477f5231afb28e3be522dfe1b25c7325fdf63025505da424dccd61b03229", + "matched_searches": [] + }, + { + "number": 365, + "title": "Reduce E8 recursive cost with four coupled frame changes", + "head": "a22270515e9c6102dda3b22e75ca2c62e82812ff", + "updated_at": "2026-10-11T03:53:11Z", + "body_sha256": "1714657b10db5682df73572c0a7940b92ebc029632e127af2fd14d8b3c482d29", + "matched_searches": [] + }, + { + "number": 366, + "title": "Conditional κ = 8.04939789231485e-4: 123 coupled frame changes after #364 (+0.00751%)", + "head": "d3d84202e528d6e147a8ea62463ae5c0125997cf", + "updated_at": "2026-10-11T04:50:45Z", + "body_sha256": "9f6863819d8df67a255be94a2c19a7cfdb7f3eeddc8700eeefc4374b663b7171", + "matched_searches": [] + }, + { + "number": 367, + "title": "Speed up exact frame algebra with pinned replay evidence", + "head": "522285db971642c2d744cc8d45f2a5ade3a55e19", + "updated_at": "2026-10-11T04:50:28Z", + "body_sha256": "81aaaf636a84a8c5f8eb25036018debfe713ce2c0d82937cdd8de7252203fd10", + "matched_searches": [] + }, + { + "number": 368, + "title": "Archive 100 research ideas: results, failures and untested proposals", + "head": "fa8ab946df57ebadae1a470b637c2a590a0a5317", + "updated_at": "2026-10-11T04:47:29Z", + "body_sha256": "b16963d7e08d95682cc3ff2e322567977863ea1875130347e11acbb19d724880", + "matched_searches": [] + }, + { + "number": 369, + "title": "Conditional κ = 8.049462195041506e-4: two kernels and 15 extra retimings after #366", + "head": "a8d05f093d347477d0ed267f4df9592d21dad5db", + "updated_at": "2026-10-11T05:38:19Z", + "body_sha256": "7c6e23a1ce48c65df86d6bdc58aa0189367b9861b5a6246ca46dacffcd325969", + "matched_searches": [] + }, + { + "number": 370, + "title": "κ = 8.75481145306751e-4: first E8 bit word (complex-bound; +9.29% over #352)", + "head": "b7fe9cdf2da009c947ff6b334c562bc190b30373", + "updated_at": "2026-10-11T05:05:44Z", + "body_sha256": "8b24ac1c09b64ca1c545e04c439d9773396e4e92e6b8fe39a2c2a1488163d560", + "matched_searches": [] + }, + { + "number": 371, + "title": "Account for final-grid rounding in the Gaussian block enclosure", + "head": "988ef67986c313445936fc7103908b6163b9d47e", + "updated_at": "2026-10-11T05:09:25Z", + "body_sha256": "5b6f275033d6bf26bf2e075761aa4870d40d79f31a258df42d688b777ed6728e", + "matched_searches": [] + }, + { + "number": 372, + "title": "Refine reviewed gen4 envelopes: conditional kappa = 0.000723571593879006127174", + "head": "e2fae6a92775b8f609d917a9cc93b31e2559dd5f", + "updated_at": "2026-10-11T05:17:12Z", + "body_sha256": "92b5c74851576121b267c099a78dc9b945097a1140512bf78e3f10e052c221a1", + "matched_searches": [] + }, + { + "number": 373, + "title": "κ = 9.3191395651209e-4: #370's E8 bit word and Sussman's E8 complex unit in the seven-stage bridged word (+6.45 % over #370)", + "head": "3ff87b5dc0b22a57958547ee347d5da25b7f9401", + "updated_at": "2026-10-11T05:26:18Z", + "body_sha256": "0e0fb363a4994f0ef4245bf46e054b0699129ab61fd33d1f4eb16e28f0864a8e", + "matched_searches": [] + }, + { + "number": 374, + "title": "Conditional κ = 9.54395132518163e-4: coupled complex retiming after #375 (+0.01588%)", + "head": "4316086532cb7424c25777ccfcc272b16c675608", + "updated_at": "2026-10-11T11:37:33Z", + "body_sha256": "e9aa5ebeec272bd60742c3f610b90afce2144ea791b2633277fdf5b35232d725", + "matched_searches": [] + }, + { + "number": 375, + "title": "κ = 9.5424356568133e-4: seven-stage E8 suppliers with the complex idle climbs at halving degree two (+2.40 % over #373)", + "head": "79874623cf86d92325c26ccafc31413d12e9d248", + "updated_at": "2026-10-11T05:43:05Z", + "body_sha256": "4dce0b72b32649d1f0bfda3c4a45d7df6c2c277fa8d910b7d8c862e4df8d4551", + "matched_searches": [] + }, + { + "number": 376, + "title": "Conditional κ=0.0011208649522582786: split centres with complete signed admission", + "head": "5522b4edf9748ccda787df81f0a83eda83cdc4e8", + "updated_at": "2026-10-11T18:08:52Z", + "body_sha256": "73785b61b26de71b82f175b1e9e337c56a12982d4c2c54724d8fa93bb34e7bbd", + "matched_searches": [] + }, + { + "number": 377, + "title": "κ = 9.98243154231047e-4: nine-stage complex E8 (≈2^-9.9683; complex +14.036%, bit side pending)", + "head": "d0a620fcc99ba012468d61d01f5bb14007076d50", + "updated_at": "2026-10-11T11:37:34Z", + "body_sha256": "522e5edbe404ae7d7cec8da2900d76fc2b509cc38f675f378002c1c4c30bcae1", + "matched_searches": [] + }, + { + "number": 378, + "title": "Conditional κ = 9.5464544449649·10⁻⁴: Sussman's E8 complex unit re-timed by far piece relocation, in #375's unsplit B₃ (+0.042 % over #375)", + "head": "54a1eb4e6d0b1bc584f1cc5b21d091b0ce3f5c68", + "updated_at": "2026-10-11T09:15:12Z", + "body_sha256": "b50759c07bb73b38902cedebdb108a253c9549810bc20a994304cbaa33e83466", + "matched_searches": [] + }, + { + "number": 379, + "title": "E8 low-read bit with seven-stage complex supplier", + "head": "e01bcc51ca7ee93cec54350afae8f163aafc8f93", + "updated_at": "2026-10-11T11:32:49Z", + "body_sha256": "9780f881638d8e9d6c199e96d9754f4a625ddae0c6c08e9fadc9193cb6ea1989", + "matched_searches": [] + }, + { + "number": 380, + "title": "Conditional κ = 9.67261003170394e-4: seven-stage E8 bit with nine-stage complex (+1.32149% over #378)", + "head": "6e95ce5fb4112e5e98382886d7904aee29e31c56", + "updated_at": "2026-10-11T11:37:35Z", + "body_sha256": "43227064bae0fd4e2d32031b19cd3faed36bbe46626542a9fe93045f3e7f3f6c", + "matched_searches": [] + }, + { + "number": 381, + "title": "κ = 9.95656966441037e-4: #370's E8 bit word in the nine-stage bridged word with #377's nine-stage complex E8 (above 2^-10; +2.94 % over #380)", + "head": "00765b291d0f924f337298eb1e2930cb0878b95e", + "updated_at": "2026-10-11T06:14:26Z", + "body_sha256": "26a60fb92133201d20c3461cca75f67dd512c6b03119e765b0bd29d4245bcd9b", + "matched_searches": [] + }, + { + "number": 382, + "title": "Conditional κ = 9.98243154231047·10⁻⁴: our retimed + kernel E8 bit word in B₃ (unsplit) with #377's nine-stage complex component (+0.26 % over #381)", + "head": "536329e6cddd37d70a6b52cbe2c2604ea18c5e83", + "updated_at": "2026-10-11T11:37:36Z", + "body_sha256": "9f3ac282a11d31001a378085ec082e294d9d653aca0587997fc5ab17855ebc64", + "matched_searches": [] + }, + { + "number": 383, + "title": "Nine-stage low-read E8 composition: conditional kappa 0.000996761861969671", + "head": "26b8600364803eddd66c25a187c7fb8435b7f632", + "updated_at": "2026-10-11T06:47:01Z", + "body_sha256": "955e52577b566a8924c4339fe3811ac475f1775a7abacc415bcd1582c41c57f1", + "matched_searches": [] + }, + { + "number": 384, + "title": "Conditional κ = 9.98634656132003·10⁻⁴: #377's nine-stage E8 complex component with our #378 re-timed E8 unit, paired with our #382 bit word (+0.039 % over #382)", + "head": "3fa794621ee566edcad56f86d2e4d0ab53da490e", + "updated_at": "2026-10-11T09:15:05Z", + "body_sha256": "d54cfeb378e369357655117e5ba4303ea8356c64d2d220ef3538bd48a4acdc5e", + "matched_searches": [] + }, + { + "number": 385, + "title": "Retimed nine-stage complex + kernel bit: conditional kappa 0.000998390813251625", + "head": "ad7647ef25b1df0e51189a41072d08a928d759d5", + "updated_at": "2026-10-11T11:37:37Z", + "body_sha256": "edcb7b019916026a6e9d3754f475cbafcd82ab754468b96cc1a6021c472be3ba", + "matched_searches": [] + }, + { + "number": 386, + "title": "Compressed nine-stage E8 windows and whole-block banking for a conditional κ = 9.98243154231047e-4 > 2^-10 bound", + "head": "dd11cf8069554f0333afde398f12a56c3a7c29dd", + "updated_at": "2026-10-11T06:44:27Z", + "body_sha256": "ab3a1f1fd0c2bcffc64da9ca9880a8cffa2af1b7b711cfca87e9b290e5f06a38", + "matched_searches": [] + }, + { + "number": 387, + "title": "Conditional kappa 0.000998634658090835: finite bootstrap and exact coarse precision", + "head": "d9fb9410b1ae6f6ada376a1e7fd12bc176e476ea", + "updated_at": "2026-10-11T11:38:41Z", + "body_sha256": "77fb8ae98d91386bc5120595e9f8e1c1146a1d0b09893d0c65dae8c36afe8cfc", + "matched_searches": [] + }, + { + "number": 388, + "title": "κ = 9.93946061393808e-4: exact seven-nine B-order composition", + "head": "783e019de2a27c30cd0dc858f4611f044e6fe77a", + "updated_at": "2026-10-11T06:47:19Z", + "body_sha256": "b771ecc47587206101ff1a67d8e500ef236ec1196c5d2f47417f788c6ead35e9", + "matched_searches": [] + }, + { + "number": 389, + "title": "Complete far-retimed E8 replay and coupled bit frames; conditional kappa 0.000998634658090835", + "head": "b3c45822ca847aec8c0c019bb04db30881fc2966", + "updated_at": "2026-10-11T07:38:55Z", + "body_sha256": "15a050bfbf3057db4ebcaa23ccd5e1411a115aa1e7a6a7dc24119fdc69cc31b5", + "matched_searches": [] + }, + { + "number": 390, + "title": "E8 prefix restoration and heterogeneous helper banks: conditional kappa = 1.000220222889528e-3", + "head": "0e790f2dfb64e17bdee154aee151bb0c1dddb28e", + "updated_at": "2026-10-11T11:37:42Z", + "body_sha256": "dd3b2ac1e75ac6ab520f77e009bcc285639d63092a9d15c7bd663a654e3cd8e7", + "matched_searches": [] + }, + { + "number": 391, + "title": "κ = 9.93946061393808e-4: clean-checkout replay successor for frozen #388", + "head": "efd5bb117722075e0f9f80f35de51b862bb1e197", + "updated_at": "2026-10-11T07:13:59Z", + "body_sha256": "f3a04e9e41d2bd186b025fb2b2a8ce94292dd66b275a3639fe1da0bda38dccda", + "matched_searches": [] + }, + { + "number": 392, + "title": "Conditional kappa 0.001000220224856110: six fixed levels on #390", + "head": "ac55c57035c197f744390fe4bc9cf49df1b61816", + "updated_at": "2026-10-11T07:46:57Z", + "body_sha256": "953ce42aa5c03c0cdc18c43fc97b99ee55ada42f2b691a549ba10c80fff5c883", + "matched_searches": [] + }, + { + "number": 394, + "title": "Conditional κ = 1.000385913854264·10⁻³: bank padding fused into three new free sink helpers on #390's E8 complex program (+0.0166 % over #390)", + "head": "baead918497269357c7da7eefc78eb56a9e4d9aa", + "updated_at": "2026-10-11T09:15:02Z", + "body_sha256": "cf7ad12d0ef6545e35a9fc91f1086c06068bf52b7746a6f49a86348bb49a8d0f", + "matched_searches": [] + }, + { + "number": 395, + "title": "Conditional kappa 0.001001256225581264: signed prefixes and padding fusion", + "head": "c60df7a806d1525c461b4b674598c37685c5ff3a", + "updated_at": "2026-10-11T08:08:49Z", + "body_sha256": "0fe7df903436a7695b53d398b030abfa8168748413a4912069b832d747eac425", + "matched_searches": [] + }, + { + "number": 396, + "title": "Conditional kappa 0.001001098432210898: signed-prefix donor gauges", + "head": "ba07af491bc299269436a7e2454a5043d53a6ad0", + "updated_at": "2026-10-11T09:09:55Z", + "body_sha256": "6d880f67414c63db499f4c491dc74bf0cab1798fc96ba90e2f43dc7b27c987d6", + "matched_searches": [] + }, + { + "number": 397, + "title": "Formalize the indexed B_K scalar bridge and bind the pinned B3 word", + "head": "cb6455fa1e9af68be47c33948d3d1a6f0717a5e4", + "updated_at": "2026-10-11T18:03:59Z", + "body_sha256": "50e6125e3806267c9b1a8f3b9614e3df2768c062693bdd4bca559f62e246c440", + "matched_searches": [] + }, + { + "number": 398, + "title": "Title: Signed target-prefix cancellation on R781: conditional kappa = 0.001002494659629864", + "head": "c3251c8f33fac9332fb3606c2dc0bd4f32de4615", + "updated_at": "2026-10-11T07:58:05Z", + "body_sha256": "a9206a0e12981987179c471fe490deb846f081b0a4aadf3bcdf090c79938df8a", + "matched_searches": [] + }, + { + "number": 399, + "title": "Conditional κ = 1.002661106042177·10⁻³: our #394 padding fusion on #398's R781 signed-prefix E8 complex program (+0.0166 % over #398)", + "head": "3e04107b9381d957a7da7e632ddb662b518429c8", + "updated_at": "2026-10-11T09:14:59Z", + "body_sha256": "2c291e641312e6b882105d8a1eb78e6caf1101905916fae2ea79a47c41a44086", + "matched_searches": [] + }, + { + "number": 400, + "title": "Conditional kappa 0.001002683712533373: R781 heterogeneous banks and padding fusion", + "head": "b73a8b4f3d8b32676e7527005911a11a60a1c4fd", + "updated_at": "2026-10-11T08:43:31Z", + "body_sha256": "ba8bfc222e3f2e6932c7d7d9ef5cf979bf0bdfbb7b1f96126d7255689a5d5067", + "matched_searches": [] + }, + { + "number": 401, + "title": "research: response-subspace gauges and two-sided normalization, kappa = 1.013310887459710e-3", + "head": "7844f72c6051a4408284c3092490687061675c1a", + "updated_at": "2026-10-11T08:44:39Z", + "body_sha256": "c0a1bd12b802c6a6b1b95105cb92b6f09a3bff6fe95c4545d28e89a7b1436a5e", + "matched_searches": [] + }, + { + "number": 402, + "title": "Conditional κ = 1.013357935292321·10⁻³: exact value-level re-synthesis of two targets on #401's response-subspace R781 E8 complex program (+4.70·10⁻⁸ over #401)", + "head": "ac91a9ce6780bdea6b1753cee90fcf437ca4c783", + "updated_at": "2026-10-11T09:43:21Z", + "body_sha256": "2c432d80249ca0fb1009d388f042cf80de77ea4d0584f0eec356dd0e156b5d88", + "matched_searches": [] + }, + { + "number": 403, + "title": "Conditional kappa 0.001013370540420331: 64-replica response-subspace banks", + "head": "4e3ef5fe92652b1a740b32cbea90d0fea678062e", + "updated_at": "2026-10-11T09:35:11Z", + "body_sha256": "2b99f05f1e5f5fe9088175911f10e95dcaf716b84a9256dd1022f6fa2ae250a5", + "matched_searches": [] + }, + { + "number": 404, + "title": "research: shared-donor chains and overlapping target recovery, conditional kappa = 1.016422320428301e-3", + "head": "12f488264cdd74a3b60d0fb534f4955792384f5c", + "updated_at": "2026-10-11T09:16:42Z", + "body_sha256": "354f8aacd5092ac36b46d3b4f8f0212e62a4cd33cafc75765b30b2c67017b84f", + "matched_searches": [] + }, + { + "number": 405, + "title": "Conditional kappa 0.001013417593791468: target re-synthesis with 64-replica banks", + "head": "66bc6cbfd0f93bcb88f7e36205ae8b160c9e5845", + "updated_at": "2026-10-11T09:20:30Z", + "body_sha256": "0616485d810d65e80d732819bc24acaa5b7b5cf7c12fe4d17df1c4d54fd2c6cf", + "matched_searches": [] + }, + { + "number": 406, + "title": "Conditional kappa 0.001016469657190768: shared-donor chains with target re-synthesis", + "head": "5d0d8dff39db99f922ead6d11963aa643511e3ee", + "updated_at": "2026-10-11T09:46:14Z", + "body_sha256": "bcea50e942e03d98b2784b981fcb86dcb8ac536920a3c383c28731dae355e110", + "matched_searches": [] + }, + { + "number": 407, + "title": "Conditional κ = 1.016526770666368·10⁻³: response-gauge re-pivoting (checker-clean) and padding fusion on #404's shared-donor R781 E8 complex program (+5.71·10⁻⁸ over #406)", + "head": "2eca2715826bb899a17d013552d5cf35d42567d1", + "updated_at": "2026-10-11T10:43:44Z", + "body_sha256": "22d44c9a066e3bd3d979932101828e73ff7aea907b57bb636de6d5cae237b7e2", + "matched_searches": [ + 0 + ] + }, + { + "number": 408, + "title": "κ = 1.017022657082799e-3: 205 shared-donor gauges with 64-replica banks", + "head": "26332a3a4bed23484d5cde2c9d4f72b6de130a9b", + "updated_at": "2026-10-11T09:40:25Z", + "body_sha256": "b0c0ee42de0aa24b24c2db3ed6f4213f8c497344676ec428f7a9f383df6719c5", + "matched_searches": [] + }, + { + "number": 409, + "title": "Conditional kappa 0.001017250500928266: ordered sequential entrance gauges", + "head": "212e03d7665d08fc6a037d3e33612cb7fc60874d", + "updated_at": "2026-10-11T10:09:17Z", + "body_sha256": "1b335772951c428544ded37a8e7d383786e91005c270b08e923aca3dd07e5fae", + "matched_searches": [] + }, + { + "number": 410, + "title": "κ = 1.017562145187818e-3: enlarged entrance spaces with sequential donor promotion", + "head": "95ad14d5359d62a89e7bb06eb59b68029e77fb6f", + "updated_at": "2026-10-11T09:57:46Z", + "body_sha256": "32b066cccad390e55cc2f60961720ccab920871b8a894a3545e9229093bb5c73", + "matched_searches": [] + }, + { + "number": 411, + "title": "κ = 1.017629458064773e-3: exact target-prefix resynthesis on sequential206", + "head": "f58d95f2c5da03445e704ea9c72cc55df9e68190", + "updated_at": "2026-10-11T10:02:50Z", + "body_sha256": "976302142e7baca61f061caad5c71648fab005a82dc7b0e7238cd970d51ca332", + "matched_searches": [] + }, + { + "number": 412, + "title": "Conditional κ = 1.017776060460931·10⁻³: checker-clean composition of sequential and enlarged entrance gauges with re-pivoting and padding fusion (+1.47·10⁻⁷ over #411; #406/#408–#410 fail gx E4)", + "head": "616d9d678c00d79693b869934464003ba5b8d1b1", + "updated_at": "2026-10-11T11:37:44Z", + "body_sha256": "d3b76ba7f97555f818942f0719e06a783e0e4d051e84edc9e8adcd45957cdf74", + "matched_searches": [] + }, + { + "number": 413, + "title": "Candidate conditional kappa 0.001017671197486403: enlarged entrance spaces", + "head": "cacb1f486a2ef5a184829b7f4d0cc4e357b47001", + "updated_at": "2026-10-11T10:22:00Z", + "body_sha256": "3759d07b244b7b28a185a62463413a1d987497b6c4c244177d507d8e39da94a5", + "matched_searches": [] + }, + { + "number": 414, + "title": "κ = 1.017660918442154e-3: grouped 210-gauge entrances with exact prefixes", + "head": "7132ca3ebee286fbb01ff5a2f61a6fc32d36ecd4", + "updated_at": "2026-10-11T10:20:10Z", + "body_sha256": "9b9b6530710c0a7c4e7048566e8e80ea742a7176902cd75176049a0284c512e0", + "matched_searches": [] + }, + { + "number": 415, + "title": "Candidate conditional kappa 0.001017786140030308: enlarged entrances and target prefixes", + "head": "4ad1ef5c67e9943d21ee8c13325ca5705546ae28", + "updated_at": "2026-10-11T10:31:07Z", + "body_sha256": "aa88673cbdea773b016b50c730621d8b1919857a84e9c8eee2ffa62b807ccfe6", + "matched_searches": [] + }, + { + "number": 416, + "title": "κ = 1.017798035290733e-3: propagated frames admit 214 entrance gauges", + "head": "c76d101df11ad4152c52fd9d68344c064e453d3a", + "updated_at": "2026-10-11T10:24:33Z", + "body_sha256": "61a2b14ba850b0caa34757dc23c1b3f7f0b8e6016a7c6f2ae658c5ddf2bfe3a1", + "matched_searches": [ + 0 + ] + }, + { + "number": 417, + "title": "E8 bit supplier c ≈ 1.044064·10⁻³ in the nine-stage word (+2.2 % bit cap; no new κ, complex-bound)", + "head": "3f681fb571036ca4a267570318260b0d083f7b9d", + "updated_at": "2026-10-11T11:43:12Z", + "body_sha256": "b9331b018b7c574bc5877dce24e696fde8be6c8197bedcd0c5ab5736dcfa898d", + "matched_searches": [] + }, + { + "number": 418, + "title": "Candidate conditional kappa 0.001017923290728024: propagated entrance frames", + "head": "ff8737920a4bb1a910eb069a5f86db6efdefa589", + "updated_at": "2026-10-11T10:45:10Z", + "body_sha256": "3d5b72ce6e2a030e1676d926d1fb8942da6a82d28cb7a2b1125259fb1c6b22ce", + "matched_searches": [ + 0 + ] + }, + { + "number": 419, + "title": "Conditional κ = 1.017962405296845·10⁻³: checker-clean grouped and frame-closure entrance promotions with a target-124 helper prefix on our #412 word (+3.9·10⁻⁸ over #418; #414–#416 fail gx E4/gxcore E5)", + "head": "70a276cb948e5be6071cde3f1bebdaf2f995ab8e", + "updated_at": "2026-10-11T11:59:38Z", + "body_sha256": "87d804f852c33b365934e546a426093bb1296871d592e8938902e672cc0c090a", + "matched_searches": [] + }, + { + "number": 420, + "title": "κ = 1.017812636706245e-3: one further chronological closure with exact target prefixes", + "head": "079d514cdb40b2152ffa743853556b0117b98438", + "updated_at": "2026-10-11T10:40:46Z", + "body_sha256": "7980f0a009c4ccd34e93192d5386c4bd1c0a5da4d0dd2cf9c1fa7cdb9d3a09c0", + "matched_searches": [] + }, + { + "number": 421, + "title": "κ = 1.017889833900852e-3: two full rank-two entrances with complete prefix replay", + "head": "6dfe3f978e2fcf3701523bda73744d56a1f8ac6f", + "updated_at": "2026-10-11T10:51:15Z", + "body_sha256": "bad6f0739c9b3c55bf3726b074cff432146dce448d8ee53ce54cd75d1952039b", + "matched_searches": [ + 0 + ] + }, + { + "number": 422, + "title": "Candidate conditional kappa 0.001018475695250068: grouped entrance capacity and shared-frame enlargement", + "head": "dc7a552857c04f936daad0dc8e8b0164e5797f1a", + "updated_at": "2026-10-11T11:55:14Z", + "body_sha256": "1c927af662da62eb152109c44b3190d9803244fd72664b734f2b7e771a24336a", + "matched_searches": [ + 0 + ] + }, + { + "number": 423, + "title": "κ = 1.018335129864748e-3: fourteen entrance enlargements with shared frame costs", + "head": "997613cb3064b4096b996409a671e558251d55f8", + "updated_at": "2026-10-11T10:56:01Z", + "body_sha256": "ec56788f58cde27e1129571128915a2c186337e60e176b408c6c65f81b638f6c", + "matched_searches": [ + 0 + ] + }, + { + "number": 424, + "title": "Conditional κ = 1.018509848057013·10⁻³: checker-clean entrance enlargements, closure and rank-two gauges with a target-125 helper prefix on our #419 word (+1.75·10⁻⁷ over #423)", + "head": "92c6ea78f5cf726dc7621854d53140512ba1c46a", + "updated_at": "2026-10-11T12:23:54Z", + "body_sha256": "50cb716cd86fa408398a97cfac895504dededd842069ecec3eec3cd1841cb16c", + "matched_searches": [ + 0 + ] + }, + { + "number": 425, + "title": "κ = 1.048005508028206e-3: mutable-basis Hamming packets (≈2^-9.89814; conditional; complex +4.97%)", + "head": "e11ccea1d092beb1b01b4ee4ce49da478234254c", + "updated_at": "2026-10-11T13:23:19Z", + "body_sha256": "1a5148ff0448c5b3e04dd4fe7f9b7223aa1cfdad2554933dfa39e742c765c49e", + "matched_searches": [] + }, + { + "number": 426, + "title": "Conditional kappa 0.001018766833114736: checker-clean chronological gauges and R767 reuse", + "head": "88d552526893cd15325948bb1487e9a4d4bf32f6", + "updated_at": "2026-10-11T12:25:07Z", + "body_sha256": "bf21e8b05c5801d399a0de258e7cb4e0701b87e85099bfa42be6a8d1068fbfb8", + "matched_searches": [] + }, + { + "number": 427, + "title": "κ = 1.018364819189613e-3: two joint gate-frame blocks with complete replay", + "head": "360d1b182a5f098619d435339d060d9b0cd9f469", + "updated_at": "2026-10-11T11:17:29Z", + "body_sha256": "6391f2aa5c36271140331fed961aee45701414ffff26bcb042633a91c319bb20", + "matched_searches": [] + }, + { + "number": 428, + "title": "κ = 1.018419742888184e-3: combined exact gate-frame retimings", + "head": "700e057c910245e8a5ad2249d23831c9e45504b3", + "updated_at": "2026-10-11T11:22:11Z", + "body_sha256": "abb4615abc37f3376d7c5bb478c324254cfe0dc4f19baace071f33836376081c", + "matched_searches": [] + }, + { + "number": 429, + "title": "Candidate conditional kappa 0.001019646575559504: R779 gauged helper inlining", + "head": "b25cbe3350e32efb211508c1dd41a134770fba16", + "updated_at": "2026-10-11T11:52:18Z", + "body_sha256": "7ec49da114b6e4b6c8d3dce07c5835b20257f8120c237ffe104cbdc4fd5b160d", + "matched_searches": [] + }, + { + "number": 430, + "title": "Independently audit B3 composition and PR390 helper interfaces", + "head": "06c806849952efb9f9b90c2dc80477725a216fce", + "updated_at": "2026-10-11T11:35:09Z", + "body_sha256": "b9679d84eb175ca48ef1892b5300e7d1ab4543e9e7cafcf233beb65b6e3bfa8b", + "matched_searches": [] + }, + { + "number": 431, + "title": "Candidate conditional kappa 0.001056975315151441: Hamming complex and retimed bit composition", + "head": "71c5988803b1fc66fc9e8c2bc50949033be06e37", + "updated_at": "2026-10-11T13:23:16Z", + "body_sha256": "a2d96e8a99d8780a70abb516aa4c3618ec9d15fd335f3bbecc682b860ba472c1", + "matched_searches": [] + }, + { + "number": 432, + "title": "Best gx/gxcore-clean κ = 1.019752143318808·10⁻³: our #424 layers, 14 gate-frame retimings and a target-172 prefix on #426's R779 word (+9.85·10⁻⁷ over #426)", + "head": "642b702149b975e3a535f139243cd3afd286e868", + "updated_at": "2026-10-11T12:24:12Z", + "body_sha256": "ce8737751f568527dc73acedbc1b5ac0ec83aebf6760834603a9ee6e1af30922", + "matched_searches": [] + }, + { + "number": 433, + "title": "Split centres and source-basis reuse for conditional κ = 0.001120864952258278", + "head": "6d9244518175caf9e0089f92486959bc2c317273", + "updated_at": "2026-10-11T13:23:14Z", + "body_sha256": "a00f0c13d37c3b0873d5711e2d9c3605e7c671d714d0aabb4ebd64d662af03b8", + "matched_searches": [] + }, + { + "number": 434, + "title": "Conditional kappa 0.001249035299298004: hosting-selected rank147 kernel", + "head": "6c0c0522665dda10201673c17fbb589f737d226c", + "updated_at": "2026-10-11T14:12:58Z", + "body_sha256": "5d7acc206041922dec3b80108bcc2410bf2d1c9eb9ba8f463805f948e75567b0", + "matched_searches": [] + }, + { + "number": 435, + "title": "κ = 0.001128832830332521: #417's shared-donor kernel on #433's R758 bit word (+0.71%)", + "head": "2c9c833ac8709402c37fc88a6a23393fb0d397fb", + "updated_at": "2026-10-11T12:21:29Z", + "body_sha256": "a5b721a243e17dcdab4f6ada0c6880777f78c6b175285c9d4769b867af085f0f", + "matched_searches": [ + 2 + ] + }, + { + "number": 436, + "title": "Conditional κ = 1.128983115440183e-3: an E8 bit word with 740 helpers under #433's complex supplier", + "head": "8f6b8297b08ad863940d5168a2db5402fad3690f", + "updated_at": "2026-10-11T14:11:28Z", + "body_sha256": "8ae2313e46be625150ca35c02aa0d812942ba318a46a78409566f34c62025b09", + "matched_searches": [] + }, + { + "number": 437, + "title": "κ = 1.128922474816875e-3: twelve early-final-use bit-helper resets", + "head": "ba6c10ba78e788764cfaa250d6a250d278580482", + "updated_at": "2026-10-11T13:24:46Z", + "body_sha256": "d02fb2865aed5f23160031fecbfe6f1754d4d1ee186211b2eb92e6e1f820e470", + "matched_searches": [] + }, + { + "number": 438, + "title": "κ = 0.001133508328719775: early resets + kernel re-derived on the R747 bit word (+0.41% over #435)", + "head": "e3b56de7869f6af88d48ac0ab1d7959c4c9e6176", + "updated_at": "2026-10-11T12:36:25Z", + "body_sha256": "5a0de50f8c6cde2aa2ec86b1bac42e31c7d7613ee72841fdc2224d7ebfe9f1e5", + "matched_searches": [] + }, + { + "number": 439, + "title": "Conditional κ = 0.001133928043872860: R740 shared-donor kernel with explicit residual bank routes", + "head": "fa3a588ec1e383083abb8de9c51904fb9d689ad4", + "updated_at": "2026-10-11T14:47:32Z", + "body_sha256": "4f1cf98ddf5862966b2a0e0c25961ebd67405ee011a926bbc2ff22eb77078a6d", + "matched_searches": [ + 2 + ] + }, + { + "number": 440, + "title": "κ = 1.136403735815528e-3: R740 shared-donor kernel with 57 primitive frame changes", + "head": "bd03373b6d4d4e380d0b6ea7d55cd2ac8f163544", + "updated_at": "2026-10-11T13:04:16Z", + "body_sha256": "0a70c74f48644d9b35dec158e5e2c4651f505a3009ad556a254c3e6568a1acd2", + "matched_searches": [] + }, + { + "number": 441, + "title": "κ = 1.138798055343319e-3: R740 block retiming after shared-donor kernel", + "head": "6160c13526f5f957902910b462164c93c1d8f39a", + "updated_at": "2026-10-11T13:17:26Z", + "body_sha256": "b47f2df21c47831552a38ca19fdcf6e781af72c639606dbf95b297590585f097", + "matched_searches": [ + 1 + ] + }, + { + "number": 443, + "title": "Conditional κ = 0.001138823042306561: retain rank138 with complete 32-replica banks", + "head": "5a514e94f156edcc5fd827b87494d962f79d0f6c", + "updated_at": "2026-10-11T15:28:13Z", + "body_sha256": "06e829b96f0ef147025bad1777aa5d6cdcd306935f7f562d5a91e8628f5ecf49", + "matched_searches": [] + }, + { + "number": 444, + "title": "Conditional κ = 0.001246073505487942: R740 replicated kernel with idle-data hosting", + "head": "8c4242ea61c67827fe62b07b2edc093d7ddfa631", + "updated_at": "2026-10-11T15:41:40Z", + "body_sha256": "93911fa632583ae4461f95cb71df0aa52d8eca6bf470d0a14b4c782eaec0614f", + "matched_searches": [] + }, + { + "number": 445, + "title": "Conditional κ = 0.001263365464781156: eleven-stage R740 hosting with complete row bound", + "head": "40ab91daf2b5e87fc4071dedae1699d5d7e7cecc", + "updated_at": "2026-10-11T15:58:55Z", + "body_sha256": "7b7869a31ce77e8d071b9d2b2916b0d1bbc3a4d81698a0723ff3f84de78b71bf", + "matched_searches": [] + }, + { + "number": 446, + "title": "Format obstructions (no new κ): exact bounds on window width, copy cost and label dimension", + "head": "309482849b6ddf34db998f53612d34c19f6e3233", + "updated_at": "2026-10-11T15:55:07Z", + "body_sha256": "15cf239d321010469bd2e6a980cd6d8d67998cdf6aa0f73f68b65285d3f27300", + "matched_searches": [] + }, + { + "number": 447, + "title": "Conditional κ = 0.001265848755025709: rank147 kernel with eleven-stage hosting", + "head": "d3cf3079091bb7e93a23e9cd98e82ccb89697328", + "updated_at": "2026-10-11T14:44:15Z", + "body_sha256": "5066ec2627df496420eededb4a5a7ce8513c494e7a395314506da94a54365c19", + "matched_searches": [] + }, + { + "number": 448, + "title": "Under review (split-residual interface): cross-copy idle-axis hosting, one residual on two copies of one idle child; computed κ = 0.001330733966732373 not established", + "head": "359022bcd71143e45d48def0dd005bf67f339aa7", + "updated_at": "2026-10-11T21:15:56Z", + "body_sha256": "fac59cab0bda24626b1d8d0aa266b0e66ce37e6c8337eeaf81a917d71436b220", + "matched_searches": [ + 2 + ] + }, + { + "number": 450, + "title": "Conditional κ = 0.001347744547714835: eleven-stage cross-copy hosting with target mixing (+1.278% over #448)", + "head": "350943275564c53b209c1277aac7d691807726be", + "updated_at": "2026-10-11T17:45:50Z", + "body_sha256": "7c8620d115b53423ff67234e6cd942e7348008091ecf726af7fab460f57fcd63", + "matched_searches": [] + }, + { + "number": 451, + "title": "Conditional κ = 0.001265931727546219: dual eleven-stage whole-residual hosting", + "head": "f3a38153678b55063fc005901cc968266166507d", + "updated_at": "2026-10-11T16:50:58Z", + "body_sha256": "898f86ecd1c8ccd6d101365976120cdfae3f50409dd71b96f86cb8c640f39650", + "matched_searches": [] + }, + { + "number": 452, + "title": "Speed up pinned E8 replay with shared prefixes and exact admission", + "head": "8a8079ec31abac7ccc4a0eae89df83b309fafbe1", + "updated_at": "2026-10-11T15:11:54Z", + "body_sha256": "ed3d3bc085ea434babcccb9278c4270954f5902d9fe5748767db22ceb34a8f5c", + "matched_searches": [] + }, + { + "number": 453, + "title": "Under review: rank137 cross-copy candidate; inherited operator obstruction", + "head": "cff79050526545e7b66d24a7f4c65f22c1da8618", + "updated_at": "2026-10-11T15:59:15Z", + "body_sha256": "bc9e93ec97d69b92413968422c1d6a1ea0906401abdd591f20fbf7224f06c573", + "matched_searches": [] + }, + { + "number": 454, + "title": "Conditional κ = 0.001266536148630310: target mixing with whole-residual hosting", + "head": "d14eb0dd425bd681e3b43f208d089e679d600176", + "updated_at": "2026-10-11T17:33:36Z", + "body_sha256": "469b78a3c6b647b3db77be09f0cb0635dbf60cbe8de7b63fe099d52b62c77c57", + "matched_searches": [] + }, + { + "number": 455, + "title": "research: whole-residual replica pooling and program portfolios, conditional kappa = 0.001266541949425315", + "head": "f76fc4e36030d4e00b4cbb83b1dbc661a0974c4e", + "updated_at": "2026-10-11T16:11:46Z", + "body_sha256": "c0697b0e7f16bec53c7c7f1e094a1e43b996851a9cd1b41256c5c83c9f6fdf5a", + "matched_searches": [] + }, + { + "number": 456, + "title": "Conditional κ = 0.001266564732900111: seven-replica whole-residual hosting", + "head": "fb010029442f39315333d56c1427df4eabe2960e", + "updated_at": "2026-10-11T16:26:10Z", + "body_sha256": "3e068359835dfe48ff2b7559240af86e1721aaf4fb2f9f351b6697edda3d3efa", + "matched_searches": [ + 0 + ] + }, + { + "number": 457, + "title": "Conditional κ = 0.001266309796182835: rank151 bit kernel on #451's dual eleven-stage hosting (+0.0299%)", + "head": "3e89db7725785f8e8e172d04d1d4804f57db72f3", + "updated_at": "2026-10-11T16:49:06Z", + "body_sha256": "9335fd3218687ad0f8df6eb4d3e63729846696d59db08f2b3f3cfe1179a45086", + "matched_searches": [] + }, + { + "number": 458, + "title": "Conditional κ = 0.001274032589159993: complex kernel with paid residual adapters", + "head": "44e9eae8287951c1e6dbbd3c553f5743fe2240b0", + "updated_at": "2026-10-11T19:46:04Z", + "body_sha256": "21aaa0278c121b157361ac8783c11723378f4c80b514196a19d52555338942a8", + "matched_searches": [] + }, + { + "number": 459, + "title": "Conditional κ = 0.001266536148630309: rank151 kernel + target-prefix mixing on #451, complex-bound (+0.0477%)", + "head": "e037bc50c3d5efc1bec0d258a9f274f79ba45ec7", + "updated_at": "2026-10-11T17:03:10Z", + "body_sha256": "5e9643c566e62c2feba3bad6ea99a7d8580641349731afa6bdf3564bd9a0f007", + "matched_searches": [] + }, + { + "number": 460, + "title": "Conditional κ = 0.001274415506145115: paid complex kernel + rank151 target mixing", + "head": "b98bbb4bc398ad67a41f123c6c301628c37e1d6b", + "updated_at": "2026-10-11T17:32:26Z", + "body_sha256": "46f2ed9bf19e81ce4f12210058cb2093e18e14a6ee68c4857a6f205f99ce97ad", + "matched_searches": [] + }, + { + "number": 461, + "title": "Conditional kappa = 0.001274032592088050: sharper bit bad-class charge on #458", + "head": "dc297912ad446779f983818816617c03dfc76e16", + "updated_at": "2026-10-11T16:50:06Z", + "body_sha256": "0b75dfcb7a26a24a905905972d21ae9d08f31c0912095ac53282d2647d667477", + "matched_searches": [] + }, + { + "number": 462, + "title": "Conditional κ = 0.001274494971185576: four-replica whole bit hosting", + "head": "a63b25e65578816d78843c0e25131d9be7567cd2", + "updated_at": "2026-10-11T17:26:20Z", + "body_sha256": "5a04efc35587427a9424f9a505ca44f2ebbadb69cc4df0ebe3c228d743df3c19", + "matched_searches": [] + }, + { + "number": 463, + "title": "Conditional κ = 0.001283479303751122: E8 bit word R715 (carrier lower bound + F2 overlap cancellation) with #458's complex supplier (+0.711% over #460)", + "head": "cdf0c1c6540df987467988fd771340670f4136f3", + "updated_at": "2026-10-11T17:34:40Z", + "body_sha256": "72ca67b66a92fdae4a28ae90866db55465e49bca5d420750c3c586313cd31fc8", + "matched_searches": [] + }, + { + "number": 464, + "title": "Conditional κ = 0.001347744550711765: sharper bit bad-class charge on #450's word", + "head": "8c546e9918ae37d842916d89ffe28f2c08cdb3d3", + "updated_at": "2026-10-11T17:45:22Z", + "body_sha256": "e5e32f85c8a331666ccb2123bd98d4aee8bf48b0bbd974812647b741ae5d3c03", + "matched_searches": [] + }, + { + "number": 465, + "title": "Conditional kappa = 0.001283479306671789: certified R715 assembly with sharp bit charge", + "head": "22c2a15c232084a31b6c8f0263e2e8ce831047ea", + "updated_at": "2026-10-11T17:08:50Z", + "body_sha256": "71fdd44f01178a5916fc6a024192121dda88dbe230ebe899d4daef49d4ba5a74", + "matched_searches": [] + }, + { + "number": 466, + "title": "Conditional κ = 0.001274415506145115: complex response kernel + rank151/mixed bit word on #451 (+0.670%)", + "head": "c2f8e18b1b3e39abb5d2f63b9ee4582c96cd75de", + "updated_at": "2026-10-11T20:18:17Z", + "body_sha256": "8515e94976d617a3ad9f78d209d9924aa790701fcedb83863bddff98a4fc2c18", + "matched_searches": [ + 2 + ] + }, + { + "number": 467, + "title": "Conditional κ = 0.001289283116193775: R715 shared kernel, retiming and whole pooling", + "head": "e28109cd3fe2f2853449e4c49a55887790e16ba2", + "updated_at": "2026-10-11T17:39:33Z", + "body_sha256": "bf27b2cbc4aa7a166d25327fd2ef34000735fc697e005cb6d79305e552331fe8", + "matched_searches": [] + }, + { + "number": 469, + "title": "Conditional κ = 0.001350580884553120: gate-frame retiming of #450's eleven-stage cross-copy word (+0.2105%)", + "head": "66d5090c3c46a24b6c0c25ce86451d749788b4de", + "updated_at": "2026-10-13T05:12:44Z", + "body_sha256": "0f505e091f1d87388ec61d783babf13d62c525cebfbd0fba43115260170c4006", + "matched_searches": [] + }, + { + "number": 470, + "title": "Conditional κ = 0.001291474845253222: retimed kernel and reordered R715 deliveries", + "head": "aaf3ef64672cb96d2f0cfe36410640ee59c07c9f", + "updated_at": "2026-10-11T18:07:43Z", + "body_sha256": "f4f05da54d3b1a3ded921acfdf99e9f01905cd2c5bb8abaae8aa7abe3c2ae182", + "matched_searches": [] + }, + { + "number": 471, + "title": "Conditional kappa = 0.001274548075945587: full-nine-axis kernel normalization and same-owner spectator borrowing", + "head": "56b3da6aa1295d37ce43f1753479bfe4737b7ac3", + "updated_at": "2026-10-11T17:43:32Z", + "body_sha256": "591a8fa265d5cd4415d0b8a87f199182542e952cd757b3175089dc7f79ecc77c", + "matched_searches": [] + }, + { + "number": 472, + "title": "Conditional κ = 0.001292099559442278: R715 shared kernel, target mixing and whole hosting", + "head": "259c68488b7aa8a14cf3fcae7fc499381c9bf729", + "updated_at": "2026-10-11T22:12:30Z", + "body_sha256": "d242ba370c7bdf99ec4492e2582b0bd3661ecdd56dd7c9009d743c63587aa931", + "matched_searches": [] + }, + { + "number": 473, + "title": "Conditional kappa 0.001467289440740487: rank-sector factory on 112 ports", + "head": "c26b3cc74d0203948f973a41d38340116c79dab8", + "updated_at": "2026-10-12T00:54:12Z", + "body_sha256": "492579ea23087f2d3e29b8f1a3ba25901576048f8868735eaf5e83e35bc361f6", + "matched_searches": [] + }, + { + "number": 474, + "title": "Bind the selected gen4 certificate to fresh replay outputs", + "head": "6563bc97e4c0f86d4ff9b11476ae925a6be7ff7f", + "updated_at": "2026-10-11T18:04:47Z", + "body_sha256": "48aabbd05f492b915a8bad59e3b86a265f4a9d649955507a8cd4d117b277f9c2", + "matched_searches": [] + }, + { + "number": 475, + "title": "Remove compact FFT reservation and top-bit costs with complementary reservoirs", + "head": "5996e33ecad6a0ccd578aec58831457829d75575", + "updated_at": "2026-10-11T23:50:07Z", + "body_sha256": "c7cf4f0277c640f38cf26dcb9fc18db36e59a04c1ad232c683c81c447c42ca6e", + "matched_searches": [] + }, + { + "number": 476, + "title": "Conditional kappa = 0.001291542455423938: two-layer target factoring on R715 (+0.1461% over #470)", + "head": "e850569c33ad1d5771e2f8b1c6dfe7a445396167", + "updated_at": "2026-10-11T18:14:32Z", + "body_sha256": "f68ace374d50d201b68531199ef3f06b1f27da758dde041e730a6d7b79a2c860", + "matched_searches": [] + }, + { + "number": 478, + "title": "Conditional kappa = 0.001295508560071773: fourteen target factors on PR473 (+0.1226%)", + "head": "bea1d52fd330c699903f81612ee58be81697d1eb", + "updated_at": "2026-10-11T18:31:32Z", + "body_sha256": "2b89a4b2bc37b5460994aff386a8f4e9ede0cf322d9b771839b8a566576c1ff6", + "matched_searches": [] + }, + { + "number": 479, + "title": "Remove the chirp-generation dimension factor with exact streamed phases", + "head": "40dd01058439cdffae3e3b41c4fe52edaccf5f91", + "updated_at": "2026-10-12T01:36:44Z", + "body_sha256": "1a4fbec9ef32a4e5f9ed3fdd85694a181fa1d889ced9bad73a96147d0a1badf7", + "matched_searches": [] + }, + { + "number": 480, + "title": "Under review (split-residual interface): cross-copy hosting on #472's R715 eleven-stage word; computed κ = 0.001372550159367980 not established", + "head": "668c7dd0fa76d0da4289c9dea63b965e730142d0", + "updated_at": "2026-10-11T21:15:57Z", + "body_sha256": "e5e5b2747eedf07db012088c0e4d9ae0a579c12c52cb48df45860052b9deb99a", + "matched_searches": [] + }, + { + "number": 481, + "title": "Batch Gaussian boundary right-hand sides to reduce their cost", + "head": "5f3db6a11198bab07d8effe8f0c9f5df9c3f2eb7", + "updated_at": "2026-10-12T06:02:03Z", + "body_sha256": "93239bd43ca472ef4a273e0e1bf3960598df816427306be9fa07e406d2a28c38", + "matched_searches": [] + }, + { + "number": 482, + "title": "Conditional κ = 0.001168862033074029: R715 target factors in non-hosting banks", + "head": "ab81e78de235ed11d4279ee89b0824650c372e17", + "updated_at": "2026-10-11T19:18:57Z", + "body_sha256": "c2fe18cb1a1d5961e725f0cc0189909cfd7dba9ff1447635cdca38b53c150c8e", + "matched_searches": [] + }, + { + "number": 483, + "title": "Conditional kappa = 0.001296606691405309: response-kernel cancellation and nested-donor flags on R715", + "head": "3738c3ce2d04d6a6c6363408ff9402286f592bc7", + "updated_at": "2026-10-11T19:33:13Z", + "body_sha256": "e6b4297aac011ebb52046de1791bdf088aae17874b584e01245f7ad4a81ecb8b", + "matched_searches": [] + }, + { + "number": 485, + "title": "Method + bounds (no frontier claim): kernel width rule, EXACT pivot maximum 112 and a seeded 112-pivot selection on the R715 word", + "head": "af51ea7ad6570f04c8424be7cc6f4070bfd1e6ff", + "updated_at": "2026-10-11T21:49:41Z", + "body_sha256": "f8da7eec28bd84d0abaacf729257e74cf704ab2a45a136223d4635eb5597786a", + "matched_searches": [] + }, + { + "number": 486, + "title": "Build binary compression halo boxes with fused streaming and sparse repair", + "head": "f14e5881b7681641fade599b5389995843088e20", + "updated_at": "2026-10-12T09:53:36Z", + "body_sha256": "01343af1ecc03dd4a8c095d92e5f89ebdff693d5b1f187cbe0811254d4bdf6aa", + "matched_searches": [] + }, + { + "number": 487, + "title": "[Lean] Verification of selected 1320-port bijection, κ=0.000661885549259598", + "head": "a9d9fd5196311a0ecf91a6b021879f2bacc0ee68", + "updated_at": "2026-10-12T01:59:03Z", + "body_sha256": "4979e263afd8d970735f177b62d21f4cbc709acfcf3cbcff90d49e7b686a0d46", + "matched_searches": [] + }, + { + "number": 488, + "title": "[Lean] Verification of binary input preparation, κ=0.000661885549259598", + "head": "34eb901441affffaba76b00920f2f9cb05777117", + "updated_at": "2026-10-12T02:00:00Z", + "body_sha256": "9db889c6f360a2e50b04f3cbef3aca29401413818964b81a628a76b6a3c4c0f8", + "matched_searches": [] + }, + { + "number": 489, + "title": "Replace local Gaussian inverse branches with two convolutions", + "head": "8922e3b3f0fd7772b0fb42028eb2532984c3ab42", + "updated_at": "2026-10-12T12:28:35Z", + "body_sha256": "79256133e52ca5f1dd97ca6d07b4f58ad074dd1a1c70b8fe5beed7ff03cf7cb6", + "matched_searches": [] + }, + { + "number": 490, + "title": "Conditional κ = 0.001295625678120464: whole-owner GL cover with sharp fallback", + "head": "63e9d2c22a02fdf40df824ba95d21cd2d6f01db7", + "updated_at": "2026-10-11T19:58:25Z", + "body_sha256": "5af5fa188d8b4c3d71b8db3b8243ccaf685eb2fd1b7630260f6e11c7c1ef15bd", + "matched_searches": [] + }, + { + "number": 491, + "title": "R715 count-only fallback correction: conditional κ = 0.001296611983223706", + "head": "996f67f7c21b8e56b4a2b0174c419ce48c480414", + "updated_at": "2026-10-11T20:56:33Z", + "body_sha256": "0675b29ff388db3a44408e3e36ab7bbf9d8074f89e02001d12d8194b3c6ef1fb", + "matched_searches": [] + }, + { + "number": 492, + "title": "Conditional kappa = 0.001297375468897877: response retiming and stage-conditioned donor flags (+0.05929% over #483)", + "head": "0c9eb6f80cef2e5797e5b7af940f447c0bdf25ad", + "updated_at": "2026-10-11T20:07:32Z", + "body_sha256": "6fb8b01830ac76914b7cae821bdfcea0d734b7dfc3de052ef15d86737e091e5e", + "matched_searches": [ + 1 + ] + }, + { + "number": 494, + "title": "Under review (split-residual interface): #493's R489 bit word with #448's cross-copy complex supplier; computed κ = 0.001435468764627892 not established", + "head": "419907c71246c050f1c3fd2a504469b74bf7798e", + "updated_at": "2026-10-11T21:15:59Z", + "body_sha256": "82b14b84bf34d08c205e737bfb60dc4ec2c5bad1ddb367405807ad3ad4706174", + "matched_searches": [] + }, + { + "number": 495, + "title": "Add combined E8 witness at κ = 0.001307044366925301", + "head": "355d9f7ff293e291676ff4a32eed434419692576", + "updated_at": "2026-10-11T20:44:01Z", + "body_sha256": "36e6db5e5f1928fb64a27fb65ac901beecd68d7a1b9fe24b99bdadc35ad88569", + "matched_searches": [] + }, + { + "number": 496, + "title": "Conditional κ = 0.001332077359286333: pooled whole-owner complex supply", + "head": "00cf70efd6a8637531deafef698157ca83e249ee", + "updated_at": "2026-10-11T20:57:04Z", + "body_sha256": "6e1c71346ee60917235202dd092331c140e219cab1e5863c73bafb19bd1f01a5", + "matched_searches": [] + }, + { + "number": 497, + "title": "Conditional κ = 0.001325117552367841: moment-directed complex hosting", + "head": "b1972da7c6d11eb9745273d81bbba3fe9e565e88", + "updated_at": "2026-10-11T21:00:36Z", + "body_sha256": "b8466ce0f9018e4472442a3048fb399427e17e6f04ca06934be11b11f04a0f87", + "matched_searches": [] + }, + { + "number": 498, + "title": "Conditional kappa = 0.001301970637653655: geometric intersections and rational paired whole-owner hosting", + "head": "44a703782a69a897350572b5b078d5292fdbf92d", + "updated_at": "2026-10-11T21:26:02Z", + "body_sha256": "f2efdc8ec0dfa598b7028de0ccebf91176b57cbcc52981d6674c0b1cedc884fd", + "matched_searches": [] + }, + { + "number": 499, + "title": "Retimed complex word (#495) on cross-copy hosting with #493's bit word: conditional κ 1.452948511251494e-3 (stacked on #494)", + "head": "0f3e55dbf6b29a28bf462b4b3ec2a3ef06a28f5d", + "updated_at": "2026-10-11T22:00:08Z", + "body_sha256": "16260084181606e41718bf052f066a276ebad3a9643f6fe89b3395bc0f47eeda", + "matched_searches": [ + 2 + ] + }, + { + "number": 500, + "title": "Conditional κ = 0.001308501945841842: kernel79 complex supplier under #471's footprint rule at nine stages, with #493's bit word (+0.38%)", + "head": "0362f1a6c5ee953b96b9f9a5aace1af07d898226", + "updated_at": "2026-10-11T21:35:47Z", + "body_sha256": "ba1efb5ccec8cde0d11c2515ca8762254a2f7982ab6bfad08cd63eacce42d67d", + "matched_searches": [] + }, + { + "number": 501, + "title": "Conditional κ = 0.001343518018117309: retimed pooled whole-owner complex supply", + "head": "1dc056496fdbbc74073ed26d948a2dc235dbf356", + "updated_at": "2026-10-11T21:40:05Z", + "body_sha256": "ca07eff228e5bafe168ce59046d50c820e96ea41eb19c622a13396720fb21417", + "matched_searches": [] + }, + { + "number": 502, + "title": "Conditional κ = 0.001343518018117309: retimed gauge word with pooled whole owners", + "head": "4d30b8322184598e65e90a92389e17e1baedd9eb", + "updated_at": "2026-10-11T21:42:38Z", + "body_sha256": "5043b46a186c7d2d95a227be287e84169b0649db596f4717bb7cf7dab5c55a61", + "matched_searches": [] + }, + { + "number": 504, + "title": "Method + knowledge (no frontier claim): read-then-climb bit word R687 (c ≈ 1.315433·10⁻³), a copy lower bound, exact pivot certificates", + "head": "35057a6d70f23480f4e960327d41ecac31ad5cb0", + "updated_at": "2026-10-11T22:32:56Z", + "body_sha256": "cb9cd07d7cd26d213584fbfed1783c8e56c788401c816ed66b4a0abb5937a45a", + "matched_searches": [] + }, + { + "number": 505, + "title": "Asynchronous whole-owner replicas: kappa 0.001357701757628940 (+1.9236% over #496)", + "head": "4ee769c8e28837482272b5f4742497da8e2fc9d4", + "updated_at": "2026-10-11T22:05:40Z", + "body_sha256": "0aa4d889d3f366b84aed411601bfa4d3254b26dd13ab38fe5d5af319b5c210b0", + "matched_searches": [] + }, + { + "number": 506, + "title": "Conditional κ = 0.001369588870945540: retimed word with asynchronous whole owners", + "head": "a4948baee6c7ea35323db74ff636620c6af2925a", + "updated_at": "2026-10-11T22:33:13Z", + "body_sha256": "10dc7153c6c432826c630f437fa8bf4343b13f511d3ca68ac546f5573b0056c6", + "matched_searches": [] + }, + { + "number": 507, + "title": "κ = 0.001363614743745701: partial-own factory with 84 kernel pivots", + "head": "8d4444cf8a16d500cbb94add6e4fa8bcfb9c7d5e", + "updated_at": "2026-10-11T22:33:18Z", + "body_sha256": "ed76f21fbf2e789639a763a3e320e74d1d23aa4badfac1fbbeda6e24e9d14772", + "matched_searches": [] + }, + { + "number": 508, + "title": "Conditional kappa 0.001372554837726243: coordinated gauge collapse with retimed asynchronous whole owners", + "head": "3213fc136270ca8372ce9f8fbb828e78ba96cecf", + "updated_at": "2026-10-11T22:39:31Z", + "body_sha256": "f857040d8e84add70a001eaac08906633a2f032dba20aab2684a92f72419205d", + "matched_searches": [] + }, + { + "number": 511, + "title": "[Lean] Add checked binary count dispatcher", + "head": "1ece74dc70a421cfd4e23e8b59ab9e3645872950", + "updated_at": "2026-10-12T02:00:59Z", + "body_sha256": "549ba68517a4cd4a224b8e276247f8fe8b4a401ad78351c958becd0b4c8dc271", + "matched_searches": [] + }, + { + "number": 512, + "title": "Conditional κ = 0.001388049083313897: fresh partial-own asynchronous whole-owner certificate", + "head": "73d367fe754cf5921cd954221133b20ac752f932", + "updated_at": "2026-10-11T23:05:48Z", + "body_sha256": "55fc9690383deea069ea30a3632170c075c66e7e0cfaa91215bd4be188fbc0a7", + "matched_searches": [] + }, + { + "number": 515, + "title": "Bit word R685 (R687 lineage): L-copy inline + Bcw copy deletions, c = 1.323554·10⁻³ (+0.62% over #504's R687)", + "head": "6590606e733768f6a7004b3f55ae35f988ba515f", + "updated_at": "2026-10-11T23:35:02Z", + "body_sha256": "669a09938a1049055cb2dde58428a5f95c0d5bb98425ec7175d9cc513058b508", + "matched_searches": [] + }, + { + "number": 517, + "title": "Coordinated kernel84: fresh two-platform witness and exact packing ceiling", + "head": "65518fcff5a7bd490365273ae5469a82aac14853", + "updated_at": "2026-10-11T23:44:12Z", + "body_sha256": "1f540a0ef987bef677d56e3cf1e2edd3518ffa4c16d8c156f7ae658404c547d9", + "matched_searches": [] + }, + { + "number": 518, + "title": "Conditional kappa 0.001393662920776407: blockwise pair exposure, 99 pivots and whole-owner allocation", + "head": "e0a071dce251eeca96d446f73147048cfebbd5c7", + "updated_at": "2026-10-11T23:50:50Z", + "body_sha256": "a7bc2db007ef213a4171f5bbe07bec91b57f74aa79a028746cd8f85627d064a7", + "matched_searches": [] + }, + { + "number": 519, + "title": "[Lean] Add automatic-width binary counting", + "head": "080c0a17307919a568cf5b919101c9b6f5c42bcd", + "updated_at": "2026-10-12T02:00:20Z", + "body_sha256": "a18e76f79e00e9c27e4b93c9586b0d939d303cc109adc5bba774a1b9bce860ed", + "matched_searches": [] + }, + { + "number": 521, + "title": "Native BIT ADDRESS fusion: two recursive queries to one", + "head": "a190fdb39f31647fc6f651625353710624627348", + "updated_at": "2026-10-12T00:19:55Z", + "body_sha256": "839d4e565a74275fcd68cfbbd3db17b0d4813db0f986ba3111ae09a374687e9d", + "matched_searches": [] + }, + { + "number": 522, + "title": "Conditional kappa 0.001402213284556683: rank-factor coordinate totals merge 56 recursive pairs", + "head": "e9f8075b5212e9bddf361097dbb022dcd052e0bb", + "updated_at": "2026-10-12T00:25:04Z", + "body_sha256": "1c6ed55272a4a8c4fbd864e64b9f4353736d8c114957b4a13dde3bbca6ddce9a", + "matched_searches": [] + }, + { + "number": 525, + "title": "Kernel102 checkpoint: full cold reconstruction and exact fixed-word ceiling", + "head": "71acd0c35ee81de848316b3f2b4c3bd15b219c51", + "updated_at": "2026-10-12T00:49:30Z", + "body_sha256": "93ba959dadb6dba92c8ed9ad9a04e809f013085f742f626267d3b7ddeb665e3d", + "matched_searches": [] + }, + { + "number": 526, + "title": "[Lean] Bound automatic-width counting by 12n+4", + "head": "f6092eac77d965d6dc197cf796b0a3580382c0ef", + "updated_at": "2026-10-12T02:00:30Z", + "body_sha256": "dea3db038b59de7f3f61ff7fcf1485f091736c16ac7fa51fc33b1126c4f60899", + "matched_searches": [] + }, + { + "number": 527, + "title": "Conditional kappa 0.001467289440740487: rank-sector factory on112 ports", + "head": "2080903b9e6bd01e3f64cc4c7c62ea1b3af0aa6a", + "updated_at": "2026-10-12T00:55:34Z", + "body_sha256": "0b1d31cd09aec8cdbcf8c865d6a5059cf909e6c6067b286b13a3889f275a5fee", + "matched_searches": [] + }, + { + "number": 529, + "title": "Conditional κ = 0.001469603966017302: rank-sector102 on112 ports, fully rebuilt", + "head": "05fc7e332651a41860add3c217cd6f6e88758003", + "updated_at": "2026-10-12T01:20:07Z", + "body_sha256": "4478c653b9dce20e10ba4383671b76d7f80365de6d86cd67a033d5eae19afcb9", + "matched_searches": [] + }, + { + "number": 530, + "title": "[Lean] Compose prepared-input counting within 18n+12", + "head": "1b457e5fe4e7ba6ff489af411c9977c1bd031d3b", + "updated_at": "2026-10-12T02:00:50Z", + "body_sha256": "504b6010063d97bb978f836cb7d352065f57fa6230d7601d88e4da8c2840e090", + "matched_searches": [] + }, + { + "number": 532, + "title": "Conditional kappa 0.001467978682990812: paid circuit retirement on the 112-port supplier", + "head": "9b8a8ece611da59ef93a05820da66c5bdb9026c7", + "updated_at": "2026-10-12T01:41:28Z", + "body_sha256": "b0ef276ac81f1cd831fae42f1d5835d22cc1b6972e3244c271e614e9a67f643c", + "matched_searches": [] + }, + { + "number": 540, + "title": "[Lean] Verify one literal PR442 invocation against the multi-host contract", + "head": "acc1917034d10f464271ab115fda314fd4eee7a3", + "updated_at": "2026-10-13T05:42:17Z", + "body_sha256": "a477d76cd64e634beb22b275c9f0b64bb8c21dee2fbb2fc9a1e71d1e6b9293a3", + "matched_searches": [] + }, + { + "number": 553, + "title": "[Lean] Certify PR531 ownership, controller windows and width matching", + "head": "0c3e5ee4719d705afd63fefd001091d70e55182b", + "updated_at": "2026-10-12T05:44:14Z", + "body_sha256": "9678a96c2b83088fe7b7a3bdd78465ee65257ad19ec8d29576d69cfa23af9c1a", + "matched_searches": [] + }, + { + "number": 565, + "title": "[Lean] Add physical compact-counter copy with a linear bound", + "head": "890b2906ebb76b3c9392a08d64e933630c06b1ac", + "updated_at": "2026-10-12T07:19:03Z", + "body_sha256": "ab8fec88c4f0ade5e4956a51bd4002709e49eb8995539cc99833013a118bf525", + "matched_searches": [] + }, + { + "number": 566, + "title": "[Lean] Compose prepared inputs with compact counting", + "head": "86d39f3247a5a1df4f040ed71d8251bed77b91ec", + "updated_at": "2026-10-12T07:43:15Z", + "body_sha256": "ff21bd64c504735c6d7f60146f24002a7baae0ae741c44282ad37af4f0d37d83", + "matched_searches": [] + }, + { + "number": 570, + "title": "[Lean] Compute a binary ceiling-log parameter on explicit tapes", + "head": "9278e39baec4f23267336c7d212306d0c0003d08", + "updated_at": "2026-10-12T08:58:23Z", + "body_sha256": "244f793f8ec790fb17501e7cc2cff67eb6ab2cfb58ea27279ba5e05ccca0fad4", + "matched_searches": [] + }, + { + "number": 573, + "title": "[Lean] Connect eight-tape parameter setup to the real ceiling logarithm", + "head": "576e6ec9f442ed4c0e171821ff70f1856629778c", + "updated_at": "2026-10-12T09:51:51Z", + "body_sha256": "2adee3dbbc0e0c756d1db8c1ff84e030e44a701bbcbc3edffd822e8766bffece", + "matched_searches": [] + }, + { + "number": 581, + "title": "[Lean] Prove the exact canonical identity for selected Clifford child 0→9", + "head": "8fd596eed28b0c6a845fe04ae5372af407875ded", + "updated_at": "2026-10-12T11:35:22Z", + "body_sha256": "81524cae07acdb2be5397a23df6c7fbf19bd09a0c6fc4c5444c930d4a064f597", + "matched_searches": [] + }, + { + "number": 585, + "title": "[Lean] Verify selected rational certificate arithmetic", + "head": "809915a264d4fbe1f7597cc13da3610dc4d52f15", + "updated_at": "2026-10-12T12:18:34Z", + "body_sha256": "12cf659fe49cf6f03534b510d7248f73813716b57486677e0110c2c31ac35e4b", + "matched_searches": [] + }, + { + "number": 590, + "title": "[Lean] Verify historical bit scalar boundaries", + "head": "58690bdbb587f482569ba1bdf7bf61a5396b4768", + "updated_at": "2026-10-12T13:49:49Z", + "body_sha256": "fe975c7cf235016a4f2fd60982048f8f4a4d706a63b029dddf5423de7fa62d6f", + "matched_searches": [] + }, + { + "number": 594, + "title": "Conditional κ = 0.001609915765452068: independent PR591 replay", + "head": "770e8ef302e2fd48e9522373ef7ff980187c978b", + "updated_at": "2026-10-12T14:41:40Z", + "body_sha256": "4dfa729fd3c97cec55859272f755317d081450ef1e0a7e5c6dcdda5926ef229a", + "matched_searches": [ + 2 + ] + }, + { + "number": 597, + "title": "[Lean] Verify current R480 scalar boundaries", + "head": "a87e6cce090c6bdc4f0687fe80719411835b94eb", + "updated_at": "2026-10-12T15:31:16Z", + "body_sha256": "98944f6101be685540c2137db6626e55393e85b81b8f4e84cb90b3d1eaf73921", + "matched_searches": [] + }, + { + "number": 605, + "title": "[Lean] Prove the pinned PR588 native Real moment bound", + "head": "d676cf35234943613d7208719e7d96f7500fdfcf", + "updated_at": "2026-10-12T17:50:45Z", + "body_sha256": "141b1bcac7663f2c24540de029656b6ab9c7bdf5d7cd7fc72fe76fd3478f2e2d", + "matched_searches": [] + }, + { + "number": 611, + "title": "Independent replay: κ = 0.00162128508944984 for PR604 cold_end", + "head": "6eb9071d7d7cc0109af23aa37b149cf1b75c526c", + "updated_at": "2026-10-12T18:20:14Z", + "body_sha256": "3fc552af5c4eb2303b38b319ba4466dedaa3227ea95494238c116b2a6119a97b", + "matched_searches": [] + }, + { + "number": 612, + "title": "[Lean] Verify current R420 boundaries and B-XOR interfaces", + "head": "ce37f3ce35ba8891771e01492b3a21978763bebb", + "updated_at": "2026-10-12T18:31:54Z", + "body_sha256": "e92a0b05568f4ed1bf39e78d73c2fd95ec2ea103a11b096f3d90d256ab7fff2c", + "matched_searches": [] + }, + { + "number": 620, + "title": "Research notes (no κ claim): E8 decoder floors are tight; #615 levers exhausted; +1.1e-7 κ owner-map headroom on #617", + "head": "e9cf03bbdf7094b5a83f6dbd1d74bfd77a05fb87", + "updated_at": "2026-10-13T02:36:29Z", + "body_sha256": "02ad3325307a47c3336fcb110bd9b3008439e8dc7418a30128ae0b2b3745e4b3", + "matched_searches": [] + }, + { + "number": 627, + "title": "Conditional κ = 0.001635749838057164: two factored cold ends on the K492 supplier", + "head": "f95308a9afa5adc071fe75c8cd7feec172503d4f", + "updated_at": "2026-10-12T22:38:57Z", + "body_sha256": "09f124866038f6702ce39b8798589ad485d50e5a9bcb82674605fc5aab41538d", + "matched_searches": [ + 1 + ] + }, + { + "number": 628, + "title": "Uniform rounded prime-power cyclic inversion (no κ claim)", + "head": "0768f97d06c623b8211e651543c66135796b62bf", + "updated_at": "2026-10-13T00:00:33Z", + "body_sha256": "e3a04fcf0bb4aa0b5ee341f88d35a49666e1c1bce00cc94f036c7730a8029457", + "matched_searches": [] + }, + { + "number": 629, + "title": "Conditional κ = 0.001635768210079684: four dim-8 hyperplane cold ends per word (h4a) on the K-triangle witness", + "head": "9f3b92d06ba876ce7101238882d35565993eca57", + "updated_at": "2026-10-12T23:06:38Z", + "body_sha256": "b747663ab66c86e4e1e6033d4d1fc1f088176b4fce826a0b6cdc50a04cc6cfa1", + "matched_searches": [] + }, + { + "number": 630, + "title": "Correct the archived E6 screen with an exact exceptional-root census", + "head": "11a7cc98f8a9ef5192720bc37b45cf2c8369777a", + "updated_at": "2026-10-12T23:10:17Z", + "body_sha256": "d2c2e0a5974516654329cf129d87c80ffd339b4d675274699be64cdeba0c43e5", + "matched_searches": [] + }, + { + "number": 631, + "title": "Prove E8 star-decoder puncture thresholds through 35 deleted lines", + "head": "fb893b5ee1317c2da3b297e6fe78eca0857d1a76", + "updated_at": "2026-10-12T23:12:30Z", + "body_sha256": "fc8bf2ffe6807dba46c8f7230425d785650bdc3b83645cc031ed39e0817673fe", + "matched_searches": [] + }, + { + "number": 632, + "title": "Conditional κ = 0.001635877117861902: owner repair on PR627 factored ends", + "head": "22d0e6e4d21711420b95d5a47d3cb8b6226de717", + "updated_at": "2026-10-12T23:15:58Z", + "body_sha256": "40329ed05ad26589dcdfa090eda1117d67ce88e21db93479798022c9ff09a30a", + "matched_searches": [] + }, + { + "number": 633, + "title": "Independently replay and audit PR627 factored cold ends", + "head": "dc14a57d17c63b0e427a5623ef23a2459bc196e9", + "updated_at": "2026-10-12T23:22:05Z", + "body_sha256": "ec81407da4ded9c9d7283483ae58c1185e7971f825168c7411081b78789cbab7", + "matched_searches": [] + }, + { + "number": 634, + "title": "Research notes (no κ claim): #109 and lower bounds, the coding gap, a Lorentzian minrank obstruction, and a loss chain", + "head": "189b5771bc1792d5038105463e476e30cb6eb58c", + "updated_at": "2026-10-12T23:39:00Z", + "body_sha256": "3c56fb648b4dafa7e5225f23942ee528eb242ff3afaf7885e26b56406f0fe43a", + "matched_searches": [] + }, + { + "number": 635, + "title": "Conditional κ = 0.001636241501576388: h4a plus PR627's two factored jp8 cold ends", + "head": "a6895a69f8ad98ab45777b03e9e6f48888c39f6f", + "updated_at": "2026-10-12T23:41:56Z", + "body_sha256": "298efdfee4cfc15fe14f4ef865103f2cd189e830f841236fcb9d8763a7cd5881", + "matched_searches": [] + }, + { + "number": 636, + "title": "Conditional κ = 0.001636269762440408: combined cold ends and PR635 owner repair", + "head": "679621828a85bac68af869fb0e55b54508e6b14b", + "updated_at": "2026-10-12T23:58:45Z", + "body_sha256": "467263c5d0839aae4970b4bf406513f866b67a06cf8c6b28d68a29d51e56dcfa", + "matched_searches": [] + }, + { + "number": 637, + "title": "Conditional κ = 0.001636448463297071: four premix-only dim-8 cold ends (u4) on PR635", + "head": "4edb0dda99c495141cc56ae6e8a74e632a74db8a", + "updated_at": "2026-10-12T23:56:53Z", + "body_sha256": "487b4ed546d2378c9c6b22a091022e3f9467f6428eb61f3be345352996a0e180", + "matched_searches": [] + }, + { + "number": 638, + "title": "Conditional κ = 0.001636456810414854: twenty-row owner improvement over PR637", + "head": "a77f4a358b5129cda3e510a11a7f9a818aba5274", + "updated_at": "2026-10-13T00:19:13Z", + "body_sha256": "99eab558b0dd39cb249dc99e645b0d300c9e47d679712a63b23f9a0d47f242f6", + "matched_searches": [] + }, + { + "number": 639, + "title": "Conditional κ = 0.001636461592777116: attain the fixed-dispatch packing ceiling", + "head": "a374528ad44924951514067c3e104b7afb0e54c3", + "updated_at": "2026-10-13T00:31:26Z", + "body_sha256": "239e83a03a639b09cfccb253488776f954534c463d727c0727ef26448fc22939", + "matched_searches": [] + }, + { + "number": 640, + "title": "Conditional κ = 0.001636464689763295: four CK cold ends and concentrated packing", + "head": "8ef4414fc65c8189f37fc43dc51915cb565d041e", + "updated_at": "2026-10-13T00:42:54Z", + "body_sha256": "86b5bb98334bb974ef7f8aedb1ffb9d95b5963a65b8cc73838fd9cbf0154ceb0", + "matched_searches": [] + }, + { + "number": 641, + "title": "Conditional κ = 0.001636523543003976: cost-neutral pivot swaps with four entering ends (s4) on PR635", + "head": "ff580ea5407aa427d64233523e46ee0afe24a766", + "updated_at": "2026-10-13T00:36:30Z", + "body_sha256": "9e8ec8735a47c9586559c28e4d3e69c850261184851935306b25d875000d3a8b", + "matched_searches": [ + 2 + ] + }, + { + "number": 642, + "title": "Conditional κ = 0.001636472098484378: selective helper-249 dispatch", + "head": "d1154e23e13d85fdbf64d4b41fa20bb0f56a428f", + "updated_at": "2026-10-13T00:46:54Z", + "body_sha256": "63d845b50fa5dc70d588c397ca1d97096db92df2f35e62292d19c0065ed0cb09", + "matched_searches": [] + }, + { + "number": 643, + "title": "Conditional κ = 0.001636542223442109: second jp8-family supplier replaces the CK call (twin dispatch) on PR637", + "head": "bbfa9fe1d84d5572f4d144c2ee56a3eddc7a83f5", + "updated_at": "2026-10-13T00:59:49Z", + "body_sha256": "447375754a42e2199952232b8bc2113e60d3cdefc4cde70ecc51affeb3bda6dc", + "matched_searches": [] + }, + { + "number": 644, + "title": "Conditional κ = 0.001636569158555067: attain PR643 fixed-dispatch packing ceiling", + "head": "5d9427d492b0d3f22a895e2c519624f293eac44e", + "updated_at": "2026-10-13T01:16:23Z", + "body_sha256": "c6b0c9a734f050df903497a5fb7f0566493c101019c2fae7f183cc3543cbb627", + "matched_searches": [] + }, + { + "number": 645, + "title": "Gauge44 factory and whole-family assignment for conditional κ = 0.001649483702558979", + "head": "638a5171dd1aca89ff50d07dcbe288b567769804", + "updated_at": "2026-10-13T01:13:08Z", + "body_sha256": "d66376f20644f30f23c8aa71d1edc6ed6a8e9e30edb34f740f788b8bb5edb5b6", + "matched_searches": [] + }, + { + "number": 646, + "title": "Research: eight signed-root K triangles with 480 helpers (no record claim)", + "head": "cdfe8273bb5054e0a837a3594309c6262e995b1f", + "updated_at": "2026-10-13T01:15:30Z", + "body_sha256": "124c2f60199036ab1c41c4f2d5c6b7adaec00b694235108da10d8af18a0e676a", + "matched_searches": [] + }, + { + "number": 647, + "title": "Research: paid-copy E8 exact-RAM realization with an attributed DFT corollary", + "head": "956bb581e7f97328e1b53baa5aca3d2490f2f607", + "updated_at": "2026-10-13T01:17:19Z", + "body_sha256": "6e14dc73c4de261aeb2c54301713e85a4b7b20f15fe134913d63b9659757d639", + "matched_searches": [] + }, + { + "number": 648, + "title": "Conditional κ = 0.001651096360425895: repacked owner map on PR645's gauge44 construction", + "head": "52b3fc87653a19a024d74144f6c4dc453ffd69cb", + "updated_at": "2026-10-13T01:27:30Z", + "body_sha256": "fa8b5214545e96fae98b8d4298d4b36582b0b150acc244e80715c4bb16ca2e99", + "matched_searches": [] + }, + { + "number": 649, + "title": "Conditional κ = 0.001652528731617094: PR589 bit supplier and dissolved owner map on PR645's gauge44 construction", + "head": "1b931ee055d738753778e1051300140c16ae219d", + "updated_at": "2026-10-13T01:36:57Z", + "body_sha256": "ecac93411aa722338de1ebf4c9627cb5d4a7c3923f9adcc8d2cf35fc3bee2ef0", + "matched_searches": [ + 0 + ] + }, + { + "number": 651, + "title": "Research: the complex delivery layer is rigid — target hosting and raw-face sharing closed exactly", + "head": "df5b9c41fcea749242af886646dfebb9d86319a7", + "updated_at": "2026-10-13T01:41:20Z", + "body_sha256": "ca349b829dea8fd9d6b6adf8c526b50e090c64933a0f620139e93b347aa16af0", + "matched_searches": [] + }, + { + "number": 652, + "title": "Conditional κ = 0.001652760598550299: alternating dissolve/gap-merge owner map on the PR649 gauge44 + PR589 package", + "head": "c5bf1d01ca573ac62353893fb3add857ff8f27e3", + "updated_at": "2026-10-13T01:41:39Z", + "body_sha256": "76db631355fcc98a4399b67fa7a052e9b09bed89d7d6ef0cd5dd0b5a51ecc8a8", + "matched_searches": [] + }, + { + "number": 653, + "title": "Conditional κ = 0.001652704716932828: joint-call owners beyond PR649", + "head": "db9cbf96b13621c940a2f9db019da3378b52ed51", + "updated_at": "2026-10-13T01:57:04Z", + "body_sha256": "47be4b571d25be31502676b578d88c03b7b70803e3437ceb8684bf7e9e4257f9", + "matched_searches": [] + }, + { + "number": 654, + "title": "Conditional κ = 0.001651390457077212: PR648 complex supplier with the merged #589 bit supplier (outdated, independent)", + "head": "a935a545760946489bd6f26fe5349a10820316c2", + "updated_at": "2026-10-13T02:00:47Z", + "body_sha256": "84f1ac0a3ce0634be20baf5dbade68d41392fb8656dc0b8ef1a1efc405caa882", + "matched_searches": [] + }, + { + "number": 655, + "title": "Conditional κ = 0.00165395497190225: pivot swaps, entering ends and cold dim-8 ends layered on PR645's gauge44 with PR589", + "head": "3e669dc7987cb2295a71664b77e110c0cd979a87", + "updated_at": "2026-10-13T02:13:00Z", + "body_sha256": "9795e848488fe0dd0f3be5fd7c2b40f54f282a6a261475cc694928aefa5fb023", + "matched_searches": [ + 0, + 2 + ] + }, + { + "number": 656, + "title": "Conditional κ = 0.001654108529511355: joint two-call owner map on the PR655 gauge44-layered word", + "head": "0805e78f5fecc700804d4766d7e3e1d7d7e6a2ba", + "updated_at": "2026-10-13T02:15:12Z", + "body_sha256": "6c21ab8889a9bd3687da5650a4225bce1da5e3d637bbc691a8f57f0eb69bc255", + "matched_searches": [] + }, + { + "number": 657, + "title": "No new κ: the square-root wall — every current assembly has κ < 1/2 (checked)", + "head": "7bb75c269abeb0d8c850c99c7de3a978019cd7c1", + "updated_at": "2026-10-13T02:21:17Z", + "body_sha256": "2abfb4f028abcb8f3f078dcb3c0fe9089fc76143d5bf191a165e5b89f753cc79", + "matched_searches": [] + }, + { + "number": 658, + "title": "Conditional κ = 0.001654192296855146: joint three- and four-call owners on PR656", + "head": "a1f15d0c78e1ca44d3414d184e57637b36c6822d", + "updated_at": "2026-10-13T02:34:59Z", + "body_sha256": "f52399c0b9d4160600ec9fa185787bbc4e9d8a330f0e5c7d5994ffcfd5b255b3", + "matched_searches": [] + }, + { + "number": 659, + "title": "Conditional κ = 0.001656193765416678: gauge44 without K-triangles (56 cold ends), with layered ends", + "head": "4982f0ca66ffe0960b5a6451deb5b66b1039326b", + "updated_at": "2026-10-13T02:56:07Z", + "body_sha256": "296a7cd1b63e5c9cab4587c4228f67aae3b7a06e955b5ae4e3f5fda598658d33", + "matched_searches": [ + 2 + ] + }, + { + "number": 660, + "title": "Conditional κ = 0.001654269575689572: six more layered cold ends and full-48 packing", + "head": "2bb2015c7a343a3521e757b5659545ee29430ce1", + "updated_at": "2026-10-13T03:09:35Z", + "body_sha256": "38b00e47aa78deb369802681a0c6b64021a676e1b51e27af0411580956222eab", + "matched_searches": [] + }, + { + "number": 661, + "title": "Scoped negative result: R420 phase-B frames are moment-optimal at fixed gate order", + "head": "9ca7aa3ab0a3260a2f36ac86b9911a31fd88bd89", + "updated_at": "2026-10-13T03:07:36Z", + "body_sha256": "18455fe51fdfd772960e5bb8d5d4726fbbba6df85a5ca121fdd12b2e1cee3123", + "matched_searches": [] + }, + { + "number": 662, + "title": "Tooling: accelerate exact Clifford helper checks with identical receipts", + "head": "458744109003e0958798f27c1f04be78f03663ce", + "updated_at": "2026-10-13T03:10:01Z", + "body_sha256": "b3f95f5b50fed9d6928628f090e1a59a31d3fc9ae01a1072166ab410d651e7ff", + "matched_searches": [] + }, + { + "number": 663, + "title": "Independent audit: nonlinear dirty restoration and exact PR628 leaf count", + "head": "e0e546fd01b396478c68b6b6c5a16d87515983ba", + "updated_at": "2026-10-13T03:17:07Z", + "body_sha256": "5b2ca999102f445b145ecbf58c6d449bca30a66f468496e5df8894fd08638c3e", + "matched_searches": [] + }, + { + "number": 664, + "title": "Conditional κ = 0.00165861362787227: three entrance-promotion groups on the PR659 no-triangle word", + "head": "fed4c136d20835764be543dcf6c0c60177aee9ed", + "updated_at": "2026-10-13T03:17:28Z", + "body_sha256": "eef95a63a3cb0fcffb9d4039c838adb2a1244b1e1cd62de037d4374db4d1a4f0", + "matched_searches": [] + }, + { + "number": 665, + "title": "Research note: price a width-9 spectral split with dirty restoration", + "head": "d0e4f1eb295e5cce508dc76c6937290a9175e42b", + "updated_at": "2026-10-13T03:19:00Z", + "body_sha256": "7741fbc4461d49bed837de98595ba00b6e07965872747c79ba3fb996a7a1bb3c", + "matched_searches": [] + }, + { + "number": 666, + "title": "Composite cyclic inverses: exact certificates and modular lifting", + "head": "8e5a8d4da5bf6d83dc0b39ec90fea15e3cf627d6", + "updated_at": "2026-10-13T04:51:29Z", + "body_sha256": "7e105e495840df8d091824dce84cd859f30e346e2b3b36ffcddf126478b189ac", + "matched_searches": [] + }, + { + "number": 667, + "title": "[Tooling] Exact integer-Horner logarithm intervals with pinned equivalence tests", + "head": "8d6ffc19ca56af24d8bd525b6c3133842741b766", + "updated_at": "2026-10-13T03:23:51Z", + "body_sha256": "9d35dfcac99270663ea4399f9b367436b69ea0e9b01e601ecaddb49df1288503", + "matched_searches": [] + }, + { + "number": 668, + "title": "Independent verification: exact CRT resultants through radix 27", + "head": "b861542035d612ff844d0a9d1deaa0713329811a", + "updated_at": "2026-10-13T03:24:39Z", + "body_sha256": "1e7d983fd21dd10c417dd2499f5ff313dbb748b230ab5a29db7f50b2b84c5edc", + "matched_searches": [] + }, + { + "number": 669, + "title": "Scoped negative result: asymmetric hypercube stars and sharp local punctures", + "head": "308f1e6ec3bb0b6ec0584cf7bfe219addc219b1e", + "updated_at": "2026-10-13T03:28:19Z", + "body_sha256": "2d86839a872afb2c187eca7629822aa7354fdffce0c456a5e9f8085bab6f0362", + "matched_searches": [] + }, + { + "number": 670, + "title": "Research: simplify one R420 block from 50 to 33 XOR gates (no new kappa)", + "head": "2e31fcad7f9ecc8b97039ecb2333e581fd725fa1", + "updated_at": "2026-10-13T03:30:19Z", + "body_sha256": "b6040b93ac0f4f9af13186e1fe3be529516b2ff51f544ca88ca676e6ed9b330f", + "matched_searches": [] + }, + { + "number": 671, + "title": "Conditional κ = 0.001658714981837397: pattern-flow owner map on the PR664 promoted word", + "head": "16a27439d4ba1db451b6179c9475793529a485b6", + "updated_at": "2026-10-13T03:30:54Z", + "body_sha256": "9f88ae9cd2c47188c9c8217bb46b01ee02d049ef84314a57753e9c8f8aca9974", + "matched_searches": [] + }, + { + "number": 672, + "title": "Tooling: exact integer exponential intervals with pinned replay evidence", + "head": "7519539e28eaa59f6cb1ebc7a83413ade5521afa", + "updated_at": "2026-10-13T03:39:20Z", + "body_sha256": "f6e47f45b991cb9e2e1bc7c5b23f96b72855c1ab359fd0043941f7406ac510c1", + "matched_searches": [ + 0 + ] + }, + { + "number": 673, + "title": "Research: dirty echo, verifier repair, and priced bit-sharing boundaries", + "head": "0b4f514c60d9bc7786415d7cbc24754f24d6dc3b", + "updated_at": "2026-10-13T05:59:25Z", + "body_sha256": "804b5c5f0d29fe72146b5d8e669288bd52485e3d1385191689d23ace0eca24bd", + "matched_searches": [] + }, + { + "number": 674, + "title": "Research: reduce R420 block 5 from 46 to 34 XOR gates (no new kappa)", + "head": "1b01fd8b135fb2c458554fbbbab4338336bf366d", + "updated_at": "2026-10-13T03:41:09Z", + "body_sha256": "f1ac4e6f67cbce68c71399195bfc1736daddd82f1b3909e9b133b7368792a27c", + "matched_searches": [] + }, + { + "number": 675, + "title": "Research audit: PR626 owner boundaries and bridge-omission blind spot", + "head": "f011d03633f0570257b653e7aa1e869b1b06d06a", + "updated_at": "2026-10-13T03:42:31Z", + "body_sha256": "e0e63ed6f857c77c092b29ae32c9ec8a3dd34ac8d9fcb236a93b68e5daa3e849", + "matched_searches": [] + }, + { + "number": 676, + "title": "Conditional κ = 0.001659319032684569: six dim-8 cold ends and three entrance promotions on the PR659 no-triangle word", + "head": "18649d6b37a6865894e0c0775ba4b558e3168877", + "updated_at": "2026-10-13T03:43:54Z", + "body_sha256": "29a8d1a3bc0c56b6e991a670e2aa8fba71e687f7ba6fa391d22739a8d9fecc23", + "matched_searches": [] + }, + { + "number": 677, + "title": "Research note: restored DATA-shear boundaries for PR #521's native BIT query (exact query costs, no new κ)", + "head": "613c02b8b4411f991f108dcc1481b3f9100b996f", + "updated_at": "2026-10-13T03:43:59Z", + "body_sha256": "e88435374080f98baa31e90f14054647d7c327874415d6b58ba73b0b442f7555", + "matched_searches": [] + }, + { + "number": 678, + "title": "Independent verification of the #543 bit moment using binomial enclosures", + "head": "bdc9317efd6d928a0f050159670d1316ba5f4c5b", + "updated_at": "2026-10-13T03:47:52Z", + "body_sha256": "0cc15dac0475593984d8b6e9ac476b79ba685c9de54cdf2b32b92999932702a7", + "matched_searches": [] + }, + { + "number": 679, + "title": "Scoped negative result: volume-aware selector batching of complex children", + "head": "dce137e540acd2b689281afe222cd32c0ec1f1ae", + "updated_at": "2026-10-13T03:51:23Z", + "body_sha256": "58e934665f8717399e79444f22530d7aa88c60c573cc7461f3df192b2bc00d22", + "matched_searches": [] + }, + { + "number": 680, + "title": "Scoped negative result: certify 33 fixed Clifford register words (no kappa claim)", + "head": "c3a5b6b7afec35d259c29bc2d8bb8516e975ad31", + "updated_at": "2026-10-13T03:49:15Z", + "body_sha256": "ee72dd369960cd2cee8b718f7a09f73e8ed20400dfd51069575ae6952ec8f243", + "matched_searches": [] + }, + { + "number": 681, + "title": "Consolidate six circuit PRs: 31.72% fewer bit ADDs and 22–25% fewer complex primitives", + "head": "e536f6fc8aad65adef8ac4682d13625598a5c3f9", + "updated_at": "2026-10-13T05:05:39Z", + "body_sha256": "01c3110e44edbd3e68caef56438a6f8cb47eb616aa156a324006bd4f7f90fe1a", + "matched_searches": [] + }, + { + "number": 682, + "title": "Research audit: tensor E8 rate and finite-depth center-copy correction", + "head": "cfc7130e0e371395f4cf2f96c122c240cdbeab97", + "updated_at": "2026-10-13T04:01:47Z", + "body_sha256": "2b879cb23a5aaf8f3bcd17b7864d4d65a471676d8bedaf9e46bfc8978f238b48", + "matched_searches": [] + }, + { + "number": 683, + "title": "Scoped negative result: partial K/M face bypass requires four carriers", + "head": "cbf30fdb56126d8cb7594f32e4d9a74ea7cd80a7", + "updated_at": "2026-10-13T04:00:46Z", + "body_sha256": "4646497aed7c65011062f4666daa206a74275fba60e4c9e2af2ae4125243de68", + "matched_searches": [ + 1 + ] + }, + { + "number": 684, + "title": "Audit Gaussian chirp domain and exact block budgets", + "head": "14dd937d9e2d3e51092c0c35a8c2c9cdf8ba81f4", + "updated_at": "2026-10-13T04:01:08Z", + "body_sha256": "6cc46d16eb0e0a0dbcf083f24bc0ee88b8edf4f77b0e9ec499786a721cf3b63c", + "matched_searches": [] + }, + { + "number": 685, + "title": "Conditional κ = 0.001660339298410333: four entrance promotions and 72 cold ends", + "head": "5fc2a0c4e10558f09f03a8e42559dcf8e381e57e", + "updated_at": "2026-10-13T04:02:54Z", + "body_sha256": "d9518d3eed9bdebb2ae9a67faa27db0197d43a081bf37c2fdeac4c56a83e48df", + "matched_searches": [] + }, + { + "number": 686, + "title": "Research: save 108 R420 XORs with restored frame-zero sharing (no new kappa)", + "head": "23dcb610c2b156b76b9d599ea296c3cbde224b2d", + "updated_at": "2026-10-13T04:06:36Z", + "body_sha256": "ee1b8fc0c1571543654ec1cbb2dc7ebcc2357f793f29b1a3f4058c773f528d0a", + "matched_searches": [] + }, + { + "number": 687, + "title": "Scoped negative result: certify one K-triangle relocation neighborhood", + "head": "82bbb9c3ac34540f196410d137ebc59d9c2c43a9", + "updated_at": "2026-10-13T04:07:09Z", + "body_sha256": "fe36421d49ba8c6f0d26d37fb5c065d023e577ed2da08baf8b3b6636f77413ef", + "matched_searches": [] + }, + { + "number": 688, + "title": "Research: compose R420 circuits with 16,704 fewer hosted instructions (no new kappa)", + "head": "bb05c40c3e6319aa8c131b06a105e3648ac6c95b", + "updated_at": "2026-10-13T04:08:46Z", + "body_sha256": "a656fde0d2be8d992b245fe40585d8af3f59b6ab3f87db93a139942e46738875", + "matched_searches": [] + }, + { + "number": 689, + "title": "Research: minimize balanced ternary dirty echo calls at fixed scratch", + "head": "0dedef12f05f9a06faf9d4e1c8b1462c0e3bff3a", + "updated_at": "2026-10-13T04:14:38Z", + "body_sha256": "75bfbf1fe82273a4609b9bec9f421252216707627ff33c962928f88bf1c0c1a9", + "matched_searches": [] + }, + { + "number": 691, + "title": "Research: shorten R420 phase-A quad 13 from 19 to 12 XORs (no new kappa)", + "head": "ee6b9175fe006c11871802866c487b5ecc1a93a4", + "updated_at": "2026-10-13T04:16:35Z", + "body_sha256": "9c8601e542db91da1611f1e14a93b38e234bd503bea68cb3ee6afaea35de6eb3", + "matched_searches": [] + }, + { + "number": 692, + "title": "Independent verification: weighted-stride closures and bilinear dual (no kappa)", + "head": "c5b53a5e80372a1fae9830d8dcf21aaabce3f729", + "updated_at": "2026-10-13T04:16:13Z", + "body_sha256": "424cf60fa6cf0920093987c108a1225811d769fc82c5799f844849e89b40f27f", + "matched_searches": [] + }, + { + "number": 693, + "title": "Research audit: signed block extraction and coefficient-alias controls", + "head": "7d857bb58fb55ada6d05364a4b6f01bba8e2283f", + "updated_at": "2026-10-13T04:17:11Z", + "body_sha256": "17e33fe13b0e73c25dd598fd2e07bb8671c4f1186f906b623292b720f9af6b8c", + "matched_searches": [] + }, + { + "number": 694, + "title": "Research: save 6,934 R420 XORs with a restored helper basis", + "head": "9732ac127dd4bef98a846aaa904c20b5a84e72c1", + "updated_at": "2026-10-13T04:25:50Z", + "body_sha256": "d20e6c2caeccd2956a41c6d13c14e7eab37382165e26f88c9f61ee4c6f0d3f53", + "matched_searches": [] + }, + { + "number": 695, + "title": "Research consolidation: reconcile selected #626 Linux replay evidence", + "head": "e322f2f1d9cc0f830cb3a50c6e928e0a1a32383c", + "updated_at": "2026-10-13T04:20:44Z", + "body_sha256": "5930953bc4c71e7ddcda852af385f26584cc78b969532c3f684db327be55afb0", + "matched_searches": [] + }, + { + "number": 696, + "title": "Research: lower selected complex scalar primitives by 22–25% (no new kappa)", + "head": "5a3f983715027c4fd83f50bc9001d4b18463bed1", + "updated_at": "2026-10-13T04:21:56Z", + "body_sha256": "89910e6d592dea0cb4bcc37dfcf6900d86a0fd76946bbac7e6590651fd150cdf", + "matched_searches": [ + 0 + ] + }, + { + "number": 697, + "title": "Research construction: direct-source E8 with 120 fewer helpers", + "head": "3219863d868b4230eeb4bf2948758eff45efffcf", + "updated_at": "2026-10-13T04:23:26Z", + "body_sha256": "1a4e9870f099b8a7220488061fb901c89cad4f00dc71a0190adc508f62cc4c9c", + "matched_searches": [] + }, + { + "number": 698, + "title": "Scoped negative result: selected CK B frames are optimal at fixed boundaries", + "head": "ab78f797cffcbeddbb17a7eb069741085ffe3351", + "updated_at": "2026-10-13T04:23:37Z", + "body_sha256": "62ca7d93f56e1ecdb0aa2200d387c35dc48828e287cd716de6574f5aa15b1544", + "matched_searches": [] + }, + { + "number": 699, + "title": "Conditional κ = 0.001660666354374641: four entrance promotions, six dim-8 ends and a width-neutral B read exchange on the PR659 word", + "head": "f042731cb332359166e8215839f9a3da28c46c5b", + "updated_at": "2026-10-13T05:10:32Z", + "body_sha256": "c961a36a04acfbb273d2ca9aa5a2888c21c00c41b7693e0a72cc67e58df29ff9", + "matched_searches": [ + 0 + ] + }, + { + "number": 700, + "title": "Research audit: PR468 modular rank and parity arithmetic", + "head": "dee275599160965d77324c9ab635bc00ad5f702d", + "updated_at": "2026-10-13T04:24:03Z", + "body_sha256": "e73598b7a3fe58fcb138cc4be1d556c4907b3a7783d5ef7e41ffde5868d867fa", + "matched_searches": [] + }, + { + "number": 701, + "title": "Research audit: sharp fixed-a Gaussian envelope for balanced assembly (no new kappa)", + "head": "de07c015b38e5b157016db636f210c4f7f537058", + "updated_at": "2026-10-13T04:26:46Z", + "body_sha256": "274f625bdab9a9927369e6a663dbcf85a8bae9d8521c335997d429262ae1795e", + "matched_searches": [] + }, + { + "number": 702, + "title": "Research audit: verify all selected cold-wrapper amplitudes (no new kappa)", + "head": "27db45ac6befa99d6c06be920a93845023e81937", + "updated_at": "2026-10-13T04:29:11Z", + "body_sha256": "fbdd3ae170fe3426e535060eaee910c71fc4dcdc518df372a6fbd645d834c152", + "matched_searches": [] + }, + { + "number": 703, + "title": "Scoped negative result: asymmetric Hurwitz E8 copy cost is exactly 10", + "head": "358383e2f1b0f292d4d6eb897c06fd8558a4f5e6", + "updated_at": "2026-10-13T04:28:00Z", + "body_sha256": "c26725da4bc670cad661380cc88240d59a7c57ffcaaed5f1bdc359b8ce81da3e", + "matched_searches": [] + }, + { + "number": 704, + "title": "Tooling: bind review-ledger metadata to pinned family decisions", + "head": "152583fe2062f23b1149b4b20255f8e85946d558", + "updated_at": "2026-10-13T04:28:25Z", + "body_sha256": "f6d2747de012cdec31176845ece51861d3fb6fc68b5d5baf6287a0dbff97cd2e", + "matched_searches": [] + }, + { + "number": 705, + "title": "Research: determinant obstruction for rank-homogeneous register paths (no kappa)", + "head": "eeb0cd605415a73b792915aaa9185000f293c84a", + "updated_at": "2026-10-13T04:33:58Z", + "body_sha256": "1a90502aba474f464dddebda75f07610b35d8bdf60b572073339a028213e9c3f", + "matched_searches": [] + }, + { + "number": 706, + "title": "Independent verification: selected complex moments via integer root bounds", + "head": "0f7dbb54948775c010b5e5bc8ab3cf92a52a9b25", + "updated_at": "2026-10-13T04:34:41Z", + "body_sha256": "0ccfc754573dba7d4589c41ca21f18f1852c7a2e6e519a40a81a25d4f1299045", + "matched_searches": [] + }, + { + "number": 707, + "title": "Tooling: exact Gram prefix reuse with pinned equivalence and timing evidence", + "head": "098bdbe5e554bb94a4ffe14b4f80758c80884bc5", + "updated_at": "2026-10-13T04:34:21Z", + "body_sha256": "5f3329f3aaed416bca63a674e540ea6d454809caeb44b3b50b7b7dee2397886e", + "matched_searches": [] + }, + { + "number": 708, + "title": "Research: save 114 R420 XORs by sharing restored decoder operands (no new kappa)", + "head": "2ec522a466ec448f148d4355dc43b51c0ef1e0b5", + "updated_at": "2026-10-13T04:35:11Z", + "body_sha256": "2a7c37366641485a11d5ad74a36482f53765fccad1f566e960a89148c5598eda", + "matched_searches": [] + }, + { + "number": 709, + "title": "Tooling: cache exact R420 geometry for 6.47x faster mutation replay", + "head": "98310d032c67786190c1e9928f81cf7aaff27564", + "updated_at": "2026-10-13T04:36:07Z", + "body_sha256": "2c686b4761647919160672816c19967d4d3c13e5c80ccaa89daae8604187bb99", + "matched_searches": [] + }, + { + "number": 710, + "title": "Research: shorten R420 cleanup by two XORs with certified conjugation (no new kappa)", + "head": "d97c8d20a8b885271a24c5a4e8446ac7f5697d5c", + "updated_at": "2026-10-13T04:39:03Z", + "body_sha256": "a8fbeaa5c846b8c11a8c95546828487fae142eb2d2372b17ea89dd339a002964", + "matched_searches": [] + }, + { + "number": 711, + "title": "Scoped negative result: R420 adjacent A swaps force both frames", + "head": "ebd567a22d26fadc1c8292b5c57056fb52331266", + "updated_at": "2026-10-13T04:39:17Z", + "body_sha256": "e74b1820852a6aea22d7feac6c9699ff123590000c56ad261f0a32f2814d9711", + "matched_searches": [] + }, + { + "number": 712, + "title": "Independent verification: quadratic-phase certificate for a selected cold wrapper", + "head": "4773b879a1087540f5919c726ec8c670dadfa0c5", + "updated_at": "2026-10-13T04:39:49Z", + "body_sha256": "b8a6895f66a618e4d7de2d3bcc0982cc6731d33017cb70e6f06e1a76bc9ac2d9", + "matched_searches": [] + }, + { + "number": 713, + "title": "Research: save 3,150 R420 XORs with a restored target basis", + "head": "1a19af5c5ddb6de9797a6d085e5df0b90ed6d58b", + "updated_at": "2026-10-13T04:42:18Z", + "body_sha256": "76dc236a381011b0cf2fcaded0d9b7c5592a9103cf24842331359ecc534dd0ff", + "matched_searches": [] + }, + { + "number": 714, + "title": "Research: optimal clean root checkpoint saves 25–40% of binary product-shear calls", + "head": "efad8a40094ab453c0525efef0b0eff2a5d8b850", + "updated_at": "2026-10-13T04:40:45Z", + "body_sha256": "fa84eafed523b52cc43ed3626713ce1a9e1f575acf702e3b5b9b6a6c4dfecea6", + "matched_searches": [] + }, + { + "number": 715, + "title": "Scoped negative result: minimal E8 mixed-port extension is saturated", + "head": "d8ed5c6cf2781d6efa0062a2636e1a2644f96c85", + "updated_at": "2026-10-13T04:41:15Z", + "body_sha256": "44171963be1583eb32cb2e2d5c0ed3673a1c0811ff97474f3282df4cde0bc98a", + "matched_searches": [] + }, + { + "number": 716, + "title": "Research: optimal disjoint R420 target pairs save 3,250 XORs (no new kappa)", + "head": "afeb452f58ff0cbf109172335e2ba282aac3dcde", + "updated_at": "2026-10-13T04:50:03Z", + "body_sha256": "dbd421fc84cb3aa354873711afae35cc885b400713461dd740b77edadf61ebee", + "matched_searches": [] + }, + { + "number": 717, + "title": "Format limits part 2 (no κ claim): erratum to #595, exact invoice prices, frontier-word censuses, decoder floors, spec requirements, centre and fragmentation walls", + "head": "4150829a2cb66b823f4282da98985959ee448a90", + "updated_at": "2026-10-13T05:56:43Z", + "body_sha256": "3bbd29fecf12cf0091e6314f1c37c7738c69036407dd5c5da581b6aa2320c2db", + "matched_searches": [] + }, + { + "number": 718, + "title": "Scoped negative result: R420 split target reads cannot lower the paid moment", + "head": "688258f863410419d10e34b0b3014b91cdce632c", + "updated_at": "2026-10-13T04:45:35Z", + "body_sha256": "9cc099c052a1b5fa8a1666b7f8b933af5da8c5c2d9ae2d281adef46dba462578", + "matched_searches": [] + }, + { + "number": 719, + "title": "Scoped negative result: rank-two obstruction for 78 CK cleanup pairs", + "head": "a3d9c0aa0a16b68b1f4dd064671ad018013e6dd4", + "updated_at": "2026-10-13T04:45:00Z", + "body_sha256": "599ec93a1ed0a91dbce675897123ca6a1ff4f6a3457564c53fe6b579922eb748", + "matched_searches": [] + }, + { + "number": 720, + "title": "Research theorem: nine-call bound for arbitrary invertible three-register targets", + "head": "a942c0ae1b463710ca535c1fba1b07b6431b5a86", + "updated_at": "2026-10-13T04:45:45Z", + "body_sha256": "02e08109f5014323fb928088389206fd23af1a261b2d1a29f565d3a814fd7352", + "matched_searches": [] + }, + { + "number": 721, + "title": "Tooling: reduce reconciliation replay peak RSS by 56% with exact streaming", + "head": "0038fa9051bcbf52ccea8e29272840b13126e539", + "updated_at": "2026-10-13T04:47:47Z", + "body_sha256": "224724e4591cd263afb0e9ce058f9b8d4cc01c296cfa37311cae581abbe59e96", + "matched_searches": [] + }, + { + "number": 722, + "title": "Research: share JP8 cleanup coefficient work, saving 19,688 primitives (no new kappa)", + "head": "a0766ab0fab379e1997fadc3ca157578d57986c1", + "updated_at": "2026-10-13T04:50:10Z", + "body_sha256": "ba6ec653639aee869d1824fd38ebb0c2ce006d5263988d8c59ddcf85edafbaac", + "matched_searches": [] + }, + { + "number": 723, + "title": "Research: save 3,276 JP8 scalar primitives per orientation with signed digits", + "head": "d3bc41b87fc7d23f50d064a0f06f1a89e3ab02a7", + "updated_at": "2026-10-13T04:52:24Z", + "body_sha256": "645ceb489f3d7db51da903a458266dca9cb78ebf1fbf5d368dc926b3171d0a07", + "matched_searches": [ + 0 + ] + }, + { + "number": 724, + "title": "Research audit: resolve R/R0 revert expectations with exact PR626 accounting", + "head": "624ccfe44b1c5816f0279481d91cca6a5a2290ab", + "updated_at": "2026-10-13T04:51:19Z", + "body_sha256": "73e0c66307dbf300dca308b6d19b9ae613065835bd3239ea1bea7d16e7e13db7", + "matched_searches": [ + 0, + 1, + 2 + ] + }, + { + "number": 725, + "title": "Scoped negative result: sharp global-star punctures and 67 attaining patterns", + "head": "6eadc4eb4ebc355b13fa36a3138d97a583ea7f37", + "updated_at": "2026-10-13T04:52:28Z", + "body_sha256": "93b2345e3fd788756e9d3c1fcc7e39bfa526c06836566b87e32129b19279137f", + "matched_searches": [] + }, + { + "number": 726, + "title": "Exact E8 A2 Triple-Gather Census and Verification", + "head": "a3041f751114df12453afcb7ac7d0066973797fa", + "updated_at": "2026-10-13T04:54:30Z", + "body_sha256": "3a7b809aac692a87331438d8468a6b2f2fc7ade21d261f68135934351677cdb0", + "matched_searches": [] + }, + { + "number": 727, + "title": "Tooling: exact owner footprint masks reduce checker wall time by 13–19%", + "head": "71ba94c981477b3527ef21dd0f8140e795a7664d", + "updated_at": "2026-10-13T04:55:01Z", + "body_sha256": "94742e453f8376ba2ffada7fb2958037983dadef3020e6dafb4a20d87dea8e0a", + "matched_searches": [] + }, + { + "number": 728, + "title": "Research construction: save 20 R439 mini-node XORs (no new kappa)", + "head": "d454ae19fdd474b4dfa7bd2c28bbe5b0996365fb", + "updated_at": "2026-10-13T04:55:42Z", + "body_sha256": "b45ab75c63c292d28ce0095daf5222eb58d55c0de3d644044bd1d65bd2f31d49", + "matched_searches": [] + }, + { + "number": 729, + "title": "Independent verification: audit helper-frame lifetimes with a scalar-preserving regression", + "head": "deaed262cebc50bdb0c27c6ba132b8f8289b3eef", + "updated_at": "2026-10-13T04:56:24Z", + "body_sha256": "42202d75ec7c0bca980d67066b829409f8c9eef4a004cc112e239d3d0a8c0909", + "matched_searches": [] + }, + { + "number": 730, + "title": "Research: optimize ordered dirty echoes at fixed scratch (no new kappa)", + "head": "d222e348179cc02a54d6d26dbd2838944f62c6e5", + "updated_at": "2026-10-13T04:57:06Z", + "body_sha256": "13da904a4cb539698c6298fc1acea6be3f9faaaeddf66d921db27116e59806bc", + "matched_searches": [] + }, + { + "number": 731, + "title": "Independent verification: R420 compensation rank and minimum-weight kernel", + "head": "cf5ff54a358b400a7e69abe941d1d0ad0944b25e", + "updated_at": "2026-10-13T04:58:03Z", + "body_sha256": "6397d35ab6c7c11be591e558210aa07330d5814e1afd2de17dd25b5ea1a90029", + "matched_searches": [] + }, + { + "number": 732, + "title": "Research note: sharp off-target proper-star puncture threshold", + "head": "80431a74c31e807581f5c2258c87abe2084caacd", + "updated_at": "2026-10-13T04:59:10Z", + "body_sha256": "1e7c7a9177f98df3c90d221cf3031e0a8fc8dbb650eaff7e062f7d0b67bcd520", + "matched_searches": [ + 1 + ] + }, + { + "number": 733, + "title": "Research: compose R420 bases for 8,368 fewer XORs", + "head": "dfe84e09298abc5c5e0074afda59a821e10abfb4", + "updated_at": "2026-10-13T05:01:02Z", + "body_sha256": "bddafa09c73270e55118b785d37ddbfb75949c130ec991500d2c1555cf33d9bc", + "matched_searches": [] + }, + { + "number": 734, + "title": "Research: prefix-bounded signed-Horner circuits for CK and JP8 (no new kappa)", + "head": "ba76ba3321d000c8996b0b254bcf0d7260e1bbb6", + "updated_at": "2026-10-13T05:00:52Z", + "body_sha256": "1be8df9c8bc6f65392cf7ca77059a3298963fc1a5f202a577376e8c7ea40738d", + "matched_searches": [] + }, + { + "number": 735, + "title": "Research audit: tighten the packed-bit repair envelope (no new kappa)", + "head": "8d36139e49add1e55795e283b3bfa45e1cfe1bf0", + "updated_at": "2026-10-13T05:00:25Z", + "body_sha256": "5ce4d85fa312fa7f58cfa7b91b16664ea254ba6b3ea6e6f2ef18995f28425c63", + "matched_searches": [] + }, + { + "number": 736, + "title": "Tooling: skip exact zero row updates in cyclic-inverse replay", + "head": "eccc3b74767848eb6746f39412d57df6c9544b5d", + "updated_at": "2026-10-13T05:01:09Z", + "body_sha256": "72b2ff3f1b7d015f4dd24d0968e0f89210024aa3530127f565eb5c5a5cc8a650", + "matched_searches": [] + }, + { + "number": 737, + "title": "Independent verification: R420 frames by exterior algebra and odd-prime witnesses", + "head": "b41e73169430641be18c988c659d2855a6a6218a", + "updated_at": "2026-10-13T05:00:46Z", + "body_sha256": "4ea0384207a63f31e24b0947798e72472a88b68863fa8b23ebf0727487bdacd3", + "matched_searches": [] + }, + { + "number": 738, + "title": "Scoped negative result: Gaussian E8 copy floor 40 excludes three stages", + "head": "9671c5d72f3119ba26f3774f40aa7130c67bcf77", + "updated_at": "2026-10-13T05:01:06Z", + "body_sha256": "fd75f6de01302c42b00845fa00e3bb0e304c23481c7a8400c0c6e51d25eb4e1c", + "matched_searches": [] + }, + { + "number": 739, + "title": "Research construction: rescale JP8 coefficient work across magnitudes (no new kappa)", + "head": "abb9825202dba6f9bc95c7df8d12d86088fdff1a", + "updated_at": "2026-10-13T05:01:20Z", + "body_sha256": "711e663d7f1eda12a1f84587dbead8d6627e04714b3c7041cfb2be6cda2fc522", + "matched_searches": [] + }, + { + "number": 740, + "title": "Research consolidation: bind archived inventory evidence and reject optimized false PASS", + "head": "7dea7d399a773543ecfc5f77d76f57d33bcec844", + "updated_at": "2026-10-13T05:01:13Z", + "body_sha256": "a06e216c6f72ebd23262c588e0312225ebe135f662ea9e55c044ed6f10dc82c5", + "matched_searches": [] + }, + { + "number": 741, + "title": "Conditional κ = 0.001661202643272239: eight B-frame coalescences after SW4", + "head": "e516b1463606840a15f80aac1995d64ce0092e89", + "updated_at": "2026-10-13T05:01:16Z", + "body_sha256": "d23c73dd461388cad08c5690f4ea40db518052c8fa69b67c14040bde4239148e", + "matched_searches": [] + }, + { + "number": 742, + "title": "Research: shared target donors save 3,288 R420 XORs (no new kappa)", + "head": "6e7a5d271a123886dc7b54ca3180d0b9f9beda5a", + "updated_at": "2026-10-13T05:02:52Z", + "body_sha256": "29b353969ad30b3988fe2677a7cfd9e0d503e2cf687beb4837f1c999c3d603d0", + "matched_searches": [] + }, + { + "number": 743, + "title": "Research consolidation: uniform proof of the archived 2P+1 stage bound", + "head": "f39226f49486f44e9771b88121ad11f9d0b76eee", + "updated_at": "2026-10-13T05:02:53Z", + "body_sha256": "c742e1ffd0beca6912d87dcb21fe59133c4ad19d7c8fabda0c433c0d6433b11f", + "matched_searches": [] + }, + { + "number": 744, + "title": "Independent verification: fixed-space ternary echo minima and rounded leaves", + "head": "302383e0c1ec71c50860362d3f394f85664c2445", + "updated_at": "2026-10-13T05:10:23Z", + "body_sha256": "9918713683c01527aba15cb9ce4b79f17dad80769e4866ee2c99a1a29b40c94a", + "matched_searches": [] + }, + { + "number": 745, + "title": "Independent verification: JP8 adjoint replay and dirty-centre clear witness", + "head": "fc6ebccca3bd61a6eaf6ec3fcbf2e99d2888c35c", + "updated_at": "2026-10-13T05:03:22Z", + "body_sha256": "9fe8a766a41fd6cb4d18aa9ded10667b04403486303f17aaebadae4a53e3c418", + "matched_searches": [] + }, + { + "number": 746, + "title": "Research consolidation: restore reviewed PR236 source package", + "head": "ee3580bd708d82b5bdfda6a2bc3f0a34710be50e", + "updated_at": "2026-10-13T05:03:04Z", + "body_sha256": "a4cd21513eedb7ca4c42f832fe8d0d4938f601be4a082dd52730509c05883dd3", + "matched_searches": [] + }, + { + "number": 747, + "title": "Research: classify 240-port optimal punctures and certify the all-target threshold", + "head": "aeaf0899179a14644b412e838ede14db967c765e", + "updated_at": "2026-10-13T05:03:15Z", + "body_sha256": "45dc3fd86a5fcb98877cdbba1b216d4ca96dff58a1b3df87ec4754c291cd74f8", + "matched_searches": [] + }, + { + "number": 748, + "title": "Research: decoder source cosets save 244 R420 XORs (no new kappa)", + "head": "0ccc0b425d2b9667108d3a0918a5cfa0aa7a5861", + "updated_at": "2026-10-13T05:05:07Z", + "body_sha256": "2bc8e0945adc61564b1cebc0fc9c8c28696cf3c84d85fa08356e40ba857cd7e6", + "matched_searches": [] + }, + { + "number": 749, + "title": "Research: save 48,400 JP8 primitives with a restored compensation basis (no new kappa)", + "head": "d76c276a9f77df270982a61be7e53219316faf55", + "updated_at": "2026-10-13T05:07:36Z", + "body_sha256": "43a508220d714616e6e67f82982cada1eff9456d3a9aea815c3f6685769839e6", + "matched_searches": [] + }, + { + "number": 750, + "title": "Research: save 62 CK primitives per orientation by relocating one scale (no new kappa)", + "head": "b6d6934092c063ab2575ebee00f48bbc7b1c9d82", + "updated_at": "2026-10-13T05:06:33Z", + "body_sha256": "9986c98efde4449e2a22c4937fd56b85ef740ccfb487050ed5ec1787623f6452", + "matched_searches": [] + }, + { + "number": 751, + "title": "Research: save 19,688 JP8 backward primitives with reverse Horner (no new kappa)", + "head": "7a1a3a319da359ec8b6e83230a7fcf7733fac8e5", + "updated_at": "2026-10-13T05:07:24Z", + "body_sha256": "cc7d88f898147133ba27ebd4db73020ba91c6da675cf2824a947f8587c11593c", + "matched_searches": [] + }, + { + "number": 752, + "title": "Tooling: accelerate exact quadratic-affine witness replay", + "head": "3603d8d9184995ae1cc67c0f5e01f02f3a1d634e", + "updated_at": "2026-10-13T05:07:23Z", + "body_sha256": "8c8f002a2b3724913a782a696ed6c7ed73fd8a962300a79d9de7e09b5a1f03e9", + "matched_searches": [] + }, + { + "number": 753, + "title": "Research: restored decoder stars save 128 R420 XORs (no new kappa)", + "head": "2b30b63789f6d9948233fc67d9d79bca6b185c5b", + "updated_at": "2026-10-13T05:07:58Z", + "body_sha256": "0c7a41e7cdcd28e909247a72ca484b1d0f05c7d15a1e63fc5f040e583566d9cb", + "matched_searches": [] + }, + { + "number": 754, + "title": "Research construction: save 137 R420 cleanup XORs with exact four-wire synthesis", + "head": "47ebba87e064cc69d9b4834081fc74080762a74f", + "updated_at": "2026-10-13T05:08:26Z", + "body_sha256": "ad982e95f13063407458f1154b9d135fbd17ac76593d851b4081baff73fbd608", + "matched_searches": [] + }, + { + "number": 755, + "title": "Research: JP8 coefficient reuse across all scalar phases (no new kappa)", + "head": "a1dd9f819102c40e0b5e4a75215cf69ee864f480", + "updated_at": "2026-10-13T05:08:44Z", + "body_sha256": "df5e89f0f9481d04ede88b019019444d2d68ce889be6d4f3e29ef3ca7431aa95", + "matched_searches": [] + }, + { + "number": 756, + "title": "Tooling: replay balanced Fano 2.91× faster with identical exhaustive streams", + "head": "4fad623a1e4ca06959f4326e221c2f8d9125c269", + "updated_at": "2026-10-13T05:34:05Z", + "body_sha256": "496d92c80d4416eab8e8b2c24829c1f330c86c94b250195fc34f4057b28af406", + "matched_searches": [] + }, + { + "number": 757, + "title": "Research: solver-free P111 copied-rank certificate and source-order correction", + "head": "e2ec7d7e719031e8f8b8012a4ab5b20faed074ce", + "updated_at": "2026-10-13T05:12:20Z", + "body_sha256": "1d425ed0fc9ffa236b73bb6556569d144ef527db6a8963bafdea6213b2c80315", + "matched_searches": [] + }, + { + "number": 758, + "title": "Research: higher-arity dirty echoes use 152 calls at five-array cap (no new kappa)", + "head": "a164f06263e438ead570b169e5b7103aa45bf228", + "updated_at": "2026-10-13T05:10:54Z", + "body_sha256": "ffceedbf8debfc1bc287f7fa483e0b5c2919f2ae83404095a4bf7b2b537ce762", + "matched_searches": [] + }, + { + "number": 759, + "title": "Research: rooted R420 target forests save 4,784 XORs with exact class floor", + "head": "467b9da6fe130a12d0d6edda310cd6b0efd22a7e", + "updated_at": "2026-10-13T05:10:57Z", + "body_sha256": "4c9eed6a97598fd5e40452be240e7e1e11e2c7af7f6343e4fdf4ce9f071ddd27", + "matched_searches": [ + 1 + ] + }, + { + "number": 760, + "title": "Independent verification: R420 ghost return and recursive cost screen", + "head": "6872990acee84da98ba6bc12218c5f351192bcd4", + "updated_at": "2026-10-13T05:11:19Z", + "body_sha256": "c6f2d0375ddb7a6077b2da9e1b5562f7673740c4a500360c57d614511b3290f7", + "matched_searches": [] + }, + { + "number": 761, + "title": "Scoped negative result: algebraic P111 bit pairing-cost floor of 63", + "head": "287758702129e6cbca187356b92b311e8a1c843d", + "updated_at": "2026-10-13T05:11:32Z", + "body_sha256": "3ce44d3fae49fc73028836cee5afe85669b8a47f7c81b4572330e51fcd20ef92", + "matched_searches": [] + }, + { + "number": 762, + "title": "Independent verification: ten optimal tests for R420 compensation faults", + "head": "e35bd9b325c84dbe9b9c2903ea4a064ae45df80f", + "updated_at": "2026-10-13T05:12:19Z", + "body_sha256": "43ad19a34e94bdd2fa6d38d2da638f8e8a80beb684178be28fe4928c53dc996a", + "matched_searches": [] + }, + { + "number": 763, + "title": "Research audit: compact interior carries and exact exceptional repair (no new kappa)", + "head": "a5d3436b82f5a58033ec6b490ebb23db0c1860c6", + "updated_at": "2026-10-13T05:14:40Z", + "body_sha256": "e7fb012f1d2ac39c5f376ec8ddb47ae63dfe57db3cfc23c24a975219622b7ca6", + "matched_searches": [] + }, + { + "number": 764, + "title": "Research: sharp inverse-square rounding bound for cyclic scans", + "head": "983d66f0f2e48ee500ec7eee2da9244c001c5064", + "updated_at": "2026-10-13T05:17:25Z", + "body_sha256": "91f5c40440a9574600670bdd2033160b9182e63ed24a76f2bacbf20ca4fe343e", + "matched_searches": [] + }, + { + "number": 765, + "title": "Scoped negative result: tensor E8 basis mixing cannot lower 72^d copy rank", + "head": "d8eaa3db32f76111b39db9b930f347ef30118a28", + "updated_at": "2026-10-13T05:18:29Z", + "body_sha256": "94ca10d934b90ff5ad99bf8343dfd9f568e2a7c055c4a9ef52459fbafe395d7a", + "matched_searches": [] + }, + { + "number": 766, + "title": "Research audit: replay all 14 K492 assembly helper-count reversions", + "head": "56bac6775e8882f4c3bfa0cef9bcc9a61da9ba06", + "updated_at": "2026-10-13T05:19:10Z", + "body_sha256": "a027a416655c656480d990b5e7968c3336e4731684da90c282c8ee74559a3aeb", + "matched_searches": [ + 0, + 1, + 2 + ] + }, + { + "number": 767, + "title": "Scoped negative result: Gaussian E8 planar and incidence decoder obstructions", + "head": "96b4b74677d1bef99e8346bfb6a4ed0531e58a62", + "updated_at": "2026-10-13T05:20:12Z", + "body_sha256": "fe38ff3d6e0a9d94110a533003fbd24ca786f7e9288e6d043406acd82db1e977", + "matched_searches": [] + }, + { + "number": 768, + "title": "Research audit: exclude five bootstrap levels at PR387’s grid point", + "head": "57d8fbf2577bd4463834484264f980e0a7845824", + "updated_at": "2026-10-13T05:23:13Z", + "body_sha256": "14a732ba678ca279f592c3c9b958b01a547be71ce189033155877ff6a6b3af65", + "matched_searches": [] + }, + { + "number": 769, + "title": "Research: CK dyadic ladders save 13,770 / 67,146 primitives (no new kappa)", + "head": "e891b2b19e3185ec91bcf001e255af87f42389ce", + "updated_at": "2026-10-13T05:22:25Z", + "body_sha256": "5a8a556338038689f87a404bbfe971147fe09983aa834e3b1514fb6a0fb8d5c2", + "matched_searches": [] + }, + { + "number": 770, + "title": "Research: Gaussian E8 weighted maximal-clique ceiling 40 and independent replay", + "head": "48d027a664288ea1d4e987de63cb79588b8b936b", + "updated_at": "2026-10-13T05:23:56Z", + "body_sha256": "72839979381f9aac20993c9c839833ae9790a20d0b7342cf8d5fe013dd3a33f1", + "matched_searches": [] + }, + { + "number": 771, + "title": "Research audit: binary cover order and exact finite invoice guards", + "head": "340bedf9f0e65bb0e00ee6edb55d8fed11fcb7c7", + "updated_at": "2026-10-13T05:24:52Z", + "body_sha256": "d8c9ede065cf27156a9f943c8ebdb0316f358cc7a9758b4a4f024491167a0969", + "matched_searches": [] + }, + { + "number": 772, + "title": "Research: uniform proper-star ranks and all-target puncture thresholds", + "head": "02b59e553649c333072b5dd4dfb97e43942efa14", + "updated_at": "2026-10-13T05:26:08Z", + "body_sha256": "e5bf4541a0e1260f8599bbba9f053d6c578bcda11d7ca38a19eac56318440c59", + "matched_searches": [] + }, + { + "number": 773, + "title": "Research audit: exact packed-bit repair density via carry states", + "head": "dbd9da3eed9a0045b77de861099e869259f1ad13", + "updated_at": "2026-10-13T05:25:58Z", + "body_sha256": "8b1e96829d91facb914d143814fa411f90239137c7c9a2aa8bcf581fac7f0dab", + "matched_searches": [] + }, + { + "number": 774, + "title": "Research: certify R420 forest cuts under the 104-bit cap", + "head": "50f8c366f27a9083e0655593a1be3d6810d1f053", + "updated_at": "2026-10-13T05:26:35Z", + "body_sha256": "4aaeb7eb8b432db9327bf73d15d93f687a713257e72a282eae655e74350c76c9", + "matched_searches": [] + }, + { + "number": 775, + "title": "Scoped negative result: coupled partial read exchanges on P6k4", + "head": "d4c60b58d48310ffd5b65bc99ff5b40ed2e59b14", + "updated_at": "2026-10-13T05:30:45Z", + "body_sha256": "44c526bc92c5efd53cb61ecaed001864b016208126a0be61fd47fd79d0f5aff9", + "matched_searches": [] + }, + { + "number": 776, + "title": "Scoped negative result: PR626 jp8 and ck A/B frames admit no next complex tick at fixed order (exact duals, no new κ)", + "head": "8bd985fe2842c948a5a4a1554b8e090f2e371afa", + "updated_at": "2026-10-13T05:27:32Z", + "body_sha256": "47c4e884e15f5aa9be242624fbbfcd49b0592ff36a21a28c579770bf24dbf692", + "matched_searches": [ + 1 + ] + }, + { + "number": 777, + "title": "Independent verification: point-set replay of κ = 0.001661202643272239", + "head": "eca5c317d8176401a1f71a5ea1e81384c2eab1e0", + "updated_at": "2026-10-13T05:27:58Z", + "body_sha256": "8249e8f3d8877bf210bf90b1efceb11a6e503e90d1b3df436c8281e0ac4336ea", + "matched_searches": [] + }, + { + "number": 778, + "title": "Tooling: 2.09x faster exact single-intersection Gram replay", + "head": "f015b04c74801fa330f818d178e809c760fb5469", + "updated_at": "2026-10-13T05:28:18Z", + "body_sha256": "85356a229c8dc48244179070812ff15826e7fc1d2655240225dac3538692a768", + "matched_searches": [] + }, + { + "number": 779, + "title": "Tooling: exact eligibility masks accelerate historical reclamation", + "head": "daa9b0e773b53f36d5b4c3f1c7524600e5714deb", + "updated_at": "2026-10-13T05:29:23Z", + "body_sha256": "21a1d5be10a6730052747d3a601ef4213a0167d90fc274da73899aec3e913190", + "matched_searches": [] + }, + { + "number": 780, + "title": "Independent verification: endpoint-sweep audit of PR727 owner masks", + "head": "9f68dff1e1cccad2bd5b3b51f4ced0bba9765862", + "updated_at": "2026-10-13T05:31:24Z", + "body_sha256": "ccde65faca93762a9c6ef891ae70e5d9e43705826c719530af639e13d12ba75c", + "matched_searches": [] + }, + { + "number": 781, + "title": "Scoped negative result: single-pair target borrowing in all-K complex cells", + "head": "16edc23247c20cd074e5ac502f6b0e723bf53c66", + "updated_at": "2026-10-13T05:32:42Z", + "body_sha256": "791651a99b3cc092a0228001fcc9b2c84e6395a9b56795810df1ca9e16c9f541", + "matched_searches": [] + }, + { + "number": 782, + "title": "independent verification: r420 lattice parity and 480 added incidences", + "head": "a4ef6ed2f33834e4599bf84317ae9d98ba2d9547", + "updated_at": "2026-10-13T05:40:35Z", + "body_sha256": "fad60ed19dddcb5cd6153249705ef70856547f657ea0b45fc006f7c57a2dd64f", + "matched_searches": [] + }, + { + "number": 783, + "title": "Audit: independent recount confirms #696's 22–25% primitive saving (no new kappa)", + "head": "e3576811d416f91dc80b995ce4b8bc8a6144509e", + "updated_at": "2026-10-13T05:32:44Z", + "body_sha256": "4e315e1fdf38885ccbd36b15e6f38a09ecb4d824286d2d41d2786936ac532e5b", + "matched_searches": [] + }, + { + "number": 784, + "title": "Research theorem: sharp scratch-dependent call bound for dirty echoes", + "head": "548e42022b37a300f8bf745e848c38baccbce056", + "updated_at": "2026-10-13T05:32:52Z", + "body_sha256": "43cbb29b893161bf0d7979c116c8fc94ab06aa802c8c7ad7c69b69fc6932b150", + "matched_searches": [] + }, + { + "number": 785, + "title": "Scoped negative result: Hurwitz copy floor for fixed-support nonlinear messages", + "head": "83e78085ae9c110a34bff87e71387292d85e47c0", + "updated_at": "2026-10-13T05:32:57Z", + "body_sha256": "5a70dc8525605dc17c9a8b454dc600ea7acb9284f3727ace76df45a5c88bd3be", + "matched_searches": [] + }, + { + "number": 786, + "title": "Research: factor center quarters and certify the adapter-cost limit (no kappa)", + "head": "c6ae38d9f5a13c53dab623fd6947f08d92173287", + "updated_at": "2026-10-13T05:34:15Z", + "body_sha256": "1051bd810ea50269d5336cae37f6cacf04f25bdadd767fa10e09e5dad6482616", + "matched_searches": [ + 0 + ] + }, + { + "number": 787, + "title": "Research: compose complex coefficient lowering and cleanup sharing", + "head": "93ceb65cfbf339d7ca743614d4756a3af1440cd4", + "updated_at": "2026-10-13T05:34:22Z", + "body_sha256": "b25c8104a8cac2e4a70e06552df02c3b30903d0f078d16825683d6b0bd8ff417", + "matched_searches": [] + }, + { + "number": 788, + "title": "Research: reusable clean checkpoint lowers weighted binary leaf bill 20 to 16 (no new kappa)", + "head": "ff8251519e009a01ede6b27e3f5af703eaa70132", + "updated_at": "2026-10-13T05:37:08Z", + "body_sha256": "8799d14ed87b9af2307eecade33c9f6851fc2b5d75b6aaa86925e8ace837e3a7", + "matched_searches": [] + }, + { + "number": 789, + "title": "Research construction: exact factor schedules save 26 R420 XORs (no new kappa)", + "head": "d1634f3b316f2c3a1bb5f93a6117c8ebab9ab011", + "updated_at": "2026-10-13T05:39:05Z", + "body_sha256": "f5bba3e418af3975183ae4011f2af38495c813dd1dfb82a615b85cc3ae1a950b", + "matched_searches": [] + }, + { + "number": 790, + "title": "Research note: factor R420 block 9 from 38 to 24 XORs (28 fewer native ADDs, no new κ)", + "head": "08b4a039ba4938dd4f4c89a69759f49ed21923ef", + "updated_at": "2026-10-13T05:38:11Z", + "body_sha256": "72f4fdc6f5256d57ab7c2a535137784a06118d356498833334f7ad6924655cd1", + "matched_searches": [] + }, + { + "number": 791, + "title": "Research audit: exact path penalties for general idempotent labels (no new kappa)", + "head": "f80382efd4cd3e37c67b2a966398b55bb56af53c", + "updated_at": "2026-10-13T05:39:08Z", + "body_sha256": "c211b82b0035c01ca73c959694f6721cad6a6bec142901c3f6761a8ec0ccd015", + "matched_searches": [] + }, + { + "number": 792, + "title": "Finite circuit construction: interleaved R439 mini-nodes save 32 XORs (no new kappa)", + "head": "6a17fb0925c3d3bce770c90bc5c3ff0295b0f3d3", + "updated_at": "2026-10-13T05:40:11Z", + "body_sha256": "ced7f89e53388b7de8e127b4d039d037f0bf392183d0a64b441794054566a8d3", + "matched_searches": [] + }, + { + "number": 793, + "title": "Research: batch JP8 compensation, saving 80,150 / 81,464 primitives (no new kappa)", + "head": "f9383f324ee86793c5ae7b73f8e39d5827a8aa52", + "updated_at": "2026-10-13T05:52:52Z", + "body_sha256": "be1480247705da80fcdadbbb0b4e17db437e75eb6b8f061a84ef2c245eeb533b", + "matched_searches": [] + }, + { + "number": 794, + "title": "Research construction: R420 target-basis compensation saves 7,879 XORs within the existing 192-bit nine-stage prefix charge (no new κ)", + "head": "6be7364e0245c5a1c931cb1c43b3da991b755850", + "updated_at": "2026-10-13T05:43:53Z", + "body_sha256": "91478b1c24ed2a645ab45630812a2a2d3309cedf2ec80d873077a35b1f956bd2", + "matched_searches": [] + }, + { + "number": 795, + "title": "Independent exact certificate of PR741 owner-profile optimality", + "head": "56b626800c85026b10dada646c80c6b58179b427", + "updated_at": "2026-10-13T05:45:53Z", + "body_sha256": "e9d721aa953a2e127a186e02635e623cf255153207dedd0293599ba19f9a78ff", + "matched_searches": [] + }, + { + "number": 796, + "title": "Research audit: exact prime-power kernel root valuations (no new kappa)", + "head": "22902155c7875139e43e4fdf15723142d6709bdd", + "updated_at": "2026-10-13T05:47:56Z", + "body_sha256": "44aaa0ffa713b6d2982fa9a22ce14863760674e3bfb7d76ed83c65f3c225a5d3", + "matched_searches": [] + }, + { + "number": 797, + "title": "Tooling: filter default reclamation candidates before sorting", + "head": "b879e8472547bd820ce81b1b9c0463176fe5151c", + "updated_at": "2026-10-13T05:49:36Z", + "body_sha256": "80986cb213f5cfa7c1605cf774bcd15ace735352047c19c5c3701b1dc7d0443e", + "matched_searches": [] + }, + { + "number": 798, + "title": "Research note: Eisenstein E8 copy cost ≥22 and sharp clique-method limit", + "head": "0aea3382e49abd9a59d3cb6676cdb26fd15b04e5", + "updated_at": "2026-10-13T05:49:46Z", + "body_sha256": "c4810bcfbefc608e530ac5257e4edfff2b36f19c2e3e59bc919b77c0762b9b4c", + "matched_searches": [] + }, + { + "number": 799, + "title": "Conditional κ = 0.001661634653669567: four paired read exchanges on PR741's frame-coalesced word", + "head": "80e6463157cfc80b85af09e7e2f14748fe2dac60", + "updated_at": "2026-10-13T05:49:47Z", + "body_sha256": "3fa488048efffe92cd47cc2fdb2d0894f5990ac6efc8b4059b93b744799e4708", + "matched_searches": [] + }, + { + "number": 800, + "title": "Research: weighted path valuations exclude a remaining eight-call Clifford word (no kappa)", + "head": "d7d83e0a9b98f95a4443d1060336be267ac3fd80", + "updated_at": "2026-10-13T05:53:19Z", + "body_sha256": "a2b677ec81b4fd8b764fe5accd2bf953bb72a0ef5f0dd3510fb53f850053ef23", + "matched_searches": [] + }, + { + "number": 801, + "title": "Label-field census: rank-k E8 labels (Witting, Hurwitz) do not beat E8 — no κ claim", + "head": "63450b78e26b4b63641fa72c371010273d4d6866", + "updated_at": "2026-10-13T05:55:43Z", + "body_sha256": "9c5426c7f02fb909a554866b69bf328ba07a97d490497ecefe7eba7617957a9b", + "matched_searches": [] + }, + { + "number": 802, + "title": "Audit: independent replay confirms #681's 1,484-operation raw factory saving (no new kappa)", + "head": "0957b70fc2ed1ac7592467e7a24d6d0788ff6758", + "updated_at": "2026-10-13T05:56:42Z", + "body_sha256": "31bb8ecc3bcad0917a0a9c6c9f662ccdd6c340f1b19caacda108764d61c8e496", + "matched_searches": [] + }, + { + "number": 803, + "title": "Research: degree-controlled cyclic inverse bound by root reflection (no new kappa)", + "head": "d213ac12d4a1ab8f717d942e844df318ceb395fb", + "updated_at": "2026-10-13T05:58:06Z", + "body_sha256": "dad169ddf652df5277681cfb5b5eff0ee97f0da76b23d9ca4a37e405b50300eb", + "matched_searches": [] + }, + { + "number": 804, + "title": "Independent verification: integral-divisibility kernel replay and radix 81", + "head": "1f387e7090359165a0df046183eb8fa16c246d7d", + "updated_at": "2026-10-13T06:00:56Z", + "body_sha256": "2c01e3068c6cfe5463a1a65a541a39829d57ec2a97e51d9f4b651a8d9963cf41", + "matched_searches": [] + } + ], + "closest_candidates": [ + { + "number": 766, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/766", + "title": "Research audit: replay all 14 K492 assembly helper-count reversions", + "author": "gaboroa14", + "head": "56bac6775e8882f4c3bfa0cef9bcc9a61da9ba06", + "updated_at": "2026-10-13T05:19:10Z", + "classification": "direct_excluded_overlap", + "scope": "All 14 assembly source sites. Explicitly excludes 18 nonassembly scratch sites and original R504 fixture.", + "inspection": "title/body, detail, complete changed-file list, relevant patches, saved issue-comment/review arrays", + "detail_head": "56bac6775e8882f4c3bfa0cef9bcc9a61da9ba06", + "detail_file_mtime_utc": "2026-10-13T06:02:58.863021Z", + "files": [ + "research/k492-helper-accounting-audit/CLAIM.json", + "research/k492-helper-accounting-audit/EXPECTED.json", + "research/k492-helper-accounting-audit/README.md", + "research/k492-helper-accounting-audit/SOURCE.json", + "research/k492-helper-accounting-audit/verify.py" + ], + "issue_comment_count": 0, + "review_count": 0 + }, + { + "number": 724, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/724", + "title": "Research audit: resolve R/R0 revert expectations with exact PR626 accounting", + "author": "thakrarsagar", + "head": "624ccfe44b1c5816f0279481d91cca6a5a2290ab", + "updated_at": "2026-10-13T04:51:19Z", + "classification": "conceptual_overlap", + "scope": "Independent invoice recount; source mutations are assemble.py lines 118-153, not original emitter or invoice source-site replay. Credits R/R0 prose discrepancy.", + "inspection": "title/body, detail, complete changed-file list, relevant patches, saved issue-comment/review arrays", + "detail_head": "624ccfe44b1c5816f0279481d91cca6a5a2290ab", + "detail_file_mtime_utc": "2026-10-13T06:03:01.670920Z", + "files": [ + "research/r492-parent-accounting-audit/CLAIM.json", + "research/r492-parent-accounting-audit/EXPECTED.json", + "research/r492-parent-accounting-audit/README.md", + "research/r492-parent-accounting-audit/SOURCES.json", + "research/r492-parent-accounting-audit/verify.py" + ], + "issue_comment_count": 0, + "review_count": 0 + }, + { + "number": 729, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/729", + "title": "Independent verification: audit helper-frame lifetimes with a scalar-preserving regression", + "author": "sk1-j", + "head": "deaed262cebc50bdb0c27c6ba132b8f8289b3eef", + "updated_at": "2026-10-13T04:56:24Z", + "classification": "adjacent_distinct", + "scope": "Helper-frame persistent lifetime monotonicity and standalone-interface regression.", + "inspection": "title/body, detail, complete changed-file list, relevant patches, saved issue-comment/review arrays", + "detail_head": "deaed262cebc50bdb0c27c6ba132b8f8289b3eef", + "detail_file_mtime_utc": "2026-10-13T06:03:04.504695Z", + "files": [ + "research/helper-frame-lifetime-audit/GAP.json", + "research/helper-frame-lifetime-audit/README.md", + "research/helper-frame-lifetime-audit/RESULT.json", + "research/helper-frame-lifetime-audit/reproduce_gap.py", + "research/helper-frame-lifetime-audit/test_verify.py", + "research/helper-frame-lifetime-audit/verify.py" + ], + "issue_comment_count": 0, + "review_count": 0 + }, + { + "number": 675, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/675", + "title": "Research audit: PR626 owner boundaries and bridge-omission blind spot", + "author": "tekuuu", + "head": "f011d03633f0570257b653e7aa1e869b1b06d06a", + "updated_at": "2026-10-13T03:42:31Z", + "classification": "adjacent_distinct", + "scope": "Selected owner chronology and bridge-omission audit; shared roles do not duplicate eight emitter reversions.", + "inspection": "title/body" + }, + { + "number": 659, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/659", + "title": "Conditional κ = 0.001656193765416678: gauge44 without K-triangles (56 cold ends), with layered ends", + "author": "jeremykothe2", + "head": "4982f0ca66ffe0960b5a6451deb5b66b1039326b", + "updated_at": "2026-10-13T02:56:07Z", + "classification": "adjacent_distinct", + "scope": "Different R504 no-triangle construction; not original GlobalR/run504b compatibility fixture.", + "inspection": "title/body" + }, + { + "number": 655, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/655", + "title": "Conditional κ = 0.00165395497190225: pivot swaps, entering ends and cold dim-8 ends layered on PR645's gauge44 with PR589", + "author": "jeremykothe2", + "head": "3e669dc7987cb2295a71664b77e110c0cd979a87", + "updated_at": "2026-10-13T02:13:00Z", + "classification": "adjacent_distinct", + "scope": "Changed pivot and cold/entering-end construction with spot-width controls.", + "inspection": "title/body" + }, + { + "number": 641, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/641", + "title": "Conditional κ = 0.001636523543003976: cost-neutral pivot swaps with four entering ends (s4) on PR635", + "author": "jeremykothe2", + "head": "ff580ea5407aa427d64233523e46ee0afe24a766", + "updated_at": "2026-10-13T00:36:30Z", + "classification": "adjacent_distinct", + "scope": "Changed pivot-swap construction and exact per-provider spot-width rule.", + "inspection": "title/body" + } + ], + "documented_32_site_inventory": [ + { + "site": "bind.word_R", + "file_alias": "bind", + "generalized_expression": "`(v,h,centres)==(112,9,8)`, R a positive int, one R across providers", + "revert_expression": "`(v,h,R,centres)==(112,9,504,8)`", + "quantity_kind": "R", + "quantity_justification": "the bound word's own helper count", + "proof_note_reported_R492_outcome": "fail (AssertionError)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "bind.helper_range", + "file_alias": "bind", + "generalized_expression": "`range(2*112,2*112+word['R'])`", + "revert_expression": "`range(224,728)`", + "quantity_kind": "R", + "quantity_justification": "helper registers are `[2v,2v+R)`", + "proof_note_reported_R492_outcome": "fail (IndexError)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "bind.spot_width8", + "file_alias": "bind", + "generalized_expression": "`widths[h]==8 for h in SPOT`", + "revert_expression": "`… in (270,282,294,306)`", + "quantity_kind": "R (helper map)", + "quantity_justification": "the same four PR558 helpers, renumbered", + "proof_note_reported_R492_outcome": "fail (AssertionError)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.R_from_providers", + "file_alias": "emit", + "generalized_expression": "`R=pc['R']` (all providers equal)", + "revert_expression": "`R=504`", + "quantity_kind": "R", + "quantity_justification": "hosted calls run the provider words; the old code took R from the parent", + "proof_note_reported_R492_outcome": "fail (IndexError)", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.roles_72R", + "file_alias": "emit", + "generalized_expression": "`len(roles)==72*R`", + "revert_expression": "`72*504`", + "quantity_kind": "R", + "quantity_justification": "one role per (call, helper)", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.widths_range", + "file_alias": "emit", + "generalized_expression": "`for h in range(R)`", + "revert_expression": "`range(504)`", + "quantity_kind": "R", + "quantity_justification": "one width per helper", + "proof_note_reported_R492_outcome": "fail (IndexError)", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.all_helpers_owned", + "file_alias": "emit", + "generalized_expression": "`set(bycall[k])==set(range(R))`", + "revert_expression": "`range(504)`", + "quantity_kind": "R", + "quantity_justification": "every helper of a call is owned", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.physical", + "file_alias": "emit", + "generalized_expression": "`physical=DATA+C+R+2`", + "revert_expression": "`+504+`", + "quantity_kind": "R", + "quantity_justification": "stock = data + centres + R helpers + 2 coefficient columns", + "proof_note_reported_R492_outcome": "fail (independent audit)", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.reserved_tableau", + "file_alias": "emit", + "generalized_expression": "`[DATA+C,DATA+C+R]`", + "revert_expression": "`+504`", + "quantity_kind": "R", + "quantity_justification": "the private tableau holds R helper columns", + "proof_note_reported_R492_outcome": "fail (independent audit)", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "emit.parent_R0", + "file_alias": "emit", + "generalized_expression": "`parent physical-live==C+R0+2`", + "revert_expression": "`C+R+2` (provider R)", + "quantity_kind": "R0 control", + "quantity_justification": "parent stock identity", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "emit.version_label", + "file_alias": "emit", + "generalized_expression": "`'round20-R%d-…'%R`", + "revert_expression": "`'round20-R504-…'`", + "quantity_kind": "cosmetic", + "quantity_justification": "a label that no check reads", + "proof_note_reported_R492_outcome": "pass_changed (expected pass)", + "inventory_category": "recommended_eight_emitter_sites", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "audit.spot_width8", + "file_alias": "audit", + "generalized_expression": "`widths[h]==8 for h in SPOT`", + "revert_expression": "PR558 indices", + "quantity_kind": "R (helper map)", + "quantity_justification": "as bind", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "invoice.recount_R", + "file_alias": "invoice", + "generalized_expression": "`(v,h)==(112,9)`, helpers = `w['R']`", + "revert_expression": "`(v,helpers,h)==(112,504,9)`", + "quantity_kind": "R", + "quantity_justification": "helper count of the recounted word", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "invoice.run_R_n", + "file_alias": "invoice", + "generalized_expression": "common provider R, `n=2v+R`", + "revert_expression": "`helpers=504; n=728`", + "quantity_kind": "R", + "quantity_justification": "n = 2v+R", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "invoice.parent_R0", + "file_alias": "invoice", + "generalized_expression": "`parent_physical==parent_live+parent_helpers+…`", + "revert_expression": "`+helpers+`", + "quantity_kind": "R0 control", + "quantity_justification": "parent stock identity", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "invoice.route_items", + "file_alias": "invoice", + "generalized_expression": "`+2*call_count*helpers`", + "revert_expression": "`*504`", + "quantity_kind": "R", + "quantity_justification": "per-call in/out routes of the R hosted helpers (PR531 invoice_final); assemble recounts with `2*72*R`", + "proof_note_reported_R492_outcome": "fail (assemble)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "assemble.R", + "file_alias": "assemble", + "generalized_expression": "`R=invoice['helpers']`", + "revert_expression": "`R=504`", + "quantity_kind": "R", + "quantity_justification": "invoice helper count, equal for every provider", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.owners_per_call", + "file_alias": "assemble", + "generalized_expression": "`==2*112+R`", + "revert_expression": "`==728`", + "quantity_kind": "R", + "quantity_justification": "whole owners per call = 2v + R", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.hosted_72R", + "file_alias": "assemble", + "generalized_expression": "`==72*R` (new, stronger)", + "revert_expression": "`==72*504`", + "quantity_kind": "R", + "quantity_justification": "one helper owner chart per (call, helper)", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.stock_helpers", + "file_alias": "assemble", + "generalized_expression": "`local_helpers=R`", + "revert_expression": "`504`", + "quantity_kind": "R", + "quantity_justification": "physical stock term", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.provider_helpers", + "file_alias": "assemble", + "generalized_expression": "`p['helpers']==R`", + "revert_expression": "`504`", + "quantity_kind": "R", + "quantity_justification": "provider helper count", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.provider_n", + "file_alias": "assemble", + "generalized_expression": "`p['n']==2*112+R`", + "revert_expression": "`728`", + "quantity_kind": "R", + "quantity_justification": "exact columns", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.width_sum", + "file_alias": "assemble", + "generalized_expression": "`9*R-entrance-codim`", + "revert_expression": "`9*504-…`", + "quantity_kind": "R", + "quantity_justification": "Σ widths over R helpers", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.width_len", + "file_alias": "assemble", + "generalized_expression": "`len(widths)==R`", + "revert_expression": "`504`", + "quantity_kind": "R", + "quantity_justification": "one width per helper", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.exact_columns", + "file_alias": "assemble", + "generalized_expression": "`all_exact_columns==2*112+R`", + "revert_expression": "`728`", + "quantity_kind": "R", + "quantity_justification": "n = 2v+R", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.dirty_columns", + "file_alias": "assemble", + "generalized_expression": "`dirty_helper_columns==R`", + "revert_expression": "`504`", + "quantity_kind": "R", + "quantity_justification": "R helper columns restored", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.local_adapters", + "file_alias": "assemble", + "generalized_expression": "`16*(macros+children+2*112+R+8)+64*73`", + "revert_expression": "`+728+8`", + "quantity_kind": "R", + "quantity_justification": "adapter formula with n = 2v+R", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "assemble.route_items", + "file_alias": "assemble", + "generalized_expression": "`+2*72*R+`", + "revert_expression": "`+2*72*504+`", + "quantity_kind": "R", + "quantity_justification": "matches the invoice term", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "assemble.parent_banks", + "file_alias": "assemble", + "generalized_expression": "`+9*parent_banks+`, with `parent_banks=(11704-7168)/9` asserted = 504", + "revert_expression": "`+9*504+`", + "quantity_kind": "R0", + "quantity_justification": "parent geometry, independent of the providers", + "proof_note_reported_R492_outcome": "pass_identical (expected pass)", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [ + 724 + ] + }, + { + "site": "assemble.spot_width8", + "file_alias": "assemble", + "generalized_expression": "`p['widths'][h]==8 for h in SPOT`", + "revert_expression": "PR558 indices", + "quantity_kind": "R (helper map)", + "quantity_justification": "as bind", + "proof_note_reported_R492_outcome": "fail", + "inventory_category": "assembly_source_replay_claimed_by_pr766", + "exact_source_replay_overlap": [ + 766 + ], + "related_evidence_prs": [] + }, + { + "site": "controls.swap_spot", + "file_alias": "assembly_controls", + "generalized_expression": "`cold_helper_width_swap_h` for h in SPOT", + "revert_expression": "`for h in (270,282,294,306)`", + "quantity_kind": "R (helper map)", + "quantity_justification": "at a PR558 index of width 9 the swap is the identity; strict mode then reports \"Invalid admission receipt accepted\"", + "proof_note_reported_R492_outcome": "fail (`ck:cold_helper_width_swap_294` accepted)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + }, + { + "site": "identity.start_register", + "file_alias": "generated_identity_controls", + "generalized_expression": "`r = 2*112 + SPOT[2]`", + "revert_expression": "`r = 518`", + "quantity_kind": "R (helper map)", + "quantity_justification": "same-rank start-frame mutation of an entering helper (PR558 helper 294; image 288, register 512)", + "proof_note_reported_R492_outcome": "fail (StopIteration: register 518 is rank 0 here)", + "inventory_category": "outside_recommended_scope", + "exact_source_replay_overlap": [], + "related_evidence_prs": [] + } + ], + "recommended_scope": { + "sites": [ + "emit.R_from_providers", + "emit.roles_72R", + "emit.widths_range", + "emit.all_helpers_owned", + "emit.physical", + "emit.reserved_tableau", + "emit.parent_R0", + "emit.version_label" + ], + "rationale": "Complete eight-site emitter source-control slice is not claimed by identified public overlaps.", + "excludes": [ + "14 assembly source-site replay already claimed by PR766", + "duplicate PR724 invoice recount and novelty claim about R/R0 prose", + "fresh scalar/phase/restoration proof", + "original unavailable scratch 32-site suite and run504b fixture" + ], + "independent_review_controls": [ + { + "site": "emit.R_from_providers", + "source_line": 39, + "R492_expected_kind": "source_exception", + "rejection_source": "code/emit_allcold.py", + "rejection_line": 42, + "expected_exception": "IndexError", + "explanation": "Provider loop attempts to index native register 716 when forced to 504.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.roles_72R", + "source_line": 48, + "R492_expected_kind": "source_assertion", + "rejection_source": "code/emit_allcold.py", + "rejection_line": 48, + "expected_exception": "AssertionError", + "explanation": "35424 differs from 36288.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.widths_range", + "source_line": 42, + "R492_expected_kind": "source_exception", + "rejection_source": "code/emit_allcold.py", + "rejection_line": 42, + "expected_exception": "IndexError", + "explanation": "Width scan attempts native helper 492 / register 716.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.all_helpers_owned", + "source_line": 77, + "R492_expected_kind": "source_assertion", + "rejection_source": "code/emit_allcold.py", + "rejection_line": 77, + "expected_exception": "AssertionError", + "explanation": "Per-call helper set 0..491 differs from 0..503.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.physical", + "source_line": 92, + "R492_expected_kind": "downstream_output_rejection", + "rejection_source": "code/audit_allcold.py", + "rejection_line": 85, + "expected_exception": null, + "explanation": "Mutated emitter produces 7682; independent geometry or production audit rejects.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.reserved_tableau", + "source_line": 96, + "R492_expected_kind": "downstream_output_rejection", + "rejection_source": "code/audit_allcold.py", + "rejection_line": 124, + "expected_exception": null, + "explanation": "Mutated tableau end7680 violates exact namespace; independent geometry or production audit rejects.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.parent_R0", + "source_line": 93, + "R492_expected_kind": "source_assertion", + "rejection_source": "code/emit_allcold.py", + "rejection_line": 93, + "expected_exception": "AssertionError", + "explanation": "Parent physical-live514 differs from C+R+2=502.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + }, + { + "site": "emit.version_label", + "source_line": 96, + "R492_expected_kind": "accepted_changed_metadata", + "rejection_source": null, + "rejection_line": null, + "expected_exception": null, + "explanation": "Only version and directly derived template digests change; mathematical payload is identical.", + "R504_expected": "accepted_identical on a correctly constructed R504 fixture; original scratch fixture not reproduced" + } + ], + "expected_selected_geometry": { + "R": 492, + "R0": 504, + "v": 112, + "centres": 8, + "calls": 72, + "native_columns": 716, + "hosted_roles": 35424, + "live": 7168, + "physical": 7670, + "parent_live": 11704, + "parent_physical": 12218, + "centres_interval": [ + 7168, + 7176 + ], + "tableau_interval": [ + 7176, + 7668 + ], + "coefficient_interval": [ + 7668, + 7670 + ], + "rank_mass": 520704, + "deficit": 2560 + } + }, + "limitations": [ + "Only saved public open-queue title/body inventory was searched comprehensively.", + "Changed-file lists and patches were inspected only for PR766, PR724 and PR729.", + "No original PR code was executed; submitted validation reports remain author claims.", + "No review-comment endpoint was inspected; saved issue-comment and review arrays for closest three PRs were empty.", + "Non-atomic pagination duplicated PR29; deduplicated inventory and issue PR set agree but do not prove server completeness.", + "Closed PRs not represented in pinned ledger, private/local work, buried unmentioned file content and subsequent updates can overlap.", + "Current maintainer review already records generalized R504 compatibility, distinct from unavailable 32-site scratch suite.", + "Original PR626 archive omits parent/hosted GLOBAL-TEMPLATE files; a retained donor parent was found and independently matches archived parent payload digest. Record donor provenance separately from original unavailable scratch fixtures." + ], + "evidence_files": [ + { + "path": "open-pulls.json", + "sha256": "338ae6bceef91e89aba9f95a0482c9ff973a09ebba24a1cf9f01c593a6320539", + "mtime_utc": "2026-10-13T06:01:28.508101Z" + }, + { + "path": "open-issues.json", + "sha256": "9a2592b907325610b48f6c9651087349ee86761e85b30fd310e9844123d50305", + "mtime_utc": "2026-10-13T06:01:38.693470Z" + }, + { + "path": "sprint-gist.json", + "sha256": "0a03732189d0b094f0f1a41bb9e1e90dac6453cf960031a80d9e3b4a4d68243d", + "mtime_utc": "2026-10-13T06:01:40.154796Z" + }, + { + "path": "pr-766.json", + "sha256": "1d89f04729164dd838d20a1044307d95e308595fcbda5a4459e392e50b208609", + "mtime_utc": "2026-10-13T06:02:58.863021Z" + }, + { + "path": "pr-766-comments.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:02:59.347121Z" + }, + { + "path": "pr-766-reviews.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:03:00.082783Z" + }, + { + "path": "pr-766-files.json", + "sha256": "c0bd8f264b696642be9081ce9150743cd127e10b8d5686a49e79395b015e3185", + "mtime_utc": "2026-10-13T06:03:00.726179Z" + }, + { + "path": "pr-724.json", + "sha256": "835d5becb521d58cb0cf3b869a327fdb48fcde1bb045842b0de10680320fc002", + "mtime_utc": "2026-10-13T06:03:01.670920Z" + }, + { + "path": "pr-724-comments.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:03:02.167713Z" + }, + { + "path": "pr-724-reviews.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:03:02.703116Z" + }, + { + "path": "pr-724-files.json", + "sha256": "4f645e0a4bbab51f6f81a97fddbbe28d4a5fc4a142e6ef9ec3c151e870cc0dc6", + "mtime_utc": "2026-10-13T06:03:03.336649Z" + }, + { + "path": "pr-729.json", + "sha256": "5e9b45b968c2de87d695726ff14b197c489ae6011b8044776fd0c1c9cbc2430b", + "mtime_utc": "2026-10-13T06:03:04.504695Z" + }, + { + "path": "pr-729-comments.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:03:04.953137Z" + }, + { + "path": "pr-729-reviews.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "mtime_utc": "2026-10-13T06:03:05.517399Z" + }, + { + "path": "pr-729-files.json", + "sha256": "37f144f45a3944dd002ee1a5f122b257e78f29fd772e2838de93364f85042632", + "mtime_utc": "2026-10-13T06:03:06.047978Z" + } + ], + "repository_evidence": [ + { + "path": "CONTRIBUTING.md", + "sha256": "a10dd640ec6f4b1d8b6acc31220af512335dc093f634cd25f601acb07ac53d53" + }, + { + "path": "docs/research/community-k492-review.md", + "sha256": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47" + }, + { + "path": "docs/research/community-k492-integration.json", + "sha256": "ec071b7f7e425ee0cecffe2f83d25e77e9530eb21abb8b85f7656c2429d56ed2" + }, + { + "path": "docs/research/pr-ledger.md", + "sha256": "2e811684201e08007377ee97b1c35c0f0b3c026dd8207e7b0de3ff7cd1e13a91" + }, + { + "path": "docs/research/contribution-review.md", + "sha256": "d1bc578e0dcd7bd139d04fba1b494d93c78070d53ec7df80631431154b145ba7" + }, + { + "path": "certificates/selected-result.json", + "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53" + }, + { + "path": "research/complex-k492-owner-repair/PROOF-NOTE-R.md", + "sha256": "22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed" + }, + { + "path": "research/complex-k492-owner-repair/code/emit_allcold.py", + "sha256": "fe26f10fe5d30ed407a37540a45ef94f44576dd241d09e19aef5db1efb072746" + }, + { + "path": "research/complex-k492-owner-repair/code/audit_allcold.py", + "sha256": "cea021ae79658ca7ca4d07f1e1a70bdb4947afaf95b362114c11032c0fef889a" + } + ], + "actions": { + "publications": 0, + "source_modifications": 0, + "downloaded_code_executed": false + }, + "parent_fixture_resolution": { + "donor_path": "research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz", + "container_sha256": "ab8448de2036a23d9b55a196a8846512dc24fdf09855c1e0f0caa5b7a6965f7b", + "decompressed_sha256": "7db047a427a7979d69e163c78a1e32bd445628fb86723e131a3138361355a9c3", + "comparison_receipt": "research/community-k492-audit/pr626/replay/mixed-global/hosted/HOSTED.json", + "receipt_field": "parent_template_sha256", + "independently_checked_equal": true, + "synthetic": false + }, + "audit_updated_at_utc": "2026-10-13T06:17:25.229440+00:00", + "later_independent_implementation_review": { + "report": "astra-review.md", + "command": "astra-run-command.json", + "receipts": "astra-receipt-review.json", + "status": "PASS", + "pending_PR_code_executed": false, + "reviewed_repository_primary_emitter_executed": true, + "output": "/tmp/k492-emitter-astra-review-20261013" + } +} diff --git a/research/k492-emitter-independent-controls/independent.py b/research/k492-emitter-independent-controls/independent.py new file mode 100644 index 0000000000..bf70dc5cbb --- /dev/null +++ b/research/k492-emitter-independent-controls/independent.py @@ -0,0 +1,348 @@ +"""Exact, standalone structural checker for the eight K492 emitter R/R0 sites. + +No repository implementation is imported. Inputs are the retained source words, +programs, literal owner allocation, data phases, and parent template. This is +not a scalar/Clifford replay or an invoice/assembly checker. + +Prepared with substantial OpenAI Codex (GPT-6 Astra) assistance. Apache-2.0. +""" +from __future__ import annotations + +from collections import Counter, defaultdict +from functools import lru_cache +import gzip +import hashlib +import json +from pathlib import Path + + +class Rejected(ValueError): + def __init__(self, obligation, detail): + self.obligation = obligation + self.detail = detail + super().__init__(f"{obligation}: {detail}") + + +def require(condition, obligation, detail): + if not condition: + raise Rejected(obligation, detail) + + +def encoded(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def digest(value): + return hashlib.sha256(encoded(value)).hexdigest() + + +def read(path): + raw = Path(path).read_bytes() + return json.loads(gzip.decompress(raw) if str(path).endswith(".gz") else raw) + + +def rank(vectors): + """Binary Gaussian elimination; no floating point or repository rank helper.""" + pivots = {} + for item in vectors: + require(type(item) is int and 0 <= item < 512, + "frame.vector", str(item)) + value = item + while value: + k = value.bit_length() - 1 + if k not in pivots: + pivots[k] = value + break + value ^= pivots[k] + return len(pivots) + + +@lru_cache(maxsize=None) +def chart(port_vector): + """Matrix columns of x -> x + u, followed by the declared pivot swap. + + u=q+e_z has even weight, so the transvection is orthogonal over F2. + Verify its entire Gram matrix independently rather than trusting this fact. + """ + z = next(j for j in range(9) if not (port_vector >> j) & 1) + u = port_vector ^ (1 << z) + columns = [((1 << j) ^ (u if (u >> j) & 1 else 0)) for j in range(73)] + columns[0], columns[z] = columns[z], columns[0] + require(all((x & y).bit_count() % 2 == (i == j) + for i, x in enumerate(columns) for j, y in enumerate(columns)), + "chart.orthogonality", str(port_vector)) + return tuple(columns) + + +class Reconstruction: + def __init__(self, fixture): + self.root = Path(fixture) + self.base = self.root / "base" + self.plan = read(self.root / "PLAN.json") + self.allocation = read(self.root / "OWNERS.json.gz") + self.spec = read(self.root / "SPEC.json") + self.parent = read(self.base / "split-centres/GLOBAL-TEMPLATE.json.gz") + self.parent_word = read(self.base / "split-centres/CANONICAL-WORD.json.gz") + self.phases = read(self.base / "work/complex-nine-native/DATA-PHASES.json") + self.words, self.widths, self.programs, self.checks = {}, {}, {}, {} + self.source_hashes = {} + for file in sorted(self.base.rglob("*")): + if file.is_file(): + self.source_hashes[file.relative_to(self.base).as_posix()] = hashlib.sha256(file.read_bytes()).hexdigest() + for pid in sorted(self.plan["provider_registry"]): + directory = self.base / "providers" / pid + word = read(directory / "CANONICAL-WORD.json.gz") + self.words[pid] = word + require((word["v"], word["h"], len(word["centers"])) == (112, 9, 8), + "provider.geometry", pid) + require(type(word["R"]) is int and word["R"] > 0, + "provider.R", pid) + n = 2 * word["v"] + word["R"] + require(len(word["start"]) == len(word["final"]) == n, + "provider.columns", pid) + widths = [] + for h in range(word["R"]): + entrance = word["frames"][word["start"][224 + h]] + terminal = word["frames"][word["final"][224 + h]] + a, b = rank(entrance), rank(terminal) + require(a == len(entrance) and b == len(terminal) + and rank(entrance + terminal) == b, + "provider.nested_independent_frames", f"{pid}:{h}") + require(0 < b - a <= 9, "provider.width", f"{pid}:{h}") + widths.append(b - a) + self.widths[pid] = widths + require(widths == self.plan["provider_registry"][pid]["widths"], + "plan.widths", pid) + self.programs[pid] = read(directory / "LOCAL-PROGRAMS.json.gz") + self.checks[pid] = read(directory / "LOCAL-CHECKS.json") + for orientation, events in self.programs[pid].items(): + literal = dict(sorted(Counter(e[-1] for e in events if e[0] in ("climb", "center")).items())) + claimed = {int(k): v for k, v in self.checks[pid][orientation]["paid_profile"].items()} + require(literal == claimed, "provider.literal_profile", f"{pid}:{orientation}") + require(digest(events) == self.checks[pid][orientation]["sha256"], + "provider.program_digest", f"{pid}:{orientation}") + counts = {w["R"] for w in self.words.values()} + require(len(counts) == 1, "provider.common_R", str(counts)) + self.R = counts.pop() + self.v = self.parent_word["v"] + self.R0 = self.parent_word["R"] + self.live = 8 * 8 * self.v + self.centers = len(self.parent_word["centers"]) + require((self.v, self.parent_word["h"], self.R0, self.centers) == (112, 9, 504, 8), + "parent.geometry", "fixed parent must remain the retained 504-helper template") + require((self.parent["live"], self.parent["physical"]) == + (self.live + 9 * self.R0, self.live + 10 * self.R0 + self.centers + 2), + "parent.stock_R0", "parent live/physical must use R0, not provider R") + self.physical = self.live + self.centers + self.R + 2 + for port in self.parent_word["ports"]: + chart(port) + self.gram_entries = len(set(self.parent_word["ports"]))*73*73 + self.order = [tuple(c) for c in self.plan["order"]] + domain = {(s, r) for s in range(9) for r in range(8)} + require(len(self.order) == 72 and set(self.order) == domain, + "plan.call_domain", "all 9 by 8 calls exactly once") + self.dispatch = {(s, r): pid for s, r, pid in self.spec["dispatch"]} + selected = {(c["stage"], c["replica"]): c for c in self.plan["provider_calls"]} + require(set(selected) == domain and self.dispatch == {k:c["provider"] for k,c in selected.items()}, + "plan.dispatch", "spec and plan must bind the same calls") + self.selected = selected + self.old_calls = {(c["stage"], c["replica"]): c for c in self.parent["calls"]} + self.idle = {(c["child"], c["port"]): c for c in self.parent["idle_children"]} + self.side_pair = {i:(side,e["pair"]) for e in self.parent["execution_schedule"] + if e["kind"] == "idle_cover_sweep" for side,i in enumerate(e["child_indices"])} + self.by_role = {} + for row in self.allocation: + key = row["stage"], row["replica"], row["helper"] + require(key not in self.by_role, "allocation.duplicate_role", str(key)) + self.by_role[key] = row + expected = {(s, r, h) for s, r in self.order for h in range(self.R)} + require(set(self.by_role) == expected, "allocation.complete_role_domain", "72 times R literal roles") + self.expected_schedule = self.reconstruct_schedule() + + def reconstruct_schedule(self): + """Assign each parent event to its most recent local sweep, then expand.""" + src = self.parent["execution_schedule"] + local_positions = [j for j, e in enumerate(src) if e["kind"] == "local_cover_sweep"] + blocks = {} + for i, pos in enumerate(local_positions): + stop = local_positions[i+1] if i+1 < len(local_positions) else len(src)-2 + blocks[src[pos]["stage"]] = range(pos, stop) + out = [] + for time, (stage, replica) in enumerate(self.order): + for j in blocks[stage]: + event = dict(src[j], time=time, replica=replica, replicas=[replica], source_event=j) + if event["kind"] == "local_cover_sweep": + event["provider_id"] = self.dispatch[stage, replica] + out.append(event) + for j in range(len(src)-2, len(src)): + event = dict(src[j], source_event=j) + if event["kind"] == "bank_padding_cover_sweep": + event["families"] = [self.live, self.live] + else: + event.update(families=[0, self.live], charged_calls_per_cover=self.live) + out.append(event) + return out + + def verify(self, template, summary, sigmas): + """Verify semantics first; refreshable output digests are checked last.""" + removed = {"local_programs", "exact_local_clifford_recipe_sha256", "residual_adapter_sha256"} + rewritten = {"version", "live", "physical", "private_namespace", "local_providers", "calls", + "idle_children", "hosting", "route_semantics", "bank_padding", "cover_final_correction", + "execution_schedule", "loop_order", "async_schedule", "provider_dispatch"} + require(set(template) == (set(self.parent)-removed)|rewritten, + "emit.template_fields", "unexpected or missing top-level field") + for key in set(self.parent)-removed-rewritten: + require(template[key] == self.parent[key], "emit.retained_parent_field", key) + expected_padding = dict(self.parent["bank_padding"],families=[],children=[]) + expected_correction = dict(self.parent["cover_final_correction"],families=[0,self.live], + charged_calls_per_cover=self.live) + require(template["bank_padding"] == expected_padding and template["cover_final_correction"] == expected_correction, + "emit.global_corrections", "retained correction changes differ") + require({k:v for k,v in template["route_semantics"].items() if k != "helper"} == + {k:v for k,v in self.parent["route_semantics"].items() if k != "helper"}, + "emit.retained_routes", "non-helper route semantics changed") + hosting = template["hosting"] + require(hosting["max_helpers_per_physical_family_per_call"] == 1 and hosting["banks"] == [0]*9 + and hosting["owner_map_sha256"] == hashlib.sha256((self.root/"OWNERS.json.gz").read_bytes()).hexdigest(), + "emit.hosting_contract", "owner source or whole-invocation limits changed") + require(template["live"] == self.live, "emit.live", str(template["live"])) + require(template["physical"] == self.physical, "emit.physical", + f"expected {self.live}+{self.centers}+{self.R}+2={self.physical}, got {template['physical']}") + expected_namespace = {"centers":[self.live,self.live+self.centers], + "reserved_tableau":[self.live+self.centers,self.live+self.centers+self.R], + "coefficient":[self.physical-2,self.physical]} + require(template["private_namespace"] == expected_namespace, + "emit.reserved_tableau", str(template["private_namespace"])) + require(template["execution_schedule"] == self.expected_schedule, + "emit.controller_expansion", "source event blocks or complete invocation order differ") + require(template["async_schedule"]["order"] == [list(c) for c in self.order], + "emit.call_order", "plan order changed") + require(template["async_schedule"]["source_schedule"] == self.parent["execution_schedule"] + and template["async_schedule"]["source_call_order"] == [[c["stage"],c["replica"]] for c in self.parent["calls"]] + and template["async_schedule"]["source_plan_sha256"] == + hashlib.sha256((self.root/"PLAN.json").read_bytes().replace(b"\r\n",b"\n")).hexdigest(), + "emit.async_source_binding", "parent schedule/calls or source PLAN changed") + require(len(template["calls"]) == 72, "emit.call_count", str(len(template["calls"]))) + require(template["hosting"]["pooled_slots"] == self.allocation, + "emit.role_metadata", "serialized role metadata must be the complete literal allocation") + require(set(template["local_providers"]) == set(self.words), + "emit.provider_registry", "provider set changed") + for pid, word in self.words.items(): + p = template["local_providers"][pid] + require(all(p[k] == word[k] for k in ("v","h","R","ports","centers")) + and p["widths"] == self.widths[pid] + and p["local_programs"] == self.programs[pid] + and p["local_program_checks"] == self.checks[pid], + "emit.provider_semantics", pid) + linked = {"canonical_word_sha256":"CANONICAL-WORD.json.gz", "local_programs_sha256":"LOCAL-PROGRAMS.json.gz", + "exact_local_clifford_recipe_sha256":"CLIFFORD-RECIPES.json", "residual_adapter_sha256":"RESIDUAL-ADAPTERS.json"} + require(all(p[field] == self.source_hashes[f"providers/{pid}/{filename}"] for field,filename in linked.items()), + "emit.provider_artifact_binding", pid) + intervals = defaultdict(list) + paid = Counter() + actual_sigmas = {} + stream = hashlib.sha256() + entering = cross = 0 + for time, call in enumerate(template["calls"]): + key = (call["stage"], call["replica"]) + require(key == self.order[time] and call["time"] == time, + "emit.call_order", str(key)) + pid = self.dispatch[key] + require(call["provider_id"] == pid, "emit.call_provider", str(key)) + source = self.old_calls[key] + changed_call_fields = {"owners","time","provider_id","local_program_sha256"} + require({k:v for k,v in call.items() if k not in changed_call_fields} == + {k:v for k,v in source.items() if k not in changed_call_fields}, + "emit.retained_call_fields", str(key)) + require(call["orientation"] == source["orientation"], "emit.orientation", str(key)) + require(call["local_program_sha256"] == self.checks[pid][call["orientation"]]["sha256"], + "emit.call_program", str(key)) + owners = call["owners"] + require(len(owners) == 224 + self.R, "emit.all_helpers_owned", + f"{key}: expected {224+self.R} owners, got {len(owners)}") + require(len({x[0] for x in owners}) == len(owners) + and all(type(x[0]) is int and 0 <= x[0] < self.live for x in owners), + "emit.owner_family_uniqueness", str(key)) + require(owners[:224] == source["owners"][:224], "emit.data_owners", str(key)) + for helper, (family, route) in enumerate(owners[224:]): + role = self.by_role[(*key, helper)] + width = self.widths[pid][helper] + child, off = role["child"], role["offset"] + replica, port = divmod(role["copy"], 112) + side, pair = self.side_pair[child] + expected_family = ((replica * 4 + pair) * 2 + side) * 112 + port + require(family == expected_family == role["family"] and width == role["width"] + and replica == role["owner_replica"] and port == role["port"] and role["time"] == time, + "emit.role_binding", str((*key, helper))) + require(off >= 0 and off + width <= self.idle[child,port]["rank"], + "emit.role_interval", str((*key, helper))) + basis = chart(self.parent_word["ports"][port]) + axes = tuple(map(int,self.phases["recipes"][port]["idle_children"][child]["orthogonal_axes"])) + wanted = axes[off:off+width] + coordinates = [basis.index(v) for v in wanted] + spare = sorted(set(range(73)) - set(coordinates))[:9-width] + expected_route = [3,child,off] if width == 9 else [4,child,off,width,spare] + require(route == expected_route, "emit.residual_chart", str((*key,helper))) + indices = coordinates + spare + sorted(set(range(73))-set(coordinates)-set(spare)) + require(len(indices) == len(set(indices)) == 73, + "emit.chart_permutation", str((*key, helper))) + sigma = [basis[j] for j in indices] + sh = digest(sigma) + actual_sigmas[sh] = sigma + stream.update(encoded([*key,helper,family,sh])+b"\n") + intervals[child,replica,port].append((off, off+width)) + entering += width < 9 + cross += key[1] != replica + paid.update({int(k):v for k,v in self.checks[pid][call["orientation"]]["paid_profile"].items()}) + remainders = [] + for old in self.parent["idle_children"]: + child, port = old["child"], old["port"] + side, pair = self.side_pair[child] + for replica in range(8): + endpoint = 0 + for lo, hi in sorted(intervals[child,replica,port]): + require(lo == endpoint, "emit.disjoint_prefix", str((child,replica,port,lo,endpoint))) + endpoint = hi + remaining = old["rank"] - endpoint + if remaining: + remainders.append(dict(child=child,port=port,replica=replica,replicas=1, + family=((replica*4+pair)*2+side)*112+port, + rank=remaining,hosted=endpoint,pending_offset=endpoint)) + paid[remaining] += 1 + require(template["idle_children"] == remainders, "emit.idle_remainders", "literal remainder list differs") + profile = dict(sorted(paid.items())) + mass = sum(k*v for k,v in profile.items()) + require(73*self.live-mass == 2560, "emit.rank_mass", str(mass)) + require(profile == {int(k):v for k,v in self.plan["profile"].items()}, + "emit.plan_profile", str(profile)) + require(sigmas == actual_sigmas, "emit.sigma_artifact", "exact 73-column charts differ") + expected_summary = dict(live=self.live,physical=self.physical,rank_mass=mass,deficit=2560, + maxchild=max(profile),hosted_residuals=72*self.R, + entering_helper_roles=entering,unique_actual_73column_sigmas=len(actual_sigmas), + sigma_stream_sha256=stream.hexdigest(),cross_replica_helper_roles=cross, + asynchronous_order_sha256=digest([list(c) for c in self.order]),banks_per_stage=[0]*9, + provider_counts=dict(Counter(self.dispatch.values()))) + for key, value in expected_summary.items(): + require(summary[key] == value, "summary."+key, f"expected {value}, got {summary[key]}") + require({int(k):v for k,v in summary["global_profile"].items()} == profile, + "summary.global_profile", "literal program plus remainder recount differs") + require(summary["template_sha256"] == digest(template), "links.template", "digest mismatch") + parent_payload = gzip.decompress((self.base/"split-centres/GLOBAL-TEMPLATE.json.gz").read_bytes()) + require(summary["parent_template_sha256"] == hashlib.sha256(parent_payload).hexdigest(), + "links.parent", "digest mismatch") + artifact_names = ("CANONICAL-WORD.json.gz", "LOCAL-PROGRAMS.json.gz", "LOCAL-CHECKS.json", + "INDEPENDENT-LOCAL-REPLAY.json", "RESIDUAL-ADAPTERS.json", "CLIFFORD-RECIPES.json", "CLIFFORD-REVIEW.json") + required_sources = {"work/complex-nine-native/DATA-PHASES.json"} | { + f"providers/{pid}/{name}" for pid in self.words for name in artifact_names} + require(set(summary["source_artifacts"]) == required_sources, + "links.input_inventory", "exact data-phase plus seven-artifact-per-provider set required") + require(all(self.source_hashes.get(k) == v for k,v in summary["source_artifacts"].items()), + "links.inputs", "input byte digest mismatch") + return dict(status="PASS_EXACT_EMITTER_STRUCTURAL_CONTRACT",R=self.R,R0=self.R0, + provider_width_histograms={p:dict(sorted(Counter(w).items())) for p,w in self.widths.items()}, + provider_helper_frames_checked=sum(len(w) for w in self.widths.values()), + owners_per_call=224+self.R,role_domain_size=len(self.by_role),idle_remainders=len(remainders), + physical=self.physical,parent_live=self.parent["live"],parent_physical=self.parent["physical"], + global_profile=profile,rank_mass=mass,deficit=2560,entering_helper_roles=entering, + cross_replica_helper_roles=cross,actual_sigmas=len(actual_sigmas), + orthogonal_basis_gram_entries=self.gram_entries,template_semantic_sha256=digest(template)) diff --git a/research/k492-emitter-independent-controls/run.py b/research/k492-emitter-independent-controls/run.py new file mode 100644 index 0000000000..a16b7b561f --- /dev/null +++ b/research/k492-emitter-independent-controls/run.py @@ -0,0 +1,306 @@ +#!/usr/bin/env python3 +"""Replay the complete eight-site emitter slice and semantic controls offline. + +Usage from repository root: + python3 -B research/k492-emitter-independent-controls/run.py --out /tmp/k492-emitter-review + +Only the reviewed primary emitter and its witness loader run as subprocesses. +The independent checker imports no primary module. No solver, network, assembly, +invoice, credential, paid service, or original unavailable scratch fixture is used. +Prepared with substantial OpenAI Codex (GPT-6 Astra) assistance. Apache-2.0. +""" +from __future__ import annotations + +import argparse +import copy +import difflib +import gzip +import hashlib +import json +import os +from pathlib import Path +import platform +import re +import shutil +import subprocess +import sys +import time +import zlib + +from independent import Reconstruction, Rejected, digest, encoded, read, require + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE_COMMIT = "66849e1475c930fd7732b1a0067ffee7e1e95f60" +PKG = "research/complex-k492-owner-repair" +REPLAY = "research/community-k492-audit/pr626/replay/mixed-global" +PARENT = "research/structural-gain/frontier-composition/global-replay/base/split-centres/GLOBAL-TEMPLATE.json.gz" +FILES = ("CANONICAL-WORD.json.gz", "LOCAL-PROGRAMS.json.gz", "LOCAL-CHECKS.json", + "INDEPENDENT-LOCAL-REPLAY.json", "RESIDUAL-ADAPTERS.json", + "CLIFFORD-RECIPES.json", "CLIFFORD-REVIEW.json") + +# Each exact source anchor occurs once. No primary assertion is disabled. +REVERTS = [ + ("emit.R_from_providers", "R=pc['R'];assert type(R)", "R=504;assert type(R)", "primary_rejected"), + ("emit.roles_72R", "assert len(roles)==72*R", "assert len(roles)==72*504", "primary_rejected"), + ("emit.widths_range", "for h in range(R)] # HPE:", "for h in range(504)] # HPE:", "primary_rejected"), + ("emit.all_helpers_owned", "assert set(bycall[k])==set(range(R))", "assert set(bycall[k])==set(range(504))", "primary_rejected"), + ("emit.physical", "physical=DATA+C+R+2", "physical=DATA+C+504+2", "independent_rejected"), + ("emit.reserved_tableau", "'reserved_tableau':[DATA+C,DATA+C+R]", "'reserved_tableau':[DATA+C,DATA+C+504]", "independent_rejected"), + ("emit.parent_R0", "parent['physical']-parent['live']==C+R0+2", "parent['physical']-parent['live']==C+R+2", "primary_rejected"), + ("emit.version_label", "version='round20-R%d-asynchronous-whole-owner-v1'%R", "version='round20-R504-asynchronous-whole-owner-v1'", "pass_changed"), +] +PRIMARY_FAILURES = { + "emit.R_from_providers": (42,"IndexError"), + "emit.roles_72R": (48,"AssertionError"), + "emit.widths_range": (42,"IndexError"), + "emit.all_helpers_owned": (77,"AssertionError"), + "emit.parent_R0": (93,"AssertionError"), +} + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def dump(path, value): + Path(path).write_text(json.dumps(value, indent=2, sort_keys=True)+"\n", encoding="utf-8") + + +def mappings(): + items = { + "SPEC.json": f"{PKG}/data/SPEC.json", + "OWNERS.json.gz": f"{PKG}/data/OWNERS.json.gz", + "PLAN.json": f"{REPLAY}/PLAN.json", + "base/split-centres/GLOBAL-TEMPLATE.json.gz": PARENT, + "base/split-centres/CANONICAL-WORD.json.gz": f"{REPLAY}/base/split-centres/CANONICAL-WORD.json.gz", + "base/work/complex-nine-native/DATA-PHASES.json": f"{REPLAY}/base/work/complex-nine-native/DATA-PHASES.json", + } + for pid in ("ck", "jp8"): + for name in FILES: + rel = f"base/providers/{pid}/{name}" + items[rel] = f"{REPLAY}/{rel}" + return items + + +def verify_pins(): + pins = read(HERE/"INPUT-PINS.json") + expected_paths = set(mappings().values()) | {f"{PKG}/code/emit_allcold.py", f"{PKG}/code/witness.py", + f"{REPLAY}/hosted/HOSTED.json", f"{PKG}/PROOF-NOTE-R.md"} + require(pins["base_commit"] == BASE_COMMIT and set(pins["files"]) == expected_paths, + "source.pin_inventory", "exact input set required") + for path, item in pins["files"].items(): + require(sha(ROOT/path) == item["sha256"], "source.raw_pin", path) + if path.endswith(".gz"): + require(hashlib.sha256(gzip.decompress((ROOT/path).read_bytes())).hexdigest() == item["payload_sha256"], + "source.payload_pin", path) + return pins + + +def stage(out): + fixture = out/"fixture" + for target, source in mappings().items(): + path = fixture/target + path.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(ROOT/source, path) + return fixture + + +def invoke(out, fixture, name, source): + case = out/name + scripts = case/"source" + scripts.mkdir(parents=True) + (scripts/"emit_allcold.py").write_text(source, encoding="utf-8") + shutil.copyfile(ROOT/PKG/"code/witness.py", scripts/"witness.py") + argv = [sys.executable, "-B", str(scripts/"emit_allcold.py"), + "--base",str(fixture/"base"),"--owners",str(fixture/"OWNERS.json.gz"), + "--plan",str(fixture/"PLAN.json"),"--out",str(case/"emitted")] + env = dict(os.environ, WITNESS_SPEC=str(fixture/"SPEC.json"), PYTHONDONTWRITEBYTECODE="1") + for key in ("PYTHONOPTIMIZE", "WITNESS_DISCOVER", "WITNESS_RECORD"): + env.pop(key, None) + started = time.monotonic() + process = subprocess.run(argv, env=env, capture_output=True, text=True, timeout=120) + (case/"stdout.txt").write_text(process.stdout, encoding="utf-8") + (case/"stderr.txt").write_text(process.stderr, encoding="utf-8") + receipt = dict(argv=argv, cwd=str(Path.cwd()), exit_code=process.returncode, + seconds=round(time.monotonic()-started,6),stdout_sha256=sha(case/"stdout.txt"), + stderr_sha256=sha(case/"stderr.txt"), emitter_source_sha256=sha(scripts/"emit_allcold.py"), + witness_source_sha256=sha(scripts/"witness.py"), + environment_overrides={"WITNESS_SPEC":str(fixture/"SPEC.json"), "PYTHONDONTWRITEBYTECODE":"1"}, + environment_removed=["PYTHONOPTIMIZE","WITNESS_DISCOVER","WITNESS_RECORD"]) + dump(case/"COMMAND.json", receipt) + return case, process, receipt + + +def load_emission(case): + d = case/"emitted" + return read(d/"GLOBAL-TEMPLATE.json.gz"), read(d/"HOSTED.json"), read(d/"ACTUAL-SIGMAS.json.gz") + + +def semantic_controls(out, oracle, baseline): + original, original_summary, sigmas = baseline + controls = [] + + def trial(name, path, value, obligation, claim_summary=None): + template, summary = copy.deepcopy(original), copy.deepcopy(original_summary) + current = template + for token in path[:-1]: + current = current[token] + old = current[path[-1]] + current[path[-1]] = value + if claim_summary: + summary.update(claim_summary) + summary["template_sha256"] = digest(template) + require(summary["template_sha256"] != original_summary["template_sha256"], + "control.nonvacuous", name) + record = dict(name=name,json_replacement=dict(path=path,before=old,after=value), + summary_claim_changes=claim_summary or {}, refreshed_template_sha256=summary["template_sha256"], + refreshed_summary_sha256=digest(summary),sigmas_semantic_sha256=digest(sigmas), + source_pins_unchanged=True,expected_obligation=obligation) + if isinstance(old,list) and isinstance(value,list) and old[:-1] == value: + record["json_replacement"] = dict(operation="remove",path=path+[len(old)-1],before=old[-1]) + try: + result = oracle.verify(template,summary,sigmas) + except Rejected as error: + require(obligation == error.obligation,"control.expected_rejection",f"{name}: {error}") + record.update(outcome="semantic_rejected_after_hash_refresh",obligation=error.obligation,detail=error.detail) + else: + require(obligation is None,"control.unexpected_acceptance",name) + record.update(outcome="pass_changed",result=result) + controls.append(record) + + trial("R0-in-provider-stock",["physical"],original["physical"]+12,"emit.physical", + {"physical":original["physical"]+12}) + trial("R0-in-private-tableau",["private_namespace","reserved_tableau",1],7680,"emit.reserved_tableau") + trial("truncated-helper-domain",["calls",0,"owners"],original["calls"][0]["owners"][:-1],"emit.all_helpers_owned") + trial("aliased-helper-families",["calls",0,"owners",225],original["calls"][0]["owners"][224],"emit.owner_family_uniqueness") + trial("private-family-used-as-owner",["calls",0,"owners",224,0],7168,"emit.owner_family_uniqueness") + trial("provider-R-restored-to-504",["local_providers","ck","R"],504,"emit.provider_semantics") + trial("provider-width-spoof",["local_providers","ck","widths",0],8,"emit.provider_semantics") + ci, hi = next((ci,hi) for ci,c in enumerate(original["calls"]) for hi,o in enumerate(c["owners"]) + if hi>=224 and o[1][0]==4) + width = original["calls"][ci]["owners"][hi][1][3] + trial("narrow-helper-width-changed",["calls",ci,"owners",hi,1,3],width-1,"emit.residual_chart") + spare = original["calls"][ci]["owners"][hi][1][4] + trial("spectator-axis-changed",["calls",ci,"owners",hi,1,4,0],72 if spare[0]!=72 else 71,"emit.residual_chart") + trial("one-literal-role-omitted",["hosting","pooled_slots"],original["hosting"]["pooled_slots"][:-1],"emit.role_metadata", + {"hosted_residuals":72*oracle.R-1}) + trial("remainder-omitted",["idle_children"],original["idle_children"][:-1],"emit.idle_remainders") + trial("source-event-order-changed",["execution_schedule",0,"source_event"],1,"emit.controller_expansion") + trial("provider-artifact-link-changed",["local_providers","ck","residual_adapter_sha256"],"0"*64,"emit.provider_artifact_binding") + trial("retained-recipe-changed",["recipe",2,"coefficient"],-1,"emit.retained_parent_field") + trial("retained-call-window-changed",["calls",0,"window"],[],"emit.retained_call_fields") + trial("async-parent-schedule-erased",["async_schedule","source_schedule"],[],"emit.async_source_binding") + trial("cosmetic-label",["version"],"independent-emitter-cosmetic-control",None) + + for name, changed_sources, obligation in ( + ("source-inventory-erased",{},"links.input_inventory"), + ("source-artifact-hash-changed",dict(original_summary["source_artifacts"], + **{"providers/ck/RESIDUAL-ADAPTERS.json":"0"*64}),"links.inputs")): + summary = dict(original_summary,source_artifacts=changed_sources) + summary["template_sha256"] = digest(original) + try: + oracle.verify(original,summary,sigmas) + except Rejected as error: + require(error.obligation == obligation,"control.expected_rejection",f"{name}: {error}") + controls.append(dict(name=name,outcome="semantic_rejected_after_hash_refresh",obligation=error.obligation, + detail=error.detail,summary_source_artifacts=changed_sources, + refreshed_template_sha256=summary["template_sha256"],refreshed_summary_sha256=digest(summary), + source_pins_unchanged=True)) + else: + raise Rejected("control.unexpected_acceptance",name) + + # The same uncompressed JSON is accepted after actual gzip header/stream changes. + raw = encoded(original) + compressed = gzip.compress(raw,compresslevel=1,mtime=123456789) + restored = json.loads(gzip.decompress(compressed)) + result = oracle.verify(restored,original_summary,sigmas) + baseline_gzip = out/"baseline/emitted/GLOBAL-TEMPLATE.json.gz" + require(hashlib.sha256(compressed).hexdigest() != sha(baseline_gzip),"control.recompression_nonvacuous","container differs") + controls.append(dict(name="actual-gzip-recompression",outcome="pass_identical_semantics", + original_raw_sha256=sha(baseline_gzip),changed_raw_sha256=hashlib.sha256(compressed).hexdigest(), + unchanged_payload_sha256=hashlib.sha256(raw).hexdigest(),result=result)) + dump(out/"SEMANTIC-CONTROLS.json",controls) + return controls + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--out",type=Path,required=True) + args = ap.parse_args() + out = args.out.resolve() + require(not out.exists(),"output.fresh_directory",str(out)) + pins = verify_pins() + out.mkdir(parents=True) + dump(out/"INPUT-PINS.json",pins) + dump(out/"ENVIRONMENT.json",dict(python=sys.version,executable=sys.executable,platform=platform.platform(), + zlib_compile=zlib.ZLIB_VERSION,zlib_runtime=zlib.ZLIB_RUNTIME_VERSION, + base_commit=BASE_COMMIT,checker_sha256=sha(HERE/"independent.py"), + harness_sha256=sha(HERE/"run.py"),assertions_enabled=__debug__)) + fixture = stage(out) + source = (ROOT/PKG/"code/emit_allcold.py").read_text() + case, process, command = invoke(out,fixture,"baseline",source) + require(process.returncode == 0,"baseline.primary",process.stderr) + oracle = Reconstruction(fixture) + baseline = load_emission(case) + result = oracle.verify(*baseline) + retained = read(ROOT/REPLAY/"hosted/HOSTED.json") + require(baseline[1] == retained,"baseline.retained_HOSTED","fresh output must match retained receipt exactly") + dump(out/"BASELINE.json",result) + print("PASS baseline: R=492, R0=504, 35,424 roles, 7,670 physical rows",flush=True) + reverts = [] + for name, before, after, expected in REVERTS: + require(source.count(before) == 1,"revert.unique_anchor",name) + changed = source.replace(before,after) + case, process, command = invoke(out,fixture,name,changed) + patch = "".join(difflib.unified_diff(source.splitlines(True),changed.splitlines(True), + fromfile="original/emit_allcold.py",tofile=name+"/emit_allcold.py")) + (case/"source.patch").write_text(patch,encoding="utf-8") + record = dict(site=name,expected=expected,command=command,patch_sha256=sha(case/"source.patch")) + if process.returncode: + require(expected == "primary_rejected","revert.unexpected_process_failure",name+": "+process.stderr) + # Require an actual assertion or indexing failure at the mutated emitter, + # not a missing input/import/environment accident. + frames = re.findall(r'File "[^"\n]*emit_allcold\.py", line (\d+)',process.stderr) + last_error = process.stderr.rstrip().splitlines()[-1] + expected_line, expected_exception = PRIMARY_FAILURES[name] + require(frames and int(frames[-1]) == expected_line and last_error.split(":")[0] == expected_exception, + "revert.failure_kind",name) + record.update(outcome="primary_rejected",last_error=last_error,failing_emitter_line=expected_line, + failing_source_statement=changed.splitlines()[expected_line-1]) + else: + emission = load_emission(case) + try: + check = oracle.verify(*emission) + except Rejected as error: + require(expected == "independent_rejected" and error.obligation == name, + "revert.expected_semantic_failure",f"{name}: {error}") + record.update(outcome="independent_rejected",obligation=error.obligation,detail=error.detail, + refreshed_template_sha256=emission[1]["template_sha256"]) + else: + require(expected == "pass_changed","revert.unexpected_acceptance",name) + template = copy.deepcopy(emission[0]);template["version"] = baseline[0]["version"] + summary = copy.deepcopy(emission[1]);summary["template_sha256"] = baseline[1]["template_sha256"] + require(template == baseline[0] and summary == baseline[1] and emission[2] == baseline[2], + "revert.cosmetic_only","only version and its directly derived template hash may differ") + record.update(outcome="pass_changed",changed_fields=["GLOBAL-TEMPLATE.version","HOSTED.template_sha256"],result=check) + reverts.append(record) + print(f"PASS {name}: {record['outcome']}",flush=True) + dump(out/"SOURCE-REVERTS.json",reverts) + semantic = semantic_controls(out,oracle,baseline) + final = dict(status="PASS_COMPLETE_EIGHT_EMITTER_SITE_SLICE",base_commit=BASE_COMMIT, + baseline=result,source_reverts=dict(total=len(reverts),primary_rejected=5,independent_rejected=2,pass_changed=1), + semantic_controls=dict(total=len(semantic), + rejected=sum(c["outcome"] == "semantic_rejected_after_hash_refresh" for c in semantic), + positive=sum(c["outcome"].startswith("pass_") for c in semantic)), + scope="R492 emitter structural contract only, with retained native inputs and hash-matched parent", + unresolved=["Unavailable original scratch suite and original R504 fixture are not reproduced", + "Other 24 source sites are not claimed by this contribution", + "No local scalar/Clifford/phase reconstruction, invoice, assembly, or all-size theorem proof"]) + dump(out/"RESULT.json",final) + print(final["status"],flush=True) + + +if __name__ == "__main__": + main()