diff --git a/research/coded-helper-early-end8/CLAIM.md b/research/coded-helper-early-end8/CLAIM.md new file mode 100644 index 0000000000..983f418d6a --- /dev/null +++ b/research/coded-helper-early-end8/CLAIM.md @@ -0,0 +1,26 @@ +# User-selected PR781 follow-up + +The user selected PR781 and PR838 for substantial completed contributions. +This branch handles the coded-helper construction; PR838's follow-up is PR865. +No new random track is inferred for this explicitly selected task. + +Original PR781 pinned and freshly reproduced. Initial promoted transfer found +five illegal zero-frame reads from entering helpers; fully charged entrance and +gauge repairs passed both orientations. Concurrent PR855 then completed two +full provider embeddings and a packing screen. Its source was read, retained +and freshly reproduced before extending its cleanup lifetime. + +New object: helper 448's end-B inverse row and rank-eight early endpoint in +both placements and both providers. Method: exact two-read early restoration, +internal premix, original all-column native audit; independent binomial +intervals, Cartesian pattern census and mixed-variant DP for the complete cost. +Stopping rule: all four new words, native/certificate controls and complete +72-call mixture coverage. No general frame search or new topology is claimed. + +Base f567884aeb8851b6e794af1184119a3bfbe1e631. No pinned sprint issue found; +claim is local. NeoKazuya's PR855 is credited and not described as superseded. +No phase/global nomination is pursued after the favorable full budget rejects +every mixture. Publication overlap was refreshed through PR888; main remains f567884a. +PR855 remains the directly consumed predecessor. Other new proposals concern +different words, owner controllers, Lean proofs or independent checks and are +not imported. No coded-core or residue-potential-method priority is claimed. diff --git a/research/coded-helper-early-end8/CONTEXT-SELECTED.json b/research/coded-helper-early-end8/CONTEXT-SELECTED.json new file mode 100644 index 0000000000..1f107b55a2 --- /dev/null +++ b/research/coded-helper-early-end8/CONTEXT-SELECTED.json @@ -0,0 +1,153 @@ +{ + "status": "Maintainer-reviewed conditional finite construction; see the integration receipt for publication and PR resolution status", + "kappa": "1661634653669567/1000000000000000000", + "decimal": "0.001661634653669567", + "source_prs": [ + 799, + 741, + 699, + 685, + 676, + 664, + 660, + 659, + 656, + 655, + 653, + 658, + 649, + 645, + 635, + 589, + 555, + 545, + 626, + 623, + 622, + 620, + 617, + 615, + 604, + 601, + 596, + 592, + 591, + 593, + 599, + 588, + 543, + 584, + 586, + 583, + 582, + 579, + 576, + 575, + 574, + 571, + 569, + 568, + 567, + 564, + 562, + 561, + 559, + 558, + 552, + 550, + 548, + 541, + 535, + 510, + 503, + 531, + 523, + 493, + 514, + 507, + 484, + 496, + 505, + 522, + 520, + 472, + 458, + 445, + 442, + 425, + 433, + 370, + 361, + 315 + ], + "source_manifest": "research/community-frontier799-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier799-audit/ASSEMBLY.json", + "certificate_sha256": "65c7648a8edaeaf4e0b8de3e21eeda94fba124d0935010d45ac9f76375b72cec", + "proof": "docs/research/community-frontier799-review.md", + "proof_supplements": { + "research/e8-bit-r420/README.md": "9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f", + "research/complex-571-free4fc8/NOTICE.md": "a4c084abdc1c7a9ac683eeb11124335d51cff8a6deba6ee92ba5a12bceaa2c97", + "research/complex-multicold/proof/CONSTRUCTION.md": "27ece5e1c11b90d97a808b56eff897b998c10e61016db95867f84e6e6aef132f", + "research/complex-multicold/vendor/pr559/PROOF.md": "d5d498edc56fdef8c5798af7f5ec66948bd2f66c553b9efe366cdaab01bd3453", + "research/structural-gain/frontier-composition/README.md": "70f0f791cbe3b2603f85d85bb9055aa0ee1df6dc06ba82fc1921356948312887", + "research/complex-joint-prefix/proof/CONSTRUCTION.md": "a92e610e7a598d99c612d1b63d1a03a49c0cd1e15ddd29fa55c465ddd8c18105", + "research/kernel-frame-coalescing/PROOF.md": "fa8b2f36b9590ee80ff45d3f7724f8c7de8ad29a29f366d5133010c77e41fe1b", + "research/complex-571-hpeq5/README.md": "4000b37f6c07c09d971dc4010ceb137c13340f3a8809d3272046ccaf746c3e2b", + "research/hyperplane-end-lean/PROOF.md": "1cbce5cf0ff0152f71e8ae7bef25841d1ce13010af248ff7209182d2328c21c9", + "docs/research/community-hyperplane599-review.md": "3298cd0d451541508af232cac72efbd7c10580e6c6ad493a855ab0faa01ade8c", + "research/complex-571-cold14-b3/README.md": "1945785785c153c7d0e8d4c071adabe626c1091b71721ff85d2d67191b376b96", + "research/complex-571-cold14-b3/PROOF-NOTE.md": "1cf592cbc8ab8e21d2dd8c1e945a5c64c6d5cde1216fb06e05a36c1c6ec6613d", + "scripts/verify_cold617_interface.py": "95d7a9094c05ad975fb72f5ab7605593003245a503c8456764987e512028fa6a", + "docs/research/community-cold617-review.md": "b3f2bcbae1249f1f651032022ce1e6e2bfb3f563ce580bf53671f50a074d7046", + "research/complex-k492-owner-repair/README.md": "ee5a1ace4828f7a073be97e95c2d931988774dd3a29a877e65abdf429aeec902", + "research/complex-k492-owner-repair/PROOF-NOTE.md": "337d70fe7abd9afca1d90954c23bde87f4dc27888cc1a6b4bb80506fd6fbf8c5", + "research/complex-k492-owner-repair/PROOF-NOTE-R.md": "22312bb347bdf159e6a01a45c47675e6170d33b258e2fd9ed52aee88fb92c0ed", + "docs/research/community-k492-review.md": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47", + "scripts/verify_frontier626.py": "2207bd0ef04a19ef276869085afdedad80a0938fa75db5e1aa7ab73fd3429444", + "scripts/verify_frontier626_bindings.py": "cda63ff41c6d6e2e352c7bf75b84e690c0ce57e4ec6c0355573bb5d9b1f98280", + "scripts/verify_frontier588_bindings.py": "6d1932eea7b1936598118ea8e607b09c29b6e31b749ec41bbe0744ea4f0b606d", + "scripts/verify_hpe_lean_binding.py": "52aa1d23641e4c716b43c98f6b883ad042087dd03a9d01369e8e6a735b07aa03", + "research/hyperplane-end-lean/HyperplaneEnd/Exact.lean": "eebf3a3982af7ab9be45777b272a6aaa523206fa7667ceb6df63ad6589fd8183", + "docs/research/community-frontier741-review.md": "4634694fa75ea9e749ecf19d3db3e4d82effe3b61a2efdf08ac5a97275fb676a", + "research/complex-sw4-frame8/PROVENANCE.md": "c7648719b01dd93af2c3a2c6e951a54711d13892dc4bd4339d16edb4c37c9bf0", + "research/e8-bit-p111-tuned/tune/README.md": "46c7917fb252949f38b7bcd88cf568efc282e3ea065b61d11e457e41673d0b2d", + "scripts/verify_frontier741.py": "215ee6a12de8dc2392e6811a1b8f2140035f6b2d2a0d2100ff4bd2fdcb8bb39b", + "scripts/verify_frontier741_bindings.py": "eff455167e2fd0bc9a67d35241d0e69d8edc58f3a23e776dcfe8f500ca8e8d67", + "docs/research/community-frontier799-review.md": "bd91c10c67f2a873fd456b95cbb43f715a43dac0e0a66938737d591c6b754052", + "scripts/verify_frontier799.py": "19fe1b32079095160dc00fe2f7df75e0fcbc82cff37f7159b755c8a63bd5ce99", + "scripts/verify_frontier799_bindings.py": "43897b3c99212d6134870898a1840f32898aa1b3679b299e654901568ad7e19b", + "research/gauge44-frames-x/PROOF-NOTE-FRAMES-X4.md": "39c50420ebb6e8813706a49b2cf759f277c4afac9f6780fc0a7ac6a5fb86e036" + }, + "review": "docs/research/community-frontier799-review.md", + "validation": "docs/research/community-frontier799-integration.json", + "reproduce": "make frontier799-verify", + "scope": "Source-bound finite X4 construction and freshly rebuilt bit589/ancestral SW4 supplier checks; optional verified ancestry reuse recorded explicitly. Inherited all-size/compiler, common-label/mutable-source, whole-call hosting, precision/tape and analytic hypotheses remain. Not a full Lean multiplication theorem. Integration Linux CI status is separate.", + "previous_kappa": "1661202643272239/1000000000000000000", + "previous_record": "certificates/checkpoints/frontier741.json", + "audited_source_head": "80e6463157cfc80b85af09e7e2f14748fe2dac60", + "reviewed_dependency_heads": { + "588": "6d0e53b66c29abd17981881a09eaff41ac862d85", + "543": "2065fe4f72a914d907f1046603f5a36f17018535", + "568": "71c99ac935a33bb7b59a1b4a7af8725a939b0b90", + "569": "1424da81263a5305b35e4cf74ef686c275f03f3f", + "571": "b7bdc5a8de18fcf418cfb9c7d83a2b1097a5e4a3", + "575": "eac6f7e378ab622dac50a2fd4b7ef6eab014de44", + "583": "89be768f0157f5a3d8e4db69cf1748768605eac9", + "586": "4846fee5b06af770e9b3a10c36200f673d656725", + "591": "f622547244bf6d895a571a7b035142ba66279806", + "592": "1f471c445c06a45a32e2c47e8d74c8264b68356b", + "593": "fdb6dcc6d7bc29764c5b6b4d32b7fa050acf74a4", + "596": "7732dd5e46863ff294b5e443661cb9d99abf4e01", + "599": "bc13c8a3e000442606bd2dbe8583a17649ba6c32", + "601": "529ab7dcb59d5ea7a5798e9e06cf5b3aee8a1550", + "604": "1b795c5d7dea746ba310572585c0ef067574b4a6", + "615": "bf8a49a34350599763cced8592db81dc62c2c1c0", + "617": "904d62855723c00f8acef9a287a10768598fdeb2", + "622": "f69477f4f6d3c7eb1f740b166881bffed4ffa9f6", + "623": "e39a615ca601ce5d62abeb24f3fcdb8644ca1005", + "626": "660de893d27bb7abd1d5b01b1640207528a5c851", + "589": "a5afc8c6169ea61ba7c51dfd3cade02cc7b13b46", + "741": "e516b1463606840a15f80aac1995d64ce0092e89", + "799": "80e6463157cfc80b85af09e7e2f14748fe2dac60" + } +} diff --git a/research/coded-helper-early-end8/EXPECTED.json b/research/coded-helper-early-end8/EXPECTED.json new file mode 100644 index 0000000000..f8cf61b3f4 --- /dev/null +++ b/research/coded-helper-early-end8/EXPECTED.json @@ -0,0 +1,3019 @@ +{ + "base": "f567884aeb8851b6e794af1184119a3bfbe1e631", + "source_prs": [ + 781, + 855 + ], + "status": "PASS_EARLY8_CONSTRUCTION_AND_EXTENDED_COST_OBSTRUCTION", + "native_words": 8, + "new_constructions": { + "positive-ck": { + "input_content_sha256": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "helper": 448, + "inverse_row": { + "431": "-1", + "447": "-1", + "448": "1" + }, + "end_of_B_frames": { + "431": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "447": [ + 264, + 136, + 73, + 33, + 16, + 6 + ], + "448": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ] + }, + "endpoint": [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ], + "endpoint_rank": 8, + "removed_cleanup_indexes": [ + 131, + 132 + ], + "early_corrections": [ + [ + "add", + 448, + 431, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ], + [ + "add", + 448, + 447, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ] + ], + "internal_premix": [ + [ + "add", + 163, + 448, + 1, + 1, + [] + ], + [ + "add", + 167, + 448, + 1, + 1, + [] + ], + [ + "add", + 195, + 448, + -1, + 1, + [] + ] + ] + }, + "positive-jp8": { + "input_content_sha256": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "helper": 448, + "inverse_row": { + "431": "-1", + "447": "-1", + "448": "1" + }, + "end_of_B_frames": { + "431": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "447": [ + 264, + 136, + 73, + 33, + 16, + 6 + ], + "448": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ] + }, + "endpoint": [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ], + "endpoint_rank": 8, + "removed_cleanup_indexes": [ + 131, + 132 + ], + "early_corrections": [ + [ + "add", + 448, + 431, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ], + [ + "add", + 448, + 447, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ] + ], + "internal_premix": [ + [ + "add", + 163, + 448, + 1, + 1, + [] + ], + [ + "add", + 167, + 448, + 1, + 1, + [] + ], + [ + "add", + 195, + 448, + -1, + 1, + [] + ] + ] + }, + "negative-ck": { + "input_content_sha256": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "helper": 448, + "inverse_row": { + "50": "-1", + "82": "-1", + "448": "1" + }, + "end_of_B_frames": { + "50": [ + 272, + 144, + 65, + 49, + 8, + 6 + ], + "82": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "448": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ] + }, + "endpoint": [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ], + "endpoint_rank": 8, + "removed_cleanup_indexes": [ + 134, + 135 + ], + "early_corrections": [ + [ + "add", + 448, + 50, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ], + [ + "add", + 448, + 82, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ] + ], + "internal_premix": [ + [ + "add", + 162, + 448, + 1, + 1, + [] + ], + [ + "add", + 166, + 448, + 1, + 1, + [] + ], + [ + "add", + 198, + 448, + -1, + 1, + [] + ] + ] + }, + "negative-jp8": { + "input_content_sha256": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "helper": 448, + "inverse_row": { + "50": "-1", + "82": "-1", + "448": "1" + }, + "end_of_B_frames": { + "50": [ + 272, + 144, + 65, + 49, + 8, + 6 + ], + "82": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "448": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ] + }, + "endpoint": [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ], + "endpoint_rank": 8, + "removed_cleanup_indexes": [ + 134, + 135 + ], + "early_corrections": [ + [ + "add", + 448, + 50, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ], + [ + "add", + 448, + 82, + -1, + 1, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 6, + 1 + ] + ] + ], + "internal_premix": [ + [ + "add", + 162, + 448, + 1, + 1, + [] + ], + [ + "add", + 166, + 448, + 1, + 1, + [] + ], + [ + "add", + 198, + 448, + -1, + 1, + [] + ] + ] + } + }, + "new_native_receipts": { + "positive-ck": { + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "input_content_sha256": "6e6ea4df59fa36112d760a49feed3b54889fda33cc63c1d12f538a136d4bc9f6", + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "canonical_content_sha256": "53f8e0d95e09779177254c936d070a356f4eba457453f5f2e43234f6703ebac8", + "live_columns_each_orientation": 714, + "helpers": 490, + "compensation_additions": 8551, + "scalar_operations": 21777, + "center_rank_sum": 64, + "local_profile": { + "1": 2602, + "2": 569, + "3": 311, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5710, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ], + "frames": 1127, + "directed_edges": 3120, + "tau": 43, + "target_port_order_matches_baseline": true, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "early_cleanup_gates": 119, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448 + ], + "refactored_cleanup_gates": 8440, + "refactored_cleanup": true + }, + "positive-jp8": { + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "input_content_sha256": "9a4ae7a97ac783da50cd64e4e9619a79ee16d94638db533d5481286e0836e27e", + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "canonical_content_sha256": "dfbbff2e28a29cab286dbc42d8c44d42a1b304217ce295f8e899c60be626802c", + "live_columns_each_orientation": 714, + "helpers": 490, + "compensation_additions": 8647, + "scalar_operations": 22534, + "center_rank_sum": 64, + "local_profile": { + "1": 2518, + "2": 417, + "3": 455, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5754, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ], + "frames": 1046, + "directed_edges": 3031, + "tau": 43, + "target_port_order_matches_baseline": true, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "early_cleanup_gates": 119, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448 + ], + "refactored_cleanup_gates": 9137, + "refactored_cleanup": true + }, + "negative-ck": { + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "input_content_sha256": "f72902cb4cd5d7ba6f98c21731d8a342b9537618a803d9461aae78beb21b5463", + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "canonical_content_sha256": "d5940d051f3b71e22512210a9be701c83b87f48abbf923377e60477f17f7f553", + "live_columns_each_orientation": 717, + "helpers": 493, + "compensation_additions": 8545, + "scalar_operations": 21762, + "center_rank_sum": 64, + "local_profile": { + "1": 2593, + "2": 548, + "3": 305, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5722, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ], + "frames": 1114, + "directed_edges": 3099, + "tau": 43, + "target_port_order_matches_baseline": true, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "early_cleanup_gates": 122, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448 + ], + "refactored_cleanup_gates": 8431, + "refactored_cleanup": true + }, + "negative-jp8": { + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "input_content_sha256": "9d19763b1f21c5bc521f97b9f0e10ca9932eefd8bedbd57987088013ff46b473", + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "canonical_content_sha256": "bb84a6da53d11520eb36671d8300152e2c1376dc377e0e0e0c77b40b7346be22", + "live_columns_each_orientation": 717, + "helpers": 493, + "compensation_additions": 8641, + "scalar_operations": 22519, + "center_rank_sum": 64, + "local_profile": { + "1": 2509, + "2": 396, + "3": 449, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5766, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ], + "frames": 1033, + "directed_edges": 3010, + "tau": 43, + "target_port_order_matches_baseline": true, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "early_cleanup_gates": 122, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 448 + ], + "refactored_cleanup_gates": 9128, + "refactored_cleanup": true + } + }, + "original_native_controls": { + "omit_entry_correction": "zero-frame compensation reads an entering helper", + "omit_full_cleanup_correction": "('arbitrary-dirt endpoint', False)", + "restore_old_cold_end": "('hpe cone pre-check (row / column)', [('row', 266, 19)])", + "omit_coded_helper_cleanup": "('arbitrary-dirt endpoint', False)", + "understate_paid_profile": "paid local profile differs from the reported local_profile" + }, + "original_recompression": "PASS", + "model": { + "endpoint": "65528268492323474503/40000000000000000000000", + "m": 73, + "live": 7168, + "calls": 72, + "rank_mass": 520704, + "capacities": { + "16": 3584, + "8": 5376, + "32": 3584, + "48": 3584 + }, + "widths": { + "4": 2160, + "5": 3456, + "7": 2848, + "8": 7904, + "9": 19056 + }, + "local": { + "1": 181536, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576 + }, + "variants": { + "original9-positive": { + "profile": { + "1": 2, + "2": 18, + "3": 8, + "4": -5, + "5": -9 + }, + "widths": { + "4": -3, + "9": 1 + } + }, + "original9-negative": { + "profile": { + "1": -7, + "2": -3, + "3": 2, + "4": 4 + }, + "widths": { + "9": 1 + } + }, + "early8-positive": { + "profile": { + "1": 6, + "2": 17, + "3": 7, + "4": -5, + "5": -9 + }, + "widths": { + "4": -3, + "8": 1 + } + }, + "early8-negative": { + "profile": { + "1": -3, + "2": -4, + "3": 1, + "4": 4 + }, + "widths": { + "8": 1 + } + } + }, + "global": { + "1": 181659, + "2": 30016, + "3": 31104, + "4": 11520, + "5": 5040, + "6": 576, + "8": 576, + "37": 1, + "48": 2215 + } + }, + "packing": { + "patterns": 1163, + "potential_inequalities": 43031, + "dp_states": 2548, + "modified_calls": 1, + "residue": 23, + "minimum_margin": "3784588463776762504092569829/200000000000000000000000000000", + "minimum_counts": { + "early8-negative": 1, + "early8-positive": 0, + "original9-negative": 0, + "original9-positive": 0 + }, + "excluded": true, + "power_engine": "7000-term positive binomial with integer outward rounding and geometric tail" + }, + "nonempty_mixture_count": 1282974, + "current_target": { + "kappa": "1661634653669567/1000000000000000000", + "necessary_b": "1661634653669567/998338365346330433", + "excluded_from_b": "65528268492323474503/40000000000000000000000", + "source_head": "f567884aeb8851b6e794af1184119a3bfbe1e631" + }, + "scope": "Four rank-eight variants plus four original rank-nine words; fixed PR626 geometry/dispatch; whole-helper packing relaxation. Native identities/frames only; no new phase/global admission or multiplication exponent." +} diff --git a/research/coded-helper-early-end8/LICENSE b/research/coded-helper-early-end8/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/coded-helper-early-end8/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/coded-helper-early-end8/PROOF.md b/research/coded-helper-early-end8/PROOF.md new file mode 100644 index 0000000000..0f5eed697e --- /dev/null +++ b/research/coded-helper-early-end8/PROOF.md @@ -0,0 +1,154 @@ +# Retimed helper endpoint and complete favorable cost bound + +This is a fixed-program common-frame result, not a theorem about every +reversible multiplication algorithm. Let P denote the invertible scalar map +at the end of B, after input compensation, in one pinned PR855 word. Let h=448 +be its fresh coded helper. All payload values, including helper dirt, are +independent. Scalar gates on non-target registers never read a target register; +the initial precondition and generated compensation update targets only. + +## Exact cleanup row and minimum endpoint + +Multiplying the h-th output row by inverse elementary matrices in chronological +order gives the h-th row of P^-1. Target-only prefix operations have no effect +on that row. It has exactly three nonzero entries: + +``` +e_h^T P^-1 = e_h^T - e_s^T - e_t^T. +``` + +For positive embeddings `(s,t)=(431,447)`; for negative embeddings they are +`(50,82)`. An independently implemented row replay verifies the inverse-row +identity against the complete scalar word. Consequently the two operations +`h -= s; h -= t` restore the original helper value at end B. Every other +remaining cleanup gate is independent of h. Removing the old two h-targeted +full-frame gates and doing these reads first therefore preserves all endpoints. +The inherited auditor separately checks every arbitrary input column in both +orientations after the transformation. + +Let F_h,F_s,F_t be their end-B frames. In all four words, their join U has rank +eight (canonical raw basis `[256,128,64,32,16,8,6,1]`). Each operand frame is +contained in U, so the two reads have a legal common frame. The helper can stop +there; the other registers may subsequently climb to their original final +frames. Two new early-cleanup entries run before final climbs; retained entries +are renumbered after removing the old gates. Failing to update those entries is +a rejected frame/admission mutation, not a valid early-end construction. + +This also establishes a rank-eight lower bound for *any remaining monotone +common-frame cleanup at this same end-B boundary*. If the helper finishes at W, +it must contain F_h. Its final scalar row has nonzero coefficients on the +independent end-B variables s and t. Neither variable can reach that helper +through a chain of common-frame gates unless W contains its initial frame. +Frames cannot shrink. Thus W contains F_h+F_s+F_t=U and dim W>=8. Auxiliary +mixing after B cannot evade that argument. Changing the earlier word, frames, +representation, noncoordinate primitives or restoration contract is outside +the statement. No global frame or reversible-program optimum is claimed. + +## Respect the cold-helper wrapper interface + +A cold helper must not be read by the caller's zero-frame precondition or +automatically derived compensation before its entry wrapper. Simply declaring +the shorter endpoint fails that guard. Compute its dirty-response column q in +the input target chart. Put the additions `target -= q_target * h` at the start +of A, inside the wrapped child. Because the target chart and main target block +are inverse, these additions cancel the main word's helper-dirt response. +The external zero-frame compensation no longer reads h. Other dirt columns are +unchanged. The exact all-column native replay independently certifies this +calculation; omission of the premix is a negative control. + +No helper is cleared by erasing arbitrary information. The new word restores +its dirty helper exactly. Its logical child width is eight, because the helper +starts at bottom and ends at U. This is native scalar/frame evidence. New phase +lowering and residual-wrapper compilation are separate obligations, not inferred +from this finite replay. They are unnecessary to a favorable *cost rejection*. + +## Price the source climbs too + +Relative to each corresponding PR855 word, the paid local change is + +``` +4 H1 - H2 - H3, +``` + +and one width-nine helper becomes width eight. The helper's final climb is +split differently, and both source streams must reach U for the early reads; +their later climbs are still paid. At rank-mass exponent one, the local mass +falls by one, while the global idle mass increases by one. There is no new +rank deficit. Extra pointwise premix/preparation/access work is not assumed +negative or credited as a saving. The cost lower bound grants it for free. + +## Complete packing relaxation + +Keep PR626's fixed geometry: 72 calls, m=73, live=7168, rank deficit=2560 and +the data capacities 8/16/32/48. Recount capacities separately from the plan's +windows and all native data recipes. At any call choose the original provider, +the original positive/negative PR855 replacement, or its new early-eight +positive/negative replacement. Deltas agree for ck and jp8, so four counts +suffice. Every nonempty count vector whose sum is at most 72 is included: +`binomial(76,4)-1 = 1,282,974` mixtures. + +Drop all windows, call labels and physical-family restrictions. Helpers still +occupy their full audited widths in capacity slots. Allow every integer width +multiset fitting a slot, including empty slots. Charge any residual rank with +one child; splitting it costs at least as much for 0= lambda*score(pattern) +d[(j+score(pattern)) mod 37] - d[j] + <= phi(residual)-lambda*score(pattern). +``` + +Telescoping over a packing lower-bounds idle cost by +`idle_mass + lambda*S + d[S mod 37]`. Add the complete audited local profile. +Each variant's local, idle and score changes are linear; rank mass remains +520704. A positive profile coefficient uses the lower power endpoint, while a +negative coefficient uses the upper endpoint, so removed costs retain a +conservative lower bound. The checker proves nonnegative inventories for every mixture first. + +The new DP stores the minimum linear change for each number of modified calls +and residue. Extending a state by each of four variants enumerates every count +vector; order is irrelevant to its invoice. Merging equal states keeps the +lowest bound. Checking every reachable state for k=1..72 therefore covers all +1,282,974 mixtures, rather than sampling them. There are 2548 reachable states. +All their lower bounds exceed `7168*73^(1-b0)`. The least certified excess is +strictly above **0.018922942318** at one negative early-eight replacement. + +## Independent real-power enclosures + +The proof does not trust the predecessor's logarithm/exponential engine. +For r>1 set z=1-1/r and a=b0. The binomial series has + +``` +(1-z)^a = 1 - sum(k>=1) c_k, +c_1=a*z, +c_(k+1)=c_k*z*(k-a)/(k+1), +``` + +with all c_k positive and every ratio below z. After N terms the omitted tail +is at most `c_(N+1)/(1-z)`. Propagate outward integer intervals at scale 10^44 +through 7000 terms, sum their lower/upper endpoints, subtract the appropriate +geometric tail and round outward at scale 10^30. Multiplying by r encloses +`r^(1-b0)`. No float, logarithm, exponential or predecessor power implementation +is used. Exact square-root identities at a=1/2 give separate positive controls. + +## Comparison with the pinned selected target + +The inherited balanced assembly has `akappa/(1-kappa)`. The pinned PR799 target is +`1661634653669567/10^18`; its necessary complex saving is strictly above b0, +the excluded historical PR626 endpoint. All child ranks are below m=73, so +each normalized term `(r/m)^(1-b)` increases with b. Failure at b0 therefore +excludes every larger complex saving in this fixed model, including the saving +needed to match that target. This does not audit or refute PR799's different +construction, or rule out another geometry, coded core, compiler or invoice. + +The source/input pins, exact complete model, native receipts, constructions, +potential checks and minimum-state witness are reproducible. All-size/compiler, +physical hosting, analytic transfer, precision and tape assumptions remain. +The full multiplication theorem is not formalized or proved here. diff --git a/research/coded-helper-early-end8/README.md b/research/coded-helper-early-end8/README.md new file mode 100644 index 0000000000..6a91e4e225 --- /dev/null +++ b/research/coded-helper-early-end8/README.md @@ -0,0 +1,94 @@ +# Rank-eight coded-helper endpoint with complete cost rejection + +**Finite native construction and scoped negative result; no new kappa.** + +PR781's one coded helper can end at rank eight in each of PR855's four +integrated provider words. Move its two restoration reads before final climbs, +pay their common rank-eight frame and source climbs, and put its dirty-response +compensation inside the wrapped program. All 714/717 arbitrary input columns +pass in forward and inverse-transpose orientations. At the fixed end-B boundary, +the inverse-row support proves rank eight is also the minimum monotone cleanup +endpoint. This changes helper lifetime and the compensation interface; PR855's +bounded gate-frame search did not change that endpoint. + +The fully charged local change from each original PR855 word is +`4 H1 - H2 - H3`, and one width-nine helper becomes width eight. Freed hosting +rank must still be completed by idle children. An independently implemented +binomial power engine, Cartesian pattern census and residue DP check the +complete favorable packing bill. All **1,282,974 nonempty mixtures** of the +original and early-eight positive/negative variants still fail the fixed PR626 +budget. The least certified numerator excess is **greater than 0.018922942318**. +No changed-word phase, wrapper or global-owner admission is asserted; extra +preparation, phase, access and scalar work are granted free in this rejection. + +The comparison also excludes the larger complex saving needed to match the +pinned selected PR799 kappa, while retaining this geometry and whole-helper +pricing. It does not refute PR799's different construction or other geometries. + +## Reproduce + +Python 3.11+, standard library only, no network or solver: + +```sh +python -I -B research/coded-helper-early-end8/verify.py --out /fresh/external/directory +python -I -B research/coded-helper-early-end8/test_controls.py /fresh/external/directory +``` + +Expected primary line: + +``` +PASS_EARLY8_CONSTRUCTION_AND_EXTENDED_COST_OBSTRUCTION 8 native words; 1282974 mixtures excluded; no new kappa +``` + +The parent verifier may also use `-O`; both inherited native workers explicitly +run in assertion-enabled interpreters. The replay rechecks four original PR855 +words and five of their failure controls, rebuilds four new words from pinned +inputs, and independently audits every new word. It verifies all 1163 packing +patterns and 43,031 potential inequalities with the new integer-enclosed +binomial engine. The 2548 reachable DP states cover all four-way count vectors. +Exact square-root identities independently test the power engine. + +New controls omit the internal premix, omit early-tail admission, declare a +rank-seven end, omit a restore read, undercharge the paid profile, alter lambda +or a potential, and remove the integer correction. Removing the latter leaves +an uncertified mixture; it does not produce a valid global candidate. + +`EXPECTED.json` freezes the complete native receipts, end-B inverse rows, +construction recipes, full budget and minimum witness. [PROOF.md](PROOF.md) +gives the algebra, lifetime bound, full cost relaxation, DP and outward rounding. +`--write` regenerates only this package's development receipt; it is not the +normal verification path. Output includes all rebuilt words and detailed logs. + +## Pins and predecessor credit + +Base: `f567884aeb8851b6e794af1184119a3bfbe1e631`. +PR781: `85f9cfad7708cc3873bd6b32492a618feb336e59`. +PR855: `4e0e0e0159b6c845e8b1110bec6c5b81150da79d`. +The complete PR855 source package is retained unchanged under `vendor/pr855/`, +with its original notice. Its lambda and potentials are reused as witnesses; +the new checker independently replays their inequalities, extends the candidate +class and implements all real-power bounds without its log/exp code. + +Credit **NeoKazuya** for PR781's 28-gate core and PR855's provider embeddings, +cost obstruction and potential certificate. Credit icekylinx's packet/auditor +lineage, Jeremy Kothe/AtomScout/Port480's K-triangle and transfer work, Chafik +Boukhalfa's owner/frame work, DreamingOfClouds' cold-end/interface work and the +predecessors preserved in the original notice. No priority for the coded core, +whole-helper relaxation or residue-potential method is claimed. + +Prepared for **nightangelflowerwin-ops** with substantial **OpenAI Codex** +assistance in construction, mathematics, independent verification and writing. +Apache-2.0. No independent human review or literature-priority claim. + +The original PR781 raw construction was freshly reproduced before integration. +An initial transfer failed its entering-helper compensation guard; that failure +and the fully priced repaired/gauged transfer informed this changed-lifetime +experiment. The reported final result uses complete PR855 provider words; +intermediate transfer experiments are not silently promoted to suppliers. + +Scope is these explicit programs, fixed end-B frame labels, PR626 dispatch and +whole-call helper pricing. Other coded cores, earlier frame changes, different +geometry, volume-sharing rules or compiler primitives remain outside it. +All-size/compiler, physical realization, hosting, precision/tape and analytic +assumptions remain. No complete multiplication theorem or practical speedup is +claimed. The selected result and `upstream/` remain unchanged. diff --git a/research/coded-helper-early-end8/SOURCES.json b/research/coded-helper-early-end8/SOURCES.json new file mode 100644 index 0000000000..aebae4c25d --- /dev/null +++ b/research/coded-helper-early-end8/SOURCES.json @@ -0,0 +1,29 @@ +{ + "base": "f567884aeb8851b6e794af1184119a3bfbe1e631", + "pr781_head": "85f9cfad7708cc3873bd6b32492a618feb336e59", + "pr855_head": "4e0e0e0159b6c845e8b1110bec6c5b81150da79d", + "repo_inputs": { + "research/complex-k492-owner-repair/code/hpe_audit_and_transport.py": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "research/complex-k492-owner-repair/data/PLAN.json": "8c48ef6ce079916314126c5c3ff0003b32f24cf0fbfb2a033fc93e1e1949b5d5", + "research/complex-k492-owner-repair/data/SPEC.json": "2a2577ac526535826fed9d5f7f83f6e2e0ec058a146c64f7286720b995fa2323", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz": "e070ae2c78b4a1b644b418774af62b40d8d16e6ba89602f0474afb557d507c37" + }, + "vendor_inputs": { + "vendor/pr855/CODED-CELL.json": "03ba299163019b7438c5e711f0a3e3422466ee7e27d4a05c8ba0576800bc20fd", + "vendor/pr855/CONSTRUCTION-RECORD.json": "91f94b31aa6bcb9cbd21c712b7a4ffb8ee29c44a52d8efc037611c84dc47a006", + "vendor/pr855/EXACT-CERTIFICATE.json": "4f4e308a0ba5bd1cf0e54dd812e866f0e2675aa8bd254eaab760633f9c5ee3b8", + "vendor/pr855/exact.py": "37d227bb2930f923d27d00c0b94110508b645987e20b3ac517b5ea001ec83239", + "vendor/pr855/NATIVE-EXPECTED.json": "fc7fa613022ca972ce942b6cd472a5d42db444682c2bb703c8ee25ce2f0dfc73", + "vendor/pr855/native_worker.py": "4575c2d0c699f1cae829e1f51a227d973f7ccfa824a15dec039da57838e5bfd1", + "vendor/pr855/NOTICE.md": "c2e71d6104586f90fb9ec49a75172e25e3df06b2ea530dd023ef51afe9d4ec69", + "vendor/pr855/README.md": "2d4e45a161d14fa4113ccfb87a5f916e51ca95288a6070d6f68adfb4157d3fae", + "vendor/pr855/SOURCE-PINS.json": "f37d4173d8669ad354a98f9cb7a573fdae841d5cdd511e14868fcd1ba2ef5595", + "vendor/pr855/verify.py": "723219d1d91d607a30a420ca676351773a649bb0da4f1880fd0f4214d6846ad8", + "vendor/pr855/words/negative-ck.json.gz": "ccc72e03ccb8d939911cec49f87d7056c835624306e4f9f17a05f7fb2e15c810", + "vendor/pr855/words/negative-jp8.json.gz": "700fc4b6cf510057d93b7b4a3d1bb8c17556a77a804f7c029243ce4ba5f39e48", + "vendor/pr855/words/positive-ck.json.gz": "d36aa2ab2b3f305489237801c2fc5c33d5ee195590b65fe02ebc04626a844edc", + "vendor/pr855/words/positive-jp8.json.gz": "d68064f7c73d1417092f5c207a394fd087628e47af1c22ee19ea8c3363ab4874", + "CONTEXT-SELECTED.json": "9873519224e2db72d6a8c926f51e3e75129671e467948c6f6b03744f8bcfc699" + } +} diff --git a/research/coded-helper-early-end8/VALIDATION.md b/research/coded-helper-early-end8/VALIDATION.md new file mode 100644 index 0000000000..73ca3357e9 --- /dev/null +++ b/research/coded-helper-early-end8/VALIDATION.md @@ -0,0 +1,39 @@ +# Finite verification and limits + +Windows CPython 3.11.9; standard library only. Base and predecessor heads are +listed in SOURCES.json. The original PR781 verifier and complete PR855 verifier +were freshly reproduced before this experiment. No hosted CI pass is claimed. + +The normal eight-word replay passed. An isolated optimized parent also replayed +all eight words with assertion-enabled native children. Each new word is rebuilt, +its paid profile discovered, and then freshly audited for all 714/717 columns in +both orientations. Exact model recounts and square-root enclosure controls pass. + +During review, signed profile deltas were tightened to use upper power bounds +for negative coefficients. The corrected least margin remains greater than +0.018922942318. EXPECTED.json was regenerated from the audited receipts and exact +recount, then the final verifier was rerun from fresh native programs. + +Five native mutation controls and three potential controls pass. Corrupting a +vendored core or the selected-context snapshot is rejected by source preflight. +Canonical JSON comparison distinguishes integer receipts from Boolean values. + +Offline relocation uses a root whose name contains spaces, this package and +only the five pinned repository inputs. The first relocated native replay passed +all eight words but its final receipt comparison failed because it had loaded the +earlier signed-rounding implementation before the correction. The final relocated +replay uses the corrected implementation and frozen receipt and passes the +full eight-word audit, exact cost screen and strict receipt comparison under +`python -I -O -B`. Its final status is +`PASS_EARLY8_CONSTRUCTION_AND_EXTENDED_COST_OBSTRUCTION`. + +The selected-record checker passes at the pinned current PR799 target. No +selected record, upstream source, accepted construction, Make target or workflow +is changed. The broader repository suite was run for the companion PR865 and +stopped on eleven ten-second subprocess timeouts in an unchanged historical +test; no repository-wide pass is claimed here. + +The complete-cost rejection grants timing, labels, physical restrictions and +additional preparation/phase/access/scalar overhead free. Consequently these +words are not submitted as admitted phase/global suppliers, and no new kappa +or full multiplication theorem is claimed. See PROOF.md for the exact scope. diff --git a/research/coded-helper-early-end8/binomial.py b/research/coded-helper-early-end8/binomial.py new file mode 100644 index 0000000000..70ab18c465 --- /dev/null +++ b/research/coded-helper-early-end8/binomial.py @@ -0,0 +1,50 @@ +"""Independent integer-enclosed binomial powers, with a positive geometric tail. + +No logarithms, exponentials, floating point or predecessor power engine. +""" +from functools import lru_cache +from fractions import Fraction + +INTERNAL = 10**44 +SCALE = 10**30 +TERMS = 7000 + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def ceiling(numerator, denominator): + return -(-numerator // denominator) + + +@lru_cache(None) +def power_bounds(rank, saving): + """Outward bounds on SCALE*r^(1-saving), for 0=0. + +For z=1-1/r, (1-z)^saving = 1-sum_{k>=1} c_k, c_k>0. +c_1=saving*z and c_(k+1)=c_k*z*(k-saving)/(k+1). +Every ratio is > k & 1: + x ^= pivots[k] + if x: + k = x.bit_length() - 1 + for j in list(pivots): + if pivots[j] >> k & 1: + pivots[j] ^= x + pivots[k] = x + return [pivots[k] for k in sorted(pivots, reverse=True)] + + +def inverse_helper_row(word): + # A row times P^-1: multiply inverse elementary matrices in chronological + # order. No dense native-auditor state maps or its GF(2) routines are used. + row = {HELPER: Q(1)} + for event in word['A'] + word['cut'] + word['B']: + if event[0] == 'add': + source = event[2] + row[source] = row.get(source, 0) - Q(event[3], event[4]) * row.get(event[1], 0) + if not row[source]: + row.pop(source, None) + elif event[1] in row: + require(event[0] == 'scale', 'Scalar primitive') + row[event[1]] *= Q(event[3], event[2]) + require(row.get(HELPER) == 1 and len(row) == 3 and + all(not 112 <= r < 224 for r in row), 'Unexpected coded-helper inverse row') + # The target-only precondition and generated compensation have zero row + # coefficients here. The helper never receives a target-row value. + require(all(not (112 <= event[2] < 224) for event in word['A'] + word['B'] + if event[0] == 'add' and not 112 <= event[1] < 224), 'Target-to-helper dependency') + require(all(112 <= event[1] < 224 for event in word['precondition']), 'Non-target precondition') + replay = dict(row) + for event in reversed(word['precondition'] + word['A'] + word['cut'] + word['B']): + if event[0] == 'add': + source = event[2] + replay[source] = replay.get(source,0) + Q(event[3],event[4])*replay.get(event[1],0) + if not replay[source]: + replay.pop(source,None) + elif event[1] in replay: + replay[event[1]] *= Q(event[2],event[3]) + require(replay == {HELPER: Q(1)}, 'Independent inverse-row identity') + return row + + +def response(word): + # Forward basis column on the main word, followed by the target-chart + # inverse precondition. Non-target rows of the latter dirty response are + # zero, matching the explicit scalar compensation contract. + column = {HELPER: Q(1)} + for event in word['A'] + word['cut'] + word['B']: + if event[0] == 'add': + target, source = event[1:3] + column[target] = column.get(target, 0) + Q(event[3], event[4]) * column.get(source, 0) + else: + require(event[0] == 'scale', 'Scalar primitive') + column[event[1]] = column.get(event[1], 0) * Q(event[2], event[3]) + column = {r: q for r, q in column.items() if 112 <= r < 224 and q} + for event in word['precondition']: + if event[0] == 'add': + target, source = event[1:3] + column[target] = column.get(target, 0) + Q(event[3], event[4]) * column.get(source, 0) + else: + column[event[1]] = column.get(event[1], 0) * Q(event[2], event[3]) + return {r: q for r, q in column.items() if q} + + +def construct(source): + word = read(source) + require(word['report']['v'] == 112 and word['report']['h'] == 9 and + HELPER not in word['centers'] and str(HELPER) not in word.get('start_extra', {}), + 'Pinned coded helper interface') + row = inverse_helper_row(word) + frames = {} + for event in word['A'] + word['B']: + for role in ([event[1], event[2]] if event[0] == 'add' else [event[1]]): + frames[role] = event[-1] + endpoint = basis(x for role in row for x in frames[role]) + require(len(endpoint) == 8, 'Expected rank-eight cleanup join') + corrections = [['add', HELPER, role, coefficient.numerator, coefficient.denominator, endpoint] + for role, coefficient in sorted(row.items()) if role != HELPER] + touches = [i for i, event in enumerate(word['cleanup']) + if HELPER in ([event[1], event[2]] if event[0] == 'add' else [event[1]])] + require(len(touches) == 2 and all(word['cleanup'][i][1] == HELPER for i in touches), + 'Unexpected helper cleanup dependency') + require(all(i not in touches for i, _ in word['early_cleanup']), 'Helper already ends early') + old_cleanup = word['cleanup'] + new_index = {i: 2 + i - sum(j < i for j in touches) for i in range(len(old_cleanup)) if i not in touches} + word['cleanup'] = corrections + [event for i, event in enumerate(old_cleanup) if i not in touches] + word['early_cleanup'] = [[0, endpoint], [1, endpoint]] + [ + [new_index[i], frame] for i, frame in word['early_cleanup']] + word['helper_final'][str(HELPER)] = endpoint + word['refactored_cleanup'] = True + col = response(word) + premix = [['add', role, HELPER, -q.numerator, q.denominator, []] for role, q in sorted(col.items())] + word['A'] = premix + word['A'] + proof = dict(input_content_sha256=sha256(gzip.decompress(source.read_bytes())).hexdigest(), + helper=HELPER, inverse_row={str(r): str(q) for r, q in sorted(row.items())}, + end_of_B_frames={str(r): basis(frames[r]) for r in sorted(row)}, + endpoint=endpoint, endpoint_rank=8, removed_cleanup_indexes=touches, + early_corrections=corrections, internal_premix=premix) + return word, proof diff --git a/research/coded-helper-early-end8/model.py b/research/coded-helper-early-end8/model.py new file mode 100644 index 0000000000..bf2358e806 --- /dev/null +++ b/research/coded-helper-early-end8/model.py @@ -0,0 +1,62 @@ +"""Recount the fixed PR626 budget and derive all four mixture deltas.""" +from collections import Counter +from construct import read, require + +BASE = 'research/complex-k492-owner-repair' +DATA = BASE + '/vendor/multicold/vendor/pr558/vendor/pr552/complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json' + + +def integers(mapping): + return {int(r): n for r,n in mapping.items()} + + +def difference(left, right): + return {r: left.get(r,0)-right.get(r,0) for r in set(left)|set(right) if left.get(r,0)!=right.get(r,0)} + + +def build(root, original, retimed): + spec = read(root / BASE / 'data/SPEC.json') + plan = read(root / BASE / 'data/PLAN.json') + data = read(root / DATA) + calls = Counter(pid for _,_,pid in spec['dispatch']) + require(calls == {'ck':8,'jp8':64} and plan['M']==data['m']==73 and + plan['L']==9 and plan['T']==8 and data['ports']==112, 'Fixed comparison geometry') + require([[c['stage'],c['replica'],c['provider']] for c in plan['provider_calls']] == spec['dispatch'], 'Dispatch binding') + caps = Counter() + for capacity,times in plan['windows'].values(): + caps[capacity] += data['ports'] + independent_caps = Counter() + for recipe in data['recipes']: + for child in recipe['idle_children']: + independent_caps[child['rank']] += plan['T'] + require(independent_caps.pop(0)==2*112*8 and caps==independent_caps, 'Independent capacity census') + local, widths = Counter(), Counter() + for pid,count in calls.items(): + source = spec['providers'][pid] + profile, inventory = integers(source['expected_profile']), integers(source['inventory']) + registry = plan['provider_registry'][pid] + require(integers(registry['actual_paid_profile'])==profile and Counter(registry['widths'])==inventory, 'Provider source billing') + local.update({r:n*count for r,n in profile.items()}) + widths.update({w:n*count for w,n in inventory.items()}) + require(widths==Counter(w for call in plan['per_call_widths'] for w in call['widths']), 'Complete helper demand') + global_profile = integers(spec['expected']['global_profile']) + require(local+Counter(integers(spec['expected']['idle_remainder_profile']))==global_profile==integers(plan['profile']), 'Complete baseline invoice') + require(plan['live']==spec['expected']['live']==7168 and + sum(r*n for r,n in global_profile.items())==spec['expected']['rank_mass']==plan['live']*73-plan['deficit'], 'Baseline rank/deficit') + variants = {} + for family,receipts in [('original9',original),('early8',retimed)]: + for placement in ('positive','negative'): + deltas = [] + for pid in ('ck','jp8'): + receipt = receipts[placement+'-'+pid] + require(receipt['live_columns_each_orientation']==224+receipt['helpers'] and + receipt['status']=='PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES', 'Exact native obligation') + deltas.append(dict(profile=difference(integers(receipt['local_profile']),integers(spec['providers'][pid]['expected_profile'])), + widths=difference(dict(Counter(receipt['widths'])),integers(spec['providers'][pid]['inventory'])))) + require(deltas[0]==deltas[1], 'Provider-independent variant billing') + variants[family+'-'+placement] = deltas[0] + result = dict(endpoint=spec['expected']['complex_lower'],m=73,live=7168,calls=72, + rank_mass=spec['expected']['rank_mass'],capacities=dict(caps),widths=dict(widths), + local=dict(local),variants=variants) + result['global'] = global_profile + return result diff --git a/research/coded-helper-early-end8/native_worker.py b/research/coded-helper-early-end8/native_worker.py new file mode 100644 index 0000000000..be927c5d80 --- /dev/null +++ b/research/coded-helper-early-end8/native_worker.py @@ -0,0 +1,68 @@ +"""Assertion-enabled construction and independent inherited native replay.""" +from pathlib import Path +from collections import Counter +import contextlib +import gzip +import json +import runpy +import sys + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(HERE)) +from construct import construct, encode, read, require + +BASE = ROOT / 'research/complex-k492-owner-repair' +ROUTING = BASE / 'vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz' + + +def main(out): + require(__debug__, 'Native auditor requires enabled assertions') + audit = runpy.run_path(str(BASE / 'code/hpe_audit_and_transport.py'))['run'] + receipts, constructions = {}, {} + for name in ('positive-ck', 'positive-jp8', 'negative-ck', 'negative-jp8'): + source = HERE / 'vendor/pr855/words' / (name + '.json.gz') + word, proof = construct(source) + path = out / (name + '.json.gz') + def save(): + path.write_bytes(gzip.compress(encode(word), mtime=0)) + save() + # A discovery run may fail only at the expected old-profile guard. + # Every scalar, endpoint, frame and cone guard before it must pass. + try: + with (out / (name + '-discovery.log')).open('w', encoding='utf-8') as log, contextlib.redirect_stdout(log): + audit(path, ROUTING, out / (name + '-discovery')) + except AssertionError as error: + require(str(error) == 'paid local profile differs from the reported local_profile', + 'Construction rejected before profile discovery: ' + str(error)) + tb = error.__traceback__ + while tb.tb_next: + tb = tb.tb_next + paid = tb.tb_frame.f_locals['paid'] + word['report']['local_profile'] = {str(r): n for r, n in sorted(paid.items())} + word['report']['local_rank_mass'] = sum(r*n for r, n in paid.items()) + else: + raise ValueError('Retimed construction unexpectedly retained old profile') + inventory = word['report']['width_inventory'] + require(inventory['9'] > 0, 'Original coded helper width') + inventory['9'] -= 1 + inventory['8'] = inventory.get('8', 0) + 1 + save() + with (out / (name + '.log')).open('w', encoding='utf-8') as log, contextlib.redirect_stdout(log): + audit(path, ROUTING, out / name) + receipt = read(out / name / 'SCALAR-FRAME-AUDIT.json') + receipt.pop('seconds') + require(Counter(receipt['widths']) == Counter({int(r): n for r, n in inventory.items()}), 'Audited width inventory') + require(receipt['local_rank_mass'] == word['report']['local_rank_mass'], 'Audited rank mass') + require(448 in receipt['cold_hyperplane_ended_helpers'], 'Missing cold endpoint') + receipts[name] = receipt + constructions[name] = proof + print('PASS_NATIVE_EARLY8', name, flush=True) + result = dict(receipts=receipts, constructions=constructions, assertions_enabled=__debug__) + (out / 'NATIVE-RESULT.json').write_bytes((json.dumps(result, indent=2) + '\n').encode()) + + +if __name__ == '__main__': + out = Path(sys.argv[1]).resolve() + require(out.is_dir(), 'Prepared output directory required') + main(out) diff --git a/research/coded-helper-early-end8/packing.py b/research/coded-helper-early-end8/packing.py new file mode 100644 index 0000000000..7d6306672a --- /dev/null +++ b/research/coded-helper-early-end8/packing.py @@ -0,0 +1,88 @@ +"""Independent pattern census and mixed-variant cost DP. + +PR855 supplies lambda and residue potentials. Every obligation is replayed +using the new binomial interval engine and a Cartesian-product census. +""" +from fractions import Fraction as Q +from itertools import product +from construct import require +from binomial import power_bounds, SCALE + +CAPACITY_SCORES = {8: 6, 16: 12, 32: 24, 48: 37} +WIDTH_SCORES = {4: 3, 5: 3, 7: 5, 8: 6, 9: 7} + + +def patterns(): + widths = tuple(sorted(WIDTH_SCORES)) + result = [] + for capacity in sorted(CAPACITY_SCORES): + for counts in product(*(range(capacity//w+1) for w in widths)): + used = sum(w*n for w, n in zip(widths, counts)) + if used <= capacity: + result.append((capacity-used, CAPACITY_SCORES[capacity]- + sum(WIDTH_SCORES[w]*n for w, n in zip(widths, counts)))) + require(len(result) == 1163, 'Independent pattern domain') + return result + + +def verify(model, certificate): + b = Q(model['endpoint']) + require(Q(certificate['endpoint']) == b and certificate['potential_scale'] == 10**16, + 'Potential source endpoint/scale') + lam, potentials = certificate['lambda_units_1e30'], certificate['potentials'] + require(type(lam) is int and lam < 0 and len(potentials) == 37 and + all(type(x) is int for x in potentials) and potentials[0] == 0, 'Potential domain') + unit = SCALE//10**16 + intervals = {r: power_bounds(r, b) for r in range(74)} + for leftover, score in patterns(): + require(score >= 0, 'Negative pattern score') + reduced = intervals[leftover][0] - leftover*SCALE - lam*score + require(reduced >= 0, 'Pattern dual inequality') + for residue in range(37): + require((potentials[(residue+score)%37]-potentials[residue])*unit <= reduced, + 'Pattern potential inequality') + threshold = model['live'] * intervals[model['m']][1] + baseline_upper = sum(n*intervals[r][1] for r, n in model['global'].items()) + require(baseline_upper < model['live']*intervals[model['m']][0], 'Original supplier positive control') + mass = sum(c*n for c, n in model['capacities'].items()) + base_idle = mass - sum(w*n for w, n in model['widths'].items()) + score = sum(CAPACITY_SCORES[c]*n for c, n in model['capacities'].items()) - sum( + WIDTH_SCORES[w]*n for w, n in model['widths'].items()) + base = sum(n*intervals[r][0] for r, n in model['local'].items()) + base_idle*SCALE + lam*score + require(sum(r*n for r,n in model['local'].items()) + base_idle == model['rank_mass'], 'Baseline conservation') + names = sorted(model['variants']) + costs = {} + for name in names: + delta = model['variants'][name] + idle_change = -sum(w*n for w,n in delta['widths'].items()) + score_change = -sum(WIDTH_SCORES[w]*n for w,n in delta['widths'].items()) + require(sum(r*n for r,n in delta['profile'].items()) + idle_change == 0, 'Variant conservation: ' + name) + costs[name] = (sum(n*intervals[r][0 if n >= 0 else 1] for r,n in delta['profile'].items()) + + idle_change*SCALE + lam*score_change, score_change) + # These endpoint inequalities certify nonnegative inventories for every + # four-way mix of at most 72 calls, before relaxing labels and windows. + for kind in ('profile', 'widths'): + initial = model['local'] if kind == 'profile' else model['widths'] + for r,n in initial.items(): + require(n + model['calls']*min(0, *(d[kind].get(r,0) for d in model['variants'].values())) >= 0, + 'Mixed inventory can become negative') + state = {score%37: (0, (0,)*len(names))} + minima = [] + for changed in range(1, model['calls']+1): + following = {} + for residue,(cost,counts) in state.items(): + for i,name in enumerate(names): + price,shift = costs[name] + next_residue = (residue+shift)%37 + new_counts = list(counts);new_counts[i] += 1 + candidate = (cost+price,tuple(new_counts)) + if next_residue not in following or candidate < following[next_residue]: + following[next_residue] = candidate + state = following + for residue,(cost,counts) in state.items(): + minima.append((base+cost+potentials[residue]*unit-threshold, changed, residue, counts)) + margin,changed,residue,counts = min(minima) + return dict(patterns=1163, potential_inequalities=43031, dp_states=len(minima), + modified_calls=changed, residue=residue, minimum_margin=str(Q(margin,SCALE)), + minimum_counts=dict(zip(names,counts)), excluded=margin>0, + power_engine='7000-term positive binomial with integer outward rounding and geometric tail') diff --git a/research/coded-helper-early-end8/test_controls.py b/research/coded-helper-early-end8/test_controls.py new file mode 100644 index 0000000000..a33b9f0a74 --- /dev/null +++ b/research/coded-helper-early-end8/test_controls.py @@ -0,0 +1,76 @@ +"""New endpoint/wrapper/profile and exact-certificate negative controls.""" +from copy import deepcopy +import contextlib +import gzip +import json +from pathlib import Path +import runpy +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0,str(HERE)) +from construct import read, encode, require, construct +from packing import verify as price + + +def main(output): + # Retain mathematical inputs independently of the ephemeral full replay. + expected = read(HERE/'EXPECTED.json') + base = ROOT/'research/complex-k492-owner-repair' + route = base/'vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz' + require(__debug__, 'Native controls require assertions') + audit = runpy.run_path(str(base/'code/hpe_audit_and_transport.py'))['run'] + source = output/'early8/positive-ck.json.gz' + word = read(source) + premix_count = len(expected['new_constructions']['positive-ck']['internal_premix']) + cases = [] + changed = deepcopy(word);del changed['A'][:premix_count] + cases.append(('omit_internal_premix',changed,'zero-frame precondition/compensation')) + changed = deepcopy(word);changed['early_cleanup']=changed['early_cleanup'][2:] + cases.append(('omit_early_tail_admission',changed,'cleanup on non-FULL end')) + changed = deepcopy(word);changed['helper_final']['448']=changed['helper_final']['448'][:-1] + cases.append(('declare_rank7_endpoint',changed,'hpe cone pre-check')) + changed = deepcopy(word);changed['cleanup'][0][3]=0 + cases.append(('omit_one_restore_read',changed,'arbitrary-dirt endpoint')) + changed = deepcopy(word);changed['report']['local_profile']['1']-=1 + cases.append(('undercharge_profile',changed,'paid local profile differs')) + results = {} + with tempfile.TemporaryDirectory(prefix='early8-controls-') as temporary: + root = Path(temporary) + for name,changed,reason in cases: + path=root/(name+'.json.gz');path.write_bytes(gzip.compress(encode(changed),mtime=0)) + with (root/(name+'.log')).open('w',encoding='utf-8') as log,contextlib.redirect_stdout(log): + try: + audit(path,route,root/name) + except AssertionError as error: + require(reason in str(error),'Wrong native rejection: '+name+' '+str(error)) + results[name]=str(error).split(':')[0] + else: + raise ValueError('Native mutation accepted: '+name) + model=expected['model'];model['local']={int(r):n for r,n in model['local'].items()} + for key in ('widths','global','capacities'): + model[key]={int(r):n for r,n in model[key].items()} + for variant in model['variants'].values(): + for key in ('profile','widths'): + variant[key]={int(r):n for r,n in variant[key].items()} + certificate=read(HERE/'vendor/pr855/EXACT-CERTIFICATE.json') + for name,change,reason in [ + ('raise_lambda',lambda c:c.update(lambda_units_1e30=c['lambda_units_1e30']+10**24),'Pattern'), + ('raise_potential',lambda c:c['potentials'].__setitem__(22,c['potentials'][22]+1000),'Pattern potential'), + ]: + changed=deepcopy(certificate);change(changed) + try:price(model,changed) + except ValueError as error: + require(reason in str(error),'Wrong potential rejection') + results[name]='rejected' + else:raise ValueError('Bad exact certificate accepted') + changed=deepcopy(certificate);changed['potentials']=[0]*37 + require(price(model,changed)['excluded'] is False,'Integer correction control did not expose an uncertified mixture') + results['omit_integer_correction']='not certified as excluded' + print('PASS_EARLY8_CONTROLS',json.dumps(results,sort_keys=True)) + + +if __name__=='__main__': + main(Path(sys.argv[1]).resolve()) diff --git a/research/coded-helper-early-end8/vendor/pr855/CODED-CELL.json b/research/coded-helper-early-end8/vendor/pr855/CODED-CELL.json new file mode 100644 index 0000000000..035020fc43 --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/CODED-CELL.json @@ -0,0 +1,65 @@ +{ + "selected": [[6, 7], 1], + "core": [ + ["h0", "x4", 1], + ["y1", "x3", 1], + ["y2", "x5", 1], + ["y3", "x0", 1], + ["y4", "x2", 1], + ["y5", "x1", 1], + ["h0", "x2", 1], + ["y0", "y1", 1], + ["y2", "x1", 1], + ["y5", "y3", 1], + ["y0", "x4", 1], + ["y3", "y2", 1], + ["y5", "x3", 1], + ["y0", "x2", 1], + ["y1", "x4", 1], + ["y2", "x3", 1], + ["y4", "y3", 1], + ["y0", "x5", 1], + ["y1", "x0", 1], + ["y3", "h0", 1], + ["y4", "x3", 1], + ["y5", "x4", 1], + ["y0", "x1", 1], + ["y1", "x2", 1], + ["y2", "x0", 1], + ["y1", "x5", 1], + ["y2", "x4", 1], + ["y5", "x2", 1] + ], + "direct": [ + ["y5", "x3", 1], + ["y2", "x1", 1], + ["y3", "x2", 1], + ["y1", "x0", 1], + ["y4", "x5", 1], + ["y4", "x3", 1], + ["y5", "x2", 1], + ["y4", "x2", 1], + ["y0", "x4", 1], + ["y2", "x0", 1], + ["y0", "x5", 1], + ["y3", "x1", 1], + ["y1", "x4", 1], + ["y2", "x4", 1], + ["y3", "x0", 1], + ["y3", "x4", 1], + ["y1", "x5", 1], + ["y2", "x5", 1], + ["y0", "x3", 1], + ["y1", "x3", 1], + ["y2", "x3", 1], + ["y3", "x5", 1], + ["y0", "x2", 1], + ["y1", "x2", 1], + ["y5", "x1", 1], + ["y5", "x0", 1], + ["y5", "x4", 1], + ["y4", "x1", 1], + ["y4", "x0", 1], + ["y0", "x1", 1] + ] +} diff --git a/research/coded-helper-early-end8/vendor/pr855/CONSTRUCTION-RECORD.json b/research/coded-helper-early-end8/vendor/pr855/CONSTRUCTION-RECORD.json new file mode 100644 index 0000000000..30229920dd --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/CONSTRUCTION-RECORD.json @@ -0,0 +1,2244 @@ +{ + "negative-ck": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 18, + "x1": 269, + "x2": 82, + "x3": 429, + "x4": 50, + "x5": 445, + "y0": 130, + "y1": 134, + "y2": 194, + "y3": 198, + "y4": 162, + "y5": 166 + }, + "core_gate_indexes": [ + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": -1 + }, + "cold_end_transfer": { + "end_lifts": [], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2854, + "introduced": 8414, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [], + "tail_lifts": [] + }, + "entry_correction": { + "gates": [ + [ + "add", + 166, + 701, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 702, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 703, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 705, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 701, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 703, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 705, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "75fe3c219f0ea014b826b42ea604f1674b7049d2a17e5b0d7d8122c1e645322a", + "profile": { + "1": 2432, + "2": 399, + "3": 469, + "4": 168, + "5": 56, + "6": 44, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 272, + 49, + 6 + ], + "before": [ + 49, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 680, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ], + "before": [ + 256, + 128, + 81, + 33, + 8, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 692, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 257, + 128, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 321, + 128, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 693, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 32, + 16, + 6, + 1 + ], + "before": [ + 256, + 128, + 65, + 33, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 695, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 8, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 256, + 193, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 700, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 273, + 128, + 64, + 33, + 8, + 6 + ], + "before": [ + 337, + 128, + 33, + 8, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 689, + "section": "B", + "sweep": 1 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 690, + "section": "B", + "sweep": 1 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 3 + }, + "native_word_content_sha256": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "stages": { + "coded-ck-cold": "2530fc4639227c9b225f2541715f22925877598c6ecce2656eb28f6d98a27c0a", + "coded-ck-hpe": "d0e8c7168163622b42f65c1315ec3556f24a1a56f4545686031513a9ceffa066", + "coded-ck-optimized": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "coded-ck-regroup": "cbb2f5b778f13bf2667c6d013cae7e160ca739a3c3579db2e401257b68f6a00f", + "coded-ck-step1": "fa69d7482ecc2b2a4022af1f196534bb76ee09baaaa67665a836db1a7290c169", + "coded-ck-step2": "4ae3933ce2a3644800b0e62d08f1527d91ad56449de77053c633750565b4fcef", + "coded-ck-step3": "c759bf7d8791f245307a4af1b533d4ba20ad6c45e24040f34a09f8e46c1bf0ef", + "coded-ck-step4": "cb8707223f286cbb22f065a21c7b31c1d7c267d36f782d2f0e26b139fdda1efa" + } + }, + "negative-jp8": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 18, + "x1": 269, + "x2": 82, + "x3": 429, + "x4": 50, + "x5": 445, + "y0": 130, + "y1": 134, + "y2": 194, + "y3": 198, + "y4": 162, + "y5": 166 + }, + "core_gate_indexes": [ + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": -1 + }, + "cold_end_transfer": { + "end_lifts": [], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2819, + "introduced": 9112, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [], + "tail_lifts": [] + }, + "entry_correction": { + "gates": [ + [ + "add", + 166, + 701, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 702, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 703, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 166, + 705, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 701, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 703, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 198, + 705, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "75fe3c219f0ea014b826b42ea604f1674b7049d2a17e5b0d7d8122c1e645322a", + "profile": { + "1": 2432, + "2": 399, + "3": 469, + "4": 168, + "5": 56, + "6": 44, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 272, + 49, + 6 + ], + "before": [ + 49, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 680, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 33, + 17, + 8, + 6 + ], + "before": [ + 256, + 128, + 81, + 33, + 8, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 692, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 257, + 128, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 321, + 128, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 693, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 64, + 32, + 16, + 6, + 1 + ], + "before": [ + 256, + 128, + 65, + 33, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 695, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 8, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 16, + 8, + 6 + ], + "before": [ + 256, + 193, + 33, + 16, + 8, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 700, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 273, + 128, + 64, + 33, + 8, + 6 + ], + "before": [ + 337, + 128, + 33, + 8, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 689, + "section": "B", + "sweep": 1 + }, + { + "after": [ + 272, + 144, + 80, + 48, + 6, + 1 + ], + "before": [ + 272, + 144, + 81, + 49, + 6 + ], + "delta": { + "1": 1, + "2": -1, + "3": -1, + "4": 1 + }, + "index": 690, + "section": "B", + "sweep": 1 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 3 + }, + "native_word_content_sha256": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "stages": { + "coded-jp8-cold": "0587a8edaf4a741bb2226d8c2c8c40790a71438f7a84ead7ded82a5e35cd97aa", + "coded-jp8-hpe": "4f4f28d3bf9209bb2dc4098249fc42f96ac7bcc5d4517213aab3c5f7854f8baf", + "coded-jp8-optimized": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "coded-jp8-regroup": "bfb6c4f03115df85b66e4061d469b90137124fb2b23013626ce543d411974188", + "coded-jp8-step1": "e18bd7a56bc0429bee9019a6e663205906d2bc107ee421f2614fa28c7bfa5ac8", + "coded-jp8-step2": "fea6989e0aa616fb46c007d61f79a51c56e87f6392b2dcbc828ed363b0b4ec6b", + "coded-jp8-step3": "ce871911ea4bdd2d47062d0a31fdca14f765ca88829a04fd33e56c5cd236ea8f" + } + }, + "positive-ck": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 271, + "x1": 19, + "x2": 431, + "x3": 83, + "x4": 447, + "x5": 51, + "y0": 135, + "y1": 131, + "y2": 199, + "y3": 195, + "y4": 167, + "y5": 163 + }, + "core_gate_indexes": [ + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": 1 + }, + "cold_end_transfer": { + "end_lifts": [ + { + "helper": 266, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ] + }, + { + "helper": 426, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ] + }, + { + "helper": 442, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ] + } + ], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2848, + "introduced": 8411, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [ + 13, + 25, + 33 + ], + "tail_lifts": [ + { + "cleanup_index": 40, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 266, + 19 + ] + }, + { + "cleanup_index": 41, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 20, + 266 + ] + }, + { + "cleanup_index": 42, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 23, + 266 + ] + }, + { + "cleanup_index": 104, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 426, + 83 + ] + }, + { + "cleanup_index": 105, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 84, + 426 + ] + }, + { + "cleanup_index": 106, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 87, + 426 + ] + }, + { + "cleanup_index": 108, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 442, + 51 + ] + }, + { + "cleanup_index": 109, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 52, + 442 + ] + }, + { + "cleanup_index": 110, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 55, + 442 + ] + } + ] + }, + "entry_correction": { + "gates": [ + [ + "add", + 163, + 698, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 699, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 700, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 698, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 699, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 700, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 702, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "04030e0840696cae8456e7e859c4a9b7feb8a8d5679ee22d1fcf0d950bd9b47e", + "profile": { + "1": 2462, + "2": 393, + "3": 469, + "4": 162, + "5": 56, + "6": 41, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 313, + 73, + 6 + ], + "before": [ + 73, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ], + "before": [ + 256, + 128, + 65, + 41, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 710, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "before": [ + 256, + 136, + 73, + 33, + 24, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 718, + "section": "B", + "sweep": 0 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 2 + }, + "full_frame_cleanup_correction": { + "gates": [ + [ + "add", + 265, + 16, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 265, + 19, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 16, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 19, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 80, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 83, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 80, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 83, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 48, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 51, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 48, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 51, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "profile_unchanged": true + }, + "native_word_content_sha256": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "stages": { + "coded-ck-cold": "24628271aaad4cc71190039afeaaa226eabd276305fea3b7af9f7d17e3bfe07d", + "coded-ck-cold-repaired": "bb2b0b9a8152d8a68da304b275309d3ec6414b68603948ff31f283aadb66a4f2", + "coded-ck-hpe": "37a99e8e096edcc0e13fcf2f573adb654307efe495f3a40d4db048f4ad8c5d37", + "coded-ck-optimized": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "coded-ck-regroup": "692e7f0c804546903533fbfd97a44209c07703819fb4aeb2c9c00529935b7af5", + "coded-ck-step1": "de5b3e1637b2b7b1060d7230e1710b3d9a77b004ec7822059b870618d20d716a", + "coded-ck-step2": "9ce84451a37a24dd5942ad66f6debc6e65c19738beaca8caac79a548b7ff7be4", + "coded-ck-step3": "e5f40f9e6f614537364ad8136a87f618776300f503d9ebe81db4839088f20a4d", + "coded-ck-step4": "589191f13caecedb4712288e168083800ad281d290287ce0785ecb0a18063c27" + } + }, + "positive-jp8": { + "coded_cell": { + "bindings": { + "h0": 448, + "x0": 271, + "x1": 19, + "x2": 431, + "x3": 83, + "x4": 447, + "x5": 51, + "y0": 135, + "y1": 131, + "y2": 199, + "y3": 195, + "y4": 167, + "y5": 163 + }, + "core_gate_indexes": [ + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718 + ], + "pair": [ + 6, + 7 + ], + "section": "B", + "sign": 1 + }, + "cold_end_transfer": { + "end_lifts": [ + { + "helper": 266, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ] + }, + { + "helper": 426, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ] + }, + { + "helper": 442, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ] + } + ], + "sections": { + "A": { + "introduced": 438 + }, + "cleanup": { + "dropped_by_stage": 2813, + "introduced": 9109, + "kept_own": 2 + } + }, + "skipped_removed_early_gates": [ + 13, + 25, + 33 + ], + "tail_lifts": [ + { + "cleanup_index": 40, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 266, + 19 + ] + }, + { + "cleanup_index": 41, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 20, + 266 + ] + }, + { + "cleanup_index": 42, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 400, + 96, + 8, + 6 + ], + "registers": [ + 23, + 266 + ] + }, + { + "cleanup_index": 104, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 426, + 83 + ] + }, + { + "cleanup_index": 105, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 84, + 426 + ] + }, + { + "cleanup_index": 106, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 408, + 73, + 49, + 6 + ], + "registers": [ + 87, + 426 + ] + }, + { + "cleanup_index": 108, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 442, + 51 + ] + }, + { + "cleanup_index": 109, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 52, + 442 + ] + }, + { + "cleanup_index": 110, + "new_frame": [ + 256, + 128, + 65, + 33, + 16, + 8, + 6 + ], + "old_frame": [ + 289, + 161, + 24, + 6 + ], + "registers": [ + 55, + 442 + ] + } + ] + }, + "entry_correction": { + "gates": [ + [ + "add", + 163, + 698, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 699, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 700, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 163, + 702, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 698, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 699, + 1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 700, + -1, + 2, + [ + 6 + ] + ], + [ + "add", + 195, + 702, + -1, + 2, + [ + 6 + ] + ] + ], + "output_content_sha256": "04030e0840696cae8456e7e859c4a9b7feb8a8d5679ee22d1fcf0d950bd9b47e", + "profile": { + "1": 2462, + "2": 393, + "3": 469, + "4": 162, + "5": 56, + "6": 41, + "8": 8 + } + }, + "final_frame_raises": { + "changes": [ + { + "after": [ + 313, + 73, + 6 + ], + "before": [ + 73, + 6 + ], + "delta": { + "1": -2, + "2": 1 + }, + "index": 698, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 128, + 65, + 32, + 16, + 9, + 6 + ], + "before": [ + 256, + 128, + 65, + 41, + 16, + 6 + ], + "delta": { + "1": -2, + "2": 2, + "3": -2, + "4": 1 + }, + "index": 710, + "section": "B", + "sweep": 0 + }, + { + "after": [ + 256, + 129, + 64, + 33, + 17, + 9, + 6 + ], + "before": [ + 256, + 136, + 73, + 33, + 24, + 6 + ], + "delta": { + "1": -3, + "2": 3, + "3": -1 + }, + "index": 718, + "section": "B", + "sweep": 0 + } + ], + "domain": "coded 28 gates; one-vector extensions and maximal common-next frame; 12 sweeps maximum", + "sweeps": 2 + }, + "full_frame_cleanup_correction": { + "gates": [ + [ + "add", + 265, + 16, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 265, + 19, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 16, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 271, + 19, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 80, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 425, + 83, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 80, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 431, + 83, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 48, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 441, + 51, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 48, + -1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ], + [ + "add", + 447, + 51, + 1, + 2, + [ + 256, + 128, + 64, + 32, + 16, + 8, + 4, + 2, + 1 + ] + ] + ], + "profile_unchanged": true + }, + "native_word_content_sha256": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "stages": { + "coded-jp8-cold": "dec82b535e3bbeb4ec1ee5a26e054d83128ab815118957c8b26922177002fb4e", + "coded-jp8-cold-repaired": "fd818edcaa3495792ad79ed3159d58cf02a9cadb5e3a861d31c5a607331d490d", + "coded-jp8-hpe": "03b967e3083dac7138e58b8f04d3ad718c6ccb7dbb951ac16a716616f3ed0bc2", + "coded-jp8-optimized": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "coded-jp8-regroup": "a30bbf02942ad4aa693906b95ca4ae61f5ad44c1441ab6bf0bbffec94fa5a7eb", + "coded-jp8-step1": "3dc0da9a659f50d7fb013133d94cac0d33ade9aa29a0769f299a01202377689b", + "coded-jp8-step2": "103a78c6efd8aa35cf053f0e9e5860a6425f52a9d9ea079ec77d823fafa8b15b", + "coded-jp8-step3": "54d0a10139a8bdcce2782556240f3142d28980c76ff6e68ef9f298894807a9f1" + } + } +} diff --git a/research/coded-helper-early-end8/vendor/pr855/EXACT-CERTIFICATE.json b/research/coded-helper-early-end8/vendor/pr855/EXACT-CERTIFICATE.json new file mode 100644 index 0000000000..03f096f8ce --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/EXACT-CERTIFICATE.json @@ -0,0 +1,53 @@ +{ + "endpoint": "65528268492323474503/40000000000000000000000", + "patterns": 1163, + "potential_inequalities": 43031, + "mixtures": 2700, + "lambda_units_1e30": -8201202857049542392398000000, + "potential_scale": 10000000000000000, + "potentials": [ + 0, + 59314550434746, + 110079993958731, + 114380123947523, + 152189992929679, + 187269223567683, + 220011422170366, + 197583711618153, + 224836536228789, + 250606299201797, + 216161779387053, + 238154318824237, + 259060528545513, + 278948503635277, + 233891283181203, + 251059231609609, + 267413081740366, + 215818354149567, + 229949367277736, + 243402254426580, + 256204198988314, + 197941726943317, + 257256277378063, + 219365556786168, + 156607164321207, + 215921714755953, + 247475360831639, + 181711617906737, + 189131951630801, + 196100574414541, + 126718938715260, + 132403287270727, + 137681176104011, + 196995726538757, + 69161038378985, + 128475588813731, + 179241032337716 + ], + "minimum_margin_units_1e30": 23249063103322040520087343552, + "minimum_at": { + "positive": 0, + "negative": 1 + }, + "minimum_margin_greater_than": "23249063103/1000000000000" +} diff --git a/research/coded-helper-early-end8/vendor/pr855/NATIVE-EXPECTED.json b/research/coded-helper-early-end8/vendor/pr855/NATIVE-EXPECTED.json new file mode 100644 index 0000000000..8a989fcb11 --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/NATIVE-EXPECTED.json @@ -0,0 +1,2434 @@ +{ + "negative-ck": { + "canonical_content_sha256": "2a29ef51b8deee2911faeb96334dab62c16de09d645497444314098447b29835", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8548, + "directed_edges": 3096, + "early_cleanup_gates": 120, + "frames": 1114, + "helpers": 493, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "input_content_sha256": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "live_columns_each_orientation": 717, + "local_profile": { + "1": 2589, + "2": 549, + "3": 306, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5723, + "refactored_cleanup": { + "provider": "ck", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 8431, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 21762, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "negative-jp8": { + "canonical_content_sha256": "7fa93ce7be03fa80580d097aa56f206391ee3dad759ee0edc288da5e00a676e7", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8644, + "directed_edges": 3007, + "early_cleanup_gates": 120, + "frames": 1033, + "helpers": 493, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 478, + 491, + 492, + 515, + 516, + 539, + 540, + 563, + 564, + 575, + 584, + 585, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604 + ], + "input_content_sha256": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "live_columns_each_orientation": 717, + "local_profile": { + "1": 2505, + "2": 397, + "3": 450, + "4": 164, + "5": 70, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5767, + "refactored_cleanup": { + "provider": "jp8", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 9128, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 22519, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "positive-ck": { + "canonical_content_sha256": "fdffede0b46600550a12658de89963e5586a7eb37ed1463c10a091242bb04880", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8554, + "directed_edges": 3121, + "early_cleanup_gates": 117, + "frames": 1127, + "helpers": 490, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "input_content_sha256": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "live_columns_each_orientation": 714, + "local_profile": { + "1": 2598, + "2": 570, + "3": 312, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5711, + "refactored_cleanup": { + "provider": "ck", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 8440, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 21777, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 8, + 9, + 8, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + }, + "positive-jp8": { + "canonical_content_sha256": "f5c8b7a673b429d4caf99b9e6c48de6a398fbe37fe422b2495f51b3eb0229781", + "center_rank_sum": 64, + "cold_hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442 + ], + "compensation_additions": 8650, + "directed_edges": 3032, + "early_cleanup_gates": 117, + "frames": 1046, + "helpers": 490, + "hyperplane_ended_helpers": [ + 234, + 250, + 266, + 281, + 282, + 297, + 298, + 313, + 314, + 329, + 330, + 345, + 346, + 361, + 362, + 377, + 378, + 393, + 394, + 410, + 426, + 442, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 468, + 469, + 490, + 491, + 514, + 515, + 538, + 539, + 562, + 563, + 574, + 583, + 584, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601 + ], + "input_content_sha256": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934", + "live_columns_each_orientation": 714, + "local_profile": { + "1": 2514, + "2": 418, + "3": 456, + "4": 155, + "5": 61, + "6": 8, + "8": 8 + }, + "local_rank_mass": 5755, + "refactored_cleanup": { + "provider": "jp8", + "source": "k492 cold-end recipe transfer; independently audited" + }, + "refactored_cleanup_gates": 9137, + "routing_content_sha256": "7c84ac65c8b37173aa4293934f041915895e8ec30595844cc1534e2a19ae0d25", + "scalar_operations": 22534, + "scope": "Fresh exact forward and inverse-transpose scalar replay on every arbitrary input; all native frame chains and dyadic primitives. Phase lowering, wrappers, global owners and global assembly are separate.", + "status": "PASS_CHANGED_WORD_ALL_COLUMNS_AND_NATIVE_FRAMES", + "target_port_order_matches_baseline": true, + "tau": 43, + "widths": [ + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5 + ] + } +} diff --git a/research/coded-helper-early-end8/vendor/pr855/NOTICE.md b/research/coded-helper-early-end8/vendor/pr855/NOTICE.md new file mode 100644 index 0000000000..ddfeacd04e --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/NOTICE.md @@ -0,0 +1,39 @@ +# Attribution and license + +Prepared by NeoKazuya with OpenAI Codex assistance, using +GPT-6-Astra. New code, certificates and text are contributed under the +repository's Apache-2.0 license. + +The coded core and initial positive-cell experiment are from our +[PR781](https://github.com/CrocSwap/integer-mult-bounds/pull/781), pinned at +`85f9cfad7708cc3873bd6b32492a618feb336e59`. The native words extend existing +community constructions; no authorship of those inherited constructions is +claimed. + +- icekylinx's PR531 packet factory and PR425/433 supplier/auditor lineage. +- Jeremy Kothe and AtomScout's PR622 K-triangle construction; Port480's stage + transfer; GlobalR, AtomReviewer, Stack492 and ColdBeyond's accompanying + helper-count, owner and cold-end work; the PR623 dispatch lineage. +- Chafik Boukhalfa/chafreaky's PR626 owner repair and portable verification, + and PR583's frame coalescing used in the inherited provider chain. +- DreamingOfClouds' PR604 cold-end construction and PR484 exact scalar audit, + with their earlier hyperplane-end and native-audit sources. +- The PR552 phase-baseline routing word and Round19's 112-port transport. + +The unchanged native auditor and budget sources are read in place. Their exact +input hashes are in `SOURCE-PINS.json`. The inherited provider package's +[NOTICE.md](../complex-k492-owner-repair/NOTICE.md), its vendor notices and +licenses remain applicable and are retained in the repository. The full prior +attribution chain is preserved there, including the PR568/569/571/575/586 and +PR591/592/593/599/601 work. + +Chafik Boukhalfa's PR795 and Charles Bethin's PR850 are related exact +owner-profile results for the SW4 inventory. Rohan Guliani's PR815 is related +frame-search work on fixed scalar programs. These comparisons do not supply +code or proof inputs to this verifier. The original research request's scope +comparison also included Sreekanth Nair/higherbeing's PR651 and Douglas +Colkitt's PR683 through PR781. + +All inherited conditional assumptions remain conditional. Native circuit replay +and the finite packing exclusion are not formal verification of the full +multiplication theorem. diff --git a/research/coded-helper-early-end8/vendor/pr855/README.md b/research/coded-helper-early-end8/vendor/pr855/README.md new file mode 100644 index 0000000000..2f5b78a40e --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/README.md @@ -0,0 +1,223 @@ +# Two coded-helper embeddings: exact global packing obstruction + +**Status: scoped negative result. No new exponent or selected-bound change.** + +The one-helper packet construction in [PR781](https://github.com/CrocSwap/integer-mult-bounds/pull/781) +survives integration into two historical native provider chains. Its complete +helper bill defeats the local saving. This package retains four explicit native +circuits and proves that every nonempty mixture of these circuits with the +original providers exceeds PR626's complex moment budget, even after removing +the scheduling and physical-family restrictions from the owner problem. + +The claim concerns these four circuits and the stated whole-helper hosting +model. It does not rule out other coded circuits, frame assignments, helper +sharing contracts, dispatches or geometries. PR626 is the historical comparison; +the selected result at this package's base commit is PR799. + +## Reproduce + +From the repository root, using Python 3.11+ and its standard library: + +```sh +python -B research/complex-coded-helper-global-screen/verify.py +``` + +Expected status: `PASS_SCOPED_INTEGER_PACKING_OBSTRUCTION`. To retain the native +words after transport, detailed audit receipts, failure controls and derived +budget data, append `--out /path/to/a/new/directory`. An existing output +directory is rejected. The default uses a temporary directory. + +The command freshly replays all four committed words on every arbitrary-dirt +column in both orientations, recounts their native frame costs and helper +widths, and checks the exact certificate. It rejects five circuit mutations and +three mathematical mutations. A different gzip header and compression level +must reproduce the same complete mathematical receipt. Source archives retain +exact input hashes; generated words use hashes of their decompressed payloads. + +The inherited auditor uses assertions. It runs in a separate interpreter with +assertions enabled, including when the parent uses `-O` or inherits +`PYTHONOPTIMIZE`. New certificate guards use explicit exceptions. + +Validation passed on Windows with Python 3.13.5 and optimized Python 3.14.4 +(also with `PYTHONOPTIMIZE=2` set). The retained mathematical results agree. +No repository-wide suite, Linux CI or full selected-frontier replay is claimed. + +This is replay of retained explicit circuits, not a cold reconstruction of their +entire ancestral search. The baseline profile, dispatch and capacity inputs are +pinned to the inherited certificate. The baseline's full phase, controller, +physical-owner and outer-theorem checks are not rerun here. + +## What was integrated + +The baseline is `research/complex-k492-owner-repair/`, as retained at commit +`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The five inputs used here have identical +bytes at this package's base, `f567884aeb8851b6e794af1184119a3bfbe1e631`. +`SOURCE-PINS.json` identifies them and the PR781 cell at commit +`85f9cfad7708cc3873bd6b32492a618feb336e59`. + +Two placements use the same 28-gate coded core, on pair `(6,7)`: + +| Placement | Change relative to the R492 provider | Helpers | Columns per orientation | +| --- | --- | ---: | ---: | +| positive | Open the positive cell; replace three packet helpers with one coded helper | 490 | 714 | +| negative | Recode the already expanded negative cell; add one coded helper | 493 | 717 | + +Each placement is carried through both `ck` and `jp8`. The fresh coded helper is +register 448. It has its own semantic role; it does not inherit an optimization +intended for a removed packet helper. Both variants need eight rank-one dyadic +correction reads at the start of B, after the entry wrappers. Without them the +auditor reconstructs a forbidden zero-frame read from an entering helper. + +The positive placement also needs nine tail frame lifts, three cold ends raised +from dimension 4 to 7, and twelve full-frame cleanup corrections. The negative +placement retains the old endpoints and omits the six old frame-regroup edits +on reads that the coded core replaced. These are material costs of integration. +`CONSTRUCTION-RECORD.json` records the core's register bindings and gate indices, +the corrections, final frame raises, and hashes of intermediate discovery words. +Those intermediate words are not required or regenerated by this package. + +The final native audits establish exact forward and inverse-transpose endpoints, +arbitrary helper dirt, dyadic primitives, common monotone frames, cold-end cone +conditions, cleanup restoration, and the paid profile. They do not establish +phase lowering, residual adapters or a global owner map for the changed words. +Those later stages cannot rescue a failed lower bound on the required cost. + +The resulting per-call changes are the same for `ck` and `jp8`: + +| Placement | Delta H1 | Delta H2 | Delta H3 | Delta H4 | Delta H5 | Helper-width change | +| --- | ---: | ---: | ---: | ---: | ---: | --- | +| positive | +2 | +18 | +8 | -5 | -9 | remove three width-4; add one width-9 | +| negative | -7 | -3 | +2 | +4 | 0 | add one width-9 | + +The verifier derives this table from the newly replayed words and the pinned +baseline, rather than taking it as input to the cost proof. + +## Fixed budget and favorable relaxation + +Keep PR626's 72 calls (8 `ck`, 64 `jp8`), `m = 73`, 7,168 live streams and rank +deficit 2,560. At each call choose its original word, its positive replacement, +or its negative replacement. The two replacements are not composed within a +single call. Provider-independent deltas reduce the choices to 2,700 nonempty +pairs `(p,n)` with `p >= 0`, `n >= 0`, `p+n <= 72`. + +The original aggregate local profile is + +```text +{1:181536, 2:30016, 3:31104, 4:11520, 5:5040, 6:576, 8:576}. +``` + +The baseline helper counts and available slot capacities are: + +| Helper width | 4 | 5 | 7 | 8 | 9 | +| --- | ---: | ---: | ---: | ---: | ---: | +| Count | 2160 | 3456 | 2848 | 7904 | 19056 | + +| Slot capacity | 8 | 16 | 32 | 48 | +| --- | ---: | ---: | ---: | ---: | +| Count | 5376 | 3584 | 3584 | 3584 | + +The capacity inventory is recounted both from the plan's windows (112 ports per +window) and from all 112 native data recipes (8 replicas per port). The two +rank-zero children per port and replica cannot host positive-width helpers. +The original idle profile is `{1:123, 37:1, 48:2215}`. Local plus idle rank mass +is always 520,704. + +For the lower bound, discard all time windows, call labels and physical-family +uniqueness restrictions. Each helper still occupies its full audited width in +one capacity slot. All integer multisets of widths fitting a slot are allowed, +including the empty multiset: 1,163 patterns. A pattern with leftover rank `r` +is charged just one idle child of rank `r`. Splitting it could only increase +`sum r^s` for `0 < s < 1`, so this is favorable to the candidate. No feasible +assignment or global circuit is inferred from the relaxation. + +## Exact certificate + +Use the inherited endpoint + +```text +b0 = 65528268492323474503 / 40000000000000000000000, +s = 1 - b0, +phi(r) = r^s - r, with phi(0) = 0. +``` + +Give capacities `8,16,32,48` the integer scores `6,12,24,37`, and widths +`4,5,7,8,9` the scores `3,3,5,6,7`. For a pattern P in capacity c, define + +```text +B(P) = capacity_score(c) - sum width_score(w) * count_P(w). +``` + +Enumeration checks `B(P) >= 0` for every pattern. The certificate supplies a +negative rational `lambda` and 37 rational potentials `d[0],...,d[36]`, with +`d[0]=0`. The verifier checks, for every pattern and every residue j, + +```text +phi(r(P)) >= lambda * B(P), +d[(j+B(P)) mod 37] - d[j] <= phi(r(P)) - lambda * B(P). +``` + +These are 1,163 scalar inequalities and 43,031 potential inequalities. For any +integer packing, order its slot patterns arbitrarily and telescope the second +inequality from residue zero. Their total score is fixed by the demand: + +```text +S = 81984 + 2*p - 7*n. +sum_P phi(r(P)) >= lambda*S + d[S mod 37]. +``` + +If `I` is the fixed leftover rank mass and `H_local` the audited local profile, +every such packing therefore has moment numerator at least + +```text +sum_r H_local(r)*r^s + I + lambda*S + d[S mod 37]. +``` + +`exact.py` proves this lower bound strictly exceeds `7168 * 73^s` for every +nonempty mixture. The smallest certified excess is greater than +**0.023249063103**, at `(p,n) = (0,1)`. All child ranks are at most 48, below 73, +so the normalized moment increases with b. Failure at b0 excludes b0 and every +larger saving exponent in this fixed model. + +The integer correction matters. Replacing all potentials with zero still +satisfies the pattern inequalities but fails to exclude the single negative +replacement. This is an explicit control, not an assumption of numerical MIP +optimality. A positive control verifies that the inherited *unmodified* global +profile satisfies its own endpoint. + +All real-power comparisons use rational intervals. Write `r = 2^k m` with +`1 <= m < 2`; evaluate `log r` using 48 terms of the atanh series, with argument +at most 1/3 and an explicit geometric tail. Bound `exp(-b0 log r)` by its degree +21 and degree 20 alternating polynomials, then round outward at scale `10^30`. +The stored potentials use scale `10^16`. No floating-point result, optimizer, +or shortest-path implementation is trusted by the verifier. + +## Search record and limits + +The starting experiment was PR781's seed-23 positive cell. This follow-up tried +that placement and the same pair's already expanded negative cell, retaining +the original coded core and pivot. The provider optimizations were ported to +each changed word, repaired where the native audit rejected them, and audited +again. A final greedy search considered legal raises of the 28 coded gates: +one-vector extensions and the maximal common next frame, at most 12 sweeps. +It accepted three raises for each positive word and eight for each negative +word. This is a bounded search, with no claim of frame optimality. + +Fractional LP and integer MIP exploration suggested the obstruction. The +37-state potentials were then constructed from the nonnegative reduced costs. +Only the retained exact inequalities are part of the proof. Search stopped when +the exact lower bound excluded all 2,700 mixtures; no phase lowering or global +owner nomination was attempted after that decision. + +Related owner-profile results [PR795](https://github.com/CrocSwap/integer-mult-bounds/pull/795) +and [PR850](https://github.com/CrocSwap/integer-mult-bounds/pull/850) concern the +SW4 inventory and establish stronger packing results for that fixed inventory. +[PR815](https://github.com/CrocSwap/integer-mult-bounds/pull/815) studies frame +assignments of fixed scalar words. Here the scalar words and width inventory +change. This package adds four audited embeddings of PR781 and an exact +obstruction for their mixtures in PR626's budget; it makes no general novelty +claim for integer width prices or owner-packing methods. + +The complete multiplication theorem retains its inherited all-size, +realization, hosting, precision/tape and analytic assumptions. This finite +certificate neither discharges those assumptions nor formally verifies the +full theorem. Attribution and licenses are recorded in [NOTICE.md](NOTICE.md). diff --git a/research/coded-helper-early-end8/vendor/pr855/SOURCE-PINS.json b/research/coded-helper-early-end8/vendor/pr855/SOURCE-PINS.json new file mode 100644 index 0000000000..1ec1292382 --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/SOURCE-PINS.json @@ -0,0 +1,23 @@ +{ + "base_commit": "f567884aeb8851b6e794af1184119a3bfbe1e631", + "coded_cell_source": { + "commit": "85f9cfad7708cc3873bd6b32492a618feb336e59", + "path": "research/complex-packet-borrowing23/CODED-CELL.json", + "pull_request": "https://github.com/CrocSwap/integer-mult-bounds/pull/781", + "sha256": "03ba299163019b7438c5e711f0a3e3422466ee7e27d4a05c8ba0576800bc20fd" + }, + "files": { + "research/complex-k492-owner-repair/code/hpe_audit_and_transport.py": "c9a05ff291016b870b4fc925b317abd9c3a604c73ffc8920dfdbbeb475e20aa3", + "research/complex-k492-owner-repair/data/PLAN.json": "8c48ef6ce079916314126c5c3ff0003b32f24cf0fbfb2a033fc93e1e1949b5d5", + "research/complex-k492-owner-repair/data/SPEC.json": "2a2577ac526535826fed9d5f7f83f6e2e0ec058a146c64f7286720b995fa2323", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "research/complex-k492-owner-repair/vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz": "e070ae2c78b4a1b644b418774af62b40d8d16e6ba89602f0474afb557d507c37" + }, + "research_origin_commit": "66849e1475c930fd7732b1a0067ffee7e1e95f60", + "word_content_sha256": { + "negative-ck": "a6b394127bb81f23a2ca7d187c1e4642b369840a82b7627f7872fc772942a5a0", + "negative-jp8": "d7eb38ba90374b914df7751d09d5b2d9e9bd5f898766cab24824d6f51d71705e", + "positive-ck": "ffb6918e397bbc026fe7ad1914bb94e316cd6eacd1d2d249ccd7acf10749b1b2", + "positive-jp8": "8e31803f503ab2b416da2af15dd73cad1b04f33966a24b747c017bc1bfcf9934" + } +} diff --git a/research/coded-helper-early-end8/vendor/pr855/exact.py b/research/coded-helper-early-end8/vendor/pr855/exact.py new file mode 100644 index 0000000000..f2440b951c --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/exact.py @@ -0,0 +1,173 @@ +"""Check the finite packing certificate using rational arithmetic only. + +The recorded potentials are witnesses, not trusted solver output. Every edge +inequality and every mixture is checked again. See README.md for the proof. +""" +from fractions import Fraction as Q +from functools import lru_cache + +SCALE = 10**30 +POTENTIAL_SCALE = 10**16 +MODULUS = 37 +CAPACITY_SCORE = {8: 6, 16: 12, 32: 24, 48: 37} +WIDTH_SCORE = {4: 3, 5: 3, 7: 5, 8: 6, 9: 7} + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def log_interval(z): + """Bound log((1+z)/(1-z)) by 48 terms and a geometric tail.""" + require(0 <= z <= Q(1, 3), "log argument outside certified range") + value, power = Q(0), z + for j in range(48): + value += 2 * power / (2*j + 1) + power *= z*z + return value, value + 2*power / (97*(1-z*z)) + + +@lru_cache(None) +def power_bounds(r, b): + """Outward-rounded integer bounds for SCALE * r**(1-b).""" + require(type(r) is int and r >= 0 and 0 < b < 1, "power domain") + if r in (0, 1): + return r*SCALE, r*SCALE + k = r.bit_length() - 1 + l2, u2 = log_interval(Q(1, 3)) + m = Q(r, 2**k) + lm, um = log_interval((m-1)/(m+1)) + lo, hi = b*(k*l2+lm), b*(k*u2+um) + require(0 < lo <= hi < 1, "exp argument outside certified range") + + def alternating(x): + term = total = Q(1) + for n in range(1, 21): + term *= -x/n + total += term + # Decreasing terms on [0,1]: degree 21 is below, degree 20 above. + return total + term*(-x)/21, total + + lower = r*alternating(hi)[0]*SCALE + upper = r*alternating(lo)[1]*SCALE + return lower.numerator//lower.denominator, -(-upper.numerator//upper.denominator) + + +def patterns(): + """All integer width multisets fitting one capacity, including empty.""" + widths = sorted(WIDTH_SCORE) + result = [] + + def visit(capacity, j, used, multiplicities): + if j == len(widths): + score = CAPACITY_SCORE[capacity] - sum( + WIDTH_SCORE[w]*n for w, n in zip(widths, multiplicities)) + result.append((capacity, capacity-used, tuple(multiplicities), score)) + return + for n in range((capacity-used)//widths[j] + 1): + visit(capacity, j+1, used+n*widths[j], multiplicities+[n]) + + for capacity in sorted(CAPACITY_SCORE): + visit(capacity, 0, 0, []) + return result + + +def shifted(base, positive, negative, deltas): + keys = set(base) | set(deltas['positive']) | set(deltas['negative']) + result = {r: base.get(r, 0) + positive*deltas['positive'].get(r, 0) + + negative*deltas['negative'].get(r, 0) for r in keys} + require(all(type(n) is int and n >= 0 for n in result.values()), + "invalid mixture inventory") + return {r: n for r, n in result.items() if n} + + +def verify(model, certificate, check_record=True): + b = Q(model['endpoint']) + require(Q(certificate['endpoint']) == b, "endpoint mismatch") + require(set(model['capacities']) == set(CAPACITY_SCORE), "capacity domain") + require(set(model['widths']) == set(WIDTH_SCORE), "width domain") + require(certificate['potential_scale'] == POTENTIAL_SCALE, "potential scale") + lam = certificate['lambda_units_1e30'] + d = certificate['potentials'] + require(type(lam) is int and lam < 0, "lambda must be a negative integer") + require(len(d) == MODULUS and all(type(x) is int for x in d) and d[0] == 0, + "potential domain or origin") + pats = patterns() + require(len(pats) == 1163, "pattern enumeration changed") + phi = {r: power_bounds(r, b)[0] - r*SCALE for r in range(49)} + potential_unit = SCALE//POTENTIAL_SCALE + for capacity, residual, counts, score in pats: + require(score >= 0, "negative pattern score") + gap = phi[residual] - lam*score + require(gap >= 0, f"pattern dual inequality: {capacity}, {counts}") + for capacity, residual, counts, score in pats: + gap = phi[residual] - lam*score + for j in range(MODULUS): + require((d[(j+score) % MODULUS]-d[j])*potential_unit <= gap, + f"potential inequality: residue {j}, capacity {capacity}, {counts}") + + # A positive control: the inherited profile really meets its own endpoint. + threshold_lo, threshold_hi = [model['live']*x for x in power_bounds(model['m'], b)] + baseline_hi = sum(n*power_bounds(r, b)[1] for r, n in model['global'].items()) + require(baseline_hi < threshold_lo, "baseline endpoint positive control") + + capacity_mass = sum(c*n for c, n in model['capacities'].items()) + capacity_score = sum(CAPACITY_SCORE[c]*n for c, n in model['capacities'].items()) + rows = [] + for positive in range(model['calls']+1): + for negative in range(model['calls']-positive+1): + if positive + negative == 0: + continue + local = shifted(model['local'], positive, negative, model['profile_deltas']) + widths = shifted(model['widths'], positive, negative, model['width_deltas']) + require(set(local) <= set(range(1, 49)) and set(widths) <= set(WIDTH_SCORE), + "mixture uses an uncertified rank or width") + idle_mass = capacity_mass - sum(w*n for w, n in widths.items()) + score = capacity_score - sum(WIDTH_SCORE[w]*n for w, n in widths.items()) + require(idle_mass >= 0 and score >= 0, "mixture mass or score") + require(sum(r*n for r, n in local.items()) + idle_mass == model['rank_mass'], + "local/idle rank conservation") + lower = (sum(n*power_bounds(r, b)[0] for r, n in local.items()) + + idle_mass*SCALE + lam*score + d[score % MODULUS]*potential_unit) + margin = lower-threshold_hi + require(margin > 0, f"budget inequality: positive={positive}, negative={negative}") + rows.append((margin, positive, negative)) + margin, positive, negative = min(rows) + summary = { + 'endpoint': str(b), 'patterns': len(pats), + 'potential_inequalities': MODULUS*len(pats), 'mixtures': len(rows), + 'lambda_units_1e30': lam, 'potential_scale': POTENTIAL_SCALE, 'potentials': d, + 'minimum_margin_units_1e30': margin, + 'minimum_at': {'positive': positive, 'negative': negative}, + 'minimum_margin_greater_than': str(Q(margin//10**18, 10**12)), + } + if check_record: + require(summary == certificate, "recorded exact-certificate summary differs") + return summary + + +def controls(model, certificate): + from copy import deepcopy + + cases = [] + bad = deepcopy(certificate) + bad['lambda_units_1e30'] += 10**24 # Raise lambda by 10^-6. + cases.append(('raise_lambda', bad, 'pattern dual inequality')) + bad = deepcopy(certificate) + bad['potentials'][22] += 1000 + cases.append(('raise_residue_22', bad, 'potential inequality')) + bad = deepcopy(certificate) + bad['potentials'] = [0]*MODULUS + # Zero potentials satisfy the edges, but cannot exclude the one-call case. + cases.append(('omit_integer_correction', bad, 'budget inequality: positive=0, negative=1')) + rejected = {} + for name, bad, expected in cases: + try: + verify(model, bad, check_record=False) + except ValueError as error: + require(expected in str(error), f"wrong failure for {name}: {error}") + rejected[name] = str(error) + else: + raise ValueError(f"negative control accepted: {name}") + return rejected diff --git a/research/coded-helper-early-end8/vendor/pr855/native_worker.py b/research/coded-helper-early-end8/vendor/pr855/native_worker.py new file mode 100644 index 0000000000..13529fb7d2 --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/native_worker.py @@ -0,0 +1,105 @@ +"""Assertion-enabled replay of the pinned inherited native auditor.""" +import contextlib +import copy +from fractions import Fraction as Q +import gzip +import json +from pathlib import Path +import runpy +import sys + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def main(package, auditor, routing, out): + require(__debug__, "the inherited auditor requires assertions; run without -O") + audit = runpy.run_path(str(auditor))['run'] + expected = read(package/'NATIVE-EXPECTED.json') + construction = read(package/'CONSTRUCTION-RECORD.json') + core = read(package/'CODED-CELL.json')['core'] + words, receipts = {}, {} + for name in sorted(expected): + path = package/'words'/f'{name}.json.gz' + words[name] = read(path) + cell = construction[name]['coded_cell'] + bindings, indexes = cell['bindings'], cell['core_gate_indexes'] + require(len(indexes) == len(core) == 28 and indexes == sorted(set(indexes)), + f"coded core index list: {name}") + embedded = [['add', bindings[t], bindings[s], Q(q).numerator, Q(q).denominator] + for t, s, q in core] + require([words[name]['B'][i][:-1] for i in indexes] == embedded, + f"coded core embedding: {name}") + with (out/f'{name}.log').open('w', encoding='utf-8') as log: + with contextlib.redirect_stdout(log): + audit(path, routing, out/name) + receipt = read(out/name/'SCALAR-FRAME-AUDIT.json') + receipt.pop('seconds') + require(receipt == expected[name], f"native receipt mismatch: {name}") + receipts[name] = receipt + + positive, negative = words['positive-ck'], words['negative-ck'] + provenance = construction['positive-ck'] + corrections = provenance['entry_correction']['gates'] + require(positive['B'][:len(corrections)] == corrections, "entry correction location") + cleanup = provenance['full_frame_cleanup_correction']['gates'] + require(positive['cleanup'][-len(cleanup):] == cleanup, "cleanup correction location") + cases = [] + bad = copy.deepcopy(positive) + del bad['B'][:len(corrections)] + cases.append(('omit_entry_correction', bad, 'zero-frame compensation reads an entering helper')) + bad = copy.deepcopy(positive) + del bad['cleanup'][-len(cleanup):] + cases.append(('omit_full_cleanup_correction', bad, 'arbitrary-dirt endpoint')) + bad = copy.deepcopy(positive) + lift = provenance['cold_end_transfer']['end_lifts'][0] + bad['helper_final'][str(lift['helper'])] = lift['old_frame'] + cases.append(('restore_old_cold_end', bad, 'hpe cone pre-check')) + bad = copy.deepcopy(negative) + gate = next(e for e in bad['cleanup'] if e[0] == 'add' and e[1] == 448 and e[3]) + gate[3] = 0 + cases.append(('omit_coded_helper_cleanup', bad, 'arbitrary-dirt endpoint')) + bad = copy.deepcopy(positive) + bad['report']['local_profile']['2'] -= 1 + cases.append(('understate_paid_profile', bad, 'paid local profile differs')) + rejected = {} + for name, bad, reason in cases: + path = out/f'{name}.json' + path.write_text(json.dumps(bad), encoding='utf-8') + with (out/f'{name}.log').open('w', encoding='utf-8') as log: + try: + with contextlib.redirect_stdout(log): + audit(path, routing, out/name) + except AssertionError as error: + require(reason in str(error), f"wrong failure for {name}: {error}") + rejected[name] = str(error) + else: + raise ValueError(f"negative control accepted: {name}") + + # Generated gzip identity is its entire decompressed payload, not its header. + source = package/'words'/'positive-ck.json.gz' + recompressed = out/'recompressed.json.gz' + recompressed.write_bytes(gzip.compress(gzip.decompress(source.read_bytes()), + compresslevel=1, mtime=123456789)) + require(recompressed.read_bytes() != source.read_bytes(), "recompression control unchanged") + with (out/'recompressed.log').open('w', encoding='utf-8') as log: + with contextlib.redirect_stdout(log): + audit(recompressed, routing, out/'recompressed') + receipt = read(out/'recompressed'/'SCALAR-FRAME-AUDIT.json') + receipt.pop('seconds') + require(receipt == receipts['positive-ck'], "recompression changed mathematical receipt") + result = {'receipts': receipts, 'controls_rejected': rejected, + 'recompression_control': 'PASS', 'assertions_enabled': __debug__} + (out/'NATIVE-RESULT.json').write_text(json.dumps(result, indent=2)+'\n', encoding='utf-8') + + +if __name__ == '__main__': + require(len(sys.argv) == 5, "expected package, auditor, routing and output paths") + main(*(Path(x).resolve() for x in sys.argv[1:])) diff --git a/research/coded-helper-early-end8/vendor/pr855/verify.py b/research/coded-helper-early-end8/vendor/pr855/verify.py new file mode 100644 index 0000000000..939600602b --- /dev/null +++ b/research/coded-helper-early-end8/vendor/pr855/verify.py @@ -0,0 +1,173 @@ +"""Replay four explicit words and the exact global-budget obstruction (stdlib).""" +import argparse +from collections import Counter +import gzip +import hashlib +import json +import os +from pathlib import Path +import runpy +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +BASE = 'research/complex-k492-owner-repair/' +VENDOR = BASE + 'vendor/multicold/vendor/pr558/vendor/pr552/' +AUDITOR = BASE + 'code/hpe_audit_and_transport.py' +ROUTING = VENDOR + 'complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz' +DATA = VENDOR + 'complex-global/vendor531/inputs/data-base/work/complex-nine-native/DATA-PHASES.json' +EXACT = runpy.run_path(str(HERE/'exact.py')) +require = EXACT['require'] + + +def read(path): + data = path.read_bytes() + return json.loads(gzip.decompress(data) if path.suffix == '.gz' else data) + + +def integers(mapping): + return {int(r): n for r, n in mapping.items()} + + +def difference(new, old): + return {r: new.get(r, 0)-old.get(r, 0) for r in sorted(set(new) | set(old)) + if new.get(r, 0) != old.get(r, 0)} + + +def check_sources(): + pins = read(HERE/'SOURCE-PINS.json') + require(set(pins['files']) == {AUDITOR, ROUTING, DATA, BASE+'data/SPEC.json', + BASE+'data/PLAN.json'}, "source pin inventory") + for path, digest in pins['files'].items(): + require(hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == digest, + f"source pin mismatch: {path}") + require(hashlib.sha256((HERE/'CODED-CELL.json').read_bytes()).hexdigest() + == pins['coded_cell_source']['sha256'], "coded-cell source pin") + names = {f'{variant}-{pid}' for variant in ('positive', 'negative') for pid in ('ck', 'jp8')} + require(set(pins['word_content_sha256']) == names, "candidate inventory") + for name, digest in pins['word_content_sha256'].items(): + payload = gzip.decompress((HERE/'words'/f'{name}.json.gz').read_bytes()) + require(hashlib.sha256(payload).hexdigest() == digest, f"word content pin: {name}") + require(set(read(HERE/'NATIVE-EXPECTED.json')) == names, "expected receipt inventory") + return pins + + +def model_from_receipts(receipts): + spec = read(ROOT/BASE/'data/SPEC.json') + plan = read(ROOT/BASE/'data/PLAN.json') + data = read(ROOT/DATA) + expected = spec['expected'] + dispatch = spec['dispatch'] + counts = Counter(pid for _, _, pid in dispatch) + require(counts == expected['provider_counts'] == {'ck': 8, 'jp8': 64}, "dispatch counts") + require([[c['stage'], c['replica'], c['provider']] for c in plan['provider_calls']] + == dispatch, "plan dispatch") + require(plan['order'] == spec['call_order'] == [row[:2] for row in dispatch], "call order") + require(plan['M'] == data['m'] == 73 and plan['T'] == 8 and plan['L'] == 9, + "pinned geometry") + require(len(dispatch) == plan['T']*plan['L'] and data['ports'] == 112, + "call or port count") + capacities = Counter() + for rank, times in plan['windows'].values(): + capacities[rank] += data['ports'] + native_capacities = Counter() + require(len(data['recipes']) == data['ports'], "data recipe count") + for recipe in data['recipes']: + for child in recipe['idle_children']: + native_capacities[child['rank']] += plan['T'] + # The data recipe also records two empty children per port/replica. + # They cannot host any positive-width helper and contribute zero moment. + require(native_capacities.pop(0) == 2*data['ports']*plan['T'], "zero-capacity children") + require(capacities == native_capacities == {8: 5376, 16: 3584, 32: 3584, 48: 3584}, + "window/data capacity inventories disagree") + + local, widths = Counter(), Counter() + per_call = Counter(w for row in plan['per_call_widths'] for w in row['widths']) + for pid, count in counts.items(): + source = spec['providers'][pid] + profile, inventory = integers(source['expected_profile']), integers(source['inventory']) + registry = plan['provider_registry'][pid] + require(integers(registry['actual_paid_profile']) == profile, f"baseline profile: {pid}") + require(Counter(registry['widths']) == inventory, f"baseline inventory: {pid}") + local.update({r: n*count for r, n in profile.items()}) + widths.update({w: n*count for w, n in inventory.items()}) + require(widths == per_call, "per-call baseline helper inventory") + global_profile = integers(expected['global_profile']) + idle = integers(expected['idle_remainder_profile']) + require(local + Counter(idle) == global_profile == integers(plan['profile']), + "baseline local/global accounting") + require(sum(c*n for c, n in capacities.items())-sum(w*n for w, n in widths.items()) + == sum(r*n for r, n in idle.items()), "baseline idle mass") + + profile_deltas, width_deltas = {}, {} + for variant in ('positive', 'negative'): + profiles, inventories = [], [] + for pid in sorted(counts): + name = f'{variant}-{pid}' + receipt = receipts[name] + word = read(HERE/'words'/f'{name}.json.gz') + profile = integers(receipt['local_profile']) + inventory = dict(Counter(receipt['widths'])) + require(profile == integers(word['report']['local_profile']), f"paid profile: {name}") + require(inventory == integers(word['report']['width_inventory']), f"paid widths: {name}") + require(len(receipt['widths']) == receipt['helpers'] == word['report']['R'], + f"helper count: {name}") + require(receipt['live_columns_each_orientation'] == 224 + receipt['helpers'], + f"all-column replay: {name}") + baseline = spec['providers'][pid] + profiles.append(difference(profile, integers(baseline['expected_profile']))) + inventories.append(difference(inventory, integers(baseline['inventory']))) + require(profiles[0] == profiles[1] and inventories[0] == inventories[1], + f"provider-independent deltas: {variant}") + profile_deltas[variant], width_deltas[variant] = profiles[0], inventories[0] + require(plan['live'] == expected['live'] == 7168 and plan['deficit'] == expected['deficit'], + "live/deficit budget") + require(sum(r*n for r, n in global_profile.items()) == expected['rank_mass'] + == plan['live']*plan['M']-plan['deficit'], "baseline rank mass") + return {'endpoint': expected['complex_lower'], 'm': plan['M'], 'live': plan['live'], + 'calls': len(dispatch), 'rank_mass': expected['rank_mass'], + 'capacities': dict(capacities), 'widths': dict(widths), 'local': dict(local), + 'global': global_profile, 'profile_deltas': profile_deltas, 'width_deltas': width_deltas} + + +def run(out): + pins = check_sources() + environment = os.environ.copy() + environment.pop('PYTHONOPTIMIZE', None) + subprocess.run([sys.executable, '-I', '-B', '-X', 'utf8', str(HERE/'native_worker.py'), + str(HERE), str(ROOT/AUDITOR), str(ROOT/ROUTING), str(out)], + check=True, env=environment) + native = read(out/'NATIVE-RESULT.json') + require(native['assertions_enabled'] is True, "native worker assertions disabled") + for name, receipt in native['receipts'].items(): + require(receipt['input_content_sha256'] == pins['word_content_sha256'][name], + f"audited word identity: {name}") + model = model_from_receipts(native['receipts']) + certificate = read(HERE/'EXACT-CERTIFICATE.json') + exact = EXACT['verify'](model, certificate) + controls = EXACT['controls'](model, certificate) + summary = { + 'status': 'PASS_SCOPED_INTEGER_PACKING_OBSTRUCTION', + 'native_words': len(native['receipts']), 'native_controls_rejected': len(native['controls_rejected']), + 'exact_controls_rejected': len(controls), 'recompression_control': native['recompression_control'], + 'patterns': exact['patterns'], 'potential_inequalities': exact['potential_inequalities'], + 'mixtures': exact['mixtures'], 'minimum_margin_greater_than': exact['minimum_margin_greater_than'], + 'minimum_at': exact['minimum_at'], 'scope': 'Four explicit native words; fixed #626 geometry and dispatch. No global candidate admission or new exponent.'} + (out/'RESULT.json').write_text(json.dumps({'summary': summary, 'model': model, + 'exact_controls': controls}, indent=2)+'\n', encoding='utf-8') + print(json.dumps(summary, indent=2)) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path, help='retain receipts in a new directory') + args = parser.parse_args() + if args.out is not None: + out = args.out.resolve() + out.mkdir(parents=True, exist_ok=False) + run(out) + else: + with tempfile.TemporaryDirectory(prefix='coded-helper-screen-') as directory: + run(Path(directory)) diff --git a/research/coded-helper-early-end8/vendor/pr855/words/negative-ck.json.gz b/research/coded-helper-early-end8/vendor/pr855/words/negative-ck.json.gz new file mode 100644 index 0000000000..4950d002d9 Binary files /dev/null and b/research/coded-helper-early-end8/vendor/pr855/words/negative-ck.json.gz differ diff --git a/research/coded-helper-early-end8/vendor/pr855/words/negative-jp8.json.gz b/research/coded-helper-early-end8/vendor/pr855/words/negative-jp8.json.gz new file mode 100644 index 0000000000..c7797d3a41 Binary files /dev/null and b/research/coded-helper-early-end8/vendor/pr855/words/negative-jp8.json.gz differ diff --git a/research/coded-helper-early-end8/vendor/pr855/words/positive-ck.json.gz b/research/coded-helper-early-end8/vendor/pr855/words/positive-ck.json.gz new file mode 100644 index 0000000000..396f1546e0 Binary files /dev/null and b/research/coded-helper-early-end8/vendor/pr855/words/positive-ck.json.gz differ diff --git a/research/coded-helper-early-end8/vendor/pr855/words/positive-jp8.json.gz b/research/coded-helper-early-end8/vendor/pr855/words/positive-jp8.json.gz new file mode 100644 index 0000000000..286824f65f Binary files /dev/null and b/research/coded-helper-early-end8/vendor/pr855/words/positive-jp8.json.gz differ diff --git a/research/coded-helper-early-end8/verify.py b/research/coded-helper-early-end8/verify.py new file mode 100644 index 0000000000..70c630da26 --- /dev/null +++ b/research/coded-helper-early-end8/verify.py @@ -0,0 +1,100 @@ +"""Fresh eight-word native replay and complete four-variant packing screen.""" +import gzip +from fractions import Fraction as Q +from hashlib import sha256 +import json +from math import comb +import os +from pathlib import Path +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(HERE)) +from construct import read, require, encode +from model import build, BASE +from packing import verify as price +from binomial import power_bounds, SCALE + + +def check_sources(): + pins = read(HERE / 'SOURCES.json') + for name, expected in pins['repo_inputs'].items(): + require(sha256((ROOT / name).read_bytes()).hexdigest() == expected, 'Repository source drift: ' + name) + for name, expected in pins['vendor_inputs'].items(): + require(sha256((HERE / name).read_bytes()).hexdigest() == expected, 'Vendored source drift: ' + name) + return pins + + +def execute(script, arguments, log, env): + with log.open('w', encoding='utf-8') as stream: + result = subprocess.run([sys.executable, '-I', '-B', str(script), *map(str, arguments)], + env=env, stdout=stream, stderr=subprocess.STDOUT) + require(result.returncode == 0, 'Native replay failed: ' + str(log) + '\n' + log.read_text()[-2000:]) + + +def run(out): + pins = check_sources() + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', PYTHONINTMAXSTRDIGITS='0') + env.pop('PYTHONOPTIMIZE', None) + old = out / 'original9'; old.mkdir() + base = ROOT / BASE + route = base / 'vendor/multicold/vendor/pr558/vendor/pr552/complex-local/inputs/phase-baseline/CANONICAL-WORD.json.gz' + execute(HERE / 'vendor/pr855/native_worker.py', [HERE / 'vendor/pr855', base / 'code/hpe_audit_and_transport.py', route, old], out / 'original9-worker.log', env) + new = out / 'early8';new.mkdir() + execute(HERE / 'native_worker.py', [new], out / 'early8-worker.log', env) + original, retimed = read(old / 'NATIVE-RESULT.json'), read(new / 'NATIVE-RESULT.json') + require(original['assertions_enabled'] is True and retimed['assertions_enabled'] is True, 'Native assertions') + model = build(ROOT, original['receipts'], retimed['receipts']) + packing = price(model, read(HERE / 'vendor/pr855/EXACT-CERTIFICATE.json')) + require(packing['excluded'] is True, 'This certificate does not exclude the extended mixtures') + # Independent exact positive controls for the new power engine, without + # invoking either predecessor log/exp routine: r^(1-1/2)=sqrt(r). + for rank in (0,1,2,3,7,8,9,48,73): + low,high = power_bounds(rank,Q(1,2)) + require(low*low <= rank*SCALE*SCALE <= high*high, 'Binomial square-root identity') + selected = read(HERE / 'CONTEXT-SELECTED.json') + kappa = Q(selected['kappa']) + necessary_b = kappa/(1-kappa) + require(necessary_b > Q(model['endpoint']), 'Pinned current target does not exceed the excluded endpoint') + result = dict(base=pins['base'], source_prs=[781,855], status='PASS_EARLY8_CONSTRUCTION_AND_EXTENDED_COST_OBSTRUCTION', + native_words=8, new_constructions=retimed['constructions'], + new_native_receipts=retimed['receipts'], original_native_controls=original['controls_rejected'], + original_recompression=original['recompression_control'], + model=model, packing=packing, nonempty_mixture_count=comb(76,4)-1, + current_target=dict(kappa=str(kappa),necessary_b=str(necessary_b), + excluded_from_b=model['endpoint'],source_head=pins['base']), + scope='Four rank-eight variants plus four original rank-nine words; fixed PR626 geometry/dispatch; whole-helper packing relaxation. Native identities/frames only; no new phase/global admission or multiplication exponent.') + return json.loads(json.dumps(result)) + + +def main(): + import argparse + p = argparse.ArgumentParser(description=__doc__) + p.add_argument('--out', type=Path) + p.add_argument('--write', action='store_true') + a = p.parse_args() + def finish(out): + result = run(out) + if a.write: + (HERE / 'EXPECTED.json').write_bytes((json.dumps(result,indent=2)+'\n').encode()) + else: + require(json.dumps(result, sort_keys=True) == + json.dumps(read(HERE / 'EXPECTED.json'), sort_keys=True), + 'Recomputed evidence differs') + (out / 'RESULT.json').write_bytes((json.dumps(result,indent=2)+'\n').encode()) + print(result['status'], '8 native words;', result['nonempty_mixture_count'], 'mixtures excluded; no new kappa') + if a.out: + out = a.out.resolve() + require(not out.exists() and not out.is_relative_to(HERE), 'Fresh external output required') + out.mkdir(parents=True) + finish(out) + else: + with tempfile.TemporaryDirectory(prefix='early8-replay-') as tmp: + finish(Path(tmp)) + + +if __name__ == '__main__': + main()