diff --git a/research/h25-bookkeeping/CODE-SOURCES.json b/research/h25-bookkeeping/CODE-SOURCES.json new file mode 100644 index 0000000000..dc52d5744d --- /dev/null +++ b/research/h25-bookkeeping/CODE-SOURCES.json @@ -0,0 +1,388 @@ +{ + "coverage": "Every immutable package file including exact161-file v4 payload, all22 attempt records and changed historical sources, wrappers, README/TASK/SOURCES/VERIFY, input ancestry and independent reviews. CODE is bound by committed package identity; VALIDATION/optionalPUBLICATION-STATUS never substitute for science.", + "excluded_mutable": [ + "CODE-SOURCES.json", + "VALIDATION.json", + "PUBLICATION-STATUS.json" + ], + "file_count": 376, + "files": { + "CPYTHON-LICENSE.txt": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "README.md": "27e532c502eec0144c0940b4ff9d04314d40764deb272e09f12bb40099284023", + "SOURCES.json": "812d5efeab109646512e9b531cfb8845809e256fcb6fc80693131125271c0656", + "TASK.json": "d4a7db0d3bd59bef4080bacdc2f4b51691095932e114cb9cac7e14cc2c5feeaa", + "VERIFY.json": "8c155ad1e28038f71bd53b341d9a93af52f402b680f4c4a2e5101638491c47f6", + "archive_support.py": "eee90f3815f4bd90eb96152bc461ec968ffb91d47c990e77712e74f6677c51be", + "check_artifacts.py": "03d89a1df701305d37289de9a6bda4ac485da83ca43459d41de2bd4f78a50445", + "evidence/INPUT-COMMIT.json": "22b1813119738540e4ad1dde298ca23ce353d5bd5b3a4012b0899cd77ce8466b", + "evidence/control/ADMISSION-REVIEW-PROVENANCE.json": "4a7643e574eb2acebca2369125a205d9f1307afbe4db7a7a9691bfaf40e55d51", + "evidence/control/BASELINE-INTAKE.json": "227b296f8195c4a5b94c8ce99e67196bbca7987de52c97fe2056cc8434c3d4b0", + "evidence/control/BASELINE.json": "ae13cda267193b1dc31f898dfccccae28140d80d190cdd9f3f6f9f113db1ccc0", + "evidence/control/COMBINED-ADMISSION-v4.json": "bdf1788478dd6e97eba1b4a664a2d04faf5660470b77d49bcf261fe57f700fa5", + "evidence/control/ENVIRONMENT.json": "ca13147ca37e8c95358bb5f90969a010d178c6d40d7c52fe75572e82930d3720", + "evidence/control/EXECUTION-PHASE.json": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "evidence/control/FINITE-ADMISSION-v1.json": "b9e09ce10e20d27c5b0f19c3963697876f79f70789dcba71cc76adb4a863a6fd", + "evidence/control/IMPLEMENTATION-ADMISSION.json": "15fa37b108431222eeada7a4365c7a08b7528c2453b2ecc8b689447b4cb0026a", + "evidence/control/INDIVIDUAL-PILOT-SEQUENCE.json": "8209ddde663022ed8c462938d7e8891158bee4d59b024992fb579a47765df19f", + "evidence/control/PUBLICATION-UPSTREAM-REFRESH.json": "1be7a598e257fd6407840a74d48ded3126a32f6db61a6d862cc000e6be7c70de", + "evidence/control/QUALIFICATION-v4.json": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "evidence/control/UPSTREAM-REFRESH.json": "17fea48977cc49861d9a49636c361683d60d7dd9df11101218f6a794cb2874a6", + "evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.json": "c6b2355b9e36738025787021114181e5b9e23b24f6df0e1e1f57dc57912d61a5", + "evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.md": "751557dc95f0d19ae1d7ecc582ce1c01e3700dc66f292c05541d91ceec22f31e", + "evidence/control/upstream/AGENTS.md": "fbee67ab9e0ae4629a35fd9dba69c8f7e29e4a15392eb2d0f75d8768ffb65f40", + "evidence/control/upstream/CONTRIBUTING.md": "fcd1a8d0e52342a23b8ffa9e905e85ccc539fb084145ef016dfc93cedfb3d924", + "evidence/control/upstream/autoresearch.md": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d", + "evidence/control/upstream/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "evidence/control/upstream/docs/research/agent-task-catalog.json": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "evidence/control/upstream/docs/research/current-priorities.md": "70f61c8d140ae6e892f2b8f065bba4eae3e76f7a8f55f632fd4e2f9f34039bdc", + "evidence/historical-source/README.md": "aeda57fbfd6115ac4aea8f007564a0878c8b25d3100967072fa612f4da59c52f", + "evidence/historical-source/evaluate_qualification.py": "a8aa4ae0e8d3edd848ddc540d9251652667bff7e915a5ef7bcedb94f46369da4", + "evidence/historical-source/summarize_runs.py": "29cb5d246f733c3af568aa3e15909ff65be1fd72fd3e600866930f1515e14229", + "evidence/local-source/publication_guard.py": "c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d", + "evidence/publication-v1/CODE-SOURCES.json": "ba3621b6c51fb2605f0ad4e0851707e9b711cbe4dc302fa9aa18f786ebb6f5ea", + "evidence/publication-v1/VALIDATION-PREPARATION.json": "8a74ed163461415c2e776afee50e67ec8f14a1804fca2eba114b6fece4dc6a9c", + "evidence/publication-v1/registry/START.json": "9fbb2903088e4c545cc10ad6728d3f3ee9a33199afaac74502d98c2b5c7e0560", + "evidence/publication-v1/registry/receipt.json": "e2b7aca8fd4ed0f9adeee805b2dbe4a5b49210a20fc3e0a32508de4492b8615c", + "evidence/publication-v1/registry/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/publication-v1/registry/stdout.txt": "b15f09632f38df4d8682f34925dd10049c3b46168cfb9c3f3210d95e6788e1d2", + "evidence/publication-v1/registry/usage.json": "3cabd79b697c3e20964b9fb5c5e1244451249fcc4fafb71510356d831014239c", + "evidence/research/independent-review/ADAPTER-INTERFACES.md": "37dbd8f35d0cc74408261ffcbed2e2ad8442aff592e86c1558ed0ca1477ec691", + "evidence/research/independent-review/CALL-BUDGET-REVIEW.json": "ab6de6998d1db8b8f6bfffb269e12f5c614b89fafe0cfb0067ddafa5ac4ef196", + "evidence/research/independent-review/CODE-GATE.json": "78a3cf63df8de9013ea0b6d8c171154c8c3764c2672cd65ae0c9310a2327d7d6", + "evidence/research/independent-review/CODE-GATE.md": "6b8790dc7c59c1d19984d01fbcb7f1f7f660833836bc57af020d5e648583fd22", + "evidence/research/independent-review/CONTRACT-MATRIX.md": "f269dbb0d89295cc89e8ba3d85b782855edc4af3202c547dedb71fe73193b993", + "evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json": "8f06e15a082b2cca9167cc2f1822a11bf96ccc8d7ad748d4668570d9da8e7553", + "evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.md": "66825dc932ac9a5407548c56cc8330602f04ff55c0d22311cfb8dbc1e8999766", + "evidence/research/independent-review/IMPLEMENTATION-REVIEW.json": "c6b2355b9e36738025787021114181e5b9e23b24f6df0e1e1f57dc57912d61a5", + "evidence/research/independent-review/IMPLEMENTATION-REVIEW.md": "751557dc95f0d19ae1d7ecc582ce1c01e3700dc66f292c05541d91ceec22f31e", + "evidence/research/independent-review/P1-LEASE-CONTRACT.md": "4b75027333b0cedf0269913ee075302c4ffba433db8eef04062903f1a356bc39", + "evidence/research/independent-review/PROPOSAL-REVIEW.json": "6e7834e68d10c4ca3bb34a6983a0dcb9c5ba7a108f6a306dd899bd3d6375d5b5", + "evidence/research/independent-review/PROPOSAL-REVIEW.md": "2c71cbd73f306752f7f7b974877295d662b80b915758441e9c7acc196ebb5edf", + "evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json": "2e6acc7fd9e123684a5f28992aef39a288404bdc5a021d3c762b7352a9cdc585", + "evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.md": "88311c47156f38b981a8e7b49689c455ddaa79513bcefeae532d938b724838c3", + "evidence/research/independent-review/REVIEW-GATES.json": "a69a00189fdcf5d34c4caf13085f89b3d1e086ee99bc21076e8a8c096ba23f5f", + "evidence/revisions/v1/PLAN.json": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639", + "evidence/revisions/v1/PLAN.md": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5", + "evidence/revisions/v1/STAGE.json": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "evidence/revisions/v1/integration/adapters.py": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72", + "evidence/revisions/v1/priorities/set-reuse/IMPLEMENTATION.md": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7", + "evidence/revisions/v1/priorities/set-reuse/finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "evidence/revisions/v1/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/revisions/v2/PLAN.json": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639", + "evidence/revisions/v2/PLAN.md": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5", + "evidence/revisions/v2/STAGE.json": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "evidence/revisions/v2/priorities/set-reuse/IMPLEMENTATION.md": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7", + "evidence/revisions/v2/priorities/set-reuse/finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "evidence/revisions/v2/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/revisions/v3/STAGE.json": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "evidence/revisions/v3/priorities/set-reuse/IMPLEMENTATION.md": "f3966bebe186a90729deaa0c5c4630b355637a5bb17e9deea8d8f2239078210a", + "evidence/revisions/v3/priorities/set-reuse/SOURCE-READINESS.json": "9013633e144dc03c5ccb73c241fb116b4914138d6be691c2884bcc5c068d6bcd", + "evidence/revisions/v3/priorities/set-reuse/finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "evidence/revisions/v3/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/runs/finite-P1-O-v2/START.json": "3f917b4c06de0158787b23d2c847d282013da7bacff0dfc7608cde384b2b6848", + "evidence/runs/finite-P1-O-v2/receipt.json": "73a19dd6b7edfea707d1a809a6c5b65b86bfc8303e0e7846c6cfa08e59548f13", + "evidence/runs/finite-P1-O-v2/stderr.txt": "cf857d5af2231a0240d4932eae3fff889f05ce4229e514593566a46696e0e710", + "evidence/runs/finite-P1-O-v2/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-O-v2/usage.json": "b6da24f5c00a8b016cfa43e051e3db106d5515f2f66284c1771db5e50d9eb42a", + "evidence/runs/finite-P1-O-v3/START.json": "a540e2ceb113f407a4cb5315ab747965b31f1e1e0fbbb0c4e58b962c9ec3ac5c", + "evidence/runs/finite-P1-O-v3/receipt.json": "32eb9da6703a5f4b4552f7f15f31960b2b39d5c88eda8d98631dc1dd192cacd7", + "evidence/runs/finite-P1-O-v3/scientific-receipt.json": "34c359652aa4d0bf18a54035ab7c6a69bf376dfebc25a52bd677546ceb121830", + "evidence/runs/finite-P1-O-v3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-O-v3/stdout.txt": "54821a17869e76d98a8d51edd51d9aba251c08c53a3bf0217c40bc8528290671", + "evidence/runs/finite-P1-O-v3/usage.json": "6b4a35bcffa3a816f7e6f4d07b8a059ffda5cc7faeeeab9d0c761d7d9354171a", + "evidence/runs/finite-P1-normal-v2/START.json": "0a10b84d777a404908a3da90b93d04d254fa6641c52822d3c602b5ed6fc1124b", + "evidence/runs/finite-P1-normal-v2/receipt.json": "08472c32752b9efb61ec9df18a1d608475c2e992a026036ae61b27cdb8f56386", + "evidence/runs/finite-P1-normal-v2/scientific-receipt.json": "743878514b9544ddaa8146cdfe1ccd94b462add6c1918bef721518177e853bfc", + "evidence/runs/finite-P1-normal-v2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-normal-v2/stdout.txt": "6d25ad7b7ff81b7df3a263a32ad3ce1176d21ff05b55e0dcb64e422e31a10be5", + "evidence/runs/finite-P1-normal-v2/usage.json": "4943618c964b683e6174693723a58a1f5af400563fc73a24433784ad926f4ff3", + "evidence/runs/finite-P1-normal-v3/START.json": "9a7f8c8a4e642565b903b7d734a16d84257db492fe64cdf2a612baca695e524c", + "evidence/runs/finite-P1-normal-v3/receipt.json": "c6bfed16508860931a70cfa122defb2064955df0b3cb5dd8b078c8fd4e226530", + "evidence/runs/finite-P1-normal-v3/scientific-receipt.json": "97bb2b6707e9fc467e3d31eb9f7073af95edc9b416e768b6857c867208020e7c", + "evidence/runs/finite-P1-normal-v3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-normal-v3/stdout.txt": "46b26672e3262d518abffa352829094da7e5276dce36e1725eb1ed2aeb4f4c50", + "evidence/runs/finite-P1-normal-v3/usage.json": "be35e62c844a0be006e07fb04b957956604f0abdfd9f5f902ffdf0364816cf79", + "evidence/runs/finite-P2-O-v1/START.json": "d54684331db093ece311a75e06ec3974c8e6d1a86b5c1c38f69738d08f4913a9", + "evidence/runs/finite-P2-O-v1/receipt.json": "7a0198be16b8b1de498a2a29c49d83876d6ef87dc9ef7c27d959a1554d62a508", + "evidence/runs/finite-P2-O-v1/scientific-receipt.json": "0dfd9a7fe9518274a3b04fa755bc5a32082decf2b6787ec01b44ef411eedb919", + "evidence/runs/finite-P2-O-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P2-O-v1/stdout.txt": "710b9ebcb967d964191a367142e20d93ba5134ebac3181770b04f572c7730265", + "evidence/runs/finite-P2-O-v1/usage.json": "7df942f5b0e46436e27944f6d863201531f142b84d7034b3f687bdcdf4b387df", + "evidence/runs/finite-P2-normal-v1/START.json": "80f7bb9215f9e1e3fc931a40d924286ddc757615da7f12c30362187219b2854e", + "evidence/runs/finite-P2-normal-v1/receipt.json": "d628c5dd8b80494fb1685fd94f78cddd3ddf6477e76a7efcd041791699731f53", + "evidence/runs/finite-P2-normal-v1/scientific-receipt.json": "0c17246c4b14189adc02627d439123b05f2933b5b5a85d8c69901459b6d3348f", + "evidence/runs/finite-P2-normal-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P2-normal-v1/stdout.txt": "9cf8d1295b34d378784070092e03aa302224e7b503ead3ea80b5a1ac456689b4", + "evidence/runs/finite-P2-normal-v1/usage.json": "ccbe980a5524e00417c96ca64e593fecf9a87fe89dd00e4ca8c16917efc9b2c1", + "evidence/runs/finite-P3-O-v1/START.json": "f37a1fff59e891a3ef1425384406053e46a96ecc92478f59ac27f97f09be1290", + "evidence/runs/finite-P3-O-v1/receipt.json": "29aff35432c14876b164f87112facf8e594217947086a37bc7c073db32d222b8", + "evidence/runs/finite-P3-O-v1/scientific-receipt.json": "dd88c61c042b3026182704c3d380defd53d69755b5c42a79a9fbc56e224d07f7", + "evidence/runs/finite-P3-O-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P3-O-v1/stdout.txt": "4a724dedb485cda71a10b96cf20910099ba659c9a42159ee80c5631802e4b948", + "evidence/runs/finite-P3-O-v1/usage.json": "2d379009885ead1e3f31a57e94ad76a15da02522962358464b6a56f319b25be6", + "evidence/runs/finite-P3-normal-v1/START.json": "889171016eb6d36e80c1068aeeca22816725a2a36ff34344769067204173a358", + "evidence/runs/finite-P3-normal-v1/receipt.json": "4deafb884314517f5291b9b02715eb6dc5df68a45f8274ec466ab9938784d0ab", + "evidence/runs/finite-P3-normal-v1/scientific-receipt.json": "1b5cea72a0e9a2e023e4bf77e9f8b224048da8ebe31cf357ffd9994de32145ff", + "evidence/runs/finite-P3-normal-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P3-normal-v1/stdout.txt": "c98b3d8b61543d4f36d58d4f4afb51f8cf1091a7da8b4b2c16fa479df490e65f", + "evidence/runs/finite-P3-normal-v1/usage.json": "b16240fc0c1cf4440f5513d0f61aeb117b93ebb3db149e9a0ae7f48a72f8f956", + "evidence/runs/finite-combined-O-v4/START.json": "b8654eec557bee5ae03bbd5efce2e00638f4d16a443a41a6afd7ed57b486b7c0", + "evidence/runs/finite-combined-O-v4/receipt.json": "a349c7b5403c9b5bfc8a30a87de1c7334a8dac2fd9a4df92bcc82d183623a6b4", + "evidence/runs/finite-combined-O-v4/scientific-receipt.json": "e8ce0cadb455309e57d6dc650d2ab654d9424c397ca67b69420e79af5201698b", + "evidence/runs/finite-combined-O-v4/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-combined-O-v4/stdout.txt": "60a5980d3e05919c5b0f4aad5f91648edfde7cc2bebbbab5175b3d3f6b6ee50c", + "evidence/runs/finite-combined-O-v4/usage.json": "36d3d173b845e3917c84e601a601ca55b186757ae5e51b2d4beabd61281864bd", + "evidence/runs/finite-combined-normal-v4/START.json": "022b075d2a9c2b6b8ea183c16a51f21d805ca41444acaa843cecf2d09bb12949", + "evidence/runs/finite-combined-normal-v4/receipt.json": "e27774f6bd0671da631b8b9b2aca22a24d2fa85d00bde48b6a7ce52c37cfb12c", + "evidence/runs/finite-combined-normal-v4/scientific-receipt.json": "9a252ddad438c6539807181d728f833bedf093c839bf1e84fe7b9d12364e27e9", + "evidence/runs/finite-combined-normal-v4/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-combined-normal-v4/stdout.txt": "241b2cc4eae112b7ba568b035c955f56fd88726f10053a556d100bca8b3e539f", + "evidence/runs/finite-combined-normal-v4/usage.json": "0f8ffa5aed4c2b70f764e5a9088de8fdca43c8baea271966a92c177ded3d6977", + "evidence/runs/pilot-P1-B/START.json": "6600bb1bfd6e4cf6de7cb16044f3173df4c14834c7c46635b628746a196be478", + "evidence/runs/pilot-P1-B/receipt.json": "5af1f03fc8101bf126132a4be017033ae41d0dcade69da797e2c22483005e495", + "evidence/runs/pilot-P1-B/scientific-receipt.json": "5b24ea2b4f5b1de1534c0501d4377d40cd947184fd56da1d2c1fac3e7beb6ad1", + "evidence/runs/pilot-P1-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P1-B/stdout.txt": "3f38611cd867d086b277311db0ee0caa362823924f0ec5210fcd37c94a679d64", + "evidence/runs/pilot-P1-B/usage.json": "d1f9b5c62780b366e1c42b6a441625d6981bb072d520e8202287082102fc3b45", + "evidence/runs/pilot-P1-C/START.json": "bb7bfc8e2c0dfdd4f9742f8f91e240d3a6c8f9f18b4c24d0147790ca6f38cab1", + "evidence/runs/pilot-P1-C/receipt.json": "1933791e7554434c85938ee4e20069ea122b9666c47df93c14648c63d77afd72", + "evidence/runs/pilot-P1-C/scientific-receipt.json": "b46aacb01b7db8d518da7a9193d525f2a65148d261be0c167c36518f53a5f2a1", + "evidence/runs/pilot-P1-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P1-C/stdout.txt": "bcf96193669ff3ab3585bb48cf1e3b7c3e298a32a92dcee5d46289fbad3d103b", + "evidence/runs/pilot-P1-C/usage.json": "92c0b23023a5e8083f53359973f836589540d1e3fb026f961a1464a4a08baf5c", + "evidence/runs/pilot-P2-B/START.json": "025bad6d1d0720f79d458884888b85e6311191c5b2eaa7ea3b773f02dc34da3d", + "evidence/runs/pilot-P2-B/receipt.json": "56004f2e61d009b37f2db6b9c98d70d81bfdd50537fd543285129ae00a091be3", + "evidence/runs/pilot-P2-B/scientific-receipt.json": "eb1d9d9546b639fad9024b5dc5d4a177d2585590f0c02530e69d96cef5e1de34", + "evidence/runs/pilot-P2-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P2-B/stdout.txt": "7f4ad570bc105d6f02e37ceebab6dbea884e65c29390391f2b8255ca175afe43", + "evidence/runs/pilot-P2-B/usage.json": "a587ac2cc7dd3612618cbf771ec4b19ee071aa1d18a4696ac9d5217840e8f55d", + "evidence/runs/pilot-P2-C/START.json": "4b3f075cf1eb1cc27508bfc2d9745a1e7d4a30cdfbd5936b234a156387ec4d44", + "evidence/runs/pilot-P2-C/receipt.json": "120d49905ad03e7f0ca20768113f0b283b98620e6140925b387836ef558b4e69", + "evidence/runs/pilot-P2-C/scientific-receipt.json": "c8dabe911cfa72008ae39bc267806a24af7c622ecd6595dd247fe281b6c8afc6", + "evidence/runs/pilot-P2-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P2-C/stdout.txt": "542a9e3ec430d7d74f15467a261f29bcb58c0d25782e7c4dd3311185c1c12b8e", + "evidence/runs/pilot-P2-C/usage.json": "3a85a71bb41702f77d5d2a3469a3f5e2ee9473904db1c62019edd576d0bde329", + "evidence/runs/pilot-P3-B/START.json": "995475d0964509602f20a24930d10a81d04425b5474c5b6841301bfcbcb13f04", + "evidence/runs/pilot-P3-B/receipt.json": "c3229cb8e4484730d41bc5253b024df3b32655777cae76802d94958078bb66d8", + "evidence/runs/pilot-P3-B/scientific-receipt.json": "d59416d75401f76e69b7638aac4c294c47a91b224166bcb7ffb149aa717101f5", + "evidence/runs/pilot-P3-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P3-B/stdout.txt": "d04f1289c66f2680f84d4c2e0bc0aff0e956f55604a562b01297944f981be11b", + "evidence/runs/pilot-P3-B/usage.json": "b43a7b39c476a06eac9333b2b487672fe296e92e26e948f927d5dfc5f0386e27", + "evidence/runs/pilot-P3-C/START.json": "115f2e2998075a8fa04ee428ed30d0f29bb9e4f63f5dcf6189b667ad77fef98b", + "evidence/runs/pilot-P3-C/receipt.json": "9b6d0f65acdb78ac02499c0e2c57d5fc78e3e71083f06657a187a4aa821cd50a", + "evidence/runs/pilot-P3-C/scientific-receipt.json": "b4ee7896dec5a900f45026cf93bd81f9af7805c9b51f769cdd1fdbf467fea699", + "evidence/runs/pilot-P3-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P3-C/stdout.txt": "e270d9bf87b21bef57fb0346e073008b5bbc398071e58a4d616f1a875a0e3e89", + "evidence/runs/pilot-P3-C/usage.json": "e1c886385d5ab114c0ad59a5ec75a17b02c14207a038916f7b32cc28122fbfd8", + "evidence/runs/qual-B1/START.json": "cad82494cfbcb151c35957c6bc2a58d31e6d6f6d71ca26f0b05e72133e26ed50", + "evidence/runs/qual-B1/receipt.json": "7b3d7d427d2d06a9d6e436454d1ef7623e0f8ad50a0a23a0ec0d2ec0fc12b788", + "evidence/runs/qual-B1/scientific-receipt.json": "c9345eb1ff8fdf2607832b39bb4c1b51fe6f1c03db3c4ebfe463900cded6bff5", + "evidence/runs/qual-B1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B1/stdout.txt": "bca8ab8b35591f3c6204751ecf41f430ea81e91a2eea37767a8731f8e81a1517", + "evidence/runs/qual-B1/usage.json": "c8e22ca93e25676ef526ad962b08e19ad0cd445a6ef3379693e35fa2bbbc6c14", + "evidence/runs/qual-B2/START.json": "8d8f426378639068c92a463b9581cd842f913d3f3f9d360d2c6c53cb43bacc94", + "evidence/runs/qual-B2/receipt.json": "b6e9a8dc8bc89b473b2b98995f4d0aa4c08b286df22bbc122255731ecf577934", + "evidence/runs/qual-B2/scientific-receipt.json": "bb07ee0af583165a8a67a08edc5576c25f63c3103a6cefcc3643bfc71ff9dd89", + "evidence/runs/qual-B2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B2/stdout.txt": "865bf7226a10c8e9904fa67bf16c329b9fb5dbb0e577bf49cb55e718a5c255a7", + "evidence/runs/qual-B2/usage.json": "edd74814f57f6adfe9b2b629b6282d5b2814876a4be3d7adb64d77b3a46c0c36", + "evidence/runs/qual-B3/START.json": "af1bb6390e3a8fc6863bf9543f1196de1f39bc987fe01c06c73933601cc070c7", + "evidence/runs/qual-B3/receipt.json": "1e839f0e4de437b59f428213922b03e090c5794973c7a6fc763a512da9c2c0fd", + "evidence/runs/qual-B3/scientific-receipt.json": "dc41582760b650c17ebd6fc8591be5ea4685d1a5aa0b0b005de4bb15477233bf", + "evidence/runs/qual-B3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B3/stdout.txt": "6b709607dba67b762bbf52e0480a55b9e8d372a04110d7e5d0e51a4bade383ed", + "evidence/runs/qual-B3/usage.json": "df73241caa2c4579c5b083aa450bf262d0d1fd3f76080d4056dd39a6b4fe6d94", + "evidence/runs/qual-C1/START.json": "a0a76fb49ac8e9e43ef5e338efda0473e2462bd70334cfdd8a753a59eb1b3c83", + "evidence/runs/qual-C1/receipt.json": "e07bee3ecf50f5f2cd77910763f65d05baaea1ad3be50c5282a4e96b74b6ce15", + "evidence/runs/qual-C1/scientific-receipt.json": "ed60c889422cd98c2b525b6d5f731a01e8f6e0f8dfdb0de8d61c52912f591495", + "evidence/runs/qual-C1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C1/stdout.txt": "f4a724dc92d23ad1ee261f51e6b6eaa7b0d0b2df130ea8ac42f26868600c030d", + "evidence/runs/qual-C1/usage.json": "54fa64ff51c9d45fdac2655525740d4c24ac68185b3a1689b1d0741bfab71901", + "evidence/runs/qual-C2/START.json": "1b3f7c38579a12e609d856120f6bd69e97b5dc4b9b5e4ed909839e5386ca8f47", + "evidence/runs/qual-C2/receipt.json": "4f939f3897dbedeeed8a2ac0078eb24cb0c1cf7034e50f2dc60cf60dcfc2c235", + "evidence/runs/qual-C2/scientific-receipt.json": "a0bfabd6785e7dc2248fdf85e0769965bfac5916444c368ded1280f79bd944a5", + "evidence/runs/qual-C2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C2/stdout.txt": "476620742ff72624caea3b8bf075f65f72e404ea28f986a29d680360d590c269", + "evidence/runs/qual-C2/usage.json": "3b949d87012f128f178b1c86024f6c39d7586170bfd570a63199a4b9f77e1dc4", + "evidence/runs/qual-C3/START.json": "416c7d9735ec5e57191c7d54e30067a4bf9a801f8cc72893328167ef3537ebec", + "evidence/runs/qual-C3/receipt.json": "93eeaed9de3af3655d285ce2c2c92f844f73ae3646a9271e8b322d29a986bf19", + "evidence/runs/qual-C3/scientific-receipt.json": "98c77d54333878fc4cc833f36390d3f0deda472e342d572c525c8b99dfb45fe3", + "evidence/runs/qual-C3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C3/stdout.txt": "86ff5045c99f0f0a2ee34119ab5d0eeb86b59249140be8158dfb21c02bda4b19", + "evidence/runs/qual-C3/usage.json": "055a093dbfff85251fc54b013bac8bc94a5e80ddf033a5b9f065341b1804cce2", + "evidence/validation/CALL-CENSUS-PILOTS.json": "940c8583722eddd2c36a8360ec14f9219ea39f3fa58103e1d382bd7a5e37fb2c", + "evidence/validation/CALL-CENSUS.json": "55878bd7f34481472cf45876747e8ad24be40d07abc3fc4e9bb963fb8023cc10", + "evidence/validation/COMBINED-FIRST-PAIR.json": "619f1cb119331de98c06707bf5ac7dee034f9571699b5cbf4e38ce2039fcee94", + "evidence/validation/COMBINED-GATE.json": "5fca5cf80da96781c4e2ad112abee94a982341238f7fe9f38e0f6305c23fb43d", + "evidence/validation/P1-O-v2-STOP.json": "fcc04985b75c9df1345ccc87fd508a5d6a17f5540ef88f064e6a21d9d4172e9b", + "evidence/validation/P1-PILOT.json": "5f6bd00c20038685e5f8a8ab157febc9f2591602c35533ed8c0c3366e89c17bd", + "evidence/validation/P2-PILOT.json": "036e7e469ae3228e6662267adb1db841b8b7f56f333e53b491918932fbb63a78", + "evidence/validation/P3-PILOT.json": "0328ec19139806dd424bfc676963fb001678f26cf8e2fc580c83d024ae982562", + "evidence/validation/RUN-INDEX.json": "cfcc237d5267c0edc8eb4658d349aff9445044ff42cc17f0cbdc50f02772f3e0", + "payload/JOBS.json": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e", + "payload/PLAN.json": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63", + "payload/PLAN.md": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106", + "payload/STAGE.json": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "payload/baseline/CODE-SOURCES.json": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "payload/baseline/README.md": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64", + "payload/baseline/SOURCE-PINS.json": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "payload/baseline/SOURCES.json": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a", + "payload/baseline/TASK.json": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38", + "payload/baseline/VALIDATION.json": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a", + "payload/baseline/VERIFY.json": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78", + "payload/baseline/anchor.json": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "payload/baseline/archive_support.py": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f", + "payload/baseline/check_artifacts.py": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f", + "payload/baseline/engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "payload/baseline/engine/finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "payload/baseline/engine/native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "payload/baseline/engine/native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "payload/baseline/engine/profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "payload/baseline/engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "payload/baseline/engine/source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "payload/baseline/evidence/COMPLETE-GATE.json": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b", + "payload/baseline/evidence/ENVIRONMENT.json": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384", + "payload/baseline/evidence/FIRST-PAIR-GATE.json": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc", + "payload/baseline/evidence/FULL-PAIR-ADMISSION.json": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829", + "payload/baseline/evidence/INDEPENDENT-REVIEW.md": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f", + "payload/baseline/evidence/INPUT-COMMIT.json": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b", + "payload/baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa", + "payload/baseline/evidence/PLAN.json": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813", + "payload/baseline/evidence/PROFILE-v1-FAILURE.json": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f", + "payload/baseline/evidence/RESULTS.md": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f", + "payload/baseline/evidence/SOURCE-DESIGN.md": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb", + "payload/baseline/evidence/UPSTREAM-REFRESH.json": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693", + "payload/baseline/evidence/canonical/MANIFEST.json": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "payload/baseline/evidence/canonical/complement-transcript.json": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8", + "payload/baseline/evidence/canonical/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "payload/baseline/evidence/canonical/full-return.lossless.json.gz": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2", + "payload/baseline/evidence/canonical/original-stdout.txt": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "payload/baseline/evidence/canonical/rank-trace.json.gz": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "payload/baseline/evidence/canonical/witness.json.gz": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "payload/baseline/evidence/publication-v1-failure/REVISION.json": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8", + "payload/baseline/evidence/publication-v1-failure/receipt.json": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a", + "payload/baseline/evidence/publication-v1-failure/stderr.txt": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515", + "payload/baseline/evidence/publication-v1-failure/stdout.txt": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342", + "payload/baseline/evidence/publication-v1-failure/usage.json": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc", + "payload/baseline/evidence/publication-v1-failure/verify_full.py.txt": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e", + "payload/baseline/evidence/runs/full-network-B1/receipt.json": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27", + "payload/baseline/evidence/runs/full-network-B1/scientific-receipt.json": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31", + "payload/baseline/evidence/runs/full-network-B1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B1/stdout.txt": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43", + "payload/baseline/evidence/runs/full-network-B1/usage.json": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505", + "payload/baseline/evidence/runs/full-network-B2/receipt.json": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d", + "payload/baseline/evidence/runs/full-network-B2/scientific-receipt.json": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7", + "payload/baseline/evidence/runs/full-network-B2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B2/stdout.txt": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d", + "payload/baseline/evidence/runs/full-network-B2/usage.json": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891", + "payload/baseline/evidence/runs/full-network-B3/receipt.json": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506", + "payload/baseline/evidence/runs/full-network-B3/scientific-receipt.json": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495", + "payload/baseline/evidence/runs/full-network-B3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B3/stdout.txt": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe", + "payload/baseline/evidence/runs/full-network-B3/usage.json": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8", + "payload/baseline/evidence/runs/full-network-C1/receipt.json": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934", + "payload/baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342", + "payload/baseline/evidence/runs/full-network-C1/scientific-receipt.json": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8", + "payload/baseline/evidence/runs/full-network-C1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C1/stdout.txt": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd", + "payload/baseline/evidence/runs/full-network-C1/usage.json": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84", + "payload/baseline/evidence/runs/full-network-C2/receipt.json": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73", + "payload/baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969", + "payload/baseline/evidence/runs/full-network-C2/scientific-receipt.json": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c", + "payload/baseline/evidence/runs/full-network-C2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C2/stdout.txt": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c", + "payload/baseline/evidence/runs/full-network-C2/usage.json": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886", + "payload/baseline/evidence/runs/full-network-C3/receipt.json": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce", + "payload/baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237", + "payload/baseline/evidence/runs/full-network-C3/scientific-receipt.json": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb", + "payload/baseline/evidence/runs/full-network-C3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C3/stdout.txt": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0", + "payload/baseline/evidence/runs/full-network-C3/usage.json": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb", + "payload/baseline/evidence/runs/full-network-profile-v1/receipt.json": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c", + "payload/baseline/evidence/runs/full-network-profile-v1/stderr.txt": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76", + "payload/baseline/evidence/runs/full-network-profile-v1/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-profile-v1/usage.json": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78", + "payload/baseline/evidence/runs/full-network-profile-v2/receipt.json": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf", + "payload/baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a", + "payload/baseline/evidence/runs/full-network-profile-v2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-profile-v2/stdout.txt": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec", + "payload/baseline/evidence/runs/full-network-profile-v2/usage.json": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b", + "payload/baseline/frozen/scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "payload/baseline/frozen/scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "payload/baseline/frozen/scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "payload/baseline/frozen/scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "payload/baseline/frozen/scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "payload/baseline/frozen/scripts/exclusion_circuit.py": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "payload/baseline/frozen/scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "payload/baseline/frozen/scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "payload/baseline/frozen/scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "payload/baseline/frozen/scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "payload/baseline/frozen/scripts/shared_point_circuit.py": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "payload/baseline/frozen/scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "payload/baseline/frozen/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "payload/baseline/frozen/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "payload/baseline/frozen/upstream/build/figures/proof-map.tex": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "payload/baseline/frozen/upstream/build/main.tex": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "payload/baseline/frozen/upstream/build/references.bib": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "payload/baseline/frozen/upstream/build/sections/00-introduction.tex": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "payload/baseline/frozen/upstream/build/sections/01-history.tex": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "payload/baseline/frozen/upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "payload/baseline/frozen/upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "payload/baseline/frozen/upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "payload/baseline/frozen/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "payload/baseline/frozen/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "payload/baseline/frozen/upstream/build/sections/07-resampling.tex": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "payload/baseline/frozen/upstream/build/sections/08-assembly.tex": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "payload/baseline/frozen/upstream/build/sections/10-transposition.tex": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "payload/baseline/frozen/upstream/formalization.yaml": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "payload/baseline/frozen/upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "payload/baseline/full_B.py": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8", + "payload/baseline/full_C.py": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4", + "payload/baseline/full_driver.py": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "payload/baseline/guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "payload/baseline/reference/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "payload/baseline/reference/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "payload/baseline/replay.py": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90", + "payload/baseline/verify.py": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b", + "payload/baseline/verify_full.py": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8", + "payload/freeze_stage.py": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec", + "payload/integration/DERIVATION.json": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256", + "payload/integration/adapters.py": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94", + "payload/integration/derive_driver.py": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a", + "payload/integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "payload/priorities/runtime-guards/CALL-BUDGET.json": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec", + "payload/priorities/runtime-guards/IMPLEMENTATION.md": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605", + "payload/priorities/runtime-guards/PROPOSAL.json": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d", + "payload/priorities/runtime-guards/RESEARCH.md": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9", + "payload/priorities/runtime-guards/STATIC-CHECK.json": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160", + "payload/priorities/runtime-guards/guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "payload/priorities/runtime-guards/guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291", + "payload/priorities/set-reuse/CALL-BUDGET.json": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5", + "payload/priorities/set-reuse/IMPLEMENTATION.md": "6b0a86226046bc421134f18a0cd77ebc4d5dce07e0feb3b67de8c2a852856452", + "payload/priorities/set-reuse/OWNERSHIP.md": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099", + "payload/priorities/set-reuse/PORTABILITY-SOURCE.json": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82", + "payload/priorities/set-reuse/PORTABILITY.md": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1", + "payload/priorities/set-reuse/PROPOSAL.json": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d", + "payload/priorities/set-reuse/RESEARCH.md": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8", + "payload/priorities/set-reuse/SOURCE-READINESS.json": "4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556", + "payload/priorities/set-reuse/cpython-3.12.15-fractions.py": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "payload/priorities/set-reuse/finite_set_controls.py": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "payload/priorities/set-reuse/set_reuse.py": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "payload/priorities/trace-encoding/ADAPTER.md": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f", + "payload/priorities/trace-encoding/CALL-BUDGET.json": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab", + "payload/priorities/trace-encoding/PROPOSAL.json": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d", + "payload/priorities/trace-encoding/RESEARCH.md": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60", + "payload/priorities/trace-encoding/SOURCE-READINESS.json": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df", + "payload/priorities/trace-encoding/trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "payload/priorities/trace-encoding/trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447", + "payload/priorities/trace-encoding/trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "payload/run_guarded.py": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "replay.py": "50901fc7de6bbb39067e46d27f653a80b4f9f47c762a3a6c597727d8d6fc4883", + "verify.py": "f0a5e3ab9c9521f02ef33bba0508bc75cc5b49c1e117f203ff02af614444ee11", + "verify_full.py": "2fa8b3c0bd28c6162fb08190241b1d3195e48616986cf3309e293402fc5c0c2e" + }, + "schema_version": 1 +} diff --git a/research/h25-bookkeeping/CPYTHON-LICENSE.txt b/research/h25-bookkeeping/CPYTHON-LICENSE.txt new file mode 100644 index 0000000000..f26bcf4d2d --- /dev/null +++ b/research/h25-bookkeeping/CPYTHON-LICENSE.txt @@ -0,0 +1,279 @@ +A. HISTORY OF THE SOFTWARE +========================== + +Python was created in the early 1990s by Guido van Rossum at Stichting +Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands +as a successor of a language called ABC. Guido remains Python's +principal author, although it includes many contributions from others. + +In 1995, Guido continued his work on Python at the Corporation for +National Research Initiatives (CNRI, see https://www.cnri.reston.va.us) +in Reston, Virginia where he released several versions of the +software. + +In May 2000, Guido and the Python core development team moved to +BeOpen.com to form the BeOpen PythonLabs team. In October of the same +year, the PythonLabs team moved to Digital Creations, which became +Zope Corporation. In 2001, the Python Software Foundation (PSF, see +https://www.python.org/psf/) was formed, a non-profit organization +created specifically to own Python-related Intellectual Property. +Zope Corporation was a sponsoring member of the PSF. + +All Python releases are Open Source (see https://opensource.org for +the Open Source Definition). Historically, most, but not all, Python +releases have also been GPL-compatible; the table below summarizes +the various releases. + + Release Derived Year Owner GPL- + from compatible? (1) + + 0.9.0 thru 1.2 1991-1995 CWI yes + 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes + 1.6 1.5.2 2000 CNRI no + 2.0 1.6 2000 BeOpen.com no + 1.6.1 1.6 2001 CNRI yes (2) + 2.1 2.0+1.6.1 2001 PSF no + 2.0.1 2.0+1.6.1 2001 PSF yes + 2.1.1 2.1+2.0.1 2001 PSF yes + 2.1.2 2.1.1 2002 PSF yes + 2.1.3 2.1.2 2002 PSF yes + 2.2 and above 2.1.1 2001-now PSF yes + +Footnotes: + +(1) GPL-compatible doesn't mean that we're distributing Python under + the GPL. All Python licenses, unlike the GPL, let you distribute + a modified version without making your changes open source. The + GPL-compatible licenses make it possible to combine Python with + other software that is released under the GPL; the others don't. + +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible, + because its license has a choice of law clause. According to + CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 + is "not incompatible" with the GPL. + +Thanks to the many outside volunteers who have worked under Guido's +direction to make these releases possible. + + +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON +=============================================================== + +Python software and documentation are licensed under the +Python Software Foundation License Version 2. + +Starting with Python 3.8.6, examples, recipes, and other code in +the documentation are dual licensed under the PSF License Version 2 +and the Zero-Clause BSD license. + +Some software incorporated into Python is under different licenses. +The licenses are listed with code falling under that license. + + +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 +-------------------------------------------- + +1. This LICENSE AGREEMENT is between the Python Software Foundation +("PSF"), and the Individual or Organization ("Licensee") accessing and +otherwise using this software ("Python") in source or binary form and +its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, PSF hereby +grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, +analyze, test, perform and/or display publicly, prepare derivative works, +distribute, and otherwise use Python alone or in any derivative version, +provided, however, that PSF's License Agreement and PSF's notice of copyright, +i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, +2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; +All Rights Reserved" are retained in Python alone or in any derivative version +prepared by Licensee. + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python. + +4. PSF is making Python available to Licensee on an "AS IS" +basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. Nothing in this License Agreement shall be deemed to create any +relationship of agency, partnership, or joint venture between PSF and +Licensee. This License Agreement does not grant permission to use PSF +trademarks or trade name in a trademark sense to endorse or promote +products or services of Licensee, or any third party. + +8. By copying, installing or otherwise using Python, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 +------------------------------------------- + +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 + +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the +Individual or Organization ("Licensee") accessing and otherwise using +this software in source or binary form and its associated +documentation ("the Software"). + +2. Subject to the terms and conditions of this BeOpen Python License +Agreement, BeOpen hereby grants Licensee a non-exclusive, +royalty-free, world-wide license to reproduce, analyze, test, perform +and/or display publicly, prepare derivative works, distribute, and +otherwise use the Software alone or in any derivative version, +provided, however, that the BeOpen Python License is retained in the +Software, alone or in any derivative version prepared by Licensee. + +3. BeOpen is making the Software available to Licensee on an "AS IS" +basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +5. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +6. This License Agreement shall be governed by and interpreted in all +respects by the law of the State of California, excluding conflict of +law provisions. Nothing in this License Agreement shall be deemed to +create any relationship of agency, partnership, or joint venture +between BeOpen and Licensee. This License Agreement does not grant +permission to use BeOpen trademarks or trade names in a trademark +sense to endorse or promote products or services of Licensee, or any +third party. As an exception, the "BeOpen Python" logos available at +http://www.pythonlabs.com/logos.html may be used according to the +permissions granted on that web page. + +7. By copying, installing or otherwise using the software, Licensee +agrees to be bound by the terms and conditions of this License +Agreement. + + +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 +--------------------------------------- + +1. This LICENSE AGREEMENT is between the Corporation for National +Research Initiatives, having an office at 1895 Preston White Drive, +Reston, VA 20191 ("CNRI"), and the Individual or Organization +("Licensee") accessing and otherwise using Python 1.6.1 software in +source or binary form and its associated documentation. + +2. Subject to the terms and conditions of this License Agreement, CNRI +hereby grants Licensee a nonexclusive, royalty-free, world-wide +license to reproduce, analyze, test, perform and/or display publicly, +prepare derivative works, distribute, and otherwise use Python 1.6.1 +alone or in any derivative version, provided, however, that CNRI's +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) +1995-2001 Corporation for National Research Initiatives; All Rights +Reserved" are retained in Python 1.6.1 alone or in any derivative +version prepared by Licensee. Alternately, in lieu of CNRI's License +Agreement, Licensee may substitute the following text (omitting the +quotes): "Python 1.6.1 is made available subject to the terms and +conditions in CNRI's License Agreement. This Agreement together with +Python 1.6.1 may be located on the internet using the following +unique, persistent identifier (known as a handle): 1895.22/1013. This +Agreement may also be obtained from a proxy server on the internet +using the following URL: http://hdl.handle.net/1895.22/1013". + +3. In the event Licensee prepares a derivative work that is based on +or incorporates Python 1.6.1 or any part thereof, and wants to make +the derivative work available to others as provided herein, then +Licensee hereby agrees to include in any such work a brief summary of +the changes made to Python 1.6.1. + +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" +basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR +IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT +INFRINGE ANY THIRD PARTY RIGHTS. + +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. + +6. This License Agreement will automatically terminate upon a material +breach of its terms and conditions. + +7. This License Agreement shall be governed by the federal +intellectual property law of the United States, including without +limitation the federal copyright law, and, to the extent such +U.S. federal law does not apply, by the law of the Commonwealth of +Virginia, excluding Virginia's conflict of law provisions. +Notwithstanding the foregoing, with regard to derivative works based +on Python 1.6.1 that incorporate non-separable material that was +previously distributed under the GNU General Public License (GPL), the +law of the Commonwealth of Virginia shall govern this License +Agreement only as to issues arising under or with respect to +Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this +License Agreement shall be deemed to create any relationship of +agency, partnership, or joint venture between CNRI and Licensee. This +License Agreement does not grant permission to use CNRI trademarks or +trade name in a trademark sense to endorse or promote products or +services of Licensee, or any third party. + +8. By clicking on the "ACCEPT" button where indicated, or by copying, +installing or otherwise using Python 1.6.1, Licensee agrees to be +bound by the terms and conditions of this License Agreement. + + ACCEPT + + +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 +-------------------------------------------------- + +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, +The Netherlands. All rights reserved. + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION +---------------------------------------------------------------------- + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/research/h25-bookkeeping/README.md b/research/h25-bookkeeping/README.md new file mode 100644 index 0000000000..a6da90ba3f --- /dev/null +++ b/research/h25-bookkeeping/README.md @@ -0,0 +1,44 @@ +# Complete H25 bookkeeping qualification + +The three bookkeeping changes reduce median complete wall time by **20.9459%** and CPU time by **20.9302%** against fresh runs of PR5995's native C configuration. The fixed BCCBBC sequence retains the slower C3 sample and passes the declared 15% and within-arm-range noise gates. This result applies to the frozen historical H25 caller with its full retained observations in the recorded local environment. + +| Metric | Native baseline median | Combined median | Saving | Larger within-arm range | +|---|---:|---:|---:|---:| +| Wall seconds | 27.168587597 | 21.477875710 | 5.690711887 | 3.594607136 | +| CPU seconds, including compiler children | 27.09 | 21.42 | 5.67 | 2.14 | + +Individual complete pilots motivated integration; their percentages are not added and are not separately qualified factors. See `evidence/validation/COMBINED-GATE.json` and the independent final evidence review. + +## Changes and retained contract + +* Build 2,300 invocation-private operand sets instead of repeating 21,160,000 tail set constructions. Both original pairwise loops and all 10,580,000 intersections remain. A private one-use lease surrounds the authenticated CLI; unsupported state uses literal original fallback without replaying the prefix. Cleanup clears private sets even when a traceback survives. +* Deduplicate identical guard function records and construct failure messages only on failure. All distinct predicates, closure reads and native-entry freshness checks still execute at their original boundaries before arithmetic or fallback. There is no saved PASS. +* Encode admitted complement records through one checked, stateless native call. Original snapshots, exact types, arbitrary-width JSON fallback, immediate hash updates and counters remain. All 238,685 records and 55,839,507 canonical bytes retain their original identity and prefixes. New encoder-entry freshness is checked at every original native boundary. + +Every candidate process pays both cold native builds, all old independent dense/source/type/width/fallback controls, the complete new control union, admission/source checks, conversions, retained witnesses and serialization. The full original assertion-on CLI and real upstream source verification remain. Certificate, stdout, lossless typed return, ordered witnesses/ranks and complement observations match the original anchor. The engineering driver has its own digest; the original driver digest is separately authenticated as reference identity. + +The immutable `payload/` preserves all v4 bytes and its stage manifest. Publication checkouts use regular Git modes; wrappers restore measured readonly permissions only in new external copies. The two admitted Fraction source hashes identify the recorded local runtime and the retained official CPython 3.12.15 reference. Unknown source hashes are rejected. Hosted interpreter/profile receipts must be checked separately. + +## Reproduction and delivery status + +Requirements: Linux, CPython 3.12, `/usr/bin/python3.12`, GNU time, an existing C compiler and Python headers. No dependency installation is required. + +```sh +python3.12 -B scripts/research_package.py --package research/h25-bookkeeping +# Optional one fresh complete replay, retaining new external evidence: +python3.12 -B research/h25-bookkeeping/replay.py C /tmp/h25-bookkeeping-new-evidence +``` + +The registry runs finite normal/O, one complete combined C correctness replay and canonical transport. Root `replay.py B` selects the **PR5995 native C baseline**, and `C` selects the combined candidate. Historical commands inside `payload/baseline/` retain their old meanings and are not this package's entry points. Local evaluation/index scripts are labeled historical audit sources. + +One parent serial queue performed the experiment: 180s/command, 1 GiB sampled process-group RSS, 600s initial and 1500s total round allowance. All 22 original attempts total 332.099907814s, including the 2.822723142s optimized fixture failure. Its two assertion-only callback expectations were repaired without changing the adapter; fresh normal/O passed. Earlier sources, all receipts and all six samples remain. Publication wrappers use 150s inner/180s outer limits and add source authentication/copy/cleanup costs; their correctness runs do not establish another performance factor. `VALIDATION.json` distinguishes pending/final delivery checks from the completed local performance result. + +## Credit and scope + +Chris R / Clear1nsight with substantial OpenAI Codex and user-requested Astra xhigh research, implementation and independent source/evidence review; parent alone executed compiler/scientific work. Credit PR5995, PR5929 and original CrocSwap/P104 authors and notices, with the adjacent native/GMP/FLINT precedents PR5168/5382/2853/3143 retained in predecessor evidence. New contribution code is Apache-2.0; the unmodified CPython Fraction reference retains its author notices and `CPYTHON-LICENSE.txt`. + +This is finite engineering evidence for the complete frozen historical caller. It establishes no bare-CLI factor, selected-frontier change, all-size C safety theorem, new kappa or performance transfer. The separate PR5864 objective and paused mathematics/feeds/automations remain separate. + +## Open next questions + +Another caller or runtime requires its own authenticated source/output contract, independent controls and complete paid comparison. Independent reproduction on another host is useful; hosted correctness does not establish a hosted speed factor. At package preparation, exact-head hosted validation and the observed child Fraction profile remain pending; publication readbacks record their eventual disposition. TASK.json gives the bounded first steps and blockers. diff --git a/research/h25-bookkeeping/SOURCES.json b/research/h25-bookkeeping/SOURCES.json new file mode 100644 index 0000000000..696ad078e2 --- /dev/null +++ b/research/h25-bookkeeping/SOURCES.json @@ -0,0 +1,897 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "files": [ + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + }, + { + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "path": "certificates/selected-result.json", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "usage": "provenance" + }, + { + "git_blob": "e5c52c8afe086a2d0c9418833c550c865ebf8615", + "path": "scripts/audit_short_guards.py", + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "usage": "provenance" + }, + { + "git_blob": "a773311b726fd1ef98a056f6f76010e872d7908a", + "path": "scripts/certify.py", + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "usage": "provenance" + }, + { + "git_blob": "11b2e751bfb2fb141b586042b6f6fec4e498c763", + "path": "scripts/compact_control_layer.py", + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "usage": "provenance" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "scripts/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "provenance" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "scripts/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "provenance" + }, + { + "git_blob": "b0e2f3e03d7de791ca936dfd92cee2134c7dd4f5", + "path": "scripts/exclusion_circuit.py", + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "usage": "provenance" + }, + { + "git_blob": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "path": "scripts/paired_exclusion_circuit.py", + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "usage": "provenance" + }, + { + "git_blob": "910449dd510c89ca24aa56904d225b86abfb3be7", + "path": "scripts/paired_network.py", + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "usage": "provenance" + }, + { + "git_blob": "8e17b52f9573135426d7ba6865c8c9bc8da8639a", + "path": "scripts/prepare_layers.py", + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "usage": "provenance" + }, + { + "git_blob": "f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b", + "path": "scripts/search_network.py", + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "usage": "provenance" + }, + { + "git_blob": "d0864271884398d44ee1fc70f0d99bb982418156", + "path": "scripts/shared_point_circuit.py", + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "usage": "provenance" + }, + { + "git_blob": "0ec7e75046fe714968c49178cd7f83e80e9f9d94", + "path": "scripts/shared_point_network.py", + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "usage": "provenance" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "provenance" + }, + { + "git_blob": "c8cb3c3857907bf3465017b9f7ef1add4df5c29b", + "path": "upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "usage": "provenance" + }, + { + "git_blob": "f0297c9cb841ad74a7cee4b541e302073d913236", + "path": "upstream/build/figures/multiplication-flow.tex", + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "usage": "provenance" + }, + { + "git_blob": "a2d539e5a794eb8d679c6cad68c6b8d12b0fc880", + "path": "upstream/build/figures/proof-map.tex", + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "usage": "provenance" + }, + { + "git_blob": "0b11a3feb14714253c1ca06ee561a31dd2fe8662", + "path": "upstream/build/main.tex", + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "usage": "provenance" + }, + { + "git_blob": "bf01cae12597f2777199c8ee74ee9f6933a1b56e", + "path": "upstream/build/references.bib", + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "usage": "provenance" + }, + { + "git_blob": "aa9048eef857c3e694989f5bb5020109e6422502", + "path": "upstream/build/sections/00-introduction.tex", + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "usage": "provenance" + }, + { + "git_blob": "7c6f033138f97315c80e64afb6cc446a1d590538", + "path": "upstream/build/sections/01-history.tex", + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "usage": "provenance" + }, + { + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "path": "upstream/build/sections/02-streams.tex", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "usage": "provenance" + }, + { + "git_blob": "cdb0ba527aa8df5d57c151183fd3893c1a7e21ab", + "path": "upstream/build/sections/03-motifs.tex", + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "usage": "provenance" + }, + { + "git_blob": "951e792b1768e6509561380b8bbfb1d1ccb64c08", + "path": "upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "usage": "provenance" + }, + { + "git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "path": "upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "usage": "provenance" + }, + { + "git_blob": "de073e9292d58573f7065a3cd4f214e0d05f3444", + "path": "upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "usage": "provenance" + }, + { + "git_blob": "256243bf9416baefb82bf9203f80215b9ebe28f2", + "path": "upstream/build/sections/07-resampling.tex", + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "usage": "provenance" + }, + { + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "path": "upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "usage": "provenance" + }, + { + "git_blob": "4c7a1d63c912d081f70f5b166e9cab92d7774ee6", + "path": "upstream/build/sections/09-exact-arithmetic.tex", + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "usage": "provenance" + }, + { + "git_blob": "e69cc8276220edb8617a371ae9044a911fbc0767", + "path": "upstream/build/sections/10-transposition.tex", + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "usage": "provenance" + }, + { + "git_blob": "44439c716c6290cd6e512ffac91253443b37d3ab", + "path": "upstream/build/sections/11-grouped-rectangles.tex", + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "usage": "provenance" + }, + { + "git_blob": "e0584d4993df01ec08233ab344ebc1b1039bf7f7", + "path": "upstream/formalization.yaml", + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "usage": "provenance" + }, + { + "git_blob": "01c309e34d36cf3669c43d89c5dfb25cdc31b8af", + "path": "upstream/manifest.json", + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "usage": "provenance" + }, + { + "git_blob": "f26bcf4d2de6eb136e31006ca3ab447d5e488adf", + "path": "research/h25-bookkeeping/CPYTHON-LICENSE.txt", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/CPYTHON-LICENSE.txt", + "sha256": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "usage": "input" + }, + { + "git_blob": "bd5ea6238385d3115d63958ff13eba0ebed2216b", + "path": "research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json", + "sha256": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "usage": "input" + }, + { + "git_blob": "e8c4359ffeb24075069deb50975f339d80ff29e2", + "path": "research/h25-bookkeeping/evidence/revisions/v1/STAGE.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/revisions/v1/STAGE.json", + "sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "usage": "input" + }, + { + "git_blob": "f5682e63036279ae1a664c5f58b2eb304b041182", + "path": "research/h25-bookkeeping/evidence/revisions/v2/STAGE.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/revisions/v2/STAGE.json", + "sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "usage": "input" + }, + { + "git_blob": "847ef9a6f5623395661dac24ec5dc751a08a5cd2", + "path": "research/h25-bookkeeping/evidence/revisions/v3/STAGE.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/revisions/v3/STAGE.json", + "sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "usage": "input" + }, + { + "git_blob": "85adb4074b884f884344399106a57bf36ef1d58a", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json", + "sha256": "73a19dd6b7edfea707d1a809a6c5b65b86bfc8303e0e7846c6cfa08e59548f13", + "usage": "input" + }, + { + "git_blob": "2e942997481cb98c1a200e5a6758e9b250eeb748", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json", + "sha256": "32eb9da6703a5f4b4552f7f15f31960b2b39d5c88eda8d98631dc1dd192cacd7", + "usage": "input" + }, + { + "git_blob": "11e11f896e005171f897763cb4922e0591ecd788", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json", + "sha256": "34c359652aa4d0bf18a54035ab7c6a69bf376dfebc25a52bd677546ceb121830", + "usage": "input" + }, + { + "git_blob": "dc7c972a6f0f46791147d12f09df948fec176b21", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json", + "sha256": "08472c32752b9efb61ec9df18a1d608475c2e992a026036ae61b27cdb8f56386", + "usage": "input" + }, + { + "git_blob": "d8dd9a05a475dfddcd6dbfab07c0f4c2161a1b8a", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json", + "sha256": "743878514b9544ddaa8146cdfe1ccd94b462add6c1918bef721518177e853bfc", + "usage": "input" + }, + { + "git_blob": "69f6d2e5d8acf7787a1e60135788e4b59c1d311a", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json", + "sha256": "c6bfed16508860931a70cfa122defb2064955df0b3cb5dd8b078c8fd4e226530", + "usage": "input" + }, + { + "git_blob": "6ed21916936a7c5475e753f6a48b5eb359804373", + "path": "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json", + "sha256": "97bb2b6707e9fc467e3d31eb9f7073af95edc9b416e768b6857c867208020e7c", + "usage": "input" + }, + { + "git_blob": "97816feb57d7fc46604a3cfaea0c43d98b52b693", + "path": "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json", + "sha256": "7a0198be16b8b1de498a2a29c49d83876d6ef87dc9ef7c27d959a1554d62a508", + "usage": "input" + }, + { + "git_blob": "7adbaff293572c63d389a2c81ca7b64e44c3f683", + "path": "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json", + "sha256": "0dfd9a7fe9518274a3b04fa755bc5a32082decf2b6787ec01b44ef411eedb919", + "usage": "input" + }, + { + "git_blob": "eb89cf18b5f776ee16d12355b8454aaec49bc4fb", + "path": "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json", + "sha256": "d628c5dd8b80494fb1685fd94f78cddd3ddf6477e76a7efcd041791699731f53", + "usage": "input" + }, + { + "git_blob": "15e1ab8b148aa111febb7f5e023d37ddb641b907", + "path": "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json", + "sha256": "0c17246c4b14189adc02627d439123b05f2933b5b5a85d8c69901459b6d3348f", + "usage": "input" + }, + { + "git_blob": "0caea67ad8cdf0946d8d1eb2a56d51ee73c91918", + "path": "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json", + "sha256": "29aff35432c14876b164f87112facf8e594217947086a37bc7c073db32d222b8", + "usage": "input" + }, + { + "git_blob": "bca97809cf399ba1c211c8c02e59c4df64eceb89", + "path": "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json", + "sha256": "dd88c61c042b3026182704c3d380defd53d69755b5c42a79a9fbc56e224d07f7", + "usage": "input" + }, + { + "git_blob": "3c2c13ef1fa08d969ed8a90312d420e6764ce525", + "path": "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json", + "sha256": "4deafb884314517f5291b9b02715eb6dc5df68a45f8274ec466ab9938784d0ab", + "usage": "input" + }, + { + "git_blob": "d0d6dbf4e71013ad484689a6ecb6132af9f83371", + "path": "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json", + "sha256": "1b5cea72a0e9a2e023e4bf77e9f8b224048da8ebe31cf357ffd9994de32145ff", + "usage": "input" + }, + { + "git_blob": "0e7421542eef01cd2accf8c8a08b81edf5039bda", + "path": "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json", + "sha256": "a349c7b5403c9b5bfc8a30a87de1c7334a8dac2fd9a4df92bcc82d183623a6b4", + "usage": "input" + }, + { + "git_blob": "f3104629a45c883a1b55579adb876d9f2dbc7cef", + "path": "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json", + "sha256": "e8ce0cadb455309e57d6dc650d2ab654d9424c397ca67b69420e79af5201698b", + "usage": "input" + }, + { + "git_blob": "5686df2fb328285113a7e1c2b3d54b6ad01ce69c", + "path": "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json", + "sha256": "e27774f6bd0671da631b8b9b2aca22a24d2fa85d00bde48b6a7ce52c37cfb12c", + "usage": "input" + }, + { + "git_blob": "a331e570aaa61afbf4eac362c5fa8f5052335e8e", + "path": "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json", + "sha256": "9a252ddad438c6539807181d728f833bedf093c839bf1e84fe7b9d12364e27e9", + "usage": "input" + }, + { + "git_blob": "8e9f10b9cca17712092276ce56525b501359a8a2", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json", + "sha256": "5af1f03fc8101bf126132a4be017033ae41d0dcade69da797e2c22483005e495", + "usage": "input" + }, + { + "git_blob": "f1b9851782fc523d9f8b8a43e0c13a977611ac68", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json", + "sha256": "5b24ea2b4f5b1de1534c0501d4377d40cd947184fd56da1d2c1fac3e7beb6ad1", + "usage": "input" + }, + { + "git_blob": "bde4a6111bfd5f0d49708234067401395ab17dc2", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json", + "sha256": "1933791e7554434c85938ee4e20069ea122b9666c47df93c14648c63d77afd72", + "usage": "input" + }, + { + "git_blob": "af40e56a8da7f6b714a4abccb92d2d356010c6d1", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json", + "sha256": "b46aacb01b7db8d518da7a9193d525f2a65148d261be0c167c36518f53a5f2a1", + "usage": "input" + }, + { + "git_blob": "f7e363e115f5cd1f54352eb7a921b17dd3139321", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json", + "sha256": "56004f2e61d009b37f2db6b9c98d70d81bfdd50537fd543285129ae00a091be3", + "usage": "input" + }, + { + "git_blob": "8fbcaa56a90b9b9631dccb3397366f720891965f", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json", + "sha256": "eb1d9d9546b639fad9024b5dc5d4a177d2585590f0c02530e69d96cef5e1de34", + "usage": "input" + }, + { + "git_blob": "6d508831266fc774995e54bba6fa97de119f0a97", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json", + "sha256": "120d49905ad03e7f0ca20768113f0b283b98620e6140925b387836ef558b4e69", + "usage": "input" + }, + { + "git_blob": "df2123fa3f6832673693e295ad1f92e63eb27dd3", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json", + "sha256": "c8dabe911cfa72008ae39bc267806a24af7c622ecd6595dd247fe281b6c8afc6", + "usage": "input" + }, + { + "git_blob": "8a5fbd51d842b003e50e36b8a81bc05dbc6b27a5", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json", + "sha256": "c3229cb8e4484730d41bc5253b024df3b32655777cae76802d94958078bb66d8", + "usage": "input" + }, + { + "git_blob": "439b1861df6a8cb86b7ecfe69b5427b7f4497dd0", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json", + "sha256": "d59416d75401f76e69b7638aac4c294c47a91b224166bcb7ffb149aa717101f5", + "usage": "input" + }, + { + "git_blob": "70bb086d3636d4d01ae17c0e1ff5a2c9e05632de", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json", + "sha256": "9b6d0f65acdb78ac02499c0e2c57d5fc78e3e71083f06657a187a4aa821cd50a", + "usage": "input" + }, + { + "git_blob": "3c52a51bcc59f33ffcb2a1a86b9e651102a01de1", + "path": "research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json", + "sha256": "b4ee7896dec5a900f45026cf93bd81f9af7805c9b51f769cdd1fdbf467fea699", + "usage": "input" + }, + { + "git_blob": "40e189e4ead082808e3fc536092dfbce491982c0", + "path": "research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json", + "sha256": "7b3d7d427d2d06a9d6e436454d1ef7623e0f8ad50a0a23a0ec0d2ec0fc12b788", + "usage": "input" + }, + { + "git_blob": "e9a595d870769cd33e77e04693bd79c00fd952ee", + "path": "research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json", + "sha256": "c9345eb1ff8fdf2607832b39bb4c1b51fe6f1c03db3c4ebfe463900cded6bff5", + "usage": "input" + }, + { + "git_blob": "04833439fb033545952cef3ae5a68899ae0b4a25", + "path": "research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json", + "sha256": "b6e9a8dc8bc89b473b2b98995f4d0aa4c08b286df22bbc122255731ecf577934", + "usage": "input" + }, + { + "git_blob": "54609764c100f1a54e838135bee60f77cd250ba1", + "path": "research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json", + "sha256": "bb07ee0af583165a8a67a08edc5576c25f63c3103a6cefcc3643bfc71ff9dd89", + "usage": "input" + }, + { + "git_blob": "9ba6da6ef6d165998d6880af9841d74f20b6aa1d", + "path": "research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json", + "sha256": "1e839f0e4de437b59f428213922b03e090c5794973c7a6fc763a512da9c2c0fd", + "usage": "input" + }, + { + "git_blob": "f2b899fc56f8193bc4e529df05caf03a47940c94", + "path": "research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json", + "sha256": "dc41582760b650c17ebd6fc8591be5ea4685d1a5aa0b0b005de4bb15477233bf", + "usage": "input" + }, + { + "git_blob": "0bd237fc06d3e3bf0f806dd3b17f3e79c0e8af0c", + "path": "research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json", + "sha256": "e07bee3ecf50f5f2cd77910763f65d05baaea1ad3be50c5282a4e96b74b6ce15", + "usage": "input" + }, + { + "git_blob": "23f2e7a6295416688c81209aeaebec993637fe7c", + "path": "research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json", + "sha256": "ed60c889422cd98c2b525b6d5f731a01e8f6e0f8dfdb0de8d61c52912f591495", + "usage": "input" + }, + { + "git_blob": "210ba6c969592335df1123e0ba51362b607daa93", + "path": "research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json", + "sha256": "4f939f3897dbedeeed8a2ac0078eb24cb0c1cf7034e50f2dc60cf60dcfc2c235", + "usage": "input" + }, + { + "git_blob": "8b79697f184ce074142021cf9c0e6f6b2117877a", + "path": "research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json", + "sha256": "a0bfabd6785e7dc2248fdf85e0769965bfac5916444c368ded1280f79bd944a5", + "usage": "input" + }, + { + "git_blob": "d6b845772241a25b3ef5b2e1e83642aa4f911e69", + "path": "research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json", + "sha256": "93eeaed9de3af3655d285ce2c2c92f844f73ae3646a9271e8b322d29a986bf19", + "usage": "input" + }, + { + "git_blob": "55cd5b57d03528c603a6ef5aea409ca0254bab3b", + "path": "research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json", + "sha256": "98c77d54333878fc4cc833f36390d3f0deda472e342d572c525c8b99dfb45fe3", + "usage": "input" + }, + { + "git_blob": "7bf77ad826881f388450949897e9f35bd413b0af", + "path": "research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json", + "sha256": "5fca5cf80da96781c4e2ad112abee94a982341238f7fe9f38e0f6305c23fb43d", + "usage": "input" + }, + { + "git_blob": "5b4da96c298e572dfa1a266c4e689f20e86b3c70", + "path": "research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json", + "sha256": "fcc04985b75c9df1345ccc87fd508a5d6a17f5540ef88f064e6a21d9d4172e9b", + "usage": "input" + }, + { + "git_blob": "b447d0675ebcd3c76597bed9ac0768aa873e6ce4", + "path": "research/h25-bookkeeping/evidence/validation/RUN-INDEX.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/evidence/validation/RUN-INDEX.json", + "sha256": "cfcc237d5267c0edc8eb4658d349aff9445044ff42cc17f0cbdc50f02772f3e0", + "usage": "input" + }, + { + "git_blob": "4f4294e84c011ad473c8eefdc34331a4354164c5", + "path": "research/h25-bookkeeping/payload/STAGE.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/STAGE.json", + "sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "usage": "input" + }, + { + "git_blob": "6c0c5746fb991ba87221083c6485046960863331", + "path": "research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json", + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "usage": "input" + }, + { + "git_blob": "a593a0500413502de09458a98b1822c8f827e64a", + "path": "research/h25-bookkeeping/payload/baseline/anchor.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "usage": "input" + }, + { + "git_blob": "d94920c274c0a47db9763dd595230d52df0bd073", + "path": "research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "usage": "input" + }, + { + "git_blob": "4168f5c7e4cec0f182750c6908315735011ff061", + "path": "research/h25-bookkeeping/payload/baseline/engine/finite_controls.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/finite_controls.py", + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "usage": "input" + }, + { + "git_blob": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "path": "research/h25-bookkeeping/payload/baseline/engine/native_backend.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/native_backend.py", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "usage": "input" + }, + { + "git_blob": "0b6a835981d54ce7d807a3f54947eddb9eda4f9d", + "path": "research/h25-bookkeeping/payload/baseline/engine/native_gf2.c", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/native_gf2.c", + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "usage": "input" + }, + { + "git_blob": "807855eb875673c47da0ed1b5a890a417e28a846", + "path": "research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "usage": "input" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "input" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "input" + }, + { + "git_blob": "e5c52c8afe086a2d0c9418833c550c865ebf8615", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py", + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "usage": "input" + }, + { + "git_blob": "a773311b726fd1ef98a056f6f76010e872d7908a", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/certify.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/certify.py", + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "usage": "input" + }, + { + "git_blob": "11b2e751bfb2fb141b586042b6f6fec4e498c763", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py", + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "usage": "input" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "input" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "input" + }, + { + "git_blob": "b0e2f3e03d7de791ca936dfd92cee2134c7dd4f5", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py", + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "usage": "input" + }, + { + "git_blob": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_exclusion_circuit.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_exclusion_circuit.py", + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "usage": "input" + }, + { + "git_blob": "910449dd510c89ca24aa56904d225b86abfb3be7", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_network.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_network.py", + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "usage": "input" + }, + { + "git_blob": "8e17b52f9573135426d7ba6865c8c9bc8da8639a", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/prepare_layers.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/prepare_layers.py", + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "usage": "input" + }, + { + "git_blob": "f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py", + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "usage": "input" + }, + { + "git_blob": "d0864271884398d44ee1fc70f0d99bb982418156", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py", + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "usage": "input" + }, + { + "git_blob": "0ec7e75046fe714968c49178cd7f83e80e9f9d94", + "path": "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_network.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_network.py", + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "usage": "input" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "input" + }, + { + "git_blob": "c8cb3c3857907bf3465017b9f7ef1add4df5c29b", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "usage": "input" + }, + { + "git_blob": "f0297c9cb841ad74a7cee4b541e302073d913236", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex", + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "usage": "input" + }, + { + "git_blob": "a2d539e5a794eb8d679c6cad68c6b8d12b0fc880", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex", + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "usage": "input" + }, + { + "git_blob": "0b11a3feb14714253c1ca06ee561a31dd2fe8662", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex", + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "usage": "input" + }, + { + "git_blob": "bf01cae12597f2777199c8ee74ee9f6933a1b56e", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib", + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "usage": "input" + }, + { + "git_blob": "aa9048eef857c3e694989f5bb5020109e6422502", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex", + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "usage": "input" + }, + { + "git_blob": "7c6f033138f97315c80e64afb6cc446a1d590538", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex", + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "usage": "input" + }, + { + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "usage": "input" + }, + { + "git_blob": "cdb0ba527aa8df5d57c151183fd3893c1a7e21ab", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/03-motifs.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/03-motifs.tex", + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "usage": "input" + }, + { + "git_blob": "951e792b1768e6509561380b8bbfb1d1ccb64c08", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/04-swap.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "usage": "input" + }, + { + "git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/05-layers.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "usage": "input" + }, + { + "git_blob": "de073e9292d58573f7065a3cd4f214e0d05f3444", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/06-transforms.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "usage": "input" + }, + { + "git_blob": "256243bf9416baefb82bf9203f80215b9ebe28f2", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/07-resampling.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/07-resampling.tex", + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "usage": "input" + }, + { + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/08-assembly.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "usage": "input" + }, + { + "git_blob": "4c7a1d63c912d081f70f5b166e9cab92d7774ee6", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "usage": "input" + }, + { + "git_blob": "e69cc8276220edb8617a371ae9044a911fbc0767", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex", + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "usage": "input" + }, + { + "git_blob": "44439c716c6290cd6e512ffac91253443b37d3ab", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "usage": "input" + }, + { + "git_blob": "e0584d4993df01ec08233ab344ebc1b1039bf7f7", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/formalization.yaml", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/formalization.yaml", + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "usage": "input" + }, + { + "git_blob": "01c309e34d36cf3669c43d89c5dfb25cdc31b8af", + "path": "research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json", + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "usage": "input" + }, + { + "git_blob": "f4ff2a4313fc216712c42aceb9cbd7eb3b4544df", + "path": "research/h25-bookkeeping/payload/baseline/full_driver.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/full_driver.py", + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "usage": "input" + }, + { + "git_blob": "62a6091887a3894535c1d059e1b0c527d556eb76", + "path": "research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "usage": "input" + }, + { + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "path": "research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "usage": "input" + }, + { + "git_blob": "e3a8bbcfb3ea5e016b218a69487983b97250433d", + "path": "research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py", + "pin": "head:26056452f06097eae4b5b502245f8bb6d3818c61:research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py", + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "usage": "input" + } + ], + "input_commit": "26056452f06097eae4b5b502245f8bb6d3818c61", + "input_file_count": 97, + "predecessor": { + "arm": "native C with original complete controls", + "commit": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "payload_bytes_preserved": true, + "pr": 5995 + }, + "schema_version": 1 +} diff --git a/research/h25-bookkeeping/TASK.json b/research/h25-bookkeeping/TASK.json new file mode 100644 index 0000000000..6e4b7cfa03 --- /dev/null +++ b/research/h25-bookkeeping/TASK.json @@ -0,0 +1,68 @@ +{ + "actual_scope": "Complete frozen historical H25 native-C verifier: invocation-private triple-set reuse, exact live-guard bookkeeping and stateless canonical complement encoding, retaining original observations and all old/new complete costs.", + "ai_assistance": "Substantial OpenAI Codex and user-requested Astra xhigh source research/implementation and separate static review; parent-only serial scientific execution. Predecessor PR5995/PR5929 and original CrocSwap/P104 authors retain credit; retained CPython Fraction source keeps its own author notices and PSF license.", + "author": "Chris R / Clear1nsight", + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "budget_scope": "1500 seconds parent-owned aggregate scientific command budget; source research and publication work are separately described.", + "evidence": "payload/STAGE.json; evidence/control/QUALIFICATION-v4.json; evidence/validation/{COMBINED-GATE,RUN-INDEX,P1-O-v2-STOP}.json; all22 raw run receipts and21 scientific receipts; original canonical artifacts under payload/baseline/evidence/canonical.", + "open_questions": [ + { + "blocked_by": "No broader caller qualification or performance transfer is established by this package.", + "first_step": "Authenticate the new complete source/output/runtime contract and pay its independent controls before a separate bounded comparison.", + "question": "Can the exact source-bound optimization be transferred to another caller or interpreter without changing coverage?", + "why_it_matters": "The measured reduction belongs to the frozen historical H25 caller and the recorded local environment." + }, + { + "blocked_by": "Exact-head hosted validation is still pending at this draft.", + "first_step": "Record the hosted active Fraction digest/profile and execute the registered normal/optimized finite and assertion-on full correctness commands.", + "question": "Will the hosted CPython runtime match one of the two exact admitted Fraction source profiles and pass the complete replay?", + "why_it_matters": "Version labels alone do not identify distribution-patched Fraction bytes; hosted correctness does not establish the local performance factor." + } + ], + "original_card": { + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "id": "replay-runtime", + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ], + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ] + }, + "outcome": "completed", + "outcome_scope": "Completed local source-frozen three-priority performance experiment; final publication and exact-head hosted correctness have separate status in VALIDATION and publication readbacks.", + "schema_version": 1, + "scope_change_reason": "Explicit user assignment requested all three bookkeeping priorities and repeated-call reduction. The reference arm is PR5995 native C with its original controls; the combined result is measured only on the immutable v4 complete caller.", + "scope_status": "refined", + "stop_rule": "Freeze exact source and B1 C1 C2 B2 B3 C3 order; retain every sample and failure; stop on source/output/resource/target/noise failures; no automatic rerolls. Publication wrapper correctness and its costs remain separate from the measured harness.", + "task_id": "replay-runtime", + "time_budget_minutes": 25 +} diff --git a/research/h25-bookkeeping/VALIDATION.json b/research/h25-bookkeeping/VALIDATION.json new file mode 100644 index 0000000000..27691974ed --- /dev/null +++ b/research/h25-bookkeeping/VALIDATION.json @@ -0,0 +1,56 @@ +{ + "all_protected376_match_tested_readonly_bytes": true, + "committed_bytes_modes_raw_source_history": "PASS", + "committed_export_all97_inputs": "PASS", + "delivery_receipts": { + "publication-RO-O": { + "source_unchanged": true, + "status": "PASS", + "stdout_sha256": "d520348e99d8c9c8da91f5eb595bb51c61df046388d76dadda65efd0bcad4266", + "wall_seconds": 4.0854167100042105 + }, + "publication-RO-canonical": { + "source_unchanged": true, + "status": "PASS", + "stdout_sha256": "c75d0efff8545e4ee208efd0fd54e5e3860cf80a3d2aa85aa34eb5cf71d25e60", + "wall_seconds": 0.8736407149699517 + }, + "publication-RO-full": { + "source_unchanged": true, + "status": "PASS", + "stdout_sha256": "af06e8360fa132a8b58397a429b0b914dd6b0588bcf18b94fb7666c6c307f043", + "wall_seconds": 25.911516694992315 + }, + "publication-RO-normal": { + "source_unchanged": true, + "status": "PASS", + "stdout_sha256": "195a42b60ef5016b8546a08b3893305d8788cbcff19684e134684b913ae26a08", + "wall_seconds": 3.137039125955198 + }, + "publication-registry-v1": { + "source_unchanged": true, + "status": "PASS", + "stdout_sha256": "b15f09632f38df4d8682f34925dd10049c3b46168cfb9c3f3210d95e6788e1d2", + "wall_seconds": 34.88769384502666 + } + }, + "hosted_CI": "PENDING_NEW_PR", + "immutable_payload_stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "input_ancestor": "26056452f06097eae4b5b502245f8bb6d3818c61", + "local_performance_evidence_review": "evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json", + "local_performance_gate": "PASS_BOTH15PERCENT_AND_NOISE", + "local_registry_receipt": "evidence/publication-v1/registry/receipt.json", + "local_registry_seconds": 34.88769384502666, + "normal_O_combined_controls": "PASS_MEASURED_V4", + "note": "Preparation-time status; final exact-head publication readbacks may supersede this record. This file is excluded from CODE manifest self-authentication.", + "package_bytes_modes_unchanged": true, + "protected_CODE_sha256": "99f42a7d2fddea7c44f92deb08c5360983b56fc769994a35b00948330dd3b76f", + "publication_wrapper_source_review": "evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json", + "readonly_Git_free": "PASS_ALL4_NORMAL_O_FULL_CANONICAL", + "scientific_round_attempts_including_delivery": 27, + "scientific_round_wall_seconds": 400.9952149048913, + "source_bytes_and_modes_unchanged": true, + "status": "LOCAL_DELIVERY_ALL_PASS_EXACT_HEAD_HOSTED_PENDING", + "tested_export_commit": "cb2351f4c3e4c36a397429fafa18e7807243a602", + "tested_export_sha256": "a047a5962eda8f69cf5b72d4b98f3e7d7ed2b3f81115251849e40233eb123ad1" +} diff --git a/research/h25-bookkeeping/VERIFY.json b/research/h25-bookkeeping/VERIFY.json new file mode 100644 index 0000000000..96d7c36ee4 --- /dev/null +++ b/research/h25-bookkeeping/VERIFY.json @@ -0,0 +1,144 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Fresh complete finite control union for all three bookkeeping lanes plus original independent dense/typed/order/width/fallback controls; new external workspace and paid cold native builds.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "-O", + "{package}/verify.py" + ], + "checks": "Same bounded finite control union in deliberate optimized mode, retaining exception-based checks and source admission; complete caller assertions remain enabled in the separate full command.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify_full.py" + ], + "checks": "One assertion-on complete combined candidate correctness replay, exact v4 source modes restored only in a new external copy, unchanged serial runner with explicit HERE and 150-second inner limit; exact full certificate/stdout/types/witness/rank/complement, all paid controls, no hosted performance claim.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/check_artifacts.py" + ], + "checks": "Publication source custody plus unchanged baseline lossless canonical artifact verifier; exact typed return, certificate and streamed full witness/rank/complement identities; no numerical replay or timing claim.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/h25-bookkeeping/CPYTHON-LICENSE.txt", + "research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json", + "research/h25-bookkeeping/evidence/revisions/v1/STAGE.json", + "research/h25-bookkeeping/evidence/revisions/v2/STAGE.json", + "research/h25-bookkeeping/evidence/revisions/v3/STAGE.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json", + "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json", + "research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json", + "research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json", + "research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json", + "research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json", + "research/h25-bookkeeping/evidence/validation/RUN-INDEX.json", + "research/h25-bookkeeping/payload/STAGE.json", + "research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json", + "research/h25-bookkeeping/payload/baseline/anchor.json", + "research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py", + "research/h25-bookkeeping/payload/baseline/engine/finite_controls.py", + "research/h25-bookkeeping/payload/baseline/engine/native_backend.py", + "research/h25-bookkeeping/payload/baseline/engine/native_gf2.c", + "research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py", + "research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/certify.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_exclusion_circuit.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_network.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/prepare_layers.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_network.py", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/03-motifs.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/04-swap.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/05-layers.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/06-transforms.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/07-resampling.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/08-assembly.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/formalization.yaml", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json", + "research/h25-bookkeeping/payload/baseline/full_driver.py", + "research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json", + "research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json", + "research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/h25-bookkeeping/archive_support.py b/research/h25-bookkeeping/archive_support.py new file mode 100644 index 0000000000..ab74b23c99 --- /dev/null +++ b/research/h25-bookkeeping/archive_support.py @@ -0,0 +1,273 @@ +"""Git-free publication orchestration for the unchanged frozen H25 v4 payload. + +Apache-2.0. Publication custody/copy/cleanup costs are separate from the already +qualified six samples. No replay here creates another performance-factor claim. +""" +from hashlib import sha256 +import fcntl +import json +import os +from pathlib import Path, PurePosixPath +import shutil +import stat +import sys +import tempfile +import types + +ROOT = Path(__file__).resolve().parent +PAYLOAD = ROOT / "payload" +STAGE_SHA256 = "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +RUNNER_SHA256 = "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" +INNER_TIMEOUT = 150 +RSS_CAP = 1024 ** 3 +ALLOWED_JOBS = ("finite-all", "finite-O-all", "full-none", "full-all") + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(path): + hasher = sha256() + with path.open("rb") as stream: + for block in iter(lambda: stream.read(1024 * 1024), b""): + hasher.update(block) + return hasher.hexdigest() + + +def _relative(name): + need(type(name) is str, "Manifest path must be text") + path = PurePosixPath(name) + need(bool(path.parts) and not path.is_absolute() and ".." not in path.parts and + "\\" not in name and path.as_posix() == name, + "Noncanonical publication path: " + name) + return path + + +def _files(directory): + need(directory.is_dir() and not directory.is_symlink(), "Regular source directory required") + result = {} + for path in sorted(directory.rglob("*")): + need(not path.is_symlink(), "Symlink in publication source: " + str(path)) + if path.is_file(): + result[path.relative_to(directory).as_posix()] = path + else: + need(path.is_dir(), "Special file in publication source: " + str(path)) + return result + + +def _stage_inventory(directory, declared, require_modes): + files = _files(directory) + need(set(files) == set(declared["files"]) | {"STAGE.json"}, "Exact v4 payload file census") + need(digest(files["STAGE.json"]) == STAGE_SHA256, "Exact v4 stage manifest bytes") + for name, row in declared["files"].items(): + _relative(name) + need(digest(files[name]) == row["sha256"], "Exact v4 payload bytes: " + name) + if require_modes: + need(stat.S_IMODE(files[name].stat().st_mode) == row["mode"], "Exact copied v4 mode: " + name) + if require_modes: + need(stat.S_IMODE(files["STAGE.json"].stat().st_mode) == 0o444, "Readonly copied STAGE manifest") + + +def authenticate(): + """Authenticate bytes; publication checkout write/execute bits may differ. + + CODE-SOURCES.json is bound by committed package identity, not a self-hash. + Its raw digest and current protected-file modes are returned for after-run + equality. STAGE.json has the independent fixed v4 digest above. + """ + raw = (ROOT / "CODE-SOURCES.json").read_bytes() + manifest = json.loads(raw) + need(manifest.get("schema_version") == 1 and type(manifest.get("files")) is dict, + "Publication source manifest version") + files = _files(ROOT) + modes = {} + for name, expected in manifest["files"].items(): + _relative(name) + need(name != "CODE-SOURCES.json", "Source manifest cannot hash itself") + need(name in files and type(expected) is str and len(expected) == 64 and + digest(files[name]) == expected, "Exact protected publication source: " + name) + modes[name] = stat.S_IMODE(files[name].stat().st_mode) + expected_code = {name for name in manifest["files"] if Path(name).suffix in (".py", ".c")} + actual_code = {name for name in files if Path(name).suffix in (".py", ".c")} + need(actual_code == expected_code, "Complete protected publication code census") + need(digest(PAYLOAD / "STAGE.json") == STAGE_SHA256, "Frozen v4 stage identity") + declared = json.loads((PAYLOAD / "STAGE.json").read_bytes()) + need(declared.get("schema") == "h25-bookkeeping-immutable-stage-v1" and + len(declared["files"]) == 160 and declared["runner_sha256"] == RUNNER_SHA256, + "Frozen v4 payload contract") + payload_names = {"payload/" + name for name in declared["files"]} | {"payload/STAGE.json"} + need(payload_names <= set(manifest["files"]), "Entire payload must be protected by publication manifest") + _stage_inventory(PAYLOAD, declared, False) + modes["CODE-SOURCES.json"] = stat.S_IMODE((ROOT / "CODE-SOURCES.json").stat().st_mode) + return {"manifest_sha256": sha256(raw).hexdigest(), "stage": declared, + "protected_file_modes": modes} + + +def _protected_root(): + # Generic exports retain research/; standalone package directories + # also work without treating their entire filesystem parent as a repository. + return ROOT.parent.parent if ROOT.parent.name == "research" else ROOT + + +def external(path, *, new=True): + path = Path(path).resolve() + need(not path.is_relative_to(ROOT) and not path.is_relative_to(_protected_root()), + "Evidence must be outside the publication package/repository") + if new: + need(not path.exists(), "Fresh external evidence directory required") + return path + + +def _temporary_base(): + # Avoid tempfile.gettempdir(): its first call may probe TMPDIR by writing a + # test file before we have rejected an immutable/package-local destination. + candidates = [Path(value) for value in (os.environ.get("TMPDIR"),) if value] + candidates.extend((Path("/tmp"), Path("/var/tmp"))) + for candidate in candidates: + candidate = candidate.resolve() + if (candidate.is_dir() and not candidate.is_relative_to(_protected_root()) and + os.access(candidate, os.W_OK | os.X_OK)): + return candidate + raise ValueError("No writable temporary directory outside the immutable publication root") + + +def _mark_owned(directory): + (directory / "PUBLICATION-WORKSPACE.json").write_text(json.dumps({ + "schema": "h25-private-publication-workspace-v1", "path": str(directory), + "stage_sha256": STAGE_SHA256}, sort_keys=True) + "\n") + + +def temporary_parent(): + directory = Path(tempfile.mkdtemp(prefix="h25-bookkeeping-check-", dir=_temporary_base())).resolve() + _mark_owned(directory) + return directory + + +def cleanup_owned(directory): + """Remove only a wrapper-created external workspace after all checks pass.""" + directory = external(directory, new=False) + marker = json.loads((directory / "PUBLICATION-WORKSPACE.json").read_text()) + need(marker == {"schema": "h25-private-publication-workspace-v1", "path": str(directory), + "stage_sha256": STAGE_SHA256}, "Fresh private workspace ownership required") + need(directory.is_dir() and not directory.is_symlink(), "Private cleanup root must be a directory") + # Readonly copied files need no chmod; only their private parent directories + # become writable so unlink can succeed. Never follow or chmod symlinks. + for path in directory.rglob("*"): + if path.is_dir() and not path.is_symlink(): + path.chmod(0o755) + directory.chmod(0o755) + shutil.rmtree(directory) + + +def source_module(name, path, expected): + raw = path.read_bytes() + need(not path.is_symlink() and sha256(raw).hexdigest() == expected, "Authenticated source module: " + str(path)) + module = types.ModuleType(name) + module.__file__ = str(path) + exec(compile(raw, str(path), "exec"), module.__dict__) + return module + + +def _copy_stage(directory, declared): + stage = directory / "stages/v4" + stage.parent.mkdir() + shutil.copytree(PAYLOAD, stage) + # Git stores executable status, not readonly permissions. Recreate the exact + # measured stage modes exclusively within this fresh external copy. + for name, row in declared["files"].items(): + (stage / name).chmod(row["mode"]) + (stage / "STAGE.json").chmod(0o444) + for path in stage.rglob("*"): + if path.is_dir(): + need(not path.is_symlink(), "Symlink in private stage copy") + path.chmod(0o555) + stage.chmod(0o555) + _stage_inventory(stage, declared, True) + return stage + + +def _check_scientific(job, guard, science): + need(guard["status"] == "PASS" and guard["source_bytes_and_modes_unchanged"], + "Fresh bounded runner must pass with unchanged copied sources") + finite = job.startswith("finite-") + lanes = "none" if job == "full-none" else "all" + need(science["lanes"] == lanes, "Requested lane selection must be observed") + if finite: + need(science["status"] == "H25_BOOKKEEPING_FINITE_PASS" and + science["optimized"] == (1 if job == "finite-O-all" else 0), + "Complete finite union in requested interpreter mode") + original, additions = science["original_controls"], science["new_controls"] + else: + need(science["status"] == "FULL_NETWORK_COMPLETE_PASS" and science["mode"] == "candidate", + "Complete assertion-on native caller") + anchor = json.loads((PAYLOAD / "baseline/anchor.json").read_text()) + need(science["science"] == anchor["science"], "Full exact historical science equality") + original, additions = science["finite_controls"], science["bookkeeping"]["new_controls"] + need(original["status"] == "FINITE_NATIVE_GF2_CONTROLS_PASS", "Original independent controls retained") + need(set(additions) == ({"sets", "guards", "trace", "trace_entry_freshness"} if lanes == "all" else set()), + "Complete requested new-control union") + + +def run(job, evidence): + """Run one fresh fixed job; retain all evidence; never retry or select timings.""" + need(job in ALLOWED_JOBS, "Fixed finite/full publication job required") + need(sys.platform == "linux" and sys.implementation.name == "cpython" and + sys.version_info[:2] == (3, 12), "Linux CPython3.12 required; no dependency installation") + need(sys.flags.optimize in (0, 1), "Only deliberate normal/-O finite modes are supported") + need(job.startswith("finite-") or sys.flags.optimize == 0, "Full caller requires original assertions") + need(Path("/usr/bin/python3.12").is_file() and Path("/usr/bin/time").is_file(), + "System CPython3.12 and GNU time required; compiler and Python headers are also required") + before = authenticate() + evidence = external(evidence) + lock_path = _temporary_base() / ("croc-h25-bookkeeping-" + STAGE_SHA256[:20] + ".lock") + flags = os.O_CREAT | os.O_RDWR | getattr(os, "O_NOFOLLOW", 0) + with os.fdopen(os.open(lock_path, flags, 0o600), "a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + evidence.mkdir(parents=True) + _mark_owned(evidence) + publication = {"schema": "h25-publication-replay-v1", "status": "PREPARING", + "job": job, "stage_sha256": STAGE_SHA256, "runner_sha256": RUNNER_SHA256, + "publication_manifest_sha256": before["manifest_sha256"], + "runner_overrides": {"HERE": str(evidence), "TIMEOUT": INNER_TIMEOUT}, + "sampled_process_group_rss_bytes_cap": RSS_CAP, + "execution_phase_aggregate_seconds": 600, "registered_outer_timeout_seconds": 180, + "fresh_private_stage_permissions_restored": False, + "automatic_retries": 0, "fixed_benchmark_sample": False, + "hosted_performance_factor_claim": False, + "cost_scope": "Publication authentication, private copy, mode restoration and cleanup are additional correctness-wrapper costs, not replacement performance samples."} + receipt_path = evidence / "PUBLICATION-REPLAY.json" + receipt_path.write_text(json.dumps(publication, indent=2, sort_keys=True) + "\n") + old_argv = sys.argv[:] + try: + stage = _copy_stage(evidence, before["stage"]) + publication["fresh_private_stage_permissions_restored"] = True + (evidence / "control").mkdir() + (evidence / "control/EXECUTION-PHASE.json").write_text(json.dumps({ + "phase": "PUBLICATION_CORRECTNESS_ONLY", "aggregate_cap_seconds": 600, + "single_job": True, "no_performance_selection": True}, sort_keys=True) + "\n") + runner = source_module("_h25_frozen_publication_runner", stage / "run_guarded.py", RUNNER_SHA256) + runner.HERE = evidence + runner.TIMEOUT = INNER_TIMEOUT + need(runner.RSS_CAP == RSS_CAP, "Frozen one-GiB process-group limit") + sys.argv = [str(stage / "run_guarded.py"), "v4", job, "replay"] + runner.main() + guard_path = evidence / "runtime/runs/replay/receipt.json" + scientific_path = evidence / "runtime/runs/replay/science/receipt.json" + guard = json.loads(guard_path.read_text()) + science = json.loads(scientific_path.read_text()) + _check_scientific(job, guard, science) + _stage_inventory(stage, before["stage"], True) + need(authenticate() == before, "Publication bytes/modes changed during correctness replay") + publication.update(status="PASS", package_bytes_and_modes_unchanged=True, + guard_receipt_sha256=digest(guard_path), scientific_receipt_sha256=digest(scientific_path)) + receipt_path.write_text(json.dumps(publication, indent=2, sort_keys=True) + "\n") + return {"publication": publication, "guard": guard, "scientific": science, "evidence": str(evidence)} + except BaseException as error: + publication.update(status="FAIL", exception_type=type(error).__name__, exception=str(error)) + receipt_path.write_text(json.dumps(publication, indent=2, sort_keys=True) + "\n") + error.add_note("Publication replay evidence retained at " + str(evidence)) + raise + finally: + sys.argv = old_argv diff --git a/research/h25-bookkeeping/check_artifacts.py b/research/h25-bookkeeping/check_artifacts.py new file mode 100644 index 0000000000..7d26225c5c --- /dev/null +++ b/research/h25-bookkeeping/check_artifacts.py @@ -0,0 +1,36 @@ +"""Authenticate v4 and invoke its unchanged six-payload canonical transport check.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent +pins = json.loads((ROOT / "CODE-SOURCES.json").read_text())["files"] +for name in ("check_artifacts.py", "archive_support.py"): + if sha256((ROOT / name).read_bytes()).hexdigest() != pins[name]: + raise ValueError("Publication bootstrap source pin: " + name) +S = types.ModuleType("_h25_transport_support") +S.__file__ = str(ROOT / "archive_support.py") +exec(compile((ROOT / "archive_support.py").read_bytes(), S.__file__, "exec"), S.__dict__) + + +def main(): + S.need(len(sys.argv) == 1, "Fixed complete canonical transport input") + before = S.authenticate() + relative = "baseline/check_artifacts.py" + checker = S.source_module("_h25_unchanged_canonical_checker", S.PAYLOAD / relative, + before["stage"]["files"][relative]["sha256"]) + old_argv = sys.argv[:] + try: + sys.argv = [str(S.PAYLOAD / relative)] + checker.main() + S.need(S.authenticate() == before, "Publication bytes/modes changed during transport check") + finally: + sys.argv = old_argv + print(json.dumps({"status": "PASS_H25_V4_AND_CANONICAL_TRANSPORT", "stage_sha256": S.STAGE_SHA256, + "scientific_replay": False, "new_performance_factor_claim": False}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/evidence/INPUT-COMMIT.json b/research/h25-bookkeeping/evidence/INPUT-COMMIT.json new file mode 100644 index 0000000000..97271ce921 --- /dev/null +++ b/research/h25-bookkeeping/evidence/INPUT-COMMIT.json @@ -0,0 +1,112 @@ +{ + "all_modes": "100644", + "base": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "commit": "26056452f06097eae4b5b502245f8bb6d3818c61", + "diff": { + "added": 97, + "deleted": 0, + "modified": 0 + }, + "files": { + "research/h25-bookkeeping/CPYTHON-LICENSE.txt": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "research/h25-bookkeeping/evidence/revisions/v1/STAGE.json": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "research/h25-bookkeeping/evidence/revisions/v2/STAGE.json": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "research/h25-bookkeeping/evidence/revisions/v3/STAGE.json": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json": "73a19dd6b7edfea707d1a809a6c5b65b86bfc8303e0e7846c6cfa08e59548f13", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json": "32eb9da6703a5f4b4552f7f15f31960b2b39d5c88eda8d98631dc1dd192cacd7", + "research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json": "34c359652aa4d0bf18a54035ab7c6a69bf376dfebc25a52bd677546ceb121830", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json": "08472c32752b9efb61ec9df18a1d608475c2e992a026036ae61b27cdb8f56386", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json": "743878514b9544ddaa8146cdfe1ccd94b462add6c1918bef721518177e853bfc", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json": "c6bfed16508860931a70cfa122defb2064955df0b3cb5dd8b078c8fd4e226530", + "research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json": "97bb2b6707e9fc467e3d31eb9f7073af95edc9b416e768b6857c867208020e7c", + "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json": "7a0198be16b8b1de498a2a29c49d83876d6ef87dc9ef7c27d959a1554d62a508", + "research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json": "0dfd9a7fe9518274a3b04fa755bc5a32082decf2b6787ec01b44ef411eedb919", + "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json": "d628c5dd8b80494fb1685fd94f78cddd3ddf6477e76a7efcd041791699731f53", + "research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json": "0c17246c4b14189adc02627d439123b05f2933b5b5a85d8c69901459b6d3348f", + "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json": "29aff35432c14876b164f87112facf8e594217947086a37bc7c073db32d222b8", + "research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json": "dd88c61c042b3026182704c3d380defd53d69755b5c42a79a9fbc56e224d07f7", + "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json": "4deafb884314517f5291b9b02715eb6dc5df68a45f8274ec466ab9938784d0ab", + "research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json": "1b5cea72a0e9a2e023e4bf77e9f8b224048da8ebe31cf357ffd9994de32145ff", + "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json": "a349c7b5403c9b5bfc8a30a87de1c7334a8dac2fd9a4df92bcc82d183623a6b4", + "research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json": "e8ce0cadb455309e57d6dc650d2ab654d9424c397ca67b69420e79af5201698b", + "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json": "e27774f6bd0671da631b8b9b2aca22a24d2fa85d00bde48b6a7ce52c37cfb12c", + "research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json": "9a252ddad438c6539807181d728f833bedf093c839bf1e84fe7b9d12364e27e9", + "research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json": "5af1f03fc8101bf126132a4be017033ae41d0dcade69da797e2c22483005e495", + "research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json": "5b24ea2b4f5b1de1534c0501d4377d40cd947184fd56da1d2c1fac3e7beb6ad1", + "research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json": "1933791e7554434c85938ee4e20069ea122b9666c47df93c14648c63d77afd72", + "research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json": "b46aacb01b7db8d518da7a9193d525f2a65148d261be0c167c36518f53a5f2a1", + "research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json": "56004f2e61d009b37f2db6b9c98d70d81bfdd50537fd543285129ae00a091be3", + "research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json": "eb1d9d9546b639fad9024b5dc5d4a177d2585590f0c02530e69d96cef5e1de34", + "research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json": "120d49905ad03e7f0ca20768113f0b283b98620e6140925b387836ef558b4e69", + "research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json": "c8dabe911cfa72008ae39bc267806a24af7c622ecd6595dd247fe281b6c8afc6", + "research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json": "c3229cb8e4484730d41bc5253b024df3b32655777cae76802d94958078bb66d8", + "research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json": "d59416d75401f76e69b7638aac4c294c47a91b224166bcb7ffb149aa717101f5", + "research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json": "9b6d0f65acdb78ac02499c0e2c57d5fc78e3e71083f06657a187a4aa821cd50a", + "research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json": "b4ee7896dec5a900f45026cf93bd81f9af7805c9b51f769cdd1fdbf467fea699", + "research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json": "7b3d7d427d2d06a9d6e436454d1ef7623e0f8ad50a0a23a0ec0d2ec0fc12b788", + "research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json": "c9345eb1ff8fdf2607832b39bb4c1b51fe6f1c03db3c4ebfe463900cded6bff5", + "research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json": "b6e9a8dc8bc89b473b2b98995f4d0aa4c08b286df22bbc122255731ecf577934", + "research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json": "bb07ee0af583165a8a67a08edc5576c25f63c3103a6cefcc3643bfc71ff9dd89", + "research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json": "1e839f0e4de437b59f428213922b03e090c5794973c7a6fc763a512da9c2c0fd", + "research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json": "dc41582760b650c17ebd6fc8591be5ea4685d1a5aa0b0b005de4bb15477233bf", + "research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json": "e07bee3ecf50f5f2cd77910763f65d05baaea1ad3be50c5282a4e96b74b6ce15", + "research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json": "ed60c889422cd98c2b525b6d5f731a01e8f6e0f8dfdb0de8d61c52912f591495", + "research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json": "4f939f3897dbedeeed8a2ac0078eb24cb0c1cf7034e50f2dc60cf60dcfc2c235", + "research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json": "a0bfabd6785e7dc2248fdf85e0769965bfac5916444c368ded1280f79bd944a5", + "research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json": "93eeaed9de3af3655d285ce2c2c92f844f73ae3646a9271e8b322d29a986bf19", + "research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json": "98c77d54333878fc4cc833f36390d3f0deda472e342d572c525c8b99dfb45fe3", + "research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json": "5fca5cf80da96781c4e2ad112abee94a982341238f7fe9f38e0f6305c23fb43d", + "research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json": "fcc04985b75c9df1345ccc87fd508a5d6a17f5540ef88f064e6a21d9d4172e9b", + "research/h25-bookkeeping/evidence/validation/RUN-INDEX.json": "cfcc237d5267c0edc8eb4658d349aff9445044ff42cc17f0cbdc50f02772f3e0", + "research/h25-bookkeeping/payload/STAGE.json": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "research/h25-bookkeeping/payload/baseline/anchor.json": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "research/h25-bookkeeping/payload/baseline/engine/finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "research/h25-bookkeeping/payload/baseline/engine/native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "research/h25-bookkeeping/payload/baseline/engine/native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/07-resampling.tex": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/08-assembly.tex": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/formalization.yaml": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "research/h25-bookkeeping/payload/baseline/full_driver.py": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "input_count": 97, + "publication": "NOT_PUSHED", + "sparse_staging": "Exact97 approved paths staged with --sparse -f to include historical ignored build reference files; no ignore/sparse rules changed" +} diff --git a/research/h25-bookkeeping/evidence/control/ADMISSION-REVIEW-PROVENANCE.json b/research/h25-bookkeeping/evidence/control/ADMISSION-REVIEW-PROVENANCE.json new file mode 100644 index 0000000000..51c01e3fbb --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/ADMISSION-REVIEW-PROVENANCE.json @@ -0,0 +1,12 @@ +{ + "final_source_binding": "Final review independently admits P1eeeead... and760f... controls and unchanged integration/runner, matching source-frozen v4; final normal/O union and six raw complete runs bind actual source via STAGE and guard receipts.", + "intermediate_review_status": "Captured while the reviewer was finalizing its mutable report; that intermediate text snapshot was not separately retained and is not presented as a resolvable final review artifact. Original admission remains unchanged.", + "no_scientific_code_or_samples_changed": true, + "original_admission": "control/COMBINED-ADMISSION-v4.json", + "original_admission_sha256": "bdf1788478dd6e97eba1b4a664a2d04faf5660470b77d49bcf261fe57f700fa5", + "recorded_intermediate_review_sha256": "510ff81211fa3df758fe8acd8ea738b679003456b0db7bfb8887cba046542ea5", + "resolvable_final_review_snapshots": { + "control/admissions/v4-final/IMPLEMENTATION-REVIEW.json": "c6b2355b9e36738025787021114181e5b9e23b24f6df0e1e1f57dc57912d61a5", + "control/admissions/v4-final/IMPLEMENTATION-REVIEW.md": "751557dc95f0d19ae1d7ecc582ce1c01e3700dc66f292c05541d91ceec22f31e" + } +} diff --git a/research/h25-bookkeeping/evidence/control/BASELINE-INTAKE.json b/research/h25-bookkeeping/evidence/control/BASELINE-INTAKE.json new file mode 100644 index 0000000000..878931e3ec --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/BASELINE-INTAKE.json @@ -0,0 +1,635 @@ +{ + "actual_files": 125, + "files": { + "CODE-SOURCES.json": { + "bytes": 15321, + "mode": 292, + "sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7" + }, + "README.md": { + "bytes": 7441, + "mode": 292, + "sha256": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64" + }, + "SOURCE-PINS.json": { + "bytes": 4016, + "mode": 292, + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" + }, + "SOURCES.json": { + "bytes": 25055, + "mode": 292, + "sha256": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a" + }, + "TASK.json": { + "bytes": 3716, + "mode": 292, + "sha256": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38" + }, + "VALIDATION.json": { + "bytes": 12629, + "mode": 292, + "sha256": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a" + }, + "VERIFY.json": { + "bytes": 4326, + "mode": 292, + "sha256": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78" + }, + "anchor.json": { + "bytes": 1926, + "mode": 292, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "archive_support.py": { + "bytes": 2122, + "mode": 292, + "sha256": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f" + }, + "check_artifacts.py": { + "bytes": 4735, + "mode": 292, + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "engine/compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "engine/finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "engine/native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "engine/native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "engine/profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "engine/source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "engine/source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "evidence/COMPLETE-GATE.json": { + "bytes": 3753, + "mode": 292, + "sha256": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b" + }, + "evidence/ENVIRONMENT.json": { + "bytes": 478, + "mode": 292, + "sha256": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384" + }, + "evidence/FIRST-PAIR-GATE.json": { + "bytes": 2751, + "mode": 292, + "sha256": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc" + }, + "evidence/FULL-PAIR-ADMISSION.json": { + "bytes": 1118, + "mode": 292, + "sha256": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829" + }, + "evidence/INDEPENDENT-REVIEW.md": { + "bytes": 9330, + "mode": 292, + "sha256": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f" + }, + "evidence/INPUT-COMMIT.json": { + "bytes": 5098, + "mode": 292, + "sha256": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b" + }, + "evidence/LOCAL-INPUT-INDEX-STOP.json": { + "bytes": 409, + "mode": 292, + "sha256": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa" + }, + "evidence/PLAN.json": { + "bytes": 2688, + "mode": 292, + "sha256": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813" + }, + "evidence/PROFILE-v1-FAILURE.json": { + "bytes": 414, + "mode": 292, + "sha256": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f" + }, + "evidence/RESULTS.md": { + "bytes": 3273, + "mode": 292, + "sha256": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f" + }, + "evidence/SOURCE-DESIGN.md": { + "bytes": 7474, + "mode": 292, + "sha256": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb" + }, + "evidence/UPSTREAM-REFRESH.json": { + "bytes": 1590, + "mode": 292, + "sha256": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693" + }, + "evidence/canonical/MANIFEST.json": { + "bytes": 1912, + "mode": 292, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "evidence/canonical/complement-transcript.json": { + "bytes": 227, + "mode": 292, + "sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "evidence/canonical/complex-network.json": { + "bytes": 5662, + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "evidence/canonical/full-return.lossless.json.gz": { + "bytes": 2360, + "mode": 292, + "sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "evidence/canonical/original-stdout.txt": { + "bytes": 137, + "mode": 292, + "sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "mode": 292, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "mode": 292, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "evidence/publication-v1-failure/REVISION.json": { + "bytes": 559, + "mode": 292, + "sha256": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8" + }, + "evidence/publication-v1-failure/receipt.json": { + "bytes": 1090, + "mode": 292, + "sha256": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a" + }, + "evidence/publication-v1-failure/stderr.txt": { + "bytes": 1638, + "mode": 292, + "sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515" + }, + "evidence/publication-v1-failure/stdout.txt": { + "bytes": 947, + "mode": 292, + "sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342" + }, + "evidence/publication-v1-failure/usage.json": { + "bytes": 120, + "mode": 292, + "sha256": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc" + }, + "evidence/publication-v1-failure/verify_full.py.txt": { + "bytes": 1529, + "mode": 292, + "sha256": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e" + }, + "evidence/runs/full-network-B1/receipt.json": { + "bytes": 1037, + "mode": 292, + "sha256": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27" + }, + "evidence/runs/full-network-B1/scientific-receipt.json": { + "bytes": 14581, + "mode": 292, + "sha256": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31" + }, + "evidence/runs/full-network-B1/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-B1/stdout.txt": { + "bytes": 3665, + "mode": 292, + "sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43" + }, + "evidence/runs/full-network-B1/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505" + }, + "evidence/runs/full-network-B2/receipt.json": { + "bytes": 1037, + "mode": 292, + "sha256": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d" + }, + "evidence/runs/full-network-B2/scientific-receipt.json": { + "bytes": 14583, + "mode": 292, + "sha256": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7" + }, + "evidence/runs/full-network-B2/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-B2/stdout.txt": { + "bytes": 3667, + "mode": 292, + "sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d" + }, + "evidence/runs/full-network-B2/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891" + }, + "evidence/runs/full-network-B3/receipt.json": { + "bytes": 1036, + "mode": 292, + "sha256": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506" + }, + "evidence/runs/full-network-B3/scientific-receipt.json": { + "bytes": 14602, + "mode": 292, + "sha256": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495" + }, + "evidence/runs/full-network-B3/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-B3/stdout.txt": { + "bytes": 3686, + "mode": 292, + "sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe" + }, + "evidence/runs/full-network-B3/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8" + }, + "evidence/runs/full-network-C1/receipt.json": { + "bytes": 1036, + "mode": 292, + "sha256": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934" + }, + "evidence/runs/full-network-C1/scientific-finite-controls.json": { + "bytes": 1595, + "mode": 292, + "sha256": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342" + }, + "evidence/runs/full-network-C1/scientific-receipt.json": { + "bytes": 17953, + "mode": 292, + "sha256": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8" + }, + "evidence/runs/full-network-C1/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-C1/stdout.txt": { + "bytes": 3947, + "mode": 292, + "sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd" + }, + "evidence/runs/full-network-C1/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84" + }, + "evidence/runs/full-network-C2/receipt.json": { + "bytes": 1037, + "mode": 292, + "sha256": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73" + }, + "evidence/runs/full-network-C2/scientific-finite-controls.json": { + "bytes": 1598, + "mode": 292, + "sha256": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969" + }, + "evidence/runs/full-network-C2/scientific-receipt.json": { + "bytes": 17972, + "mode": 292, + "sha256": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c" + }, + "evidence/runs/full-network-C2/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-C2/stdout.txt": { + "bytes": 3963, + "mode": 292, + "sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c" + }, + "evidence/runs/full-network-C2/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886" + }, + "evidence/runs/full-network-C3/receipt.json": { + "bytes": 1036, + "mode": 292, + "sha256": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce" + }, + "evidence/runs/full-network-C3/scientific-finite-controls.json": { + "bytes": 1589, + "mode": 292, + "sha256": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237" + }, + "evidence/runs/full-network-C3/scientific-receipt.json": { + "bytes": 17954, + "mode": 292, + "sha256": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb" + }, + "evidence/runs/full-network-C3/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-C3/stdout.txt": { + "bytes": 3954, + "mode": 292, + "sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0" + }, + "evidence/runs/full-network-C3/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb" + }, + "evidence/runs/full-network-profile-v1/receipt.json": { + "bytes": 1077, + "mode": 292, + "sha256": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c" + }, + "evidence/runs/full-network-profile-v1/stderr.txt": { + "bytes": 3199, + "mode": 292, + "sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76" + }, + "evidence/runs/full-network-profile-v1/stdout.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-profile-v1/usage.json": { + "bytes": 118, + "mode": 292, + "sha256": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78" + }, + "evidence/runs/full-network-profile-v2/receipt.json": { + "bytes": 1049, + "mode": 292, + "sha256": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf" + }, + "evidence/runs/full-network-profile-v2/scientific-receipt.json": { + "bytes": 14657, + "mode": 292, + "sha256": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a" + }, + "evidence/runs/full-network-profile-v2/stderr.txt": { + "bytes": 0, + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/full-network-profile-v2/stdout.txt": { + "bytes": 3705, + "mode": 292, + "sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec" + }, + "evidence/runs/full-network-profile-v2/usage.json": { + "bytes": 82, + "mode": 292, + "sha256": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b" + }, + "frozen/scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "frozen/scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "frozen/scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "frozen/scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "frozen/scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "frozen/scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "frozen/scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "frozen/scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "frozen/scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "frozen/scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "frozen/scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "frozen/scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "frozen/upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "frozen/upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "frozen/upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "frozen/upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "frozen/upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "frozen/upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "frozen/upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "frozen/upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "frozen/upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "frozen/upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "frozen/upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "frozen/upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "frozen/upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "frozen/upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "frozen/upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "frozen/upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "frozen/upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "frozen/upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "frozen/upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "frozen/upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + }, + "full_B.py": { + "bytes": 584, + "mode": 292, + "sha256": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8" + }, + "full_C.py": { + "bytes": 585, + "mode": 292, + "sha256": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4" + }, + "full_driver.py": { + "bytes": 20178, + "mode": 292, + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" + }, + "guard.py": { + "bytes": 5090, + "mode": 292, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "reference/certificates/complex-network.json": { + "bytes": 5662, + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "reference/certificates/selected-result.json": { + "bytes": 6419, + "mode": 292, + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "replay.py": { + "bytes": 2731, + "mode": 292, + "sha256": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90" + }, + "verify.py": { + "bytes": 2216, + "mode": 292, + "sha256": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b" + }, + "verify_full.py": { + "bytes": 1804, + "mode": 292, + "sha256": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + } + }, + "legacy_manifest_file_count_field": 117, + "manifest_entries_verified": 123, + "manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "source_archive_sha256": "85f237491523c1c7c0776e829432f785e12a4b06a0e9a8d376bb685d7aa4c068", + "source_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6" +} diff --git a/research/h25-bookkeeping/evidence/control/BASELINE.json b/research/h25-bookkeeping/evidence/control/BASELINE.json new file mode 100644 index 0000000000..9ca5f27992 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/BASELINE.json @@ -0,0 +1,11 @@ +{ + "pr": 5995, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "arm": "PR5995 native C configuration with all original qualification controls; NOT the older Python-only arm", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "historical_wall_median": 28.63625624598353, + "historical_cpu_median": 28.46, + "historical_times_are_orientation_only": true, + "new_performance_claim_requires_fresh_same_session_baseline": true +} diff --git a/research/h25-bookkeeping/evidence/control/COMBINED-ADMISSION-v4.json b/research/h25-bookkeeping/evidence/control/COMBINED-ADMISSION-v4.json new file mode 100644 index 0000000000..c9c9ca9a2f --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/COMBINED-ADMISSION-v4.json @@ -0,0 +1,11 @@ +{ + "P1_adapter_sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "P1_controls_sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "all_old_and_new_controls_paid": true, + "baseline": "PR5995 native C4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "review_sha256": "510ff81211fa3df758fe8acd8ea738b679003456b0db7bfb8887cba046542ea5", + "scientific_spent_before_seconds": 177.46565306693083, + "selection_reason": "All3 original variants pass complete individual pilots; narrowly reviewed source-only exact Fraction portability policy now requires fresh complete new-control union", + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "SOURCE_ADMITTED_FOR_COMBINED_NORMAL_O_FINITE_UNION" +} diff --git a/research/h25-bookkeeping/evidence/control/ENVIRONMENT.json b/research/h25-bookkeeping/evidence/control/ENVIRONMENT.json new file mode 100644 index 0000000000..1e0d5aade0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/ENVIRONMENT.json @@ -0,0 +1,16 @@ +{ + "compiler_version_first_line": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", + "configured_compiler": "x86_64-linux-gnu-gcc", + "full_assertions_required": true, + "implementation": "cpython", + "new_round_wall_spent_before_combination": 177.46565306693083, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "processor": "Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "required_hash_seed": "0", + "required_locale": "C.UTF-8", + "required_timezone": "UTC", + "scientific_executable": "/usr/bin/python3.12", + "setup_inspection_executable": "/usr/bin/python3", + "source_only_environment_inspection_no_compilation_or_scientific_import": true +} diff --git a/research/h25-bookkeeping/evidence/control/EXECUTION-PHASE.json b/research/h25-bookkeeping/evidence/control/EXECUTION-PHASE.json new file mode 100644 index 0000000000..0a531abbd0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/EXECUTION-PHASE.json @@ -0,0 +1,9 @@ +{ + "phase": "INITIAL_FEASIBILITY", + "aggregate_cap_seconds": 600, + "total_round_cap_seconds": 1500, + "per_command_seconds": 180, + "sampled_process_group_rss_bytes": 1073741824, + "all_failed_attempts_count": true, + "scientific_runs_started": 0 +} diff --git a/research/h25-bookkeeping/evidence/control/FINITE-ADMISSION-v1.json b/research/h25-bookkeeping/evidence/control/FINITE-ADMISSION-v1.json new file mode 100644 index 0000000000..bc70eed31a --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/FINITE-ADMISSION-v1.json @@ -0,0 +1,19 @@ +{ + "all_runs_parent_only": true, + "files": { + "integration/adapters.py": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72", + "integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "priorities/runtime-guards/guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "priorities/runtime-guards/guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291", + "run_guarded.py": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + }, + "initial_cap_seconds": 600, + "reviewer": "bookkeeping_review GPT6astra xhigh", + "scientific_spent_before_seconds": 0, + "source_review_findings_resolved": [ + "new selected source custody paid inside scientific process", + "finite immutable/copied custody rechecked", + "independent original observer kept for old controls" + ], + "status": "P2_ONLY_NORMAL_AND_O_SOURCE_ADMITTED" +} diff --git a/research/h25-bookkeeping/evidence/control/IMPLEMENTATION-ADMISSION.json b/research/h25-bookkeeping/evidence/control/IMPLEMENTATION-ADMISSION.json new file mode 100644 index 0000000000..8a0d4dca7a --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/IMPLEMENTATION-ADMISSION.json @@ -0,0 +1,13 @@ +{ + "status": "AUTHORIZE_PARALLEL_SOURCE_IMPLEMENTATION_ONLY", + "time_utc": "2026-10-27T21:15:01.246837+00:00", + "basis": "All three primary proposals and call budgets independently source-reviewed; full code, finite correctness and complete-cost gates remain", + "independent_review_sha256": "6e7834e68d10c4ca3bb34a6983a0dcb9c5ba7a108f6a306dd899bd3d6375d5b5", + "P1": "Invocation-private sets; literal prefix/fallback; parent one-use frozen-caller lease and explicit cleanup; no loop fusion", + "P2": "Python identity-only record dedup and equivalent inline failure-only raises; every distinct fresh check at same boundary", + "P3": "Stateless checked native canonical encoder with literal JSON fallback; immediate hash/count/bytes; source-bound native-entry freshness", + "parent_owns_shared_interfaces": true, + "scientific_execution_authorized_to_workers": false, + "new_round_spent_seconds": 0, + "all_new_controls_must_be_billed": true +} diff --git a/research/h25-bookkeeping/evidence/control/INDIVIDUAL-PILOT-SEQUENCE.json b/research/h25-bookkeeping/evidence/control/INDIVIDUAL-PILOT-SEQUENCE.json new file mode 100644 index 0000000000..ca4d77b7f8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/INDIVIDUAL-PILOT-SEQUENCE.json @@ -0,0 +1,17 @@ +{ + "status": "P2_FIRST_AFTER_NORMAL_O_FINITE_PASS", + "sequence": [ + "P2-B", + "P2-C", + "P3-B", + "P3-C", + "P1-B", + "P1-C" + ], + "each_pair_requires_lane_finite_and_source_admission": true, + "baseline": "PR5995 native C with unchanged independent controls and exact observations", + "candidate_pays_all_new_controls": true, + "samples_are_pilots_not_qualified_factors": true, + "stop_on_output_source_resource_failure": true, + "no_automatic_retry_or_timing_reroll": true +} diff --git a/research/h25-bookkeeping/evidence/control/PUBLICATION-UPSTREAM-REFRESH.json b/research/h25-bookkeeping/evidence/control/PUBLICATION-UPSTREAM-REFRESH.json new file mode 100644 index 0000000000..ccc8c8ae18 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/PUBLICATION-UPSTREAM-REFRESH.json @@ -0,0 +1,18 @@ +{ + "main": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "method": "Fresh public canonical git fetch after qualification; unchanged from planning snapshot, so same guidance blobs apply", + "priority_revision": 8, + "scientific_baseline_not_migrated": true, + "source_claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/5995#issuecomment-6453885187", + "live_overlap_refresh": { + "browser": "Chrome3", + "query": "is:pr is:open H25", + "visible_open_prs": [ + 5995, + 5972, + 5929 + ], + "result": "No new H25 PR title overlap beyond known predecessors in this bounded query; not exhaustive novelty proof", + "source_claim_in_place": true + } +} diff --git a/research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json b/research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json new file mode 100644 index 0000000000..bd5ea62383 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/QUALIFICATION-v4.json @@ -0,0 +1,45 @@ +{ + "automatic_retry_or_timing_reroll": false, + "cold_fresh_process_each": true, + "complete_new_controls_and_cold_builds_inside_candidate": true, + "first_pair_gate": "Exact science/custody/resources must pass and both wall/CPU target must remain credible; otherwise stop and retain pair", + "input_reference": "Immutable baseline science anchor; original driver digest authenticated separately from actual derived driver", + "no_new_hash_schema_or_precision": true, + "noise_gate": "medianB-medianC>max(rangeB,rangeC) separately for both metrics", + "performance_gate": "medianC<=0.85*medianB separately for complete wall and GNUtime user+system CPU", + "required_before_first_pair": [ + "combined normal finite PASS", + "combined O finite PASS", + "all3 final sources independently reviewed" + ], + "retain_every_sample_and_failure": true, + "schema": "h25-bookkeeping-predeclared-combined-qualification-v1", + "sequence": [ + { + "job": "full-none", + "label": "qual-B1" + }, + { + "job": "full-all", + "label": "qual-C1" + }, + { + "job": "full-all", + "label": "qual-C2" + }, + { + "job": "full-none", + "label": "qual-B2" + }, + { + "job": "full-none", + "label": "qual-B3" + }, + { + "job": "full-all", + "label": "qual-C3" + } + ], + "stage": "v4", + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/control/UPSTREAM-REFRESH.json b/research/h25-bookkeeping/evidence/control/UPSTREAM-REFRESH.json new file mode 100644 index 0000000000..7c0a242856 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/UPSTREAM-REFRESH.json @@ -0,0 +1,24 @@ +{ + "canonical_main": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "fetched_utc": "2026-10-27T20:57:20.574532+00:00", + "files": { + "AGENTS.md": "fbee67ab9e0ae4629a35fd9dba69c8f7e29e4a15392eb2d0f75d8768ffb65f40", + "CONTRIBUTING.md": "fcd1a8d0e52342a23b8ffa9e905e85ccc539fb084145ef016dfc93cedfb3d924", + "autoresearch.md": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d", + "docs/research/current-priorities.md": "70f61c8d140ae6e892f2b8f065bba4eae3e76f7a8f55f632fd4e2f9f34039bdc", + "docs/research/agent-task-catalog.json": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "priority_revision": 8, + "live_Chrome_overlap": { + "checked_utc": "2026-10-27T21:01:37.429717+00:00", + "open_H25_PRs": [ + 5995, + 5972, + 5929 + ], + "discussion_query": "is:open bookkeeping", + "discussion_result_scope": "Seven broad discussion results; no separate exact three-priority claim observed in bounded result titles; title-only coverage is not proof of novelty", + "coverage_limit": "Bounded live searches, not exhaustive; refresh before implementation pivot and submission" + } +} diff --git a/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.json b/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.json new file mode 100644 index 0000000000..48fa627262 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.json @@ -0,0 +1,199 @@ +{ + "schema_version": 1, + "review_date": "2026-10-28", + "review_kind": "source-only", + "scientific_execution_by_reviewer": false, + "lane_sources": { + "P1": { + "set_reuse.py": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "initial_finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "finite_set_controls.py": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "revision_3_set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "revision_3_finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "P2": { + "guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "P3": { + "trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + } + }, + "integration_sources": { + "integration/adapters.py": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94", + "integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "integration/derive_driver.py": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a", + "integration/DERIVATION.json": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256", + "run_guarded.py": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + }, + "source_decisions": { + "P1": "ADMIT_REVISION_4_SERIAL_COMBINED_NORMAL_AND_OPTIMIZED_FINITE_UNION", + "P2": "ADMIT_COMPLETE_PILOT_AFTER_REPORTED_FINITE_PASSES", + "P3": "ADMIT_COMPLETE_PILOT_AFTER_REPORTED_FINITE_PASSES", + "combination": "ADMIT_SERIAL_FINITE_UNION_ON_FRESH_IMMUTABLE_REVISION_4_SOURCES" + }, + "integration_invariants": [ + "Both arms original native C configuration", + "Actual derived driver digest separate from original reference driver pin", + "Original scientific anchor unchanged", + "Original observer retained for old finite controls", + "Candidate trace explicit before bind", + "ExtendedGuard entries set before base constructor checks", + "Five pre-arithmetic encoder drift actions including wide fallback", + "P1 installed before phase wrappers and sealed afterward", + "Private constructor identity captures and CLI arm/disarm", + "Timed new-source custody before imports and finite/full receipts", + "Finite original/copied inventories rechecked", + "Parent serial lock and immutable stage ledger" + ], + "reported_observations": { + "provenance": "Parent messages; not independently replayed or receipt-audited by this reviewer", + "P2_finite": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds_approx": 1.78, + "optimized_wall_seconds_approx": 2.04 + }, + "P2_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 27.9081, + "C": 25.7346 + }, + "cpu_seconds": { + "B": 27.79, + "C": 25.62 + }, + "exact_science_equal": true, + "qualified_factor": false + }, + "P3_finite": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds_approx": 1.85, + "optimized_wall_seconds_approx": 2.22 + }, + "P3_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 27.0782, + "C": 25.0697 + }, + "cpu_seconds": { + "B": 27.01, + "C": 24.98 + }, + "qualified_factor": false + }, + "P1_finite": { + "normal": "PASS", + "normal_wall_seconds": 2.419, + "optimized_initial": "STOP", + "optimized_initial_wall_seconds": 2.8227, + "failure": "Collision fixture did not reach custom equality", + "failure_retained_and_charged": true, + "revision_3": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds": 2.4495, + "optimized_wall_seconds": 2.5654 + } + }, + "P1_revision_3_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 28.38259, + "C": 25.1397 + }, + "qualified_factor": false, + "qualifies_revision_4": false + } + }, + "P1_repair": { + "status": "SOURCE_APPROVED_AND_PARENT_REPORTED_BOTH_FINITE_MODES_PASS", + "scope": "control only", + "reason": "Original collision-triggering tail lookup is inside assert and disappears under -O", + "minimal_change": "Require nonempty callback log only when not sys.flags.optimize; retain unconditional original/candidate outcome, event-sequence, fallback and token comparisons", + "new_immutable_stage_required": true, + "complete_pilot_before_finite_passes": false, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "additional_static_repair": "All original verify_map Q calls are assertion-only; logging-Q fixture likewise requires nonempty normal events and explicitly empty optimized events with unconditional parity checks retained", + "implementation_changed": false + }, + "remaining": [ + "Fresh immutable revision 4 combined source freeze", + "Combined normal and optimized old/new finite-control union", + "Complete combined outputs and coverage", + "All new and historical costs with integration call budget", + "Fresh predeclared BCCBBC wall/CPU target and noise qualification", + "Actual hosted runtime and Fraction digest with complete correctness replay", + "Delivery and publication obligations" + ], + "performance_boundary": { + "individual_15_percent_requirement": false, + "combined_wall_reduction_minimum": 0.15, + "combined_cpu_reduction_minimum": 0.15, + "saving_must_exceed_max_within_arm_range_each_metric": true, + "add_component_percentages": false, + "goal_achieved": false + }, + "P1_portability_revision_4": { + "status": "SOURCE_APPROVED_FOR_COMBINED_FINITE_UNION", + "adapter_sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "controls_sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "allowed_sources": [ + { + "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "bytes": 38067, + "profile": "recorded-local-cpython-3.12.3" + }, + { + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "bytes": 38147, + "profile": "official-cpython-3.12.15-e848e4b09ca4bc67c0041c9ce7526dae471d4c36" + } + ], + "reviewer_checks": [ + "Exact hashes of active local file and retained official-reference file", + "Inert AST comparison changes only Fraction.__pow__", + "Whole adapter/control diff versus immutable revision 3", + "Exact source pins and actual selected digest/profile receipt", + "All prior code/descriptor/global/class/function/freshness checks unchanged", + "Integration and runner hashes unchanged", + "Existing CPython 3.12 family gate retained" + ], + "official_retrieval_provenance": "Worker retained tag/commit evidence; no second reviewer network retrieval", + "new_policy_controls": { + "known_pins": 2, + "rejected_unknown_or_nonexact": 3, + "binding_receipt_consistency": true + }, + "alternate_Fraction_source_loaded": false, + "reviewer_runtime_execution": false, + "new_costs": [ + "Fixed two-pin selection", + "Selected profile receipt allocation", + "New policy controls", + "38,147-byte retained reference source custody read/hash" + ], + "hosted_runtime_compatibility": "PENDING_ACTUAL_RUNTIME_DIGEST_NORMAL_OPTIMIZED_AND_COMPLETE_ASSERTION_ON_REPLAY", + "prior_pilot_transfer_to_revision_4": false, + "supporting_sha256": { + "PORTABILITY.md": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1", + "PORTABILITY-SOURCE.json": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82", + "SOURCE-READINESS.json": "4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556" + }, + "reference_source_custody_scope": "Selected P1 or combined candidate; baseline lanes=none does not select that directory" + }, + "execution_gate": { + "owner": "parent only", + "combined_complete_after_both_finite_modes_pass": true, + "per_process_wall_seconds": 180, + "per_process_memory_bytes": 1073741824, + "initial_campaign_wall_seconds": 600, + "total_campaign_wall_seconds": 1500, + "preserve_and_charge_failed_or_superseded_runs": true + } +} diff --git a/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.md b/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.md new file mode 100644 index 0000000000..efb62d5a09 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.md @@ -0,0 +1,73 @@ +# Independent H25 implementation and integration review + +Source review only, 2026-10-28. No reviewer scientific imports, compilation, numerical execution or source implementation edits. Parent alone owns execution. All observations below are explicitly parent-reported, not independently replayed by this reviewer. + +## Decisions and exact reviewed lane sources + +| Lane/file | SHA256 | Source disposition | +|---|---|---| +| P1 `set_reuse.py` revision 3 | `d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29` | Parent-reported complete pilot passed; retained historical source. | +| P1 `set_reuse.py` revision 4 | `eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d` | Admit fresh combined normal/optimized finite union; runtime validation pending. | +| P1 `finite_set_controls.py` initial version | `2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231` | Normal passed; optimized fixture expectation needs the bounded repair below. | +| P1 `finite_set_controls.py` revision 3 | `9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d` | Control-only repair independently reviewed; parent reports both finite modes passed. | +| P1 `finite_set_controls.py` revision 4 | `760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919` | Retains the repair and all prior controls; adds exact-pin policy and receipt consistency controls. | +| P2 `guard_candidate.py` | `320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29` | Admit finite and, following reported passes, complete pilot. | +| P2 `guard_controls.py` | `514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291` | Bounded independent behavioral controls accepted. | +| P3 `trace_encoder.c` | `57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e` | Admit finite and, following reported passes, complete pilot. | +| P3 `trace_adapter.py` | `4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60` | Same source gate. | +| P3 `trace_controls.py` | `527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447` | Original observer, exact bytes/prefix/error controls accepted. | + +P1 authenticates the source, splices the original prefix and literal fallback tail, retains both intersection loops, and uses live source globals. Parent constructor captures, final wrapper sealing, single-use reservation before the prefix, post-prefix shape/Fraction/environment checks and finally expiry implement the reviewed new whole-tail invariant. Ordinary unleased calls delegate the original once. The explicit private-list clearing and left-reference reset address traceback-retained frames. This is a scoped fresh frozen-caller contract, not generic alias or process-security proof. + +P2 preserves all distinct predicates, slot checks, short-circuit ordering, messages and original call boundaries. It deduplicates only repeated function identities. Controls reuse four bindings, with 237 mutation pairs × 7 actions and 14 stable pairs; they compare behavior rather than reimplementing the guard. Empty-cell errors, fallback entry, first failure, same-code distinct functions and shared-state restoration are covered. + +P3 retains input snapshots and original output validation, then emits a complete record through a stateless checked native call. Exact types precede direct container access, unsigned overflow is the only cleared conversion error, borrowed references remain within a GIL-held call, and one bytes allocation copies the bounded stack buffer. The adapter preserves count-read and hash/byte/count order. Primary [FASTCALL](https://docs.python.org/3.12/c-api/structures.html#c.METH_FASTCALL), [integer conversion](https://docs.python.org/3.12/c-api/long.html#c.PyLong_AsUnsignedLongLong) and [bytes ownership](https://docs.python.org/3.12/c-api/bytes.html#c.PyBytes_FromStringAndSize) documentation supports these API checks. Controls include exact record bytes, every prefix, width/type/fallback boundaries, digit-limit restoration, hash/counter failures and alias/reference behavior. + +## Integration and runner source gates + +Reviewed integration sources, rehashed unchanged for the revision 4 combination gate: + +- `integration/adapters.py`: `f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94` +- `integration/full_driver.py`: `5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1` +- `integration/derive_driver.py`: `a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a` +- `integration/DERIVATION.json`: `6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256` +- `run_guarded.py`: `b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be` + +Both new arms execute the native C configuration. The driver has its own digest and separately names the immutable original driver digest; declared literal edits and exact inverse evidence do not claim original driver bytes executed. The complete scientific anchor, original phase counts, native coverage, original controls and observer remain intact. Selected new source custody is charged inside the child before imports and before finite/full receipts. Finite returns also recheck original and copied inventories. The outer runner separately pins stage bytes/modes and preserves failures under one lock and aggregate budget. + +The initially proposed late trace-class import would have compared two candidate encoders in the old finite suite. Parent repaired this before execution: `backend.ComplementTrace` stays original; the candidate full observer is explicit; new controls compare it to the unchanged observer. + +The new native owner/entry check is installed before binding and initialized before base guard construction invokes `self.check()`. It runs at every original wrapper boundary. Five negative actions cover held guard, native Gram/complement and wide fallback Gram/complement without advancing counters or observations. Following parent-reported finite passes, source admission supports all three complete pilots. The reviewed sources are also admitted to a fresh combined finite-union stage; combined complete qualification still depends on that union passing. + +## Parent-reported observations and retained failure + +| Work | Reported outcome | Limit | +|---|---|---| +| P2 normal / optimized finite | PASS, about 1.78 / 2.04 seconds wall | Parent report; no reviewer replay. | +| P2 complete B/C pilot | PASS, wall 27.9081 → 25.7346; CPU 27.79 → 25.62 seconds; exact science agrees | Approximately 7.79% / 7.81%; one pilot, not a qualified factor. | +| P3 normal / optimized finite | PASS, about 1.85 / 2.22 seconds wall | Parent report. | +| P3 complete B/C pilot | PASS, wall 27.0782 → 25.0697; CPU 27.01 → 24.98 seconds | Approximately 7.4%; one pilot, not a qualified factor. | +| P1 normal finite | PASS, 2.419 seconds wall | Complete ownership/performance not yet established. | +| P1 optimized finite, initial control | STOP, 2.8227 seconds, collision fixture expected a callback absent under optimized assertions | Failure retained and charged. No complete P1 admission yet. | +| P1 revision 3 normal / optimized finite | PASS, 2.4495 / 2.5654 seconds wall | Parent report. | +| P1 revision 3 complete B/C pilot | PASS, wall 28.38259 → 25.13970 seconds | Parent report; about 11.43%; one pilot, not a qualified factor; does not qualify revision 4. | + +The P1 optimized failure is a control expectation issue: the original tail's collision-triggering `got.get` calls are inside an assertion removed by `-O`. Revision 3 was independently source-reviewed and approved: it keeps unconditional outcome, callback-sequence, fallback and lease comparisons, requires nonempty callbacks with assertions enabled, and explicitly requires empty callback lists under `-O`. The logging-Q fixture received the same justified correction because all original `verify_map` Q calls occur inside assertions. No controls were removed and the adapter is unchanged. Freeze a new stage before rerunning; do not erase the failed version. + +## Revision 4 Fraction source portability gate + +**ADMIT_SERIAL_COMBINED_FINITE_UNION_ON_FRESH_REVISION_4_SOURCES.** Independent source review finds no blocker in the bounded two-pin change. Hashing and inert AST comparison confirm the active local file has SHA256 `cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231` (38,067 bytes), while the retained official-reference file has SHA256 `d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0` (38,147 bytes). Only `Fraction.__pow__` differs in the AST; constructor, hash, equality, properties and `_hash_algorithm` are identical. Official tag/commit retrieval provenance is the worker's retained evidence, not a second network retrieval by this reviewer. + +The adapter uses a fixed two-entry tuple and requires an exact string before comparing its digest. Unknown digests and string subclasses still reject. It hashes the active `fractions.__file__`, selects a profile, and compares loaded functions with that source compiled locally by the running interpreter at the current optimization level. Descriptor, MRO, global, class, function and per-reservation/per-admission freshness checks are unchanged. The existing driver/native backend CPython 3.12 family gate remains unchanged. No alternate Fraction implementation is loaded by the added controls or adapter. + +The receipt now carries the actual selected `fraction_sha256` and `fraction_source_profile`, rather than a hard-coded local digest. Added controls recognize both exact pins, reject three unknown/nonexact inputs, and compare each binding receipt with the pin policy. Every revision 3 differential control and its optimized-mode repair remains. The previous local pilot is evidence for revision 3 only. + +Verified supporting file hashes: `PORTABILITY.md` = `8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1`; `PORTABILITY-SOURCE.json` = `2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82`; `SOURCE-READINESS.json` = `4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556`. + +The new pin lookup, selected-profile receipt, controls and reference-file custody belong in the complete bill. Existing custody enumerates selected `.py` sources, so retaining `cpython-3.12.15-fractions.py` adds its 38,147-byte read/hash to selected P1/combined candidate custody without executing it; the baseline with lanes=none does not select that directory. An exact-source policy pass does not establish hosted runtime compatibility: actual hosted interpreter and active Fraction digest receipts, normal/optimized finite validation and the complete assertion-on replay remain required. Hosted correctness cannot transfer local performance measurements. + +## Combination gate and remaining obligations + +The proposed order is compatible: P2 guard, then P3 extended guard; old controls keep the original observer; new P2 mutations restore before P3 native/digit mutations; those restore before P1 Fraction/hook controls. Full candidate trace exists before native binding. P1 method is installed before phase wrapping, constructor captures finish the original constructors, seal follows all class/phase wrappers, and arm/disarm bracket the authenticated CLI. + +Pending: fresh revision 4 immutable source freeze; combined normal/optimized old-and-new finite union; actual complete combined output/coverage and cost receipts; fresh predeclared B1 C1 C2 B2 B3 C3 medians and noise gates; hosted/delivery/publication checks. The combined finite-union source gate is granted, but complete qualification may proceed only after both finite modes pass. Combined call accounting must add ExtendedGuard's base-check dispatch and encoder-owner checks, plus lease/source/control/portability work. Preserve all failed and superseded stages and charge their costs. The parent remains the sole runner under the declared 180-second, 1-GiB per-process and 600-second initial/1,500-second total campaign limits. No component percentages may be added. The goal still requires at least 15% complete wall and CPU improvement, each saving exceeding both within-arm ranges. This review does not claim that target has been achieved. diff --git a/research/h25-bookkeeping/evidence/control/upstream/AGENTS.md b/research/h25-bookkeeping/evidence/control/upstream/AGENTS.md new file mode 100644 index 0000000000..fa006ceb6b --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/AGENTS.md @@ -0,0 +1,92 @@ +# Agent entry point + +For open-ended requests such as “contribute,” “use spare inference,” or +“improve the bound,” start with [autoresearch.md](autoresearch.md). It links +the current priorities and standing procedure. Check open handoffs +before using the task picker; its coverage fields identify prior checks and +remaining obligations. Explicit user tasks take precedence over that default +assignment; do not reroll an already assigned task. + +For a fresh assignment, run `python3 -B scripts/choose_current_research_task.py`. +This entry point resolves generic baseline commands and retains each frozen +card beside the current command. The historical picker and root guide stay +unchanged because research packages pin their bytes. The current command +examples are in [the standing procedure](docs/research/agent-procedure.md). + +For repeated/overnight loops, follow the +[upstream refresh checkpoint](autoresearch.md#looping-agents-refresh-upstream-at-each-research-checkpoint) +at every new round, before a major pivot and before submission. Fetch canonical +main (not an unmaintained fork), compare priority revisions, and read changed +guidance. The local task picker does not fetch updates. Preserve work in progress +and frozen evidence; start new tasks from the refreshed base. + +Default to one session of about 60 minutes unless the donor sets another budget. +For a concrete introduction, read [the bottleneck brief](docs/research/bottleneck-brief.md) +and [glossary](docs/research/research-glossary.md). Use the card's first working +example before choosing a detour. A useful finding or handoff can finish a +session; a PR is not mandatory. Read the [family status and expansion gate](docs/research/research-family-status.md) +before extending a mechanism: newer pending work may change the missing task, +and a local improvement does not by itself justify another construction round. +Partial contributions remain welcome; the director owns the complete budget. + +Before substantial research, read the +[discussion-board start here](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163) +and check [active discussions](https://github.com/CrocSwap/integer-mult-bounds/discussions) +alongside open PRs for overlap. Use the +[handoff thread](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +for concrete requests and the +[mechanism-proposals thread](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167) +for early ideas. Follow the claim/update conventions in `autoresearch.md`; +claims are advisory and discussion posts are provisional evidence. Keep one +canonical investigation thread with a current status and public artifact link; +use hub threads for short pointers. Local-only evidence must be labelled, and +useful partial/negative results do not need a new κ to merit a focused PR. + +Use `python3 scripts/find_overlap.py --task TASK_ID` for a cached search of PR +bodies, discussions and local package notes. The report states its coverage and +freshness; no matches is not proof of novelty. If changing a card's premise, +record the scope change and why the new question matters. + +When acting as an authorized maintainer/director and reassessing research +direction, follow the [priority-review procedure](autoresearch.md#6-maintainerdirector-priority-review). +Update the task catalogue and evidence log together; do not infer a new frontier +or a universal barrier from assignment weights or unreviewed discussion claims. + +Read [CONTRIBUTING.md](CONTRIBUTING.md) before making changes. Resolve the current +result, review, source manifest and reproduction command through +`certificates/selected-result.json`. Historical research notes may use “current” +for an obsolete checkpoint. + +For authorized maintainer PR work, **first follow [delta-only queue intake](docs/research/pr-intake.md)**. +Run `python3 scripts/pr_intake.py plan --refresh --output /tmp/pr-intake-plan.json`. +Read selected actionable entries; do not rereview unchanged holds, recreate +100-entry audit packages, or rerun historical suites after compaction. Persist +changed scheduling decisions in `docs/research/pr-intake-state.json` and actual +review evidence in the central ledger. This scheduling procedure takes precedence +over older batch recipes. No automatic Lean, Docker, or concurrent heavy replays. +See [research archive status](docs/research/research-archive-intake.md) for acceptance +rules: a merged archive can remain **partially reviewed**; merging is not scientific +approval or a selected-frontier update. + +Keep `upstream/`, frozen source archives and pinned evidence unchanged. Put new +research in its own scoped directory and retain predecessor attribution. +Distinguish a finite certificate, a scoped proof, a search failure and a complete +multiplication theorem. They are different claims. + +Use an isolated branch/worktree when sharing a checkout. Run checks relevant to +the change; do not run concurrent artifact-regenerating suites in one worktree. +Record exact sources, commands, environments and any unrun proof obligations. + +The standard donation prompt authorizes routine Discussion participation and +opening focused PRs. When that prompt is the user's assignment, post claims, +questions, findings, handoffs and feedback without asking again for each post; +the same applies to opening the contribution PR. Respect any narrower donor or +account restrictions. Merely reading this file does not override those restrictions. +Do not change the selected frontier or merge/close others' PRs without maintainer +authorization; existing explicit authorization remains valid. + +New research packages should include **Open next questions** and can use the +[minimal package generator and explicit replay hook](docs/research/research-package-guide.md). +Optional workflow feedback goes in the PR or the +[feedback discussion](https://github.com/CrocSwap/integer-mult-bounds/discussions/1200). +Link it once; no separate session report is required. diff --git a/research/h25-bookkeeping/evidence/control/upstream/CONTRIBUTING.md b/research/h25-bookkeeping/evidence/control/upstream/CONTRIBUTING.md new file mode 100644 index 0000000000..5185786f2e --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/CONTRIBUTING.md @@ -0,0 +1,107 @@ +# Contributing and independent review + +**For donated inference or an open-ended “contribute” task, start with +[autoresearch.md](autoresearch.md).** It provides weighted task suggestions, +semantic overlap checks and bounded stopping criteria. Follow explicit user +assignments instead of drawing a new task. The root [AGENTS.md](AGENTS.md) also +points agents there. Existing external donation prompts should use this +repository-owned guidance for current priorities. + +Before substantial research, check the +[discussion board](https://github.com/CrocSwap/integer-mult-bounds/discussions) +alongside open PRs. The [start-here post](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163) +explains claims and updates; use [handoffs](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +for concrete requests and [mechanism proposals](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167) +for early ideas. Existing discussion claims are advisory, and findings remain +provisional until their evidence is checked. + +New research packages should include **Open next questions**, with relevance, +a feasible first step and blockers. Use the optional +[package generator and replay manifest](docs/research/research-package-guide.md) +to reduce packaging work. Keep frozen predecessor packages unchanged. A focused +finding or handoff is also a valid session outcome; a PR is not mandatory. + +The standard donation prompt in autoresearch.md authorizes routine Discussion +posts and opening focused PRs without repeated permission checks. Respect narrower +donor instructions. Optional workflow feedback belongs in the PR or the +[feedback discussion](https://github.com/CrocSwap/integer-mult-bounds/discussions/1200). + + +For maintainer queue work, start with the [delta-only intake procedure](docs/research/pr-intake.md) +and persistent scheduling cache. Do not repeat unchanged blocked reviews. + +Before reviewing an existing PR, consult the [central review ledger](docs/research/pr-ledger.md). +Record the reviewed commit and its evidence separately from publication and GitHub closure. +Recheck the current head before closing incorporated work, link its retained source and attribution, +and leave partial or changed submissions open with the remaining question recorded. Research notes +and verification tools can merit integration even when they do not improve the selected bound. + +Maintainers distinguish **archival intake** from **validated incorporation**. +New isolated research packages may be merged after source/integrity intake while +remaining `partially_reviewed` in the ledger, with the unverified obligations +preserved. Such a merge retains the contribution; it does not verify a theorem, +certify a new κ, or change the selected result. Shared-code changes and known +correctness objections remain in substantive review. See the +[archive policy and exact-head index](docs/research/research-archive-intake.md). + +This is a research draft. Corrections to the mathematics, implementation, +source attribution, and stated scope are welcome through issues or pull requests. + +For a mathematical issue, identify the exact proposition, source label, or +inequality; give a counterexample or the missing implication when possible; +and distinguish numerical validation from an algorithmic proof obligation. +For the current result, start with the +[current status](docs/research/current-status.md), +[selected record](certificates/selected-result.json), and the maintainer review +at that record's `review` path. +The selected record and review identify the actual supplier sources, +reproduction command, evidence and remaining assumptions. Earlier construction +notes are historical checkpoints, even when their text calls a result current. +The [original audit](docs/audit.md) describes the retained upstream assumptions. + +For a parameter improvement, supply exact rational choices, the full dependency +argument, and an updated patch against the pinned source. Explain whether the +change stays within the parameter ceiling or changes one of its hypotheses. + +Before extending a recursive cost edit, compare its complete paid and target +histograms with the [signed invoice preflight](docs/research/recursive-invoice-preflight.md). +It can certify uniform concave-moment gains or losses without a root search. +Its accounting contract is declared; source correctness and supplier admission +still require their own evidence. + +Keep `upstream/`, frozen source archives and pinned evidence unchanged. When +changing generated artifacts, edit their generators and include the regenerated +certificates and patches in the same change. Run the checks affected by your +changes; do not launch every historical replay for an unrelated contribution. +Changes to the selected construction also need its applicable complete cold +replay: use the `reproduce` command in the selected record rather than copying a +target from a historical note. Source-bound reuse must preserve explicit coverage +and invalidation. Run artifact-regenerating suites in isolated worktrees. +The historical `make gen4-bank-verify` target checks the earlier generation, +not the selected frontier. The proof and bank scheduling supplements are supplied as Markdown; +historical PDF targets belong to their respective checkpoints. Review changes to +claims in the README and note together. Finite tests should address a mathematical +identity or a failure mode, rather than simply restating implementation details. + +**Regenerated artifacts and hashes.** When verification regenerates a compressed artifact, compare its decompressed payload (or a documented canonical representation of every proof-relevant field). Compression headers and streams can differ across Python, zlib and tar versions. Keep exact hashes for committed source archives and other immutable inputs; a regenerated container hash may be recorded with environment details but should not determine mathematical equality across environments. See the [community reproducibility audit](research/gzip-container-reproducibility/README.md) by Maxime Fleury, following Antoine Olivier’s independent replay findings. + +New contributions are under the repository's Apache-2.0 license. Retain source +attribution and disclose substantial AI assistance. Do not describe certificate +success as a formal verification of the full multiplication theorem. + +Before building on pending work, consult the [contribution-review index](docs/research/contribution-review.md), pin its sources, and preserve contributor attribution. + +Parallel approaches, small improvements, independent reproductions, review and +well-scoped negative results are welcome. Please identify predecessor work and +explain what your submission adds, even if a concurrent result has a stronger +headline. We preserve credit for useful contributions that are superseded or not +imported; see [CONTRIBUTORS.md](CONTRIBUTORS.md). Attribution corrections are +welcome too. State which proof obligations remain open rather than presenting +finite certificate checks as a complete theorem audit. + +The historical `integration/community` workflow used `make verify` for its +imported candidate chain; it is not the current selected cold replay. See +[the integration ledger](docs/research/community-integration.md) for that history +and [the batching guide](docs/research/batched-review.md) for the changed recursive +interface. Preserve the historical checkpoint tests. +Imported CC0 proof sources retain their source-specific license and notice. diff --git a/research/h25-bookkeeping/evidence/control/upstream/autoresearch.md b/research/h25-bookkeeping/evidence/control/upstream/autoresearch.md new file mode 100644 index 0000000000..2fe84a7b30 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/autoresearch.md @@ -0,0 +1,104 @@ +# Contributing donated research effort + +**Start here if you were told to “contribute.”** Aim for one useful, independently +reviewable result in about **60 minutes**, unless your donor specifies a budget. +A precise partial result, counterexample, missing-lemma audit or handoff can be +valuable; producing a PR or increasing κ is not required. + +1. Read [current priorities](docs/research/current-priorities.md) and the + [selected record](certificates/selected-result.json). Use the + [bottleneck brief](docs/research/bottleneck-brief.md) and + [glossary](docs/research/research-glossary.md) as needed. +2. **Check [handoffs #1166](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) + before drawing a card.** Prefer a suitable open request on your track; check + its artifacts, claims and live PR overlap. Do not reroll an assigned task. +3. If no suitable request fits, run `python3 scripts/choose_research_task.py`. + Inspect the card's `existing_checks` and remaining obligations. Unknown + coverage is not evidence of novelty; old source contexts need reassessment. +4. Follow the [standing procedure](docs/research/agent-procedure.md), + [CONTRIBUTING.md](CONTRIBUTING.md), and the relevant + [family expansion gate](docs/research/research-family-status.md). + Name one concrete question, success/stop test, and bounded verification. +5. Preserve source attribution and report exactly what was established. + [Post updates from a file](docs/research/coordination.md); structured metadata + is optional and advisory. Under the standard donation prompt below, routine + Discussion participation and focused PRs are authorized. Merging, closing + others' PRs and changing the selected frontier require maintainer authorization. + +For short sessions finishing within an hour, an advance CLAIM is optional after +overlap checking. Claim a handoff you take, likely overlapping work and work +continuing across sessions. FINDING/DONE does not imply scientific approval. + +## Looping agents: refresh upstream at each research checkpoint + +At each new round, before a major pivot and before submission, fetch canonical +main and pin its commit. During a longer round, check at a safe point roughly +once per hour. Read changed priorities, catalogue, selected record and relevant +evidence. The picker does not fetch or reserve work. Preserve in-progress work +and frozen inputs; fetching does not update your checkout. See the +[exact refresh procedure](docs/research/agent-procedure.md#looping-agents-refresh-upstream-at-each-research-checkpoint). + +## 1. Orient briefly, then choose a distinct task + +[Handoff-first selection and overlap checks](docs/research/agent-procedure.md#1-orient-briefly-then-choose-a-distinct-task). +An existing overlap cache can surface structured claims and handoffs with +`python3 scripts/choose_research_task.py --coordination-cache /tmp/overlap.json`. +Check the reported freshness and prose-only discussions too. + +## 2. Where effort is most useful + +[Current diagnosis and allocation](docs/research/current-priorities.md), +[machine-readable cards](docs/research/agent-task-catalog.json), and +[priority decisions](docs/research/research-priority-log.md). + +## 3. Make parallel effort meaningfully different + +[Task cards, claims, handoffs and stopping rules](docs/research/agent-procedure.md). + +## 4. Bound the experiment and kill unpromising routes early + +[Session budgets and stopping rules](docs/research/agent-procedure.md#4-bound-the-experiment-and-kill-unpromising-routes-early). + +## 5. Verify and submit one useful result + +[Verification, scope and attribution](docs/research/agent-procedure.md#5-verify-and-submit-one-useful-result). + +## 6. Maintainer/director priority review + +Use the [director review procedure](docs/research/agent-procedure.md#6-maintainerdirector-priority-review). +Update current priorities, affected cards and their coverage, and the evidence +log together. For PR work, use [delta-only intake](docs/research/pr-intake.md) +and its construction-grouped view. Do not rerun unchanged historical reviews. + +## Hill-climbing track + +For κ-oriented work, beat the best open conditional κ by a small, exact step. +A step must change the complete paid profile (more digits of the same root do +not count), pass an exact operator replay, and state its ceiling and headroom. +Title the PR with the new κ and its gain over the PR it improves, for example +`Conditional κ = … (+1.140e-9 over #4088)`. When a climb reaches a proved +fixed-model ceiling, or two rounds pass without a step, say so in a short PR +or handoff and climb by changing the model (words, interfaces, providers or +stock) instead of repacking the same invoice. This is not admission; the +selected record still decides the frontier. + +## Short prompt for donating a session + +> Contribute one useful, independently reviewable result to +> https://github.com/CrocSwap/integer-mult-bounds. Read AGENTS.md, autoresearch.md +> and CONTRIBUTING.md from the current main branch first. Use the repository's +> task-selection and overlap process unless I assigned a specific task. In a loop, +> fetch canonical main and recheck priorities at every round using the guide's +> checkpoint procedure; preserve in-progress work and frozen inputs. Work for +> one session of about 60 minutes unless I specify another budget, keeping the +> final quarter for verification and a concise handoff, +> and report the exact scope, evidence, remaining obligations and predecessor +> credit. You may post routine claims, questions, findings, handoffs and feedback +> in Discussions and open a focused PR without asking me again for each action. +> Do not merge, close others' PRs or change the selected frontier. + +Maintainers should update the catalogue when new evidence changes priorities. +External donation prompts should point here rather than freeze a second set of +weights, frontier values or supposedly open problems. + +Prepared by Douglas Colkitt with OpenAI Codex assistance. Apache-2.0. diff --git a/research/h25-bookkeeping/evidence/control/upstream/certificates/selected-result.json b/research/h25-bookkeeping/evidence/control/upstream/certificates/selected-result.json new file mode 100644 index 0000000000..581f8d8700 --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/certificates/selected-result.json @@ -0,0 +1,112 @@ +{ + "status": "Selected maintainer-reviewed conditional P104 helper-subspace construction with exact Linux primary and independent caller replays", + "kappa": "62009/20000000", + "decimal": "0.00310045", + "source_prs": [ + 5599, + 5565, + 5580, + 5569, + 5561, + 5551, + 5545, + 5544, + 5550, + 5567, + 2305, + 2152, + 2219, + 5398, + 5400, + 4610, + 5241, + 4470, + 4447, + 4441, + 4440, + 4416, + 4433, + 4359, + 4268, + 3945, + 4085, + 2979, + 4076, + 4088, + 1673, + 1758, + 1786, + 23, + 555, + 589 + ], + "source_manifest": "certificates/frontier5599-source.json", + "certificate": "certificates/frontier5599/CLAIM.json", + "certificate_sha256": "66fbb5b21f32f1c4ba544c20d5a44ebcdfd11bce2bfa2d609c656ae520d3b21e", + "proof": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "proof_supplements": { + "notes/batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/semantic-bulk/pr23/semantic-bulk-17-note.tex": "652242b05174bb776ffc6165af170df9c8cf220dbd0fc26c24d778f320dbabc8", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1", + "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "docs/research/pr-intake-evidence/pr4359/PROOF-REVIEW.md": "7d67bb814285f7634029fbd378c6457156545f0b38858cc1c6ec34b68cd9d162", + "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b", + "docs/research/pr-intake-evidence/pr4416/PROOF-REVIEW.md": "2c2bbe6fe1bab44778192118f27e59a0d23dbe02c47aa8a42845093f1ce46f49", + "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md": "b84f833e3072cbab372fbda2ece98fbc031c15e590cf73003ddea35a5222e148", + "research/final4610-independent-admission/PROOF.md": "e573cbbe6fa5481c0533e773de404e10f4dc7907b5ebfe404bdcd02dcf9844d8", + "research/final4610-independent-admission/SPECIALIZATION.md": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md": "7688e5d8bf40fcdfb5bea43ba47e1f8d60a77a91ede6c307bb8163a9a7e16b3f", + "research/p104-helper-subspace-splits/PROOF.md": "f4c68acf9373e34d88e14e1a7791b4b739c8b5297a1ae4c0121f579a02fde04e", + "research/p104-productive-controller/PROOF.md": "f4c4e400092954562252df6c4dd157a9b4c1642252168ce72738cdbecfc5ad41", + "research/p104-caller-independent-audit/PROOF.md": "d73ff9587a85db8063391919ffc4a17521ccd5759cdaf6338ba036703239d839", + "research/p104-free-endpoint-contract-audit/PROOF.md": "43aeae1c090b5657f326fd7c56a5e5fbe062db29591b660a903305ca58ce9598" + }, + "review": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "validation": "docs/research/pr-intake-evidence/pr5599-completion/VALIDATION.json", + "integration": "docs/research/pr-intake-evidence/pr5599-completion/INTEGRATION.json", + "reproduce": "make frontier5599-verify", + "scope": "Conditional P104 helper-subspace splitting and all-forward productive caller. The five inherited framework assumptions remain; no materialized uniform word or complete rounded multiplier.", + "previous_kappa": "605457647/200000000000", + "previous_record": "certificates/checkpoints/frontier5413.json", + "audited_source_head": "09dd0965711ca7eeb169057a420abab1c9052137", + "source_certificate": "research/p104-helper-subspace-splits/RESULT.json", + "source_certificate_sha256": "1d92e587915052110dfb3aca8890df5afdaf496164efa5a4a52e69ceeb3c70f3", + "replay_mode": "Fresh serial Linux normal and optimized primary replays, exact original caller positive control, and independent caller inventory adaptation. All under sampled 1 GiB descendant RSS guards. Prior selected framework/BIT foundation is explicitly reused.", + "contributors": "docs/research/community-p1045599-contributors.md", + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "audit_pr": 5550, + "audit_head": "6125c07ae8ba4b8550e2a0a28a2c6be503153059" +} diff --git a/research/h25-bookkeeping/evidence/control/upstream/docs/research/agent-task-catalog.json b/research/h25-bookkeeping/evidence/control/upstream/docs/research/agent-task-catalog.json new file mode 100644 index 0000000000..3404fbdd5e --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/docs/research/agent-task-catalog.json @@ -0,0 +1,1281 @@ +{ + "schema_version": 1, + "priority_revision": 8, + "priority_log": "docs/research/research-priority-log.md", + "assessed_on": "2026-10-26", + "status": "Research suggestions, not reservations or assertions that these questions are unclaimed. Check current main and live PRs.", + "tracks": [ + { + "id": "bit-mechanisms", + "weight": 20, + "tasks": [ + { + "id": "bit-helper-contract", + "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/g20-helper-split/README.md", + "research/g20-conjugation-admission/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "G20", + "helper split", + "5679", + "5708", + "independent target" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + { + "id": "r437-carrier-integration", + "question": "Can the paid R437 two-window carrier improvement be admitted by the actual pooled compiler and physical caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/r437-two-window-carrier/README.md", + "research/r437-reverse-row-coefficient/README.md" + ], + "methods": [ + "Close one compiler/request, caller or precision/stock implication for the pinned paid exchange.", + "Falsify that exact interface with an arbitrary-dirty-state or chronology counterexample." + ], + "acceptance_gate": "Pin the complete source and destination contracts, exact paid and scalar deltas, and all remaining assumptions. A local moment gain is not a physical or all-size supplier admission.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Choose one unclaimed obligation: pooled compiler codebook/request alignment, actual physical caller, or precision/stock envelope using the already reported reverse coefficient. Pin the input and receiver, preserve dirty/source windows, and test one binding with a rejection control. Stop at unresolved dependencies; do not rederive the coefficient or quote the local moment as a completed bound.", + "bottleneck_link": "The exchange changes the paid profile; integration must establish that its gain survives the complete caller.", + "allowed_variations": [ + "One compiler rebind, one actual caller boundary, or one precision/stock implication." + ], + "scope_change_triggers": [ + "Ignoring added ADDs, retaining an obsolete reverse coefficient, or declaring global admission from the local histogram." + ], + "overlap_terms": [ + "R437", + "two-window carrier", + "4067", + "4147", + "pooled compiler", + "request alignment", + "reverse row coefficient" + ], + "existing_checks": [ + { + "scope": "PR #4067: source-bound two-window carrier with (2,2) to (1,3) paid exchange and fixed OQ4 host.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Pooled compiler/request rebind, physical caller and precision/stock admission.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4147: reverse row coefficient follow-up.", + "evidence": "research/r437-reverse-row-coefficient/README.md", + "remaining": "Use the exact coefficient in a caller-bound precision/stock proof rather than repeat the arithmetic.", + "status": "author-checked", + "source_commit": "72e7bb797adf82aeb525a399f56ab8adbab8e93c", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + } + ] + }, + { + "id": "complex-mechanisms", + "weight": 20, + "tasks": [ + { + "id": "p104-side-correction", + "question": "Can joint helper bases and a legal causal split improve the complete P104 productive/paid invoice?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "research/p104-helper-subspace-splits/README.md", + "research/dyadic-helper-channel-capacity/README.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Start with the selected #5599 emitted word and review pending #5718 distinct input/output bases plus #5717/#5719 coverage before claiming work. Pick one uncovered source word, helper group and cut region. Prove the arbitrary-input relation and legal entry/exit corrections, then compare full target and paid profiles. Reject if completion, owned lifetimes or consumer costs repay the gain. A static pairing rank alone is not a physical split.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "P104", + "helper basis", + "helper split", + "5718", + "dyadic capacity" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "complex-rank-shape-decoder", + "question": "Can a legal decoder or coframe change improve the full signed moment, including changed helper targets?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Price one complete changed itinerary with both paid and productive histograms. Check #5693/#5698 for overlap and their exact hypotheses before another coframe search. Use the signed invoice preflight where its boundary contract agrees; an inconclusive concave comparison is not a power crossing. Stop if an optimistic complete budget fails at the chosen target or native delivery remains unspecified.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "coframe", + "signed moment", + "5693", + "5698" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "complex-new-helper-inventory", + "question": "Can a changed helper inventory earn productive credit that survives completion, compilation and the actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Specify all arbitrary inputs, owned fields, restored outputs and a physically legal consumer. Compare complete P and T, including target debits and precision/stock costs. #5599 is a positive control for target refinement, not permission to split every helper for free. #5614 is a hypothetical compiler budget, not an emitted 145-split word. Stop at the first unpaid boundary or a failing optimistic full bill.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "productive helper", + "target refinement", + "5599", + "5614" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + } + ] + }, + { + "id": "recursive-interfaces", + "weight": 20, + "tasks": [ + { + "id": "joint-query-controller", + "question": "Can a changed query demand or caller remove real work while satisfying native chronology and restoration?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose an exact caller and a new demand/interface hypothesis. Read the scoped #5617/#5631/#5649/#5747 and #5720/#5745 objections before rebuilding an excluded schedule. Compare the complete matched source/consumer protocols including all retained helper outputs. For an active-mode injection, first check #5745: its canonical delivery claim repays the eight removed centre jobs. Audit that exact claim or change its channel/feedback hypothesis; do not repeat the same free-injection search. Stop if the full favorable budget fails or the required restored output is unobservable.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "query demand", + "active mode", + "5720", + "5745", + "5747", + "caller" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "centre-path-sharing", + "question": "Can a specified persistent boundary eliminate a repeated centre operation in the current caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Write a two-call input/output contract on the current source word, including arbitrary centre baselines and every later read. Price producer, retention, native alignment and restoration jointly. Historical 64-per-call and 1.90x figures are not current budgets. Stop if a missing consumer or restored-input obligation consumes the saving; reopen only with a changed legal boundary.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "centre path", + "persistent boundary", + "dirty recoding" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "coverage-law-change", + "question": "Can a completed call earn more independent productive target credit without an offsetting paid bill?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "A source-bound arbitrary-input identity and legal producer/consumer boundary with the complete paid and productive target invoice, including restoration, ownership, native alignment and extra charges. Price under the actual current model; historical ceiling.py assumptions must be established before use. A favorable optimistic relaxation keeps a route open but is not a completed supplier. A scoped local result remains useful; expansion requires the family-level budget gate.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Use #5599 as a completed positive control, then choose one uncovered cut/module beyond an applicable frozen exclusion. Derive independence, saturation and chronological availability rather than counting rational rank alone. Price target credits and all new jobs together, then check compiler and actual caller compatibility. Stop on a nonphysical credit or an unfavorable complete relaxation.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "target credit", + "helper split", + "coverage law" + ], + "existing_checks": [ + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment.", + "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + } + ] + }, + { + "id": "adversarial-audit", + "weight": 15, + "tasks": [ + { + "id": "selected-stock-envelope", + "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "starting_points": [ + "research/selected-bootstrap-stock-audit/README.md", + "research/bootstrap-cutoff-time-space-split/README.md", + "certificates/selected-result.json", + "docs/research/community-efficient1000-review.md", + "research/stock-margin-chain/README.md" + ], + "methods": [ + "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.", + "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope." + ], + "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.", + "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.", + "allowed_variations": [ + "One stage or one explicit reserve/depth implication.", + "An independently checked same-domain proof repair, retaining all remaining assumptions." + ], + "scope_change_triggers": [ + "Importing the historical 57604 or 252 allowance without a selected-producer binding.", + "Calling a conditional fit lemma a full outer-proof adoption.", + "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality." + ], + "overlap_terms": [ + "selected stock", + "stock envelope", + "bootstrap cutoff", + "1956", + "1965", + "1990", + "2972", + "stock-margin-chain", + "actual_stock_coefficient" + ], + "existing_checks": [ + { + "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.", + "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation", + "remaining": "Derive one actual reserve/depth coefficient from the selected producer.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "uniform-transfer-audit", + "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "native_all_columns", + "owned_erasure", + "compiler", + "precision_tape", + "analytic_recovery" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "census-pruning-audit", + "question": "Does the reported word-census parity-pruning error invalidate a specific exclusion we still rely on, and what bounded repair is justified?", + "starting_points": [ + "research/f7-weight-parity-census-correction/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct the tiny counterexample and trace one affected exclusion to its exact pruning code.", + "Compare corrected and unpruned enumeration on a small exhaustive domain, then audit the changed pruning implication." + ], + "acceptance_gate": "Pin the old and proposed corrected engines, distinguish a disproved pruning rule from a disproved final bound, and state exactly which downstream exclusions need revalidation. #2973 is an author-checked source archive; neither its new f(7) claim nor all old conclusions are automatically accepted or rejected.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Reconstruct the eight prefix states of 01021323 and compare bit-0 versus Hamming-weight parity budgets independently. Trace the reported false prune to one pinned predecessor (#2542, #2634 or #2691), then test a small exhaustive domain. Stop after a source-impact handoff or corrected-prune proof; a full seven-label replay needs a separate resource budget and a named research decision it can change.", + "bottleneck_link": "An unsound exclusion can wrongly close a mechanism; correcting its dependency boundary is more useful than extending the same census.", + "allowed_variations": [ + "One predecessor pruning rule, one independently exhaustive small domain, or one downstream dependency audit." + ], + "scope_change_triggers": [ + "Launching a larger census before validating the prune and explaining which active decision it changes.", + "Treating a small-domain counterexample to the old rule as a counterexample to every reported seven-label bound." + ], + "overlap_terms": [ + "2973", + "2542", + "2634", + "2691", + "weight parity", + "bit-0", + "01021323", + "census pruning" + ] + } + ] + }, + { + "id": "independent-verification", + "weight": 10, + "tasks": [ + { + "id": "independent-moment", + "question": "Does a changed construction's serialized target/paid invoice independently support its claimed improvement?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Independently recount one changed emitted word and its complete caller, importing no constructor or pricing engine. Include target losses, owned lifetimes, native orientation and extra charges. Check existing #5633/#5708/#5717/#5719 coverage to avoid duplicate audits and preserve its exact head. Stop after the chosen missing implication; a correct root alone is not supplier admission.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "invoice", + "signed moment", + "productive target", + "independent recount" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + } + ] + }, + { + "id": "verifier-engineering", + "weight": 8, + "tasks": [ + { + "id": "replay-runtime", + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ], + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ] + }, + { + "id": "portable-replay", + "question": "Can one reproducible environment or artifact-comparison failure be repaired?", + "starting_points": [ + "research/gzip-container-reproducibility/README.md", + "docs/ci-verification.md" + ], + "methods": [ + "Reproduce one portability failure and add a minimal cross-environment fix.", + "Audit one canonical-payload comparison for omitted proof-relevant fields." + ], + "acceptance_gate": "Preserve immutable source hashes and proof-relevant content; a different compressed byte stream alone is not a mathematical mismatch.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Reproduce one specific mismatch or audit one canonical comparison for omitted proof-relevant fields.", + "bottleneck_link": "Portable exact checks prevent environment failures from blocking valid contributions.", + "allowed_variations": [ + "One interpreter/version mismatch or one payload field comparison." + ], + "scope_change_triggers": [ + "Removing immutable-source pins because generated compressed bytes differ." + ], + "overlap_terms": [ + "gzip container", + "reproducibility", + "canonical payload" + ] + } + ] + }, + { + "id": "consolidation", + "weight": 5, + "tasks": [ + { + "id": "overlap-receipt", + "question": "What exact content and credit of a small named PR set has already been retained?", + "starting_points": [ + "docs/research/pr-ledger.md", + "CONTRIBUTORS.md" + ], + "methods": [ + "Compare exact heads and retained artifacts to write a source-bound disposition receipt.", + "Audit an existing receipt for missing content or predecessor attribution." + ], + "acceptance_gate": "Separate complete integration, partial retention and changed heads; make no autonomous closures.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Compare that set to retained artifacts; produce a complete or explicitly partial disposition receipt.", + "bottleneck_link": "Reliable overlap evidence preserves credit and prevents repeated review of already-retained material.", + "allowed_variations": [ + "One small related PR family or one existing integration receipt." + ], + "scope_change_triggers": [ + "Treating matching titles or one shared blob as proof of full incorporation." + ], + "overlap_terms": [ + "overlap receipt", + "partial integration", + "attribution" + ] + }, + { + "id": "scope-navigation", + "question": "Can one misleading historical-current claim or missing research cross-reference be corrected?", + "starting_points": [ + "docs/research/current-status.md", + "docs/research/pr-ledger.md", + "certificates/selected-result.json" + ], + "methods": [ + "Trace one confusing path from onboarding to its authoritative source.", + "Index one tightly related family of obstructions with explicit excluded and open hypotheses." + ], + "acceptance_gate": "Produce evidence-backed navigation, preserve historical records and avoid a duplicate global survey.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "first_experiment": "Repair one confusing path or produce a scoped map of one related obstruction family.", + "bottleneck_link": "Clear navigation lowers entry cost for central research; a global survey without a concrete fix is not required.", + "allowed_variations": [ + "One historical-current ambiguity or one bounded family index." + ], + "scope_change_triggers": [ + "Rewriting frozen scientific packages just to change their historical wording." + ], + "overlap_terms": [ + "current status", + "historical checkpoint", + "scope navigation" + ] + } + ] + }, + { + "id": "incumbent-optimization", + "weight": 2, + "tasks": [ + { + "id": "selected-packing", + "question": "Is there meaningful uncovered packing headroom for an exact current word and boundary contract?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Check live overlap and exact model/source binding first. Distinguish a chronological construction from a pooled optimum. State the applicable fixed-inventory ceiling and remaining headroom; changed words or interfaces require a new fully charged model. Do not launch a residual search without an explicit scope and time cap.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Derive or authenticate a ceiling for the exact current paid/target inventory before searching. Old #1240/#4091 caps do not constrain #5599 automatically. Require an unclaimed domain, time cap and useful complete margin. Stop at the applicable ceiling; change the word or boundary instead of adding seeds.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing", + "4091", + "4088", + "staged-fourth-mixture-ceiling", + "staged544-mixed-fourth-entry" + ], + "existing_checks": [ + { + "scope": "PR #4091: pooled optimum at one-third staging for pinned fixed words; not a chronological fill.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Independent scope/source check; any residual optimization is explicitly bounded and optional.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4088: later 1090-call literal fill improves the earlier 1080-call witness.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Complete admission remains separate; old residual-bin instructions must not be copied blindly.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + { + "id": "scalar-to-moment", + "question": "Can a scalar/frame rewrite improve the complete signed moment through paid jobs, productive targets, or both?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "docs/research/recursive-invoice-preflight.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Require a legal chronological rewrite and favorable complete signed target-minus-paid moment with all extra charges. Unchanged ADD counts or unchanged paid-call counts alone decide neither success nor failure. Compiler, native and outer admission remain separate obligations.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Construct one legal source-bound rewrite and compare complete before/after P and T. Charge restoration, source windows and owned helpers. A paid call need not disappear: a legal target split or rank redistribution may win. Stop if the signed moment is unchanged or the consumer repays the gain. Do not extend a scalar-only census on ADD counts.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "signed moment", + "target split", + "rank exchange", + "scalar rewrite" + ], + "existing_checks": [ + { + "scope": "PR #3998: consecutive A2 scalar contraction", + "evidence": "research/staged544-a2-graph-rewrite/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4019: separated A2 sites with unchanged recursive histogram", + "evidence": "research/staged544-separated-a2/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "f408e09df300b575235f7f77f81948071397e16d", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4112: composition audit", + "evidence": "research/staged544-a2-composition-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4152: A1858 contraction audit", + "evidence": "research/staged544-a1858-contraction-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + } + ] + } + ], + "selection_context": { + "refreshed_on": "2026-10-26", + "kappa": "62009/20000000", + "source_pr": 5599, + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "record": "certificates/selected-result.json", + "review": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "orientation_command": "python3 -B scripts/research_selected_baseline.py", + "scope": "Revision-8 strategic reassessment. PR5599 is selected and independently replayed under five inherited assumptions. Archived successor claims are not admissions. Compare complete signed target/paid moments and the current nine outer rows; no historical balanced-transfer cap is imposed." + } +} diff --git a/research/h25-bookkeeping/evidence/control/upstream/docs/research/current-priorities.md b/research/h25-bookkeeping/evidence/control/upstream/docs/research/current-priorities.md new file mode 100644 index 0000000000..6f5d40d13d --- /dev/null +++ b/research/h25-bookkeeping/evidence/control/upstream/docs/research/current-priorities.md @@ -0,0 +1,116 @@ +# Current research priorities + +**Revision 8 — October 26, 2026.** This is the active diagnosis; the +[standing procedure](agent-procedure.md) covers sessions and coordination. +Refresh this file and the [task catalogue](agent-task-catalog.json) at each round. + +The [selected conditional result](../../certificates/selected-result.json) is +**κ = 0.00310045**, PR #5599 at +`09dd0965711ca7eeb169057a420abab1c9052137`. The +[maintainer review](pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md) +records complete serial Linux primary, optimized and independent caller replays. +The same **five framework assumptions remain**. This is not a complete +formalization or a materialized rounded multiplier. Credit and predecessor +contributions are in the [contributor map](community-p1045599-contributors.md). + +Start with `python3 -B scripts/research_selected_baseline.py`. This authenticates +bindings and reports distinct complex, ordinary BIT, admitted BIT and outer +budgets; it is not a scientific replay. Use the selected record's reproduction +command only for a separately budgeted validation task. + +## What changed + +**Joint helper bases and legal independent-target splitting work.** The reviewed +#5599 construction refines thirteen helper targets while preserving the paid +Gaussian count. Consequently, the old rule requiring removal of a paid transition +was too narrow. Optimize the **complete signed moment**: productive credits, +paid children, additional charges, and their legal realization. Fewer scalar +ADDs alone are still insufficient. + +**Complex currently binds; BIT is the next cap.** The selected admitted BIT +saving remains **.0034** (ordinary .0034363538396). New G20 proposals #5679/#5708 +report ordinary component savings around .0035074/.0035077. Their archival +publication is not admission and does not change the selected bound. A large +complex improvement needs a compatible BIT improvement. The current nine outer +rows track supplier budgets directly; the historical `κ=a/(1+a)` conversion and +`1/99` planning threshold do not describe this selected assembly. + +**Retain a diverse portfolio, but replace stale assignments.** No reliable +track-level success-rate data supports changing weights. Keep independent +mechanisms and audits active alongside helper improvements. Check the live +[handoff thread](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +and exact source heads before drawing a card. Use the +[revision-8 family record](research-family-status.md#revision-8-evidence-and-assignments) +for scoped evidence and reopening conditions. + +## Next bounded decisions + +| Track / cards | Next useful experiment | Stop rule | +|---|---|---| +| Complex helpers: `p104-side-correction`, `coverage-law-change` | One uncovered helper group and causal cut; legal input/output bases, independent targets and the complete caller bill. #5718 proposes distinct boundary bases; #5611/#5615 supply proposed dyadic tools. | Static capacity or rational rank without physical delivery is not a split. Stop if completion or target debits consume the gain. | +| BIT: `bit-helper-contract` | Review the #5679/#5708 chain before another G20 search; identify a changed helper trajectory or target split and preserve every arbitrary input. | A frozen common-frame exclusion does not cover a changed word; neither does a new ordinary saving automatically raise admitted BIT. | +| New decoders/interfaces | One complete changed producer/consumer contract, with an optimistic full signed bill before a wider search. | Respect the exact caller/coframe/connector hypotheses in recent negative results. Unknown delivery, restoration or native costs are not zero. | +| Supplier audit | Delta coverage on a latest candidate. #5717 adds explicit owned lifetimes; #5719 audits exact #5713 temporal premises. | Do not transfer these checks automatically to #5718 or rerun unchanged #5599 admission. Stop with one resolved gap or a precise remaining obligation. | +| All-size audit/formalization | One selected assumption ID, quantified proposition, actual caller and independent proof/counterexample. | #5625 row reentry and #5707 root-prefix lowering are partial interfaces, not all five assumptions discharged. | +| Verification tooling | Preserve exact coverage while removing measured replay or coordination friction. #5729 proposes a faster complete E7 replay. | Faster output is not equivalent coverage until checked. No default Lean, Docker or heavy orientation run. | + +**Decorrelation is semantic.** Claim a tuple of source head, helper/cut region +or proposition, changed hypothesis and consumer contract. Different seeds do +not reserve different work. Prefer an unclaimed concrete handoff; keep one +canonical thread. A scoped lemma, counterexample, independent audit or released +handoff is useful even without a new κ or PR. Do not send every agent to the same +small helper-split domain. + +## Price the current contract + +Write `T_r` for productive targets and `P_r` for paid children. At a candidate +saving `C`, compare the full target and paid power sums with exponent `1-C`, +including every additional fee required by that supplier's normalization. +A favorable raw margin is only the first gate: finite compiler closure, +native operators, dirty restoration, stock/precision and outer use still need +coverage. Productive helpers are not free zero-initialized scratch. + +Use [signed invoice preflight](recursive-invoice-preflight.md) when old and new +boundary contracts match. A concave-order certificate can settle a full family +of tariffs; an inconclusive result is not a proof of a power crossing. The new +selected-invoice exporter (#5735) reconstructs the authenticated P104 ledger; +#5732 bounds a fixed rational power and #5746 handles common-base ranks over +the whole power interval. These are accounting tools, not native or compiler +proofs. Changed +contracts need a justified comparison, not a silent reuse of the old bill. + +For **κ > .01**, work backward from the actual nine outer rows and both suppliers +at that target, with strict margins. The present .0034 admitted BIT budget cannot +support it. Specify a mechanism capable of a favorable fully charged target-scale +bill before expanding the search. A hypothetical passing profile, such as #5614's +145-split benchmark, does not supply the physical word. No current result proves +a universal ceiling for finite networks. + +Old .001687 packing caps, 64-per-call centre costs and ideal lever multipliers +remain historical evidence in earlier priority-log entries. They must not be used +as current limits without proving exact model/inventory equivalence. In the same +way, the thirteen-helper refinement bound in #5702 concerns that fixed expansion, +not every target split. New topology, changed data paths or a different recursive +boundary require a fresh complete budget. + +## Allocation + +These are portfolio shares, not success probabilities. Revision 8 retains all +revision-7 weights; it changes tasks, evidence and stopping rules. + +| Track | Share | Useful outcome | +|---|---:|---| +| Bit mechanisms (`bit-mechanisms`) | 20% | A completed changed BIT path/target contract or a new mechanism | +| Complex mechanisms (`complex-mechanisms`) | 20% | A legal helper/decoder change with a favorable complete signed bill | +| Recursive interfaces (`recursive-interfaces`) | 20% | A genuinely cheaper composed boundary with restored outputs accounted for | +| Adversarial audit (`adversarial-audit`) | 15% | One caller-bound missing implication resolved or falsified | +| Independent verification/formalization (`independent-verification`) | 10% | Independent coverage of an uncovered source-specific claim | +| Verifier engineering (`verifier-engineering`) | 8% | Measured speed or reliability improvement without coverage loss | +| Consolidation (`consolidation`) | 5% | Exact-head overlap, credit, coverage or navigation repair | +| Incumbent optimization (`incumbent-optimization`) | 2% | A new complete signed-moment gain, within an applicable scoped budget | + +Archive merging preserves work and credit; it does not establish a new theorem +or select a frontier. Read [archive status](research-archive-intake.md) and the +[central ledger](pr-ledger.md) before interpreting GitHub's merged state. +Reassess after a new supplier admission, a changed binding outer row, a resolved +framework assumption, or a target-scale complete construction/counterexample. diff --git a/research/h25-bookkeeping/evidence/historical-source/README.md b/research/h25-bookkeeping/evidence/historical-source/README.md new file mode 100644 index 0000000000..96fd10a611 --- /dev/null +++ b/research/h25-bookkeeping/evidence/historical-source/README.md @@ -0,0 +1 @@ +These are exact local source snapshots used for receipt evaluation and indexing before publication. Their relative paths refer to the original round layout. They are retained for audit and are not package entry points. Use the registered root wrappers and replay.py described in the package README. diff --git a/research/h25-bookkeeping/evidence/historical-source/evaluate_qualification.py b/research/h25-bookkeeping/evidence/historical-source/evaluate_qualification.py new file mode 100644 index 0000000000..f050908c4f --- /dev/null +++ b/research/h25-bookkeeping/evidence/historical-source/evaluate_qualification.py @@ -0,0 +1,62 @@ +"""Evaluate the predeclared receipts; never run or select a replacement sample.""" +import argparse +import hashlib +import json +from pathlib import Path +import statistics + +HERE = Path(__file__).resolve().parent + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--first-pair', action='store_true') + args = parser.parse_args() + rules_raw = (HERE / 'control/QUALIFICATION-v4.json').read_bytes() + rules = json.loads(rules_raw) + anchor = json.loads((HERE / 'baseline/anchor.json').read_bytes())['science'] + rows = [] + sequence = rules['sequence'][:2] if args.first_pair else rules['sequence'] + for spec in sequence: + directory = HERE / 'runtime/runs' / spec['label'] + receipt = json.loads((directory / 'receipt.json').read_bytes()) + science = json.loads((directory / 'science/receipt.json').read_bytes()) + if not (receipt['status'] == 'PASS' and receipt['job'] == spec['job'] and + receipt['stage_sha256'] == rules['stage_sha256'] and receipt['source_bytes_and_modes_unchanged'] and + science['status'] == 'FULL_NETWORK_COMPLETE_PASS' and science['science'] == anchor): + raise RuntimeError('Qualified sample source/science/custody differs: ' + spec['label']) + usage = receipt['usage'] + rows.append({'label': spec['label'], 'arm': 'C' if spec['job'] == 'full-all' else 'B', + 'wall': receipt['wall_seconds'], 'cpu': usage['user_seconds'] + usage['system_seconds'], + 'stage_sha256': receipt['stage_sha256'], 'spent_before': receipt['spent_before_seconds']}) + if rows != sorted(rows, key=lambda row: row['spent_before']): + raise RuntimeError('Predeclared sample order was not preserved') + metrics = {} + for metric in ('wall', 'cpu'): + baseline = [row[metric] for row in rows if row['arm'] == 'B'] + candidate = [row[metric] for row in rows if row['arm'] == 'C'] + b, c = statistics.median(baseline), statistics.median(candidate) + saving = b - c + noise = max(max(baseline) - min(baseline), max(candidate) - min(candidate)) + metrics[metric] = {'baseline': baseline, 'candidate': candidate, + 'baseline_median': b, 'candidate_median': c, + 'saving': saving, 'reduction_percent': 100 * saving / b, + 'max_within_arm_range': noise, 'target_pass': c <= 0.85 * b, + 'noise_pass': saving > noise} + passed = all(row['target_pass'] and row['noise_pass'] for row in metrics.values()) + result = {'status': ('FIRST_PAIR_CREDIBLE_CONTINUE' if passed else 'FIRST_PAIR_STOP') if args.first_pair else + ('COMBINED_15_PERCENT_BOTH_METRICS_AND_NOISE_PASS' if passed else 'COMBINED_TARGET_OR_NOISE_MISS'), + 'qualified_factor': passed and not args.first_pair, 'metrics': metrics, 'samples': rows, + 'rules_sha256': hashlib.sha256(rules_raw).hexdigest(), + 'every_sample_retained': True, 'full_anchor_equal': True, + 'all_new_controls_and_cold_builds_billed': True, + 'publication_and_hosted_validation_remain_separate': True} + name = 'COMBINED-FIRST-PAIR.json' if args.first_pair else 'COMBINED-GATE.json' + (HERE / 'validation' / name).write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + print(json.dumps(result, sort_keys=True)) + if not passed: + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/evidence/historical-source/summarize_runs.py b/research/h25-bookkeeping/evidence/historical-source/summarize_runs.py new file mode 100644 index 0000000000..8fb39d78a6 --- /dev/null +++ b/research/h25-bookkeeping/evidence/historical-source/summarize_runs.py @@ -0,0 +1,42 @@ +"""Bounded receipt index; no scientific imports, replay, compilation or timing.""" +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def main(): + rows = [] + for path in sorted((HERE / 'runtime/runs').glob('*/receipt.json')): + raw = json.loads(path.read_bytes()) + usage = raw.get('usage') or {} + if 'raw' in usage: + try: + usage = json.loads(usage['raw'].strip().splitlines()[-1]) + except (ValueError, IndexError): + usage = {} + science_path = path.parent / 'science/receipt.json' + science = json.loads(science_path.read_bytes()) if science_path.exists() else {} + row = {'label': raw['label'], 'status': raw['status'], 'wall': raw['wall_seconds'], + 'cpu': (usage['user_seconds'] + usage['system_seconds']) if 'user_seconds' in usage else None, + 'stage_sha256': raw['stage_sha256'], 'termination': raw['termination'], + 'source_unchanged': raw['source_bytes_and_modes_unchanged'], + 'science_status': science.get('status'), 'lanes': science.get('lanes'), + 'has_complete_science_anchor': 'science' in science} + rows.append(row) + result = {'runs': rows, 'spent_seconds': sum(row['wall'] for row in rows), + 'failed_attempts': sum(row['status'] != 'PASS' for row in rows)} + (HERE / 'validation/RUN-INDEX.json').write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + status_path = HERE / 'STATUS.json' + status = json.loads(status_path.read_bytes()) + status.update(scientific_runs_started=bool(rows), new_round_spent_seconds=result['spent_seconds'], + retained_failed_attempts=result['failed_attempts']) + status_path.write_text(json.dumps(status, indent=2, sort_keys=True) + '\n') + print(json.dumps({'run_count': len(rows), 'spent_seconds': result['spent_seconds'], + 'failed_attempts': result['failed_attempts'], 'index': 'validation/RUN-INDEX.json', + 'runs': [{k: row[k] for k in ('label', 'status', 'wall', 'cpu')} for row in rows]}, + sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/evidence/local-source/publication_guard.py b/research/h25-bookkeeping/evidence/local-source/publication_guard.py new file mode 100644 index 0000000000..1bb7c6bb98 --- /dev/null +++ b/research/h25-bookkeeping/evidence/local-source/publication_guard.py @@ -0,0 +1,184 @@ +"""Parent-only delivery checks charged to the existing round ledger. + +This orchestration is separate from the frozen performance harness and never +creates performance samples. Jobs are exact registered package checks. +""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import signal +import subprocess +import sys +import time + +HERE = Path(__file__).resolve().parent + + +def content_digest(path): + hasher = hashlib.sha256() + with path.open('rb') as stream: + for block in iter(lambda: stream.read(1024 * 1024), b''): + hasher.update(block) + return hasher.hexdigest() + + +def inventory(package): + result = {} + for path in sorted(package.rglob('*')): + if path.is_symlink(): + raise RuntimeError('Symlinked publication source') + if path.is_file(): + result[str(path.relative_to(package))] = [content_digest(path), + path.stat().st_mode & 0o777] + return result + + +def descendants(root, known): + """Track nested new sessions too; retain pid/start identity against reuse.""" + processes = {} + for path in Path('/proc').iterdir(): + if not path.name.isdigit(): + continue + try: + raw = (path / 'stat').read_text() + fields = raw[raw.rfind(')') + 2:].split() + processes[int(path.name)] = (int(fields[1]), int(fields[2]), int(fields[19]), + int(fields[21]) * os.sysconf('SC_PAGE_SIZE')) + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + active = {pid for pid, start in known.items() if pid in processes and processes[pid][2] == start} + if root in processes and (root not in known or processes[root][2] == known[root]): + active.add(root) + while True: + added = {pid for pid, row in processes.items() if row[0] in active} - active + if not added: + break + active.update(added) + for pid in active: + known[pid] = processes[pid][2] + groups = {processes[pid][1] for pid in active} + return sum(processes[pid][3] for pid in active), groups + + +def kill_descendants(root, known, sig): + _, groups = descendants(root, known) + for group in groups: + if group == os.getpgrp(): + raise RuntimeError('Refusing to signal parent process group') + try: + os.killpg(group, sig) + except ProcessLookupError: + pass + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('job', choices=('finite', 'finite-O', 'full', 'canonical', 'registry')) + parser.add_argument('label') + parser.add_argument('--repository', type=Path, default=HERE / 'publication-repo') + args = parser.parse_args() + if not args.label or any(c not in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_' for c in args.label): + raise ValueError('Simple new run label required') + repository = args.repository.resolve() + package = repository / 'research/h25-bookkeeping' + before = inventory(package) + with (HERE / 'runtime/science.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + runs = HERE / 'runtime/runs' + spent = 0.0 + for folder in runs.iterdir(): + if folder.is_dir(): + if not (folder / 'receipt.json').exists(): + raise ValueError('Unclosed prior scientific attempt') + spent += json.loads((folder / 'receipt.json').read_bytes())['wall_seconds'] + cap = min(1500, json.loads((HERE / 'control/EXECUTION-PHASE.json').read_bytes())['aggregate_cap_seconds']) + if spent >= cap: + raise ValueError('Round scientific budget consumed') + folder = runs / args.label + folder.mkdir() + command = ['/usr/bin/python3.12', '-B'] + if args.job == 'finite-O': + command.append('-O') + if args.job == 'registry': + command.extend([str(repository / 'scripts/research_package.py'), '--package', 'research/h25-bookkeeping']) + else: + entry = {'finite': 'verify.py', 'finite-O': 'verify.py', 'full': 'verify_full.py', + 'canonical': 'check_artifacts.py'}[args.job] + command.append(str(package / entry)) + env = os.environ.copy() + for name in ('PYTHONPATH', 'PYTHONOPTIMIZE', 'PYTHONINSPECT', 'PYTHONSTARTUP', 'PYTHONPYCACHEPREFIX'): + env.pop(name, None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC', PYTHONDONTWRITEBYTECODE='1') + usage_path = folder / 'usage.json' + timed = ['/usr/bin/time', '-f', '{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', + '-o', str(usage_path), '--', *command] + started = {'label': args.label, 'job': 'publication-' + args.job, 'command': command, + 'stage_sha256': hashlib.sha256((package / 'payload/STAGE.json').read_bytes()).hexdigest(), + 'publication_source_inventory_sha256': hashlib.sha256(json.dumps(before, sort_keys=True).encode()).hexdigest(), + 'runner_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + 'spent_before_seconds': spent, 'phase_cap_seconds': cap, + 'performance_sample': False} + (folder / 'START.json').write_text(json.dumps(started, indent=2, sort_keys=True) + '\n') + start = time.monotonic() + peak = 0 + stop = None + known = {} + with (folder / 'stdout.txt').open('wb') as out, (folder / 'stderr.txt').open('wb') as err: + process = subprocess.Popen(timed, cwd=repository, env=env, stdout=out, stderr=err, start_new_session=True) + try: + # Capture the unreaped child generation before poll/wait can + # release its PID, including for a very short failed command. + descendants(process.pid, known) + if process.pid not in known: + raise RuntimeError('Could not capture original publication process identity') + while process.poll() is None: + rss, _ = descendants(process.pid, known) + peak = max(peak, rss) + if peak > 1024 ** 3: + stop = 'sampled_descendant_tree_rss_cap' + elif time.monotonic() - start > min(180, cap - spent): + stop = 'outer_wall_or_aggregate_cap' + elif max((folder / 'stdout.txt').stat().st_size, (folder / 'stderr.txt').stat().st_size) > 2 * 1024 ** 2: + stop = 'output_cap' + if stop: + kill_descendants(process.pid, known, signal.SIGTERM) + break + time.sleep(0.05) + try: + code = process.wait(timeout=2) + except subprocess.TimeoutExpired: + kill_descendants(process.pid, known, signal.SIGKILL) + code = process.wait() + finally: + kill_descendants(process.pid, known, signal.SIGKILL) + process.wait() + elapsed = time.monotonic() - start + stdout_path, stderr_path = folder / 'stdout.txt', folder / 'stderr.txt' + stdout_bytes, stderr_bytes = stdout_path.stat().st_size, stderr_path.stat().st_size + if max(stdout_bytes, stderr_bytes) > 2 * 1024 ** 2: + stop = stop or 'output_cap' + usage = None + if usage_path.exists(): + raw = usage_path.read_text() + try: + usage = json.loads(raw.strip().splitlines()[-1]) + except (ValueError, IndexError): + usage = {'raw': raw} + unchanged = inventory(package) == before + receipt = dict(started, status='PASS' if code == 0 and stop is None and stderr_bytes == 0 and unchanged else 'STOP', + exit=code, termination=stop, wall_seconds=elapsed, usage=usage, + source_bytes_and_modes_unchanged=unchanged, sampled_descendant_tree_rss_bytes=peak, + stdout_sha256=content_digest(stdout_path), stdout_bytes=stdout_bytes, + stderr_sha256=content_digest(stderr_path), stderr_bytes=stderr_bytes, + inner_scientific_guard='Unchanged v4 runner, explicit external HERE and150s cap, each child1GiB; outer packaging envelope180s') + (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps(receipt, sort_keys=True)) + if receipt['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/evidence/publication-v1/CODE-SOURCES.json b/research/h25-bookkeeping/evidence/publication-v1/CODE-SOURCES.json new file mode 100644 index 0000000000..710493d414 --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/CODE-SOURCES.json @@ -0,0 +1,381 @@ +{ + "coverage": "Every immutable package file including exact161-file v4 payload, all22 attempt records and changed historical sources, wrappers, README/TASK/SOURCES/VERIFY, input ancestry and independent reviews. CODE is bound by committed package identity; VALIDATION/optionalPUBLICATION-STATUS never substitute for science.", + "excluded_mutable": [ + "CODE-SOURCES.json", + "VALIDATION.json", + "PUBLICATION-STATUS.json" + ], + "file_count": 369, + "files": { + "CPYTHON-LICENSE.txt": "3b2f81fe21d181c499c59a256c8e1968455d6689d269aa85373bfb6af41da3bf", + "README.md": "27e532c502eec0144c0940b4ff9d04314d40764deb272e09f12bb40099284023", + "SOURCES.json": "812d5efeab109646512e9b531cfb8845809e256fcb6fc80693131125271c0656", + "TASK.json": "d4a7db0d3bd59bef4080bacdc2f4b51691095932e114cb9cac7e14cc2c5feeaa", + "VERIFY.json": "8c155ad1e28038f71bd53b341d9a93af52f402b680f4c4a2e5101638491c47f6", + "archive_support.py": "eee90f3815f4bd90eb96152bc461ec968ffb91d47c990e77712e74f6677c51be", + "check_artifacts.py": "03d89a1df701305d37289de9a6bda4ac485da83ca43459d41de2bd4f78a50445", + "evidence/INPUT-COMMIT.json": "22b1813119738540e4ad1dde298ca23ce353d5bd5b3a4012b0899cd77ce8466b", + "evidence/control/ADMISSION-REVIEW-PROVENANCE.json": "4a7643e574eb2acebca2369125a205d9f1307afbe4db7a7a9691bfaf40e55d51", + "evidence/control/BASELINE-INTAKE.json": "227b296f8195c4a5b94c8ce99e67196bbca7987de52c97fe2056cc8434c3d4b0", + "evidence/control/BASELINE.json": "ae13cda267193b1dc31f898dfccccae28140d80d190cdd9f3f6f9f113db1ccc0", + "evidence/control/COMBINED-ADMISSION-v4.json": "bdf1788478dd6e97eba1b4a664a2d04faf5660470b77d49bcf261fe57f700fa5", + "evidence/control/ENVIRONMENT.json": "ca13147ca37e8c95358bb5f90969a010d178c6d40d7c52fe75572e82930d3720", + "evidence/control/EXECUTION-PHASE.json": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "evidence/control/FINITE-ADMISSION-v1.json": "b9e09ce10e20d27c5b0f19c3963697876f79f70789dcba71cc76adb4a863a6fd", + "evidence/control/IMPLEMENTATION-ADMISSION.json": "15fa37b108431222eeada7a4365c7a08b7528c2453b2ecc8b689447b4cb0026a", + "evidence/control/INDIVIDUAL-PILOT-SEQUENCE.json": "8209ddde663022ed8c462938d7e8891158bee4d59b024992fb579a47765df19f", + "evidence/control/PUBLICATION-UPSTREAM-REFRESH.json": "1be7a598e257fd6407840a74d48ded3126a32f6db61a6d862cc000e6be7c70de", + "evidence/control/QUALIFICATION-v4.json": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "evidence/control/UPSTREAM-REFRESH.json": "17fea48977cc49861d9a49636c361683d60d7dd9df11101218f6a794cb2874a6", + "evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.json": "c6b2355b9e36738025787021114181e5b9e23b24f6df0e1e1f57dc57912d61a5", + "evidence/control/admissions/v4-final/IMPLEMENTATION-REVIEW.md": "751557dc95f0d19ae1d7ecc582ce1c01e3700dc66f292c05541d91ceec22f31e", + "evidence/control/upstream/AGENTS.md": "fbee67ab9e0ae4629a35fd9dba69c8f7e29e4a15392eb2d0f75d8768ffb65f40", + "evidence/control/upstream/CONTRIBUTING.md": "fcd1a8d0e52342a23b8ffa9e905e85ccc539fb084145ef016dfc93cedfb3d924", + "evidence/control/upstream/autoresearch.md": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d", + "evidence/control/upstream/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "evidence/control/upstream/docs/research/agent-task-catalog.json": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "evidence/control/upstream/docs/research/current-priorities.md": "70f61c8d140ae6e892f2b8f065bba4eae3e76f7a8f55f632fd4e2f9f34039bdc", + "evidence/historical-source/README.md": "aeda57fbfd6115ac4aea8f007564a0878c8b25d3100967072fa612f4da59c52f", + "evidence/historical-source/evaluate_qualification.py": "a8aa4ae0e8d3edd848ddc540d9251652667bff7e915a5ef7bcedb94f46369da4", + "evidence/historical-source/summarize_runs.py": "29cb5d246f733c3af568aa3e15909ff65be1fd72fd3e600866930f1515e14229", + "evidence/local-source/publication_guard.py": "c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d", + "evidence/research/independent-review/ADAPTER-INTERFACES.md": "37dbd8f35d0cc74408261ffcbed2e2ad8442aff592e86c1558ed0ca1477ec691", + "evidence/research/independent-review/CALL-BUDGET-REVIEW.json": "ab6de6998d1db8b8f6bfffb269e12f5c614b89fafe0cfb0067ddafa5ac4ef196", + "evidence/research/independent-review/CODE-GATE.json": "78a3cf63df8de9013ea0b6d8c171154c8c3764c2672cd65ae0c9310a2327d7d6", + "evidence/research/independent-review/CODE-GATE.md": "6b8790dc7c59c1d19984d01fbcb7f1f7f660833836bc57af020d5e648583fd22", + "evidence/research/independent-review/CONTRACT-MATRIX.md": "f269dbb0d89295cc89e8ba3d85b782855edc4af3202c547dedb71fe73193b993", + "evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json": "8f06e15a082b2cca9167cc2f1822a11bf96ccc8d7ad748d4668570d9da8e7553", + "evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.md": "66825dc932ac9a5407548c56cc8330602f04ff55c0d22311cfb8dbc1e8999766", + "evidence/research/independent-review/IMPLEMENTATION-REVIEW.json": "c6b2355b9e36738025787021114181e5b9e23b24f6df0e1e1f57dc57912d61a5", + "evidence/research/independent-review/IMPLEMENTATION-REVIEW.md": "751557dc95f0d19ae1d7ecc582ce1c01e3700dc66f292c05541d91ceec22f31e", + "evidence/research/independent-review/P1-LEASE-CONTRACT.md": "4b75027333b0cedf0269913ee075302c4ffba433db8eef04062903f1a356bc39", + "evidence/research/independent-review/PROPOSAL-REVIEW.json": "6e7834e68d10c4ca3bb34a6983a0dcb9c5ba7a108f6a306dd899bd3d6375d5b5", + "evidence/research/independent-review/PROPOSAL-REVIEW.md": "2c71cbd73f306752f7f7b974877295d662b80b915758441e9c7acc196ebb5edf", + "evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json": "2e6acc7fd9e123684a5f28992aef39a288404bdc5a021d3c762b7352a9cdc585", + "evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.md": "88311c47156f38b981a8e7b49689c455ddaa79513bcefeae532d938b724838c3", + "evidence/research/independent-review/REVIEW-GATES.json": "a69a00189fdcf5d34c4caf13085f89b3d1e086ee99bc21076e8a8c096ba23f5f", + "evidence/revisions/v1/PLAN.json": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639", + "evidence/revisions/v1/PLAN.md": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5", + "evidence/revisions/v1/STAGE.json": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "evidence/revisions/v1/integration/adapters.py": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72", + "evidence/revisions/v1/priorities/set-reuse/IMPLEMENTATION.md": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7", + "evidence/revisions/v1/priorities/set-reuse/finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "evidence/revisions/v1/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/revisions/v2/PLAN.json": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639", + "evidence/revisions/v2/PLAN.md": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5", + "evidence/revisions/v2/STAGE.json": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "evidence/revisions/v2/priorities/set-reuse/IMPLEMENTATION.md": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7", + "evidence/revisions/v2/priorities/set-reuse/finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "evidence/revisions/v2/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/revisions/v3/STAGE.json": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "evidence/revisions/v3/priorities/set-reuse/IMPLEMENTATION.md": "f3966bebe186a90729deaa0c5c4630b355637a5bb17e9deea8d8f2239078210a", + "evidence/revisions/v3/priorities/set-reuse/SOURCE-READINESS.json": "9013633e144dc03c5ccb73c241fb116b4914138d6be691c2884bcc5c068d6bcd", + "evidence/revisions/v3/priorities/set-reuse/finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "evidence/revisions/v3/priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "evidence/runs/finite-P1-O-v2/START.json": "3f917b4c06de0158787b23d2c847d282013da7bacff0dfc7608cde384b2b6848", + "evidence/runs/finite-P1-O-v2/receipt.json": "73a19dd6b7edfea707d1a809a6c5b65b86bfc8303e0e7846c6cfa08e59548f13", + "evidence/runs/finite-P1-O-v2/stderr.txt": "cf857d5af2231a0240d4932eae3fff889f05ce4229e514593566a46696e0e710", + "evidence/runs/finite-P1-O-v2/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-O-v2/usage.json": "b6da24f5c00a8b016cfa43e051e3db106d5515f2f66284c1771db5e50d9eb42a", + "evidence/runs/finite-P1-O-v3/START.json": "a540e2ceb113f407a4cb5315ab747965b31f1e1e0fbbb0c4e58b962c9ec3ac5c", + "evidence/runs/finite-P1-O-v3/receipt.json": "32eb9da6703a5f4b4552f7f15f31960b2b39d5c88eda8d98631dc1dd192cacd7", + "evidence/runs/finite-P1-O-v3/scientific-receipt.json": "34c359652aa4d0bf18a54035ab7c6a69bf376dfebc25a52bd677546ceb121830", + "evidence/runs/finite-P1-O-v3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-O-v3/stdout.txt": "54821a17869e76d98a8d51edd51d9aba251c08c53a3bf0217c40bc8528290671", + "evidence/runs/finite-P1-O-v3/usage.json": "6b4a35bcffa3a816f7e6f4d07b8a059ffda5cc7faeeeab9d0c761d7d9354171a", + "evidence/runs/finite-P1-normal-v2/START.json": "0a10b84d777a404908a3da90b93d04d254fa6641c52822d3c602b5ed6fc1124b", + "evidence/runs/finite-P1-normal-v2/receipt.json": "08472c32752b9efb61ec9df18a1d608475c2e992a026036ae61b27cdb8f56386", + "evidence/runs/finite-P1-normal-v2/scientific-receipt.json": "743878514b9544ddaa8146cdfe1ccd94b462add6c1918bef721518177e853bfc", + "evidence/runs/finite-P1-normal-v2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-normal-v2/stdout.txt": "6d25ad7b7ff81b7df3a263a32ad3ce1176d21ff05b55e0dcb64e422e31a10be5", + "evidence/runs/finite-P1-normal-v2/usage.json": "4943618c964b683e6174693723a58a1f5af400563fc73a24433784ad926f4ff3", + "evidence/runs/finite-P1-normal-v3/START.json": "9a7f8c8a4e642565b903b7d734a16d84257db492fe64cdf2a612baca695e524c", + "evidence/runs/finite-P1-normal-v3/receipt.json": "c6bfed16508860931a70cfa122defb2064955df0b3cb5dd8b078c8fd4e226530", + "evidence/runs/finite-P1-normal-v3/scientific-receipt.json": "97bb2b6707e9fc467e3d31eb9f7073af95edc9b416e768b6857c867208020e7c", + "evidence/runs/finite-P1-normal-v3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P1-normal-v3/stdout.txt": "46b26672e3262d518abffa352829094da7e5276dce36e1725eb1ed2aeb4f4c50", + "evidence/runs/finite-P1-normal-v3/usage.json": "be35e62c844a0be006e07fb04b957956604f0abdfd9f5f902ffdf0364816cf79", + "evidence/runs/finite-P2-O-v1/START.json": "d54684331db093ece311a75e06ec3974c8e6d1a86b5c1c38f69738d08f4913a9", + "evidence/runs/finite-P2-O-v1/receipt.json": "7a0198be16b8b1de498a2a29c49d83876d6ef87dc9ef7c27d959a1554d62a508", + "evidence/runs/finite-P2-O-v1/scientific-receipt.json": "0dfd9a7fe9518274a3b04fa755bc5a32082decf2b6787ec01b44ef411eedb919", + "evidence/runs/finite-P2-O-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P2-O-v1/stdout.txt": "710b9ebcb967d964191a367142e20d93ba5134ebac3181770b04f572c7730265", + "evidence/runs/finite-P2-O-v1/usage.json": "7df942f5b0e46436e27944f6d863201531f142b84d7034b3f687bdcdf4b387df", + "evidence/runs/finite-P2-normal-v1/START.json": "80f7bb9215f9e1e3fc931a40d924286ddc757615da7f12c30362187219b2854e", + "evidence/runs/finite-P2-normal-v1/receipt.json": "d628c5dd8b80494fb1685fd94f78cddd3ddf6477e76a7efcd041791699731f53", + "evidence/runs/finite-P2-normal-v1/scientific-receipt.json": "0c17246c4b14189adc02627d439123b05f2933b5b5a85d8c69901459b6d3348f", + "evidence/runs/finite-P2-normal-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P2-normal-v1/stdout.txt": "9cf8d1295b34d378784070092e03aa302224e7b503ead3ea80b5a1ac456689b4", + "evidence/runs/finite-P2-normal-v1/usage.json": "ccbe980a5524e00417c96ca64e593fecf9a87fe89dd00e4ca8c16917efc9b2c1", + "evidence/runs/finite-P3-O-v1/START.json": "f37a1fff59e891a3ef1425384406053e46a96ecc92478f59ac27f97f09be1290", + "evidence/runs/finite-P3-O-v1/receipt.json": "29aff35432c14876b164f87112facf8e594217947086a37bc7c073db32d222b8", + "evidence/runs/finite-P3-O-v1/scientific-receipt.json": "dd88c61c042b3026182704c3d380defd53d69755b5c42a79a9fbc56e224d07f7", + "evidence/runs/finite-P3-O-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P3-O-v1/stdout.txt": "4a724dedb485cda71a10b96cf20910099ba659c9a42159ee80c5631802e4b948", + "evidence/runs/finite-P3-O-v1/usage.json": "2d379009885ead1e3f31a57e94ad76a15da02522962358464b6a56f319b25be6", + "evidence/runs/finite-P3-normal-v1/START.json": "889171016eb6d36e80c1068aeeca22816725a2a36ff34344769067204173a358", + "evidence/runs/finite-P3-normal-v1/receipt.json": "4deafb884314517f5291b9b02715eb6dc5df68a45f8274ec466ab9938784d0ab", + "evidence/runs/finite-P3-normal-v1/scientific-receipt.json": "1b5cea72a0e9a2e023e4bf77e9f8b224048da8ebe31cf357ffd9994de32145ff", + "evidence/runs/finite-P3-normal-v1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-P3-normal-v1/stdout.txt": "c98b3d8b61543d4f36d58d4f4afb51f8cf1091a7da8b4b2c16fa479df490e65f", + "evidence/runs/finite-P3-normal-v1/usage.json": "b16240fc0c1cf4440f5513d0f61aeb117b93ebb3db149e9a0ae7f48a72f8f956", + "evidence/runs/finite-combined-O-v4/START.json": "b8654eec557bee5ae03bbd5efce2e00638f4d16a443a41a6afd7ed57b486b7c0", + "evidence/runs/finite-combined-O-v4/receipt.json": "a349c7b5403c9b5bfc8a30a87de1c7334a8dac2fd9a4df92bcc82d183623a6b4", + "evidence/runs/finite-combined-O-v4/scientific-receipt.json": "e8ce0cadb455309e57d6dc650d2ab654d9424c397ca67b69420e79af5201698b", + "evidence/runs/finite-combined-O-v4/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-combined-O-v4/stdout.txt": "60a5980d3e05919c5b0f4aad5f91648edfde7cc2bebbbab5175b3d3f6b6ee50c", + "evidence/runs/finite-combined-O-v4/usage.json": "36d3d173b845e3917c84e601a601ca55b186757ae5e51b2d4beabd61281864bd", + "evidence/runs/finite-combined-normal-v4/START.json": "022b075d2a9c2b6b8ea183c16a51f21d805ca41444acaa843cecf2d09bb12949", + "evidence/runs/finite-combined-normal-v4/receipt.json": "e27774f6bd0671da631b8b9b2aca22a24d2fa85d00bde48b6a7ce52c37cfb12c", + "evidence/runs/finite-combined-normal-v4/scientific-receipt.json": "9a252ddad438c6539807181d728f833bedf093c839bf1e84fe7b9d12364e27e9", + "evidence/runs/finite-combined-normal-v4/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/finite-combined-normal-v4/stdout.txt": "241b2cc4eae112b7ba568b035c955f56fd88726f10053a556d100bca8b3e539f", + "evidence/runs/finite-combined-normal-v4/usage.json": "0f8ffa5aed4c2b70f764e5a9088de8fdca43c8baea271966a92c177ded3d6977", + "evidence/runs/pilot-P1-B/START.json": "6600bb1bfd6e4cf6de7cb16044f3173df4c14834c7c46635b628746a196be478", + "evidence/runs/pilot-P1-B/receipt.json": "5af1f03fc8101bf126132a4be017033ae41d0dcade69da797e2c22483005e495", + "evidence/runs/pilot-P1-B/scientific-receipt.json": "5b24ea2b4f5b1de1534c0501d4377d40cd947184fd56da1d2c1fac3e7beb6ad1", + "evidence/runs/pilot-P1-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P1-B/stdout.txt": "3f38611cd867d086b277311db0ee0caa362823924f0ec5210fcd37c94a679d64", + "evidence/runs/pilot-P1-B/usage.json": "d1f9b5c62780b366e1c42b6a441625d6981bb072d520e8202287082102fc3b45", + "evidence/runs/pilot-P1-C/START.json": "bb7bfc8e2c0dfdd4f9742f8f91e240d3a6c8f9f18b4c24d0147790ca6f38cab1", + "evidence/runs/pilot-P1-C/receipt.json": "1933791e7554434c85938ee4e20069ea122b9666c47df93c14648c63d77afd72", + "evidence/runs/pilot-P1-C/scientific-receipt.json": "b46aacb01b7db8d518da7a9193d525f2a65148d261be0c167c36518f53a5f2a1", + "evidence/runs/pilot-P1-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P1-C/stdout.txt": "bcf96193669ff3ab3585bb48cf1e3b7c3e298a32a92dcee5d46289fbad3d103b", + "evidence/runs/pilot-P1-C/usage.json": "92c0b23023a5e8083f53359973f836589540d1e3fb026f961a1464a4a08baf5c", + "evidence/runs/pilot-P2-B/START.json": "025bad6d1d0720f79d458884888b85e6311191c5b2eaa7ea3b773f02dc34da3d", + "evidence/runs/pilot-P2-B/receipt.json": "56004f2e61d009b37f2db6b9c98d70d81bfdd50537fd543285129ae00a091be3", + "evidence/runs/pilot-P2-B/scientific-receipt.json": "eb1d9d9546b639fad9024b5dc5d4a177d2585590f0c02530e69d96cef5e1de34", + "evidence/runs/pilot-P2-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P2-B/stdout.txt": "7f4ad570bc105d6f02e37ceebab6dbea884e65c29390391f2b8255ca175afe43", + "evidence/runs/pilot-P2-B/usage.json": "a587ac2cc7dd3612618cbf771ec4b19ee071aa1d18a4696ac9d5217840e8f55d", + "evidence/runs/pilot-P2-C/START.json": "4b3f075cf1eb1cc27508bfc2d9745a1e7d4a30cdfbd5936b234a156387ec4d44", + "evidence/runs/pilot-P2-C/receipt.json": "120d49905ad03e7f0ca20768113f0b283b98620e6140925b387836ef558b4e69", + "evidence/runs/pilot-P2-C/scientific-receipt.json": "c8dabe911cfa72008ae39bc267806a24af7c622ecd6595dd247fe281b6c8afc6", + "evidence/runs/pilot-P2-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P2-C/stdout.txt": "542a9e3ec430d7d74f15467a261f29bcb58c0d25782e7c4dd3311185c1c12b8e", + "evidence/runs/pilot-P2-C/usage.json": "3a85a71bb41702f77d5d2a3469a3f5e2ee9473904db1c62019edd576d0bde329", + "evidence/runs/pilot-P3-B/START.json": "995475d0964509602f20a24930d10a81d04425b5474c5b6841301bfcbcb13f04", + "evidence/runs/pilot-P3-B/receipt.json": "c3229cb8e4484730d41bc5253b024df3b32655777cae76802d94958078bb66d8", + "evidence/runs/pilot-P3-B/scientific-receipt.json": "d59416d75401f76e69b7638aac4c294c47a91b224166bcb7ffb149aa717101f5", + "evidence/runs/pilot-P3-B/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P3-B/stdout.txt": "d04f1289c66f2680f84d4c2e0bc0aff0e956f55604a562b01297944f981be11b", + "evidence/runs/pilot-P3-B/usage.json": "b43a7b39c476a06eac9333b2b487672fe296e92e26e948f927d5dfc5f0386e27", + "evidence/runs/pilot-P3-C/START.json": "115f2e2998075a8fa04ee428ed30d0f29bb9e4f63f5dcf6189b667ad77fef98b", + "evidence/runs/pilot-P3-C/receipt.json": "9b6d0f65acdb78ac02499c0e2c57d5fc78e3e71083f06657a187a4aa821cd50a", + "evidence/runs/pilot-P3-C/scientific-receipt.json": "b4ee7896dec5a900f45026cf93bd81f9af7805c9b51f769cdd1fdbf467fea699", + "evidence/runs/pilot-P3-C/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/pilot-P3-C/stdout.txt": "e270d9bf87b21bef57fb0346e073008b5bbc398071e58a4d616f1a875a0e3e89", + "evidence/runs/pilot-P3-C/usage.json": "e1c886385d5ab114c0ad59a5ec75a17b02c14207a038916f7b32cc28122fbfd8", + "evidence/runs/qual-B1/START.json": "cad82494cfbcb151c35957c6bc2a58d31e6d6f6d71ca26f0b05e72133e26ed50", + "evidence/runs/qual-B1/receipt.json": "7b3d7d427d2d06a9d6e436454d1ef7623e0f8ad50a0a23a0ec0d2ec0fc12b788", + "evidence/runs/qual-B1/scientific-receipt.json": "c9345eb1ff8fdf2607832b39bb4c1b51fe6f1c03db3c4ebfe463900cded6bff5", + "evidence/runs/qual-B1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B1/stdout.txt": "bca8ab8b35591f3c6204751ecf41f430ea81e91a2eea37767a8731f8e81a1517", + "evidence/runs/qual-B1/usage.json": "c8e22ca93e25676ef526ad962b08e19ad0cd445a6ef3379693e35fa2bbbc6c14", + "evidence/runs/qual-B2/START.json": "8d8f426378639068c92a463b9581cd842f913d3f3f9d360d2c6c53cb43bacc94", + "evidence/runs/qual-B2/receipt.json": "b6e9a8dc8bc89b473b2b98995f4d0aa4c08b286df22bbc122255731ecf577934", + "evidence/runs/qual-B2/scientific-receipt.json": "bb07ee0af583165a8a67a08edc5576c25f63c3103a6cefcc3643bfc71ff9dd89", + "evidence/runs/qual-B2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B2/stdout.txt": "865bf7226a10c8e9904fa67bf16c329b9fb5dbb0e577bf49cb55e718a5c255a7", + "evidence/runs/qual-B2/usage.json": "edd74814f57f6adfe9b2b629b6282d5b2814876a4be3d7adb64d77b3a46c0c36", + "evidence/runs/qual-B3/START.json": "af1bb6390e3a8fc6863bf9543f1196de1f39bc987fe01c06c73933601cc070c7", + "evidence/runs/qual-B3/receipt.json": "1e839f0e4de437b59f428213922b03e090c5794973c7a6fc763a512da9c2c0fd", + "evidence/runs/qual-B3/scientific-receipt.json": "dc41582760b650c17ebd6fc8591be5ea4685d1a5aa0b0b005de4bb15477233bf", + "evidence/runs/qual-B3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-B3/stdout.txt": "6b709607dba67b762bbf52e0480a55b9e8d372a04110d7e5d0e51a4bade383ed", + "evidence/runs/qual-B3/usage.json": "df73241caa2c4579c5b083aa450bf262d0d1fd3f76080d4056dd39a6b4fe6d94", + "evidence/runs/qual-C1/START.json": "a0a76fb49ac8e9e43ef5e338efda0473e2462bd70334cfdd8a753a59eb1b3c83", + "evidence/runs/qual-C1/receipt.json": "e07bee3ecf50f5f2cd77910763f65d05baaea1ad3be50c5282a4e96b74b6ce15", + "evidence/runs/qual-C1/scientific-receipt.json": "ed60c889422cd98c2b525b6d5f731a01e8f6e0f8dfdb0de8d61c52912f591495", + "evidence/runs/qual-C1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C1/stdout.txt": "f4a724dc92d23ad1ee261f51e6b6eaa7b0d0b2df130ea8ac42f26868600c030d", + "evidence/runs/qual-C1/usage.json": "54fa64ff51c9d45fdac2655525740d4c24ac68185b3a1689b1d0741bfab71901", + "evidence/runs/qual-C2/START.json": "1b3f7c38579a12e609d856120f6bd69e97b5dc4b9b5e4ed909839e5386ca8f47", + "evidence/runs/qual-C2/receipt.json": "4f939f3897dbedeeed8a2ac0078eb24cb0c1cf7034e50f2dc60cf60dcfc2c235", + "evidence/runs/qual-C2/scientific-receipt.json": "a0bfabd6785e7dc2248fdf85e0769965bfac5916444c368ded1280f79bd944a5", + "evidence/runs/qual-C2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C2/stdout.txt": "476620742ff72624caea3b8bf075f65f72e404ea28f986a29d680360d590c269", + "evidence/runs/qual-C2/usage.json": "3b949d87012f128f178b1c86024f6c39d7586170bfd570a63199a4b9f77e1dc4", + "evidence/runs/qual-C3/START.json": "416c7d9735ec5e57191c7d54e30067a4bf9a801f8cc72893328167ef3537ebec", + "evidence/runs/qual-C3/receipt.json": "93eeaed9de3af3655d285ce2c2c92f844f73ae3646a9271e8b322d29a986bf19", + "evidence/runs/qual-C3/scientific-receipt.json": "98c77d54333878fc4cc833f36390d3f0deda472e342d572c525c8b99dfb45fe3", + "evidence/runs/qual-C3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/qual-C3/stdout.txt": "86ff5045c99f0f0a2ee34119ab5d0eeb86b59249140be8158dfb21c02bda4b19", + "evidence/runs/qual-C3/usage.json": "055a093dbfff85251fc54b013bac8bc94a5e80ddf033a5b9f065341b1804cce2", + "evidence/validation/CALL-CENSUS-PILOTS.json": "940c8583722eddd2c36a8360ec14f9219ea39f3fa58103e1d382bd7a5e37fb2c", + "evidence/validation/CALL-CENSUS.json": "55878bd7f34481472cf45876747e8ad24be40d07abc3fc4e9bb963fb8023cc10", + "evidence/validation/COMBINED-FIRST-PAIR.json": "619f1cb119331de98c06707bf5ac7dee034f9571699b5cbf4e38ce2039fcee94", + "evidence/validation/COMBINED-GATE.json": "5fca5cf80da96781c4e2ad112abee94a982341238f7fe9f38e0f6305c23fb43d", + "evidence/validation/P1-O-v2-STOP.json": "fcc04985b75c9df1345ccc87fd508a5d6a17f5540ef88f064e6a21d9d4172e9b", + "evidence/validation/P1-PILOT.json": "5f6bd00c20038685e5f8a8ab157febc9f2591602c35533ed8c0c3366e89c17bd", + "evidence/validation/P2-PILOT.json": "036e7e469ae3228e6662267adb1db841b8b7f56f333e53b491918932fbb63a78", + "evidence/validation/P3-PILOT.json": "0328ec19139806dd424bfc676963fb001678f26cf8e2fc580c83d024ae982562", + "evidence/validation/RUN-INDEX.json": "cfcc237d5267c0edc8eb4658d349aff9445044ff42cc17f0cbdc50f02772f3e0", + "payload/JOBS.json": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e", + "payload/PLAN.json": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63", + "payload/PLAN.md": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106", + "payload/STAGE.json": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "payload/baseline/CODE-SOURCES.json": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "payload/baseline/README.md": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64", + "payload/baseline/SOURCE-PINS.json": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "payload/baseline/SOURCES.json": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a", + "payload/baseline/TASK.json": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38", + "payload/baseline/VALIDATION.json": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a", + "payload/baseline/VERIFY.json": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78", + "payload/baseline/anchor.json": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "payload/baseline/archive_support.py": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f", + "payload/baseline/check_artifacts.py": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f", + "payload/baseline/engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "payload/baseline/engine/finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "payload/baseline/engine/native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "payload/baseline/engine/native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "payload/baseline/engine/profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "payload/baseline/engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "payload/baseline/engine/source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "payload/baseline/evidence/COMPLETE-GATE.json": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b", + "payload/baseline/evidence/ENVIRONMENT.json": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384", + "payload/baseline/evidence/FIRST-PAIR-GATE.json": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc", + "payload/baseline/evidence/FULL-PAIR-ADMISSION.json": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829", + "payload/baseline/evidence/INDEPENDENT-REVIEW.md": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f", + "payload/baseline/evidence/INPUT-COMMIT.json": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b", + "payload/baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa", + "payload/baseline/evidence/PLAN.json": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813", + "payload/baseline/evidence/PROFILE-v1-FAILURE.json": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f", + "payload/baseline/evidence/RESULTS.md": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f", + "payload/baseline/evidence/SOURCE-DESIGN.md": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb", + "payload/baseline/evidence/UPSTREAM-REFRESH.json": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693", + "payload/baseline/evidence/canonical/MANIFEST.json": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "payload/baseline/evidence/canonical/complement-transcript.json": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8", + "payload/baseline/evidence/canonical/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "payload/baseline/evidence/canonical/full-return.lossless.json.gz": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2", + "payload/baseline/evidence/canonical/original-stdout.txt": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "payload/baseline/evidence/canonical/rank-trace.json.gz": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "payload/baseline/evidence/canonical/witness.json.gz": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "payload/baseline/evidence/publication-v1-failure/REVISION.json": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8", + "payload/baseline/evidence/publication-v1-failure/receipt.json": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a", + "payload/baseline/evidence/publication-v1-failure/stderr.txt": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515", + "payload/baseline/evidence/publication-v1-failure/stdout.txt": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342", + "payload/baseline/evidence/publication-v1-failure/usage.json": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc", + "payload/baseline/evidence/publication-v1-failure/verify_full.py.txt": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e", + "payload/baseline/evidence/runs/full-network-B1/receipt.json": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27", + "payload/baseline/evidence/runs/full-network-B1/scientific-receipt.json": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31", + "payload/baseline/evidence/runs/full-network-B1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B1/stdout.txt": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43", + "payload/baseline/evidence/runs/full-network-B1/usage.json": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505", + "payload/baseline/evidence/runs/full-network-B2/receipt.json": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d", + "payload/baseline/evidence/runs/full-network-B2/scientific-receipt.json": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7", + "payload/baseline/evidence/runs/full-network-B2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B2/stdout.txt": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d", + "payload/baseline/evidence/runs/full-network-B2/usage.json": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891", + "payload/baseline/evidence/runs/full-network-B3/receipt.json": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506", + "payload/baseline/evidence/runs/full-network-B3/scientific-receipt.json": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495", + "payload/baseline/evidence/runs/full-network-B3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-B3/stdout.txt": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe", + "payload/baseline/evidence/runs/full-network-B3/usage.json": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8", + "payload/baseline/evidence/runs/full-network-C1/receipt.json": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934", + "payload/baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342", + "payload/baseline/evidence/runs/full-network-C1/scientific-receipt.json": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8", + "payload/baseline/evidence/runs/full-network-C1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C1/stdout.txt": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd", + "payload/baseline/evidence/runs/full-network-C1/usage.json": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84", + "payload/baseline/evidence/runs/full-network-C2/receipt.json": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73", + "payload/baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969", + "payload/baseline/evidence/runs/full-network-C2/scientific-receipt.json": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c", + "payload/baseline/evidence/runs/full-network-C2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C2/stdout.txt": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c", + "payload/baseline/evidence/runs/full-network-C2/usage.json": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886", + "payload/baseline/evidence/runs/full-network-C3/receipt.json": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce", + "payload/baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237", + "payload/baseline/evidence/runs/full-network-C3/scientific-receipt.json": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb", + "payload/baseline/evidence/runs/full-network-C3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-C3/stdout.txt": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0", + "payload/baseline/evidence/runs/full-network-C3/usage.json": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb", + "payload/baseline/evidence/runs/full-network-profile-v1/receipt.json": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c", + "payload/baseline/evidence/runs/full-network-profile-v1/stderr.txt": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76", + "payload/baseline/evidence/runs/full-network-profile-v1/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-profile-v1/usage.json": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78", + "payload/baseline/evidence/runs/full-network-profile-v2/receipt.json": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf", + "payload/baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a", + "payload/baseline/evidence/runs/full-network-profile-v2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "payload/baseline/evidence/runs/full-network-profile-v2/stdout.txt": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec", + "payload/baseline/evidence/runs/full-network-profile-v2/usage.json": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b", + "payload/baseline/frozen/scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "payload/baseline/frozen/scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "payload/baseline/frozen/scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "payload/baseline/frozen/scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "payload/baseline/frozen/scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "payload/baseline/frozen/scripts/exclusion_circuit.py": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "payload/baseline/frozen/scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "payload/baseline/frozen/scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "payload/baseline/frozen/scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "payload/baseline/frozen/scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "payload/baseline/frozen/scripts/shared_point_circuit.py": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "payload/baseline/frozen/scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "payload/baseline/frozen/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "payload/baseline/frozen/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "payload/baseline/frozen/upstream/build/figures/proof-map.tex": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "payload/baseline/frozen/upstream/build/main.tex": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "payload/baseline/frozen/upstream/build/references.bib": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "payload/baseline/frozen/upstream/build/sections/00-introduction.tex": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "payload/baseline/frozen/upstream/build/sections/01-history.tex": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "payload/baseline/frozen/upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "payload/baseline/frozen/upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "payload/baseline/frozen/upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "payload/baseline/frozen/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "payload/baseline/frozen/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "payload/baseline/frozen/upstream/build/sections/07-resampling.tex": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "payload/baseline/frozen/upstream/build/sections/08-assembly.tex": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "payload/baseline/frozen/upstream/build/sections/10-transposition.tex": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "payload/baseline/frozen/upstream/formalization.yaml": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "payload/baseline/frozen/upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "payload/baseline/full_B.py": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8", + "payload/baseline/full_C.py": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4", + "payload/baseline/full_driver.py": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "payload/baseline/guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "payload/baseline/reference/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "payload/baseline/reference/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "payload/baseline/replay.py": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90", + "payload/baseline/verify.py": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b", + "payload/baseline/verify_full.py": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8", + "payload/freeze_stage.py": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec", + "payload/integration/DERIVATION.json": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256", + "payload/integration/adapters.py": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94", + "payload/integration/derive_driver.py": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a", + "payload/integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "payload/priorities/runtime-guards/CALL-BUDGET.json": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec", + "payload/priorities/runtime-guards/IMPLEMENTATION.md": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605", + "payload/priorities/runtime-guards/PROPOSAL.json": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d", + "payload/priorities/runtime-guards/RESEARCH.md": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9", + "payload/priorities/runtime-guards/STATIC-CHECK.json": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160", + "payload/priorities/runtime-guards/guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "payload/priorities/runtime-guards/guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291", + "payload/priorities/set-reuse/CALL-BUDGET.json": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5", + "payload/priorities/set-reuse/IMPLEMENTATION.md": "6b0a86226046bc421134f18a0cd77ebc4d5dce07e0feb3b67de8c2a852856452", + "payload/priorities/set-reuse/OWNERSHIP.md": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099", + "payload/priorities/set-reuse/PORTABILITY-SOURCE.json": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82", + "payload/priorities/set-reuse/PORTABILITY.md": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1", + "payload/priorities/set-reuse/PROPOSAL.json": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d", + "payload/priorities/set-reuse/RESEARCH.md": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8", + "payload/priorities/set-reuse/SOURCE-READINESS.json": "4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556", + "payload/priorities/set-reuse/cpython-3.12.15-fractions.py": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "payload/priorities/set-reuse/finite_set_controls.py": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "payload/priorities/set-reuse/set_reuse.py": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "payload/priorities/trace-encoding/ADAPTER.md": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f", + "payload/priorities/trace-encoding/CALL-BUDGET.json": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab", + "payload/priorities/trace-encoding/PROPOSAL.json": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d", + "payload/priorities/trace-encoding/RESEARCH.md": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60", + "payload/priorities/trace-encoding/SOURCE-READINESS.json": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df", + "payload/priorities/trace-encoding/trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "payload/priorities/trace-encoding/trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447", + "payload/priorities/trace-encoding/trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "payload/run_guarded.py": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "replay.py": "50901fc7de6bbb39067e46d27f653a80b4f9f47c762a3a6c597727d8d6fc4883", + "verify.py": "f0a5e3ab9c9521f02ef33bba0508bc75cc5b49c1e117f203ff02af614444ee11", + "verify_full.py": "2fa8b3c0bd28c6162fb08190241b1d3195e48616986cf3309e293402fc5c0c2e" + }, + "schema_version": 1 +} diff --git a/research/h25-bookkeeping/evidence/publication-v1/VALIDATION-PREPARATION.json b/research/h25-bookkeeping/evidence/publication-v1/VALIDATION-PREPARATION.json new file mode 100644 index 0000000000..ae02e4d5b9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/VALIDATION-PREPARATION.json @@ -0,0 +1,9 @@ +{ + "hosted_CI": "PENDING_NEW_PR", + "immutable_payload_stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "input_ancestor": "26056452f06097eae4b5b502245f8bb6d3818c61", + "local_performance_gate": "PASS_BOTH15PERCENT_AND_NOISE", + "normal_O_combined_controls": "PASS_MEASURED_V4", + "note": "Preparation-time status; final exact-head publication readbacks may supersede this record. This file is excluded from CODE manifest self-authentication.", + "status": "PUBLICATION_CHECKS_PENDING" +} diff --git a/research/h25-bookkeeping/evidence/publication-v1/registry/START.json b/research/h25-bookkeeping/evidence/publication-v1/registry/START.json new file mode 100644 index 0000000000..2ed3bfb47e --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/registry/START.json @@ -0,0 +1,17 @@ +{ + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/publication-repo/scripts/research_package.py", + "--package", + "research/h25-bookkeeping" + ], + "job": "publication-registry", + "label": "publication-registry-v1", + "performance_sample": false, + "phase_cap_seconds": 600, + "publication_source_inventory_sha256": "b4eee7afcf353d8b84030727512bfe9d4bd3efafd90e5f87e795dc6404d9d9fa", + "runner_sha256": "c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d", + "spent_before_seconds": 332.099907813943, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/publication-v1/registry/receipt.json b/research/h25-bookkeeping/evidence/publication-v1/registry/receipt.json new file mode 100644 index 0000000000..6bfd4ce5a8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/registry/receipt.json @@ -0,0 +1,34 @@ +{ + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/publication-repo/scripts/research_package.py", + "--package", + "research/h25-bookkeeping" + ], + "exit": 0, + "inner_scientific_guard": "Unchanged v4 runner, explicit external HERE and150s cap, each child1GiB; outer packaging envelope180s", + "job": "publication-registry", + "label": "publication-registry-v1", + "performance_sample": false, + "phase_cap_seconds": 600, + "publication_source_inventory_sha256": "b4eee7afcf353d8b84030727512bfe9d4bd3efafd90e5f87e795dc6404d9d9fa", + "runner_sha256": "c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d", + "sampled_descendant_tree_rss_bytes": 463388672, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 332.099907813943, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 55288, + "stdout_sha256": "b15f09632f38df4d8682f34925dd10049c3b46168cfb9c3f3210d95e6788e1d2", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 455212, + "system_seconds": 5.25, + "user_seconds": 42.94 + }, + "wall_seconds": 34.88769384502666 +} diff --git a/research/h25-bookkeeping/evidence/publication-v1/registry/stderr.txt b/research/h25-bookkeeping/evidence/publication-v1/registry/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/publication-v1/registry/stdout.txt b/research/h25-bookkeeping/evidence/publication-v1/registry/stdout.txt new file mode 100644 index 0000000000..6e236e7f86 --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/registry/stdout.txt @@ -0,0 +1,13 @@ +CHECK Fresh complete finite control union for all three bookkeeping lanes plus original independent dense/typed/order/width/fallback controls; new external workspace and paid cold native builds. +{"budget_phase_sha256": "be039b8fcf768f417c1aec029ef1fd1000b2a507be48c1530235bb5f3dd4c3ad", "command": ["/usr/bin/python3.12", "-B", "/tmp/h25-bookkeeping-check-aefodues/replay/stages/v4/integration/full_driver.py", "--output", "/tmp/h25-bookkeeping-check-aefodues/replay/runtime/runs/replay/science", "--lanes", "all", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "finite-all", "label": "replay", "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes": 58535936, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.0, "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS", "stderr_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 10866, "stdout_sha256": "cc9e46179e59cf57a797788ca02f1a6ec9de8be162b70d9042bbdd46aba55cc5", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 40584, "system_seconds": 0.09, "user_seconds": 3.06}, "wall_seconds": 3.297701485978905} +{"complete_cli_not_run": true, "optimization": 0, "publication": {"automatic_retries": 0, "cost_scope": "Publication authentication, private copy, mode restoration and cleanup are additional correctness-wrapper costs, not replacement performance samples.", "execution_phase_aggregate_seconds": 600, "fixed_benchmark_sample": false, "fresh_private_stage_permissions_restored": true, "guard_receipt_sha256": "5247101792fa5309c2551097685501a027b6214f8644235ec1352bcd031d2244", "hosted_performance_factor_claim": false, "job": "finite-all", "package_bytes_and_modes_unchanged": true, "publication_manifest_sha256": "ba3621b6c51fb2605f0ad4e0851707e9b711cbe4dc302fa9aa18f786ebb6f5ea", "registered_outer_timeout_seconds": 180, "runner_overrides": {"HERE": "/tmp/h25-bookkeeping-check-aefodues/replay", "TIMEOUT": 150}, "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes_cap": 1073741824, "schema": "h25-publication-replay-v1", "scientific_receipt_sha256": "93ec4ac9dfa407650dd5c0413bab73918341aab885e9d54a8dd5ddf7a482c23a", "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS"}, "scientific": {"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "all", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}, "sets": {"cases": 23, "optimize": 0, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "error"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "source_pin_policy_cases": [{"digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "outcome": "recognized"}, {"digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "outcome": "recognized"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "StringSubclass", "outcome": "rejected"}], "status": "P1_FINITE_SET_CONTROLS_PASS"}, "trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 5, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}, "priorities/set-reuse/cpython-3.12.15-fractions.py": {"mode": 292, "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.03188996100000008, "wall_seconds": 0.032034939038567245}, "unchanged_python": {"cpu_seconds": 0.3188809579999998, "wall_seconds": 0.32152042497182265}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.789049, "wall_seconds": 1.8202813410316594}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.6957360000000001, "wall_seconds": 0.6959112990298308}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.24603899999999992, "wall_seconds": 0.24732050899183378}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.0053440000000000015, "wall_seconds": 0.005399596004281193}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0014470000000000038, "wall_seconds": 0.0014448739821091294}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.001133000000000009, "wall_seconds": 0.0011320810299366713}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004304000000000002, "wall_seconds": 0.00435830099740997}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005348999999999993, "wall_seconds": 0.005402463022619486}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.26225899999999996, "wall_seconds": 0.274187425035052}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.12308900000000067, "wall_seconds": 0.12311893096193671}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.541598, "wall_seconds": 0.5417277360102162}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.01625399999999999, "wall_seconds": 0.01625152095220983}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.014747999999999983, "wall_seconds": 0.014756049029529095}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.22592600000000002, "wall_seconds": 0.23555985203711316}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"}, "status": "PASS_H25_COMPLETE_FINITE_UNION"} +CHECK Same bounded finite control union in deliberate optimized mode, retaining exception-based checks and source admission; complete caller assertions remain enabled in the separate full command. +{"budget_phase_sha256": "be039b8fcf768f417c1aec029ef1fd1000b2a507be48c1530235bb5f3dd4c3ad", "command": ["/usr/bin/python3.12", "-B", "-O", "/tmp/h25-bookkeeping-check-f__d8x2e/replay/stages/v4/integration/full_driver.py", "--output", "/tmp/h25-bookkeeping-check-f__d8x2e/replay/runtime/runs/replay/science", "--lanes", "all", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "finite-O-all", "label": "replay", "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes": 72830976, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.0, "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS", "stderr_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 10872, "stdout_sha256": "098f592103257ed85aae97ff72ecfe4f19f1bea8279352b25231525093f37b19", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 40556, "system_seconds": 0.1, "user_seconds": 2.48}, "wall_seconds": 2.599390654009767} +{"complete_cli_not_run": true, "optimization": 1, "publication": {"automatic_retries": 0, "cost_scope": "Publication authentication, private copy, mode restoration and cleanup are additional correctness-wrapper costs, not replacement performance samples.", "execution_phase_aggregate_seconds": 600, "fixed_benchmark_sample": false, "fresh_private_stage_permissions_restored": true, "guard_receipt_sha256": "8f0e7acf9c621240a522ee4e6a61e805d9fde3c30de76d9ca5e58c6c2f2ce379", "hosted_performance_factor_claim": false, "job": "finite-O-all", "package_bytes_and_modes_unchanged": true, "publication_manifest_sha256": "ba3621b6c51fb2605f0ad4e0851707e9b711cbe4dc302fa9aa18f786ebb6f5ea", "registered_outer_timeout_seconds": 180, "runner_overrides": {"HERE": "/tmp/h25-bookkeeping-check-f__d8x2e/replay", "TIMEOUT": 150}, "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes_cap": 1073741824, "schema": "h25-publication-replay-v1", "scientific_receipt_sha256": "b6c11e02b041bcbc7ce7e929ae1d1643d0e0b293b1505b155c4064e19a8c4900", "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS"}, "scientific": {"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "all", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}, "sets": {"cases": 23, "optimize": 1, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "value"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "source_pin_policy_cases": [{"digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "outcome": "recognized"}, {"digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "outcome": "recognized"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "StringSubclass", "outcome": "rejected"}], "status": "P1_FINITE_SET_CONTROLS_PASS"}, "trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 5, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}, "priorities/set-reuse/cpython-3.12.15-fractions.py": {"mode": 292, "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 1, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.013336067000000007, "wall_seconds": 0.013333795999642462}, "unchanged_python": {"cpu_seconds": 0.132142349, "wall_seconds": 0.1322261460009031}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.0830130000000002, "wall_seconds": 1.0835343030048534}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.5897130000000004, "wall_seconds": 0.5897582080215216}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.24223899999999998, "wall_seconds": 0.24839413299923763}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004138000000000003, "wall_seconds": 0.004137049021665007}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0011730000000000074, "wall_seconds": 0.001172633026726544}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0006750000000000089, "wall_seconds": 0.0006741409888491035}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.002942, "wall_seconds": 0.0029409839771687984}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005436999999999997, "wall_seconds": 0.005436098959762603}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.26336000000000004, "wall_seconds": 0.2649791840231046}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.08511500000000072, "wall_seconds": 0.08512432395946234}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.48275999999999986, "wall_seconds": 0.48278141202172264}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.012584999999999624, "wall_seconds": 0.012583211006131023}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.00921800000000017, "wall_seconds": 0.009225047018844634}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.23479299999999992, "wall_seconds": 0.23641436698380858}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"}, "status": "PASS_H25_COMPLETE_FINITE_UNION"} +CHECK One assertion-on complete combined candidate correctness replay, exact v4 source modes restored only in a new external copy, unchanged serial runner with explicit HERE and 150-second inner limit; exact full certificate/stdout/types/witness/rank/complement, all paid controls, no hosted performance claim. +{"budget_phase_sha256": "be039b8fcf768f417c1aec029ef1fd1000b2a507be48c1530235bb5f3dd4c3ad", "command": ["/usr/bin/python3.12", "-B", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/stages/v4/integration/full_driver.py", "--output", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science", "--lanes", "all"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "full-all", "label": "replay", "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes": 423612416, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.0, "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS", "stderr_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 5163, "stdout_sha256": "b0eb88b3c79f5ea5be2adbbcc86cd45f85f8ff4314d75be9888c559317ddcc40", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 455212, "system_seconds": 0.36, "user_seconds": 21.72}, "wall_seconds": 22.359911304956768} +{"fixed_benchmark_sample": false, "hosted_performance_factor_claim": false, "publication": {"automatic_retries": 0, "cost_scope": "Publication authentication, private copy, mode restoration and cleanup are additional correctness-wrapper costs, not replacement performance samples.", "execution_phase_aggregate_seconds": 600, "fixed_benchmark_sample": false, "fresh_private_stage_permissions_restored": true, "guard_receipt_sha256": "cdb264c325afc231a34b3703d3f9afb204caa6f7ef78c5f3f941c64331441236", "hosted_performance_factor_claim": false, "job": "full-all", "package_bytes_and_modes_unchanged": true, "publication_manifest_sha256": "ba3621b6c51fb2605f0ad4e0851707e9b711cbe4dc302fa9aa18f786ebb6f5ea", "registered_outer_timeout_seconds": 180, "runner_overrides": {"HERE": "/tmp/h25-bookkeeping-check-6mcxelrs/replay", "TIMEOUT": 150}, "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", "sampled_process_group_rss_bytes_cap": 1073741824, "schema": "h25-publication-replay-v1", "scientific_receipt_sha256": "8ceae629711b431625fa7d823cfab1e38beaee919e202a42a63d06982274c2e8", "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS"}, "scientific": {"base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", "bookkeeping": {"encoder_build": {"command": ["x86_64-linux-gnu-gcc", "-shared", "-fPIC", "-O3", "-std=c11", "-Wall", "-Wextra", "-Werror", "-I/usr/include/python3.12", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/stages/v4/priorities/trace-encoding/trace_encoder.c", "-o", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/trace-cold-build/_trace_encoding.cpython-312-x86_64-linux-gnu.so"], "extension_sha256": "17c157f226fa355b463803daf103b30504ecf47307ba6353d49d747977db16aa", "no_cached_binary": true, "returncode": 0, "source_sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", "stderr": "", "stdout": ""}, "lanes": ["guards", "sets", "trace"], "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}, "sets": {"cases": 23, "optimize": 0, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "error"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "source_pin_policy_cases": [{"digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "outcome": "recognized"}, {"digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "outcome": "recognized"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "StringSubclass", "outcome": "rejected"}], "status": "P1_FINITE_SET_CONTROLS_PASS"}, "trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 5, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "original_observer_retained_for_old_controls": true, "set_reuse": {"allowances_armed": 1, "checks_captured": 1, "circuits_captured": 1, "entries": 1, "fallback_calls": 0, "fast_admissions": 1, "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "fraction_source_profile": "recorded-local-cpython-3.12.3", "private_operand_sets_constructed": 2300, "reservations": 1, "reservations_expired": 1, "schema": "h25-private-set-reuse-v1", "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1"}}, "build": {"c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", "command": ["x86_64-linux-gnu-gcc", "-shared", "-fPIC", "-O3", "-std=c11", "-Wall", "-Wextra", "-Werror", "-I/usr/include/python3.12", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/engine/native_gf2.c", "-o", "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so"], "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", "no_cached_binary": true, "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "returncode": 0, "stderr": "", "stdout": ""}, "compiler_tmpdir": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/compiler-tmp", "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "engine_custody": {"compare_side_verifier.py": {"bytes": 10571, "mode": 292, "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68"}, "finite_controls.py": {"bytes": 23815, "mode": 292, "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a"}, "native_backend.py": {"bytes": 20334, "mode": 292, "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5"}, "native_gf2.c": {"bytes": 7425, "mode": 292, "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc"}, "profile_side_verifier.py": {"bytes": 8959, "mode": 292, "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a"}, "source/complex_circuit.py": {"bytes": 19732, "mode": 292, "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1"}, "source/complex_network.py": {"bytes": 6105, "mode": 292, "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b"}}, "environment": {"executable": "/usr/bin/python3.12", "platform": "linux", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]"}, "finite_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.016480309999999943, "wall_seconds": 0.016477266035508364}, "unchanged_python": {"cpu_seconds": 0.15886486100000008, "wall_seconds": 0.15886328800115734}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "frozen_custody": {"scripts/audit_short_guards.py": {"bytes": 7956, "mode": 292, "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1"}, "scripts/certify.py": {"bytes": 11276, "mode": 292, "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e"}, "scripts/compact_control_layer.py": {"bytes": 7892, "mode": 292, "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f"}, "scripts/complex_circuit.py": {"bytes": 19732, "mode": 292, "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1"}, "scripts/complex_network.py": {"bytes": 6105, "mode": 292, "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b"}, "scripts/exclusion_circuit.py": {"bytes": 9450, "mode": 292, "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3"}, "scripts/paired_exclusion_circuit.py": {"bytes": 2289, "mode": 292, "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2"}, "scripts/paired_network.py": {"bytes": 4933, "mode": 292, "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7"}, "scripts/prepare_layers.py": {"bytes": 8196, "mode": 292, "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947"}, "scripts/search_network.py": {"bytes": 4314, "mode": 292, "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a"}, "scripts/shared_point_circuit.py": {"bytes": 13167, "mode": 292, "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95"}, "scripts/shared_point_network.py": {"bytes": 3119, "mode": 292, "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697"}, "upstream/LICENSE": {"bytes": 11357, "mode": 292, "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"}, "upstream/README.md": {"bytes": 541, "mode": 292, "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e"}, "upstream/build/figures/multiplication-flow.tex": {"bytes": 847, "mode": 292, "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320"}, "upstream/build/figures/proof-map.tex": {"bytes": 524, "mode": 292, "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848"}, "upstream/build/main.tex": {"bytes": 1882, "mode": 292, "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa"}, "upstream/build/references.bib": {"bytes": 9790, "mode": 292, "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476"}, "upstream/build/sections/00-introduction.tex": {"bytes": 11515, "mode": 292, "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0"}, "upstream/build/sections/01-history.tex": {"bytes": 9689, "mode": 292, "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead"}, "upstream/build/sections/02-streams.tex": {"bytes": 11311, "mode": 292, "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab"}, "upstream/build/sections/03-motifs.tex": {"bytes": 31874, "mode": 292, "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb"}, "upstream/build/sections/04-swap.tex": {"bytes": 19884, "mode": 292, "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906"}, "upstream/build/sections/05-layers.tex": {"bytes": 46811, "mode": 292, "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594"}, "upstream/build/sections/06-transforms.tex": {"bytes": 33854, "mode": 292, "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c"}, "upstream/build/sections/07-resampling.tex": {"bytes": 22053, "mode": 292, "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c"}, "upstream/build/sections/08-assembly.tex": {"bytes": 46444, "mode": 292, "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a"}, "upstream/build/sections/09-exact-arithmetic.tex": {"bytes": 6950, "mode": 292, "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3"}, "upstream/build/sections/10-transposition.tex": {"bytes": 2398, "mode": 292, "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb"}, "upstream/build/sections/11-grouped-rectangles.tex": {"bytes": 7405, "mode": 292, "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174"}, "upstream/formalization.yaml": {"bytes": 73925, "mode": 292, "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9"}, "upstream/manifest.json": {"bytes": 6217, "mode": 292, "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392"}}, "lanes": "all", "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", "mode": "candidate", "native_calls": {"complement_fallback": 0, "complement_native": 238685, "gram_fallback": 0, "gram_native": 59959}, "native_predecessor_pr": 5995, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}, "priorities/set-reuse/cpython-3.12.15-fractions.py": {"mode": 292, "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2110379999999998, "wall_seconds": 1.211530276981648}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.7605869999999995, "wall_seconds": 0.7605846310034394}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 8.799999999986596e-05, "wall_seconds": 8.767499821260571e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004482000000000319, "wall_seconds": 0.004482443036977202}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.223419, "wall_seconds": 0.22334415599470958}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.00726199999999988, "wall_seconds": 0.007268702029250562}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.008757000000000001, "wall_seconds": 0.008757230010814965}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003247000000000444, "wall_seconds": 0.0032460869988426566}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4700779999999991, "wall_seconds": 0.47008912899764255}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 17.382395000000002, "wall_seconds": 17.561651157040615}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0013250000000000206, "wall_seconds": 0.0013227949966676533}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0012060000000000126, "wall_seconds": 0.0012055770494043827}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.0049970000000000014, "wall_seconds": 0.004994977964088321}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004290000000004568, "wall_seconds": 0.00042802601819857955}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2623390000000008, "wall_seconds": 1.2623646979918703}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005522999999999986, "wall_seconds": 0.005523156956769526}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.2445460000000001, "wall_seconds": 0.24437875801231712}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.09506599999999987, "wall_seconds": 0.09506259404588491}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6403079999999999, "wall_seconds": 0.6403018030105159}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.015760999999999914, "wall_seconds": 0.015757800021674484}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.009411000000000058, "wall_seconds": 0.009407418954651803}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00013000000000218392, "wall_seconds": 0.00013158097863197327}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.001477999999998758, "wall_seconds": 0.0014778359909541905}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 0.022303000000000406, "wall_seconds": 0.022300234995782375}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.799999999966943e-05, "wall_seconds": 5.839200457558036e-05}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.9058970000000004, "wall_seconds": 1.9076121849939227}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21798, "wall_seconds": 0.21781613799976185}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 11.474173999999996, "wall_seconds": 11.65003290399909}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 2.5064779999999995, "wall_seconds": 2.5079622819903307}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 0.9947040000000023, "wall_seconds": 0.9948789059999399}}, "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", "process_and_compiler_cpu_seconds_before_receipt": 21.731768, "process_wall_seconds_before_receipt": 21.878567365987692, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "scientific_imports": {"audit_short_guards": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/audit_short_guards.py", "certify": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/certify.py", "compact_control_layer": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/compact_control_layer.py", "complex_circuit": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/engine/source/complex_circuit.py", "exclusion_circuit": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/exclusion_circuit.py", "paired_exclusion_circuit": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/paired_exclusion_circuit.py", "paired_network": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/paired_network.py", "prepare_layers": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/prepare_layers.py", "search_network": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/search_network.py", "shared_point_circuit": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/shared_point_circuit.py", "shared_point_network": "/tmp/h25-bookkeeping-check-6mcxelrs/replay/runtime/runs/replay/science/runtime-root/scripts/shared_point_network.py"}, "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", "status": "FULL_NETWORK_COMPLETE_PASS"}, "status": "PASS_H25_COMBINED_FULL_CORRECTNESS"} +CHECK Publication source custody plus unchanged baseline lossless canonical artifact verifier; exact typed return, certificate and streamed full witness/rank/complement identities; no numerical replay or timing claim. +{"full_typed_shape": true, "no_benchmark_or_theorem_claim": true, "payload_bytes": {"complement-transcript.json": 227, "complex-network.json": 5662, "full-return.lossless.json.gz": 7311, "original-stdout.txt": 137, "rank-trace.json.gz": 2674272, "witness.json.gz": 58143622}, "regenerated_container_hash_is_not_mathematical_identity": true, "status": "PASS_FULL_NETWORK_CANONICAL_TRANSPORT"} +{"new_performance_factor_claim": false, "scientific_replay": false, "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", "status": "PASS_H25_V4_AND_CANONICAL_TRANSPORT"} +PASS_REGISTERED_RESEARCH_PACKAGE research/h25-bookkeeping outcome=completed diff --git a/research/h25-bookkeeping/evidence/publication-v1/registry/usage.json b/research/h25-bookkeeping/evidence/publication-v1/registry/usage.json new file mode 100644 index 0000000000..5271c0d280 --- /dev/null +++ b/research/h25-bookkeeping/evidence/publication-v1/registry/usage.json @@ -0,0 +1 @@ +{"user_seconds":42.94,"system_seconds":5.25,"kernel_max_rss_kib":455212,"exit":0} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/ADAPTER-INTERFACES.md b/research/h25-bookkeeping/evidence/research/independent-review/ADAPTER-INTERFACES.md new file mode 100644 index 0000000000..1b131909b5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/ADAPTER-INTERFACES.md @@ -0,0 +1,17 @@ +# Source-announced adapter interfaces + +2026-10-28. These are worker-announced interfaces, pending implementation source review. Parent owns integration. No execution performed by reviewer. + +| Lane | Public adapter | Parent use | New controls | +|---|---|---|---| +| P1 | `bind_verify_map(module) -> {verify_map, owner, receipt}` | Install returned method in candidate only. Trusted wrappers call `owner.capture_c(c)` and `owner.capture_checks(checks)` after each original constructor succeeds. Call `owner.seal()` after final phase/class wrapping. `owner.arm_cli()` surrounds authenticated original CLI, paired with `owner.disarm_cli()` in finally. | `run_controls(backend, set_adapter) -> receipt`; explicit loaded adapter and backend, no implicit scientific module import. Lease validity and original prefix/fallback callback behavior are independently distinguished. | +| P2 | `make_runtime_guard(backend) -> RuntimeGuard-compatible class` | Candidate-only `backend.RuntimeGuard = factory(backend)` before bind. Original constructor `(module,label,native,original_functions)`, `check(self)` and fields retained. | `run_guard_controls(reference_backend,candidate_backend,native) -> receipt`; four source loads for traced/untraced original/candidate, then restore/reuse bindings across mutations. | +| P3 | `make_trace_type(backend,native_encoder_module) -> trace subclass` | Inherits original before/receipt; install instance before binding captures closures. Exposes fixed encoder owner/entry for parent freshness. | `run_controls(backend,native_module) -> receipt`; no self-build. | + +P3 C interface: standalone `_trace_encoding.encode_record(call, us, vs, output)`, `METH_FASTCALL`, exactly four positional arguments; bytes including newline or `NotImplemented`. Helper symbols use `h25_trace_*`; `H25_TRACE_EMBEDDED` omits standalone registration/init for a parent-owned combined module. The parent selects either separate owner/entry freshness or merged-module entry freshness, always before arithmetic. Count checks on every boundary where installed, including Gram if using the common guard. + +P1 reserves its one-use token at entry, expires in finally, and keeps helpers private rather than modifying scientific globals. Unsupported entry delegates original once. Unsupported post-prefix state uses the literal original tail. It plans original `enumerate(c.triples)` inner iteration, indexed private sets, explicit list clearing and left-set reference reset to avoid traceback-retained cached operands. + +Integration ordering must reconcile two different snapshots: finish class/phase wrappers before P1 owner sealing; finish trace/native wrapper closure installation before P2 RuntimeGuard capture. Do not install a new class member or closure after the corresponding snapshot. Immutable reference instances remain separate from candidate instances. + +Source admission is not code admission. Each implementation still needs exact checks of source preparation, exception paths, callbacks, borrowed/native references and all new costs. Controls should reuse restored fixtures when safe and target changed behavior; retaining existing controls does not require duplicating their full Cartesian product in each lane. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/CALL-BUDGET-REVIEW.json b/research/h25-bookkeeping/evidence/research/independent-review/CALL-BUDGET-REVIEW.json new file mode 100644 index 0000000000..13420fe377 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/CALL-BUDGET-REVIEW.json @@ -0,0 +1,43 @@ +{ + "schema_version": 1, + "status": "ALL_THREE_SOURCE_CALL_BUDGETS_ACCEPTED_NOT_MEASURED", + "reviewed": ["priorities/set-reuse/CALL-BUDGET.json", "priorities/runtime-guards/CALL-BUDGET.json", "priorities/trace-encoding/CALL-BUDGET.json"], + "P1": { + "source_formula_check": "4*N*N operand constructors replaced with N; 2*N*N intersections, N*N intersection lengths, 2*N sums/enumerates/bitcounts retained", + "N": 2300, + "operand_constructors_removed": 21157700, + "intersections_retained": 10580000, + "conditional_prefix_counts": "For declared 27600 pieces, successful Q construction and got.get counts are each 2*P+2*N=59800. Prefix/early failure counts remain data-dependent.", + "classification": "Per-invocation metadata reuse, no predicate-result reuse", + "additional_bill": "Source preparation, new parent lease, post-prefix admission, hook/binding checks, private sequence, controls and cleanup all unknown until implementation" + }, + "P2": { + "successful_traced_require_calls_before": 61, + "successful_traced_require_calls_after": 0, + "distinct_predicate_groups_retained": 59, + "function_records_before": 13, + "function_records_after": 11, + "closure_cell_reads_retained": 14, + "remaining_explicit_calls_inside_check": 36, + "classification": "True identity deduplication plus Python dispatch and eager-string elimination; no cached check result", + "limits": "Original traced closure inventory only; excludes finite/constructor/final calls and later integration entries; traceback helper frame changes are disclosed while exact outcome type/message/state remain preserved" + }, + "P3": { + "source_check": "Current local json __init__.py and encoder.py confirm new JSONEncoder for given kwargs, encode/iterencode, ordinary c_make_encoder, join and ascii calls", + "python_json_frames_removed_per_admitted_record": 4, + "replacement_native_entries_per_admitted_record": 1, + "immediate_hash_updates_retained": 238685, + "classification": "Removes Python object graph/general serializer setup; decimal conversion and byte composition move to specialized C; no record deduplication", + "limits": "Counts assume ordinary unchanged CPython JSON accelerator and admitted records; fallback pays failed native admission plus original serializer; do not sum nested constructor operations as independent constructions", + "integration_cost": "Adding encoder entry to common guard pays every original 298644 native wrapper entry, including Gram; constructor/final/finite checks additionally remain" + }, + "combined": { + "no_percent_forecast": true, + "no_component_addition": true, + "parent_diagnostic_is_not_performance_sample": true, + "must_update_after_integration": ["guard closure inventory", "encoder owner/entry checks", "call preparation and admission", "constructor/lease observations", "all new finite controls", "shared versus duplicated builds"], + "not_authorized_by_this_review": ["P1 loop fusion", "sharing intersection predicate answers", "once-per-run freshness", "intercall hash buffering", "native guard alternative"], + "qualification": "Fresh complete PR5995-native baseline and candidate wall/CPU with full cost and unchanged target/noise rules" + }, + "scientific_execution": "None" +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.json b/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.json new file mode 100644 index 0000000000..02c1482d49 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.json @@ -0,0 +1,50 @@ +{ + "schema_version": 1, + "review_kind": "source-only", + "scientific_execution_by_reviewer": false, + "P1": { + "status": "ADMIT_COMPLETE_PILOT_AFTER_PARENT_REPORTED_REVISION_3_FINITE_PASSES", + "files": { + "priorities/set-reuse/set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "priorities/set-reuse/finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "control_repair": "Mode-aware assertion-only callback expectations; initial failure retained", + "complete_pilot_condition": "Both finite modes pass" + }, + "P2": { + "status": "ADMIT_COMPLETE_PILOT_AFTER_PARENT_REPORTED_NORMAL_AND_OPTIMIZED_PASSES", + "files": { + "priorities/runtime-guards/guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "priorities/runtime-guards/guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "source_blockers": [], + "controls_source_loads": 4, + "controls_mutation_pairs": 237, + "controls_actions_per_mutation_pair": 7, + "controls_stable_action_pairs": 14, + "pilot_condition": "Parent finite normal/O controls and all original controls pass first", + "limits": "No execution or performance evidence; combined entry coverage remains separate" + }, + "P3": { + "status": "ADMIT_COMPLETE_PILOT_AFTER_PARENT_REPORTED_NORMAL_AND_OPTIMIZED_PASSES", + "files": { + "priorities/trace-encoding/trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "priorities/trace-encoding/trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "priorities/trace-encoding/trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "source_blockers_in_reviewed_files": [], + "pending": [ + "Combined stage and finite union" + ] + }, + "integration": { + "status": "ADMIT_SERIAL_COMBINED_FINITE_UNION_ON_REVIEWED_SOURCES", + "driver_approach": "Explicit fork with own digest, pinned original driver digest and inverse source transformation evidence; unchanged scientific anchor", + "observer_independence": "Parent agreed to leave backend.ComplementTrace original and construct candidate full trace explicitly; old finite controls keep original observer; new controls compare original and candidate", + "not_yet_admitted": [ + "Combined full qualification pending finite union", + "Any changed Fraction-portability implementation" + ] + }, + "latest_review": "IMPLEMENTATION-REVIEW.json" +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.md b/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.md new file mode 100644 index 0000000000..a9c1c65ea5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/CODE-GATE.md @@ -0,0 +1,31 @@ +# Implementation source gates + +This file preserves the first incremental source decisions. Current exact hashes, the approved P1 control repair, later pilot admissions and combined-stage obligations are in `IMPLEMENTATION-REVIEW.md` and `IMPLEMENTATION-REVIEW.json`. + +Source review only. The parent alone may compile or run under the serial queue. Passing this gate means the source is suitable for the next finite qualification; it does not mean it compiled, passed controls, improved performance or satisfied integration. + +## P2 — ADMIT SERIAL FINITE EXECUTION + +Reviewed `guard_candidate.py` SHA256 `320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29` and `guard_controls.py` SHA256 `514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291`. + +The guard preserves original constructor state, original slot checks, predicate and short-circuit ordering, exception messages, empty-cell/attribute exception propagation, and constructor `self.check()`. The only record change is first-occurrence identity deduplication. The factory captures original backend primitives and does not alter its input backend by itself. + +The controls are behavioral perturbations, not a duplicate implementation oracle. They retain an independent untouched backend, create four source bindings, and restore/reuse them. Stable calls prevent an always-rejecting guard from passing. Mutations cover each distinct function's code/defaults/keyword defaults, captured cell rebinding/deletion, global and builtin slots, class/native dispatch, and first-failure precedence. Held-guard, native-eligible, wide fallback and callback-container entry paths compare exact outcome type/message, prefix, counters and callback logs. Same-code distinct functions are separately checked. The suite uses explicit requirements under normal and optimized interpreters. + +The proposed 237 mutation pairs × 7 actions plus 14 stable action pairs are finite and reuse four source loads rather than generating a new expensive source binding per mutation. Shared builtins and native entries are restored in finally; the parent must serialize execution. No source blocker found. The full pilot requires successful parent finite results first. Added P3 owner/entry checks remain a separate integration gate. + +## P3 — C/ADAPTER SOURCE ACCEPTED, CONTROLS PENDING + +Reviewed `trace_encoder.c` SHA256 `57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e` and `trace_adapter.py` SHA256 `4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60`. + +The C method matches the documented positional [METH_FASTCALL signature](https://docs.python.org/3.12/c-api/structures.html#c.METH_FASTCALL). Exact container/int admission precedes unchecked item macros; no callback-capable coercion or GIL release appears. Unsigned conversion checks the error indicator and clears only overflow for fallback, matching the [integer API](https://docs.python.org/3.12/c-api/long.html#c.PyLong_AsUnsignedLongLong). Every append checks capacity; partial buffers never escape. The only successful result allocation copies the stack buffer into a new bytes object according to the [bytes API](https://docs.python.org/3.12/c-api/bytes.html#c.PyBytes_FromStringAndSize). No owned temporary references require cleanup and no borrowed argument references are retained. + +Canonical key order/punctuation/newline are correct by inspection. Adapter input unpacking, output validation, one count read, literal JSON fallback and hash/byte/count order agree with the original supported contract. The adapter exposes encoder owner/entry metadata but does not itself enforce the parent's pre-arithmetic freshness check. Controls and integrated freshness source remain pending; no full P3 execution gate yet. + +## Integration decisions reviewed + +An explicit fork of the original driver is appropriate if it records its own digest, the pinned original driver digest and exact transformation/inverse evidence while comparing unchanged scientific observations. Never claim the original driver bytes executed. + +Keep `backend.ComplementTrace` original. The old finite suite uses a single imported observer class for both oracle and candidate traces; replacing it before import would compare two candidate encoders. Parent agreed to construct the candidate full trace explicitly and run new P3 controls against the original observer. Existing comparison imports can remain in their original location. + +P1 implementation and the integrated driver remain pending source review. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/CONTRACT-MATRIX.md b/research/h25-bookkeeping/evidence/research/independent-review/CONTRACT-MATRIX.md new file mode 100644 index 0000000000..7c8b613e2a --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/CONTRACT-MATRIX.md @@ -0,0 +1,30 @@ +# Independent H25 bookkeeping contract matrix + +Status: source review only, 2026-10-28. No scientific imports, compilers, experiments or performance claims. Scope is PLAN.md/PLAN.json and control/BASELINE.json: frozen PR5995 `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, native C arm. Paths below are relative to its `research/gf2-full-network` package. The original driver's **candidate** mode is this round's baseline B; its Python **baseline** mode is not B. Existing 123 protected files remain distinct from candidate copies. + +## Existing contract and proposed preservation obligations + +| Boundary | Source-derived existing contract | Required preservation / smallest safe route | +|---|---|---| +| Full caller | `full_driver.py:144-218,257-346`: CPython 3.12, assertions on, fresh scientific modules/private copies, exact source inventories, cold native build and all finite controls. `engine/source/complex_network.py:90-120` executes all original phases once. | Candidate pays the same baseline work plus its new work. Separate new closure/driver identity from the unchanged scientific anchor; never silently repin the protected baseline. | +| Complete observations | `full_driver.py:267-325` requires original stdout/certificate bytes, lossless exact return types/order, witness, rank records, complement receipt, imports, phase counts, and final native coverage. `anchor.json` freezes science. | Preserve all outputs and independent comparisons, including 238,685 complements, 55,839,507 canonical bytes, 59,959 Gram/rank calls and zero full-run fallbacks. Final equality does not replace intermediate/error controls. | +| P1 original map | `engine/source/complex_circuit.py:313-333`: active-node/support assertions; ordered pieces, coefficient and overlap checks; then for every ordered triple, separate disjoint and cardinality-two intersection loops; exact target equality and nonzero count. | Retain the original prefix once and both literal predicates, iteration order, coefficient equality, assertions and return. Reuse only sets, never verification answers. For 2,300 triples the source implies 21.16M set constructions and 10.58M intersections, not measured time. | +| P1 admission/ownership | `ComplexSideCircuit` constructs a list of tuple triples, but `verify_map` is otherwise an ordinary Python method and can encounter custom/mutable caller state. Existing native policy governs each kernel call, not this whole method. | Admission after the unchanged prefix avoids moving failures or replaying prefix callbacks. Exact immutable triple elements alone are insufficient: establish a parent-attested frozen single-owner caller corridor with no callbacks/concurrent mutation in the optimized tail, or use the literal original tail. Each call creates private sets; no shared/persistent cache, escaped aliases or stale reuse. | +| P2 binding | `native_backend.py:109-156,317-386`: source/code/effective-builtins/class/descriptor/native validation; originals retained; final wrappers installed and runtime closure assigned before capture. | Keep originals and independent source oracle. Finalize all helper/native/trace closures before guard capture. Source/class changes outside the promised supported corridor cannot be relabeled safe fallback. | +| P2 freshness | `native_backend.py:159-209,338-376`: constructor check, checks at both wrapper entries before trace/eligibility/native/fallback, and final driver check. Distinct global slots, builtin slots, class members, function code/globals/builtins/defaults/kwdefaults/closure/cells, native slots are checked. | Identity-deduplicate repeated **function records**, preserving first occurrence and every distinct record; retain separate slot checks even when values alias. Failure-only messages preserve rejection type/message/order. No cached PASS, delayed checks or removed fallback guard. Existing serial no-mutation-during-call policy is sufficient for this narrow deduplication, not a generic security theorem. | +| Native fallback | `native_gf2.c:17-50,135-195` accepts exact dict/int, insertion order, unsigned 64-bit vectors/count and augmented-width bounds; no coercion, caller mutation or GIL release. `NotImplemented` delegates unchanged methods; genuine errors propagate. | Retain arbitrary-width Python fallback, negative/bool/subclass/custom-container behavior and exceptions. Tracing intentionally rejects callback containers before arithmetic; untraced finite fallback remains supported. | +| P3 input snapshot | `native_backend.py:224-235,338-358`: runtime check first; exact Labels/instance dictionaries/basis dictionaries; ordered big and small snapshots before arithmetic; exact ints. | Keep snapshot ownership and timing; do not defer reading mutable bases until after arithmetic. No narrowing or iteration of callback containers on the fast path. | +| P3 record/prefix | `native_backend.py:237-254`: validate list-of-exact-int or None; canonical ASCII sorted-key compact JSON plus newline; hash update, byte increment, call increment in that order. Receipt exposes current hash/count/bytes. | Stateless bytes encoder with literal JSON fallback is source-promising. Preserve empty-list/None distinction, all orders, negative/wide integers and JSON digit-limit errors. Immediate hash visibility excludes intercall buffering. Validation/encoding errors leave previous prefix/counters intact; retain original post-hash ordering if a later action fails. | +| P3 environment | Baseline trace resolves ordinary `json.dumps`; existing backend explicitly is not a sandbox against arbitrary backend/process mutation. | State the ordinary frozen serialization-runtime assumption. If changed JSON hooks are promised supported, provide admission/fallback preserving them; do not silently assert equivalence. Any new mutable native encoder entry needs explicit freshness coverage before use and a costed binding contract. | + +## Existing finite evidence versus new requirements + +`engine/finite_controls.py:111-293` contains short exhaustive ordered rows, width/count boundaries, real Label permutations, untraced fallback returns/errors, binding rejection, dense independent algebra and wrong-math/reordered-witness negatives. Lines 296-456 add pre/post binding drift, effective builtins, class dispatch, native proxy/entry, no modified-helper execution, and seven trace fixtures plus four negatives. These are retained finite controls, not a universal proof. + +New controls must discriminate the changes: P1 corrupt support/pieces/coefficients and both expected-map masks, changed triples between calls, unsupported/custom/callback tails and one-prefix execution; P2 every distinct captured identity/slot/cell with first-failure and pre-fallback counters; P3 byte-for-byte records and every prefix, bound edges, list/None, order, wide/negative fallback, invalid output and encoding/hash failure state. Run normal and optimized finite controls; full CLI stays assertion-on. Keep baseline/reference helpers untouched so candidate validation cannot compare the candidate with itself. + +## Integration and complete cost + +Parent alone integrates and runs. Sets belong to one invocation; guards belong to one bound module; traces belong to one observation stream. Avoid shared global replacement of reference guards/encoders, rebuilding guards after mutation, double-counted controls, and encoder entrypoints absent from freshness coverage. Preserve failed evidence. + +Unknown until measured: admission, allocations, encoding, extra checks, compilation/loading, complete controls, output and cleanup costs. All belong in candidate wall/CPU accounting. Frozen scientific timing and publication-wrapper timing are distinct. Fresh B1 C1 C2 B2 B3 C3 samples require combined wall **and** CPU medians at least 15% lower, each saving greater than both within-arm ranges. Individual lanes have no 15% hurdle; a scoped negative finding is permissible, but cannot satisfy an unmet combined performance goal. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json b/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json new file mode 100644 index 0000000000..2dfe08fa3d --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.json @@ -0,0 +1,163 @@ +{ + "schema": "h25-independent-final-evidence-review-v1", + "status": "ACCEPT_LOCAL_COMBINED_QUALIFICATION", + "reviewer_scientific_imports_compilation_replay": false, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "rules_sha256": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "stage_files_bytes_and_modes_verified": 160, + "sequence": [ + "qual-B1", + "qual-C1", + "qual-C2", + "qual-B2", + "qual-B3", + "qual-C3" + ], + "samples": [ + { + "label": "qual-B1", + "job": "full-none", + "wall_seconds": 27.16858759697061, + "cpu_seconds": 27.09, + "spent_before_seconds": 182.9798714609351, + "raw_receipt_sha256": "7b3d7d427d2d06a9d6e436454d1ef7623e0f8ad50a0a23a0ec0d2ec0fc12b788", + "science_receipt_sha256": "c9345eb1ff8fdf2607832b39bb4c1b51fe6f1c03db3c4ebfe463900cded6bff5" + }, + { + "label": "qual-C1", + "job": "full-all", + "wall_seconds": 21.477875709999353, + "cpu_seconds": 21.419999999999998, + "spent_before_seconds": 210.1484590579057, + "raw_receipt_sha256": "e07bee3ecf50f5f2cd77910763f65d05baaea1ad3be50c5282a4e96b74b6ce15", + "science_receipt_sha256": "ed60c889422cd98c2b525b6d5f731a01e8f6e0f8dfdb0de8d61c52912f591495" + }, + { + "label": "qual-C2", + "job": "full-all", + "wall_seconds": 21.17849980702158, + "cpu_seconds": 21.13, + "spent_before_seconds": 231.62633476790506, + "raw_receipt_sha256": "4f939f3897dbedeeed8a2ac0078eb24cb0c1cf7034e50f2dc60cf60dcfc2c235", + "science_receipt_sha256": "a0bfabd6785e7dc2248fdf85e0769965bfac5916444c368ded1280f79bd944a5" + }, + { + "label": "qual-B2", + "job": "full-none", + "wall_seconds": 27.378558369004168, + "cpu_seconds": 27.3, + "spent_before_seconds": 252.80483457492664, + "raw_receipt_sha256": "b6e9a8dc8bc89b473b2b98995f4d0aa4c08b286df22bbc122255731ecf577934", + "science_receipt_sha256": "bb07ee0af583165a8a67a08edc5576c25f63c3103a6cefcc3643bfc71ff9dd89" + }, + { + "label": "qual-B3", + "job": "full-none", + "wall_seconds": 27.14340792701114, + "cpu_seconds": 27.06, + "spent_before_seconds": 280.1833929439308, + "raw_receipt_sha256": "1e839f0e4de437b59f428213922b03e090c5794973c7a6fc763a512da9c2c0fd", + "science_receipt_sha256": "dc41582760b650c17ebd6fc8591be5ea4685d1a5aa0b0b005de4bb15477233bf" + }, + { + "label": "qual-C3", + "job": "full-all", + "wall_seconds": 24.77310694300104, + "cpu_seconds": 23.27, + "spent_before_seconds": 307.32680087094195, + "raw_receipt_sha256": "93eeaed9de3af3655d285ce2c2c92f844f73ae3646a9271e8b322d29a986bf19", + "science_receipt_sha256": "98c77d54333878fc4cc833f36390d3f0deda472e342d572c525c8b99dfb45fe3" + } + ], + "metrics": { + "wall": { + "baseline_median": 27.16858759697061, + "candidate_median": 21.477875709999353, + "saving": 5.690711886971258, + "max_within_arm_range": 3.5946071359794587, + "reduction_percent": 20.94592465162154, + "target_pass": true, + "noise_pass": true + }, + "cpu": { + "baseline_median": 27.09, + "candidate_median": 21.419999999999998, + "saving": 5.670000000000002, + "max_within_arm_range": 2.1400000000000006, + "reduction_percent": 20.93023255813954, + "target_pass": true, + "noise_pass": true + } + }, + "combined_finite": [ + { + "label": "finite-combined-normal-v4", + "wall_seconds": 2.5656101999920793, + "optimized": false, + "spent_before": 177.46565306693083 + }, + { + "label": "finite-combined-O-v4", + "wall_seconds": 2.948608194012195, + "optimized": true, + "spent_before": 180.0312632669229 + } + ], + "campaign": { + "retained_runs": 22, + "spent_seconds": 332.099907813943, + "failures": [ + { + "label": "finite-P1-O-v2", + "wall_seconds": 2.8227231420460157 + } + ], + "all_start_spent_chain_verified": true, + "phase_cap_seconds": 600, + "maximum_qualification_sampled_process_group_rss_bytes": 450019328 + }, + "verification": { + "six_exact_science_anchor_matches": true, + "retained_scientific_files_directly_hashed": 36, + "common_scientific_file_hashes": { + "science/full-return.lossless.json": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "science/side-observations/witness.json": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "science/side-observations/rank-trace.json": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "science/side-observations/result.json": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "science/original-stdout.txt": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "science/runtime-root/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "ordered_complement_receipts_match": true, + "full_stream_bytes_retained": false, + "native_calls_each": { + "complement": 238685, + "gram": 59959, + "fallbacks": 0 + }, + "each_candidate_pays_both_cold_builds_old_and_new_control_union": true, + "each_baseline_retains_native_build_and_original_controls": true, + "runtime_fraction_profile": "recorded-local-cpython-3.12.3", + "pilot_percentages_added": false, + "slow_C3_retained": true, + "source_and_cost_gate": "PASS" + }, + "publication_metadata_notes": [ + { + "finding": "Pilot census contained stale UNTESTED state and older P1 receipt.", + "resolution": "Original retained as validation/CALL-CENSUS-PILOTS.json; final CALL-CENSUS.json now matches actual v4 qual-C1 lease and combined gate.", + "verified": true + }, + { + "finding": "Original admission names an unretained intermediate mutable review digest.", + "resolution": "Original admission preserved; ADMISSION-REVIEW-PROVENANCE.json explicitly explains the gap and binds verified readonly final review snapshots. It does not claim the intermediate text was recovered.", + "verified": true + } + ], + "scope": "Observed complete frozen historical caller on local CPython 3.12.3; no bare-CLI, universal speed, selected-frontier, kappa or hosted-runtime admission. Publication wrappers and hosted correctness remain separate.", + "metadata_resolution_pins": { + "validation/CALL-CENSUS.json": "55878bd7f34481472cf45876747e8ad24be40d07abc3fc4e9bb963fb8023cc10", + "validation/CALL-CENSUS-PILOTS.json": "940c8583722eddd2c36a8360ec14f9219ea39f3fa58103e1d382bd7a5e37fb2c", + "control/ADMISSION-REVIEW-PROVENANCE.json": "4a7643e574eb2acebca2369125a205d9f1307afbe4db7a7a9691bfaf40e55d51" + }, + "remaining_evidence_blockers": [] +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.md b/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.md new file mode 100644 index 0000000000..988022ca3d --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/FINAL-EVIDENCE-REVIEW.md @@ -0,0 +1,34 @@ +# Independent final H25 evidence review + +**ACCEPT_LOCAL_COMBINED_QUALIFICATION.** The retained evidence satisfies the declared complete wall/CPU target and noise gates. This was a read-only artifact/source audit: no scientific imports, compilation, replay or additional performance run. + +## Samples and independently recomputed result + +The actual spent-before ledger preserves the predeclared **B1 C1 C2 B2 B3 C3** order from `control/QUALIFICATION-v4.json`. Every sample binds stage `558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc` and the reviewed runner. CPU is raw GNU time user plus system; wall is the outer runner's elapsed time. + +| Sample | Wall seconds | CPU seconds | +| --- | ---: | ---: | +| B1 | 27.168587597 | 27.09 | +| C1 | 21.477875710 | 21.42 | +| C2 | 21.178499807 | 21.13 | +| B2 | 27.378558369 | 27.30 | +| B3 | 27.143407927 | 27.06 | +| C3 | 24.773106943 | 23.27 | + +Wall medians are **27.168587597 → 21.477875710 seconds**, a **20.94592465% reduction**. The 5.690711887-second saving exceeds the maximum within-arm range, 3.594607136 seconds. CPU medians are **27.09 → 21.42 seconds**, a **20.93023256% reduction**; the 5.67-second saving exceeds the maximum range, 2.14 seconds. Both reductions exceed 15%. All values reproduce `validation/COMBINED-GATE.json`. The slower C3 remains included. No pilot percentage is added or substituted, and nested phase timings are not summed as savings. + +## Source, correctness and complete cost evidence + +All **160 staged files** match their declared bytes and modes; actual lane, integration and runner hashes match the independent source review. Original and new source-custody receipts agree. Actual driver and immutable reference-driver identities remain separate. Combined normal and optimized finite passes precede the first qualification sample. + +All six science records equal the original anchor. Direct hashing verifies **36 retained files**: the complete typed return, exact side witness, ordered rank trace, side result, certificate and original stdout for each sample. Common typed-return SHA256 is `542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd`; witness SHA256 is `4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82`. Every full run records 238,685 native complements and 59,959 native Gram calls with zero arithmetic fallbacks. Ordered-complement digest/count/byte receipts agree; the complete stream is summarized rather than retained, so this audit does not independently rehash its 55,839,507 underlying bytes. + +Every candidate contains both successful cold builds, original controls and the complete new union inside the measured process. Native binary hashes agree with build receipts. The new union matches the preceding normal finite record, including 23 set cases and five source-pin policy cases, 1,659 guard mutation/action pairs, trace controls and five encoder-entry rejection actions. The original observer remains independent. Every baseline retains its native build and original controls. Each candidate records one admitted/expired lease, 2,300 private sets and the actual local Fraction source/profile. Source authentication, portability reference hashing, setup, observations, serialization and receipts remain paid. + +The complete ledger has **22 retained attempts totaling 332.099907814 seconds**, including the failed optimized control attempt at **2.822723142 seconds**. Every spent-before value reconciles. Qualification runs remain below 180 seconds and the 1-GiB sampled process-group cap; the largest observed qualification sample is 450,019,328 bytes. These are recorded resource observations, not proof against unobserved instantaneous peaks. + +## Metadata corrections and boundaries + +Two documentation findings were resolved transparently. The old prequalification census survives as `validation/CALL-CENSUS-PILOTS.json`; the final census now binds the v4 C1 lease and combined gate. The original admission's intermediate review digest was not retained. `control/ADMISSION-REVIEW-PROVENANCE.json` acknowledges that gap, preserves the original admission and binds verified readonly final-review snapshots; it does not claim recovery of the missing intermediate text. Neither correction changes measured sources or samples. + +No remaining blocker was found for this local qualification. The result concerns this frozen historical full caller on local CPython 3.12.3, including its observations and validation bill. It establishes neither universal performance nor a bare-CLI, selected-frontier or kappa improvement. Publication-wrapper review and actual hosted correctness/digest validation remain separate obligations. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.json b/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.json new file mode 100644 index 0000000000..48fa627262 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.json @@ -0,0 +1,199 @@ +{ + "schema_version": 1, + "review_date": "2026-10-28", + "review_kind": "source-only", + "scientific_execution_by_reviewer": false, + "lane_sources": { + "P1": { + "set_reuse.py": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "initial_finite_set_controls.py": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "finite_set_controls.py": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "revision_3_set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "revision_3_finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "P2": { + "guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "P3": { + "trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + } + }, + "integration_sources": { + "integration/adapters.py": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94", + "integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "integration/derive_driver.py": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a", + "integration/DERIVATION.json": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256", + "run_guarded.py": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + }, + "source_decisions": { + "P1": "ADMIT_REVISION_4_SERIAL_COMBINED_NORMAL_AND_OPTIMIZED_FINITE_UNION", + "P2": "ADMIT_COMPLETE_PILOT_AFTER_REPORTED_FINITE_PASSES", + "P3": "ADMIT_COMPLETE_PILOT_AFTER_REPORTED_FINITE_PASSES", + "combination": "ADMIT_SERIAL_FINITE_UNION_ON_FRESH_IMMUTABLE_REVISION_4_SOURCES" + }, + "integration_invariants": [ + "Both arms original native C configuration", + "Actual derived driver digest separate from original reference driver pin", + "Original scientific anchor unchanged", + "Original observer retained for old finite controls", + "Candidate trace explicit before bind", + "ExtendedGuard entries set before base constructor checks", + "Five pre-arithmetic encoder drift actions including wide fallback", + "P1 installed before phase wrappers and sealed afterward", + "Private constructor identity captures and CLI arm/disarm", + "Timed new-source custody before imports and finite/full receipts", + "Finite original/copied inventories rechecked", + "Parent serial lock and immutable stage ledger" + ], + "reported_observations": { + "provenance": "Parent messages; not independently replayed or receipt-audited by this reviewer", + "P2_finite": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds_approx": 1.78, + "optimized_wall_seconds_approx": 2.04 + }, + "P2_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 27.9081, + "C": 25.7346 + }, + "cpu_seconds": { + "B": 27.79, + "C": 25.62 + }, + "exact_science_equal": true, + "qualified_factor": false + }, + "P3_finite": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds_approx": 1.85, + "optimized_wall_seconds_approx": 2.22 + }, + "P3_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 27.0782, + "C": 25.0697 + }, + "cpu_seconds": { + "B": 27.01, + "C": 24.98 + }, + "qualified_factor": false + }, + "P1_finite": { + "normal": "PASS", + "normal_wall_seconds": 2.419, + "optimized_initial": "STOP", + "optimized_initial_wall_seconds": 2.8227, + "failure": "Collision fixture did not reach custom equality", + "failure_retained_and_charged": true, + "revision_3": { + "normal": "PASS", + "optimized": "PASS", + "normal_wall_seconds": 2.4495, + "optimized_wall_seconds": 2.5654 + } + }, + "P1_revision_3_complete_pilot": { + "status": "PASS", + "wall_seconds": { + "B": 28.38259, + "C": 25.1397 + }, + "qualified_factor": false, + "qualifies_revision_4": false + } + }, + "P1_repair": { + "status": "SOURCE_APPROVED_AND_PARENT_REPORTED_BOTH_FINITE_MODES_PASS", + "scope": "control only", + "reason": "Original collision-triggering tail lookup is inside assert and disappears under -O", + "minimal_change": "Require nonempty callback log only when not sys.flags.optimize; retain unconditional original/candidate outcome, event-sequence, fallback and token comparisons", + "new_immutable_stage_required": true, + "complete_pilot_before_finite_passes": false, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "additional_static_repair": "All original verify_map Q calls are assertion-only; logging-Q fixture likewise requires nonempty normal events and explicitly empty optimized events with unconditional parity checks retained", + "implementation_changed": false + }, + "remaining": [ + "Fresh immutable revision 4 combined source freeze", + "Combined normal and optimized old/new finite-control union", + "Complete combined outputs and coverage", + "All new and historical costs with integration call budget", + "Fresh predeclared BCCBBC wall/CPU target and noise qualification", + "Actual hosted runtime and Fraction digest with complete correctness replay", + "Delivery and publication obligations" + ], + "performance_boundary": { + "individual_15_percent_requirement": false, + "combined_wall_reduction_minimum": 0.15, + "combined_cpu_reduction_minimum": 0.15, + "saving_must_exceed_max_within_arm_range_each_metric": true, + "add_component_percentages": false, + "goal_achieved": false + }, + "P1_portability_revision_4": { + "status": "SOURCE_APPROVED_FOR_COMBINED_FINITE_UNION", + "adapter_sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "controls_sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "allowed_sources": [ + { + "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "bytes": 38067, + "profile": "recorded-local-cpython-3.12.3" + }, + { + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "bytes": 38147, + "profile": "official-cpython-3.12.15-e848e4b09ca4bc67c0041c9ce7526dae471d4c36" + } + ], + "reviewer_checks": [ + "Exact hashes of active local file and retained official-reference file", + "Inert AST comparison changes only Fraction.__pow__", + "Whole adapter/control diff versus immutable revision 3", + "Exact source pins and actual selected digest/profile receipt", + "All prior code/descriptor/global/class/function/freshness checks unchanged", + "Integration and runner hashes unchanged", + "Existing CPython 3.12 family gate retained" + ], + "official_retrieval_provenance": "Worker retained tag/commit evidence; no second reviewer network retrieval", + "new_policy_controls": { + "known_pins": 2, + "rejected_unknown_or_nonexact": 3, + "binding_receipt_consistency": true + }, + "alternate_Fraction_source_loaded": false, + "reviewer_runtime_execution": false, + "new_costs": [ + "Fixed two-pin selection", + "Selected profile receipt allocation", + "New policy controls", + "38,147-byte retained reference source custody read/hash" + ], + "hosted_runtime_compatibility": "PENDING_ACTUAL_RUNTIME_DIGEST_NORMAL_OPTIMIZED_AND_COMPLETE_ASSERTION_ON_REPLAY", + "prior_pilot_transfer_to_revision_4": false, + "supporting_sha256": { + "PORTABILITY.md": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1", + "PORTABILITY-SOURCE.json": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82", + "SOURCE-READINESS.json": "4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556" + }, + "reference_source_custody_scope": "Selected P1 or combined candidate; baseline lanes=none does not select that directory" + }, + "execution_gate": { + "owner": "parent only", + "combined_complete_after_both_finite_modes_pass": true, + "per_process_wall_seconds": 180, + "per_process_memory_bytes": 1073741824, + "initial_campaign_wall_seconds": 600, + "total_campaign_wall_seconds": 1500, + "preserve_and_charge_failed_or_superseded_runs": true + } +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.md b/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.md new file mode 100644 index 0000000000..efb62d5a09 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/IMPLEMENTATION-REVIEW.md @@ -0,0 +1,73 @@ +# Independent H25 implementation and integration review + +Source review only, 2026-10-28. No reviewer scientific imports, compilation, numerical execution or source implementation edits. Parent alone owns execution. All observations below are explicitly parent-reported, not independently replayed by this reviewer. + +## Decisions and exact reviewed lane sources + +| Lane/file | SHA256 | Source disposition | +|---|---|---| +| P1 `set_reuse.py` revision 3 | `d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29` | Parent-reported complete pilot passed; retained historical source. | +| P1 `set_reuse.py` revision 4 | `eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d` | Admit fresh combined normal/optimized finite union; runtime validation pending. | +| P1 `finite_set_controls.py` initial version | `2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231` | Normal passed; optimized fixture expectation needs the bounded repair below. | +| P1 `finite_set_controls.py` revision 3 | `9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d` | Control-only repair independently reviewed; parent reports both finite modes passed. | +| P1 `finite_set_controls.py` revision 4 | `760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919` | Retains the repair and all prior controls; adds exact-pin policy and receipt consistency controls. | +| P2 `guard_candidate.py` | `320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29` | Admit finite and, following reported passes, complete pilot. | +| P2 `guard_controls.py` | `514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291` | Bounded independent behavioral controls accepted. | +| P3 `trace_encoder.c` | `57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e` | Admit finite and, following reported passes, complete pilot. | +| P3 `trace_adapter.py` | `4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60` | Same source gate. | +| P3 `trace_controls.py` | `527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447` | Original observer, exact bytes/prefix/error controls accepted. | + +P1 authenticates the source, splices the original prefix and literal fallback tail, retains both intersection loops, and uses live source globals. Parent constructor captures, final wrapper sealing, single-use reservation before the prefix, post-prefix shape/Fraction/environment checks and finally expiry implement the reviewed new whole-tail invariant. Ordinary unleased calls delegate the original once. The explicit private-list clearing and left-reference reset address traceback-retained frames. This is a scoped fresh frozen-caller contract, not generic alias or process-security proof. + +P2 preserves all distinct predicates, slot checks, short-circuit ordering, messages and original call boundaries. It deduplicates only repeated function identities. Controls reuse four bindings, with 237 mutation pairs × 7 actions and 14 stable pairs; they compare behavior rather than reimplementing the guard. Empty-cell errors, fallback entry, first failure, same-code distinct functions and shared-state restoration are covered. + +P3 retains input snapshots and original output validation, then emits a complete record through a stateless checked native call. Exact types precede direct container access, unsigned overflow is the only cleared conversion error, borrowed references remain within a GIL-held call, and one bytes allocation copies the bounded stack buffer. The adapter preserves count-read and hash/byte/count order. Primary [FASTCALL](https://docs.python.org/3.12/c-api/structures.html#c.METH_FASTCALL), [integer conversion](https://docs.python.org/3.12/c-api/long.html#c.PyLong_AsUnsignedLongLong) and [bytes ownership](https://docs.python.org/3.12/c-api/bytes.html#c.PyBytes_FromStringAndSize) documentation supports these API checks. Controls include exact record bytes, every prefix, width/type/fallback boundaries, digit-limit restoration, hash/counter failures and alias/reference behavior. + +## Integration and runner source gates + +Reviewed integration sources, rehashed unchanged for the revision 4 combination gate: + +- `integration/adapters.py`: `f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94` +- `integration/full_driver.py`: `5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1` +- `integration/derive_driver.py`: `a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a` +- `integration/DERIVATION.json`: `6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256` +- `run_guarded.py`: `b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be` + +Both new arms execute the native C configuration. The driver has its own digest and separately names the immutable original driver digest; declared literal edits and exact inverse evidence do not claim original driver bytes executed. The complete scientific anchor, original phase counts, native coverage, original controls and observer remain intact. Selected new source custody is charged inside the child before imports and before finite/full receipts. Finite returns also recheck original and copied inventories. The outer runner separately pins stage bytes/modes and preserves failures under one lock and aggregate budget. + +The initially proposed late trace-class import would have compared two candidate encoders in the old finite suite. Parent repaired this before execution: `backend.ComplementTrace` stays original; the candidate full observer is explicit; new controls compare it to the unchanged observer. + +The new native owner/entry check is installed before binding and initialized before base guard construction invokes `self.check()`. It runs at every original wrapper boundary. Five negative actions cover held guard, native Gram/complement and wide fallback Gram/complement without advancing counters or observations. Following parent-reported finite passes, source admission supports all three complete pilots. The reviewed sources are also admitted to a fresh combined finite-union stage; combined complete qualification still depends on that union passing. + +## Parent-reported observations and retained failure + +| Work | Reported outcome | Limit | +|---|---|---| +| P2 normal / optimized finite | PASS, about 1.78 / 2.04 seconds wall | Parent report; no reviewer replay. | +| P2 complete B/C pilot | PASS, wall 27.9081 → 25.7346; CPU 27.79 → 25.62 seconds; exact science agrees | Approximately 7.79% / 7.81%; one pilot, not a qualified factor. | +| P3 normal / optimized finite | PASS, about 1.85 / 2.22 seconds wall | Parent report. | +| P3 complete B/C pilot | PASS, wall 27.0782 → 25.0697; CPU 27.01 → 24.98 seconds | Approximately 7.4%; one pilot, not a qualified factor. | +| P1 normal finite | PASS, 2.419 seconds wall | Complete ownership/performance not yet established. | +| P1 optimized finite, initial control | STOP, 2.8227 seconds, collision fixture expected a callback absent under optimized assertions | Failure retained and charged. No complete P1 admission yet. | +| P1 revision 3 normal / optimized finite | PASS, 2.4495 / 2.5654 seconds wall | Parent report. | +| P1 revision 3 complete B/C pilot | PASS, wall 28.38259 → 25.13970 seconds | Parent report; about 11.43%; one pilot, not a qualified factor; does not qualify revision 4. | + +The P1 optimized failure is a control expectation issue: the original tail's collision-triggering `got.get` calls are inside an assertion removed by `-O`. Revision 3 was independently source-reviewed and approved: it keeps unconditional outcome, callback-sequence, fallback and lease comparisons, requires nonempty callbacks with assertions enabled, and explicitly requires empty callback lists under `-O`. The logging-Q fixture received the same justified correction because all original `verify_map` Q calls occur inside assertions. No controls were removed and the adapter is unchanged. Freeze a new stage before rerunning; do not erase the failed version. + +## Revision 4 Fraction source portability gate + +**ADMIT_SERIAL_COMBINED_FINITE_UNION_ON_FRESH_REVISION_4_SOURCES.** Independent source review finds no blocker in the bounded two-pin change. Hashing and inert AST comparison confirm the active local file has SHA256 `cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231` (38,067 bytes), while the retained official-reference file has SHA256 `d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0` (38,147 bytes). Only `Fraction.__pow__` differs in the AST; constructor, hash, equality, properties and `_hash_algorithm` are identical. Official tag/commit retrieval provenance is the worker's retained evidence, not a second network retrieval by this reviewer. + +The adapter uses a fixed two-entry tuple and requires an exact string before comparing its digest. Unknown digests and string subclasses still reject. It hashes the active `fractions.__file__`, selects a profile, and compares loaded functions with that source compiled locally by the running interpreter at the current optimization level. Descriptor, MRO, global, class, function and per-reservation/per-admission freshness checks are unchanged. The existing driver/native backend CPython 3.12 family gate remains unchanged. No alternate Fraction implementation is loaded by the added controls or adapter. + +The receipt now carries the actual selected `fraction_sha256` and `fraction_source_profile`, rather than a hard-coded local digest. Added controls recognize both exact pins, reject three unknown/nonexact inputs, and compare each binding receipt with the pin policy. Every revision 3 differential control and its optimized-mode repair remains. The previous local pilot is evidence for revision 3 only. + +Verified supporting file hashes: `PORTABILITY.md` = `8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1`; `PORTABILITY-SOURCE.json` = `2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82`; `SOURCE-READINESS.json` = `4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556`. + +The new pin lookup, selected-profile receipt, controls and reference-file custody belong in the complete bill. Existing custody enumerates selected `.py` sources, so retaining `cpython-3.12.15-fractions.py` adds its 38,147-byte read/hash to selected P1/combined candidate custody without executing it; the baseline with lanes=none does not select that directory. An exact-source policy pass does not establish hosted runtime compatibility: actual hosted interpreter and active Fraction digest receipts, normal/optimized finite validation and the complete assertion-on replay remain required. Hosted correctness cannot transfer local performance measurements. + +## Combination gate and remaining obligations + +The proposed order is compatible: P2 guard, then P3 extended guard; old controls keep the original observer; new P2 mutations restore before P3 native/digit mutations; those restore before P1 Fraction/hook controls. Full candidate trace exists before native binding. P1 method is installed before phase wrapping, constructor captures finish the original constructors, seal follows all class/phase wrappers, and arm/disarm bracket the authenticated CLI. + +Pending: fresh revision 4 immutable source freeze; combined normal/optimized old-and-new finite union; actual complete combined output/coverage and cost receipts; fresh predeclared B1 C1 C2 B2 B3 C3 medians and noise gates; hosted/delivery/publication checks. The combined finite-union source gate is granted, but complete qualification may proceed only after both finite modes pass. Combined call accounting must add ExtendedGuard's base-check dispatch and encoder-owner checks, plus lease/source/control/portability work. Preserve all failed and superseded stages and charge their costs. The parent remains the sole runner under the declared 180-second, 1-GiB per-process and 600-second initial/1,500-second total campaign limits. No component percentages may be added. The goal still requires at least 15% complete wall and CPU improvement, each saving exceeding both within-arm ranges. This review does not claim that target has been achieved. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/P1-LEASE-CONTRACT.md b/research/h25-bookkeeping/evidence/research/independent-review/P1-LEASE-CONTRACT.md new file mode 100644 index 0000000000..45d42ede86 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/P1-LEASE-CONTRACT.md @@ -0,0 +1,14 @@ +# P1 frozen-caller lease: implementation-ready review contract + +This is a proposed **new scoped caller invariant**, not a consequence of the existing per-native-call no-mutation rule. It enables the private frozen complete CLI only. The ordinary method API keeps literal fallback behavior. Parent owns the executable issuance mechanism and its complete cost. + +1. After authenticating frozen caller/source bytes, the candidate driver prepares a private lease owner, unavailable through scientific module globals or user arguments. It is closed by default. Parent observational constructor wrappers record the exact circuit identity after successful original `ComplexSideCircuit.__init__`, then the exact Checks identity after successful original `Checks.__init__`, verifying its circuit link. Record exactly one successful construction for this source-fixed CLI. Recording does not alter either constructor return. +2. While the parent executes the authenticated original CLI, it opens an allowance for the expected single `verify_map` phase. Source evidence is `complex_network.py:90-93`: local circuit, local Checks, compiled roles, then one map call. It is not inferred from a filename, caller-supplied bool, refcount, equality or arbitrary ownership callback. +3. The parent-owned map wrapper checks identities using anchored operations. Only the captured exact Checks/circuit in that active phase can reserve the one-use capability. Reserve at entry, before prefix execution, so nested/reentrant entry cannot obtain it. A missing, exhausted, wrong-object or already-active capability selects ordinary fallback. Do not execute arbitrary policy code supplied by the scientific caller. An opaque parent-owned token and private identity association are sufficient; no new public general-purpose API is needed. +4. The candidate executes the original prefix once. At the original tail boundary it verifies capability identity/state and performs the proposed exact post-prefix admission, including triples, local `got` keys/values, ordinary attribute dispatch, original builtin/Fraction environment and source binding. Prefix callbacks may have changed data: only this actual post-prefix state may be cached. Unsupported state executes the literal original tail without rerunning the prefix. +5. The admitted tail has no caller-defined iteration, hashing or equality: its participating containers, triples, integers and Fraction operations are authenticated exact ordinary objects. Sets remain local to the call. The source-fixed fresh process additionally promises no concurrent or reentrant mutator of this state during the tail. This promise is explicitly a supported-execution condition, not a generic alias detector or process-security claim. Parent should deny the allowance if its execution environment has active tracing/profiling or other known mutating instrumentation. Do not introduce GC tuning or experiments; only describe/validate the actual closed caller environment. +6. Expire the reservation in `finally` on success or failure. Do not store sets on Checks, circuit, backend or owner. A second direct invocation has no implicit lease and takes literal fallback; an explicitly separate supported invocation must acquire its own new capability and rebuild all sets. + +Required controls are bounded and falsifiable: wrong Checks identity; wrong circuit link; no allowance; used capability; recursive entry from a prefix callback; prefix mutation; custom collision key retained in `got`; failing prefix; and independent later invocation with changed triples. Compare baseline fallback callback order and exact return/error outcome, and count original-prefix execution once. A valid original-caller fixture demonstrates the optimized tail and private cleanup. This cannot prove safety against arbitrary process-memory mutation and makes no such claim. + +Reference independence remains mandatory. Generating a candidate function with new helper names must not mutate the globals of the untouched original reference. Parent may use a distinct candidate source-module instance and preserve the baseline in a distinct module/process. Authentication/generation, constructor observation, private owner setup, entry reservation, admission and expiry are all billed. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.json b/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.json new file mode 100644 index 0000000000..c0e52b4087 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.json @@ -0,0 +1,70 @@ +{ + "schema_version": 1, + "date": "2026-10-28", + "scope": "Source-only proposals; no implementation or numerical evidence", + "implementation_authorization_owner": "parent", + "decisions": { + "P1": { + "decision": "ACCEPT_FOR_IMPLEMENTATION", + "accepted": [ + "private per-call positional sets", + "untouched prefix", + "two literal all-pair intersection predicates", + "post-prefix exact admission including got keys", + "literal original tail fallback without prefix replay" + ], + "minimal_repair": "Declare new scoped frozen-caller invariant and concrete parent-issued per-invocation capability with trusted callback-free policy; specify issuance/denial and retain fallback absent capability", + "independent_reference_requirement": "Generated candidate helper bindings must not redirect original reference globals", + "execution_status": "NOT_RUN", + "proposal_revision": 2, + "correctness_status": "UNPROVEN_PENDING_EXECUTABLE_OWNERSHIP_AND_FINITE_REVIEW", + "resolved_blocker": "Whole-verify_map ownership cannot be inferred from existing per-native-kernel no-mutation policy", + "repair_review": "OWNERSHIP.md revision 2 explicitly establishes new whole-tail invariant and concrete parent single-use capability issuance/reservation/post-prefix validation/expiry, with generic fallback retained", + "cleanup_obligation": "Explicitly drop private set sequence and loop references in finally when promising release despite traceback-retained frames" + }, + "P2": { + "decision": "ACCEPT_FOR_IMPLEMENTATION", + "correctness_status": "UNPROVEN_PENDING_SOURCE_AND_FINITE_REVIEW", + "approved_mechanism": "Python first-identity function record deduplication plus failure-only raises", + "constraints": [ + "retain slot checks", + "preserve distinct record order and exception messages", + "preserve empty-cell and attribute exceptions", + "candidate-only factory installation", + "same constructor/wrapper/final check boundaries" + ], + "integration_obligation": "Parent must add any P3 native encoder owner/entry coverage; primary original two-entry guard is insufficient for new encoder", + "native_guard_alternative_approved": false, + "execution_status": "NOT_RUN" + }, + "P3": { + "decision": "ACCEPT_FOR_IMPLEMENTATION", + "correctness_status": "UNPROVEN_PENDING_C_SOURCE_AND_FINITE_REVIEW", + "approved_mechanism": "Stateless checked native canonical bytes encoder with literal original JSON fallback", + "constraints": [ + "unchanged before snapshot and output validation", + "immediate hash update then bytes then count", + "checked bounded buffer and integer conversions", + "no escaped borrowed refs or mutable aliases", + "ordinary frozen JSON runtime assumption", + "byte and prefix/failure comparisons" + ], + "integration_obligation": "Parent selects merged native-entry extension or separate exact module/entry freshness check before arithmetic; finalize before guard capture", + "buffering_approved": false, + "execution_status": "NOT_RUN" + } + }, + "combined": { + "arithmetic_conflict_identified": false, + "pending": [ + "all implementation source reviews", + "parent integration binding order and native entry coverage", + "normal and optimized finite controls", + "complete cold costed pilots", + "combined fresh BCCBBC target and noise gates", + "P1 executable lease and environment/source admission review" + ], + "costs": "Unknown until measured; all new checks, builds, controls and cleanup charged", + "performance_claim": null + } +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.md b/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.md new file mode 100644 index 0000000000..2793594060 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/PROPOSAL-REVIEW.md @@ -0,0 +1,43 @@ +# Independent proposal decisions + +Source-only review of each lane's RESEARCH.md and PROPOSAL.json on 2026-10-28, against CONTRACT-MATRIX.md and the frozen PR5995 sources. No implementation or numerical execution reviewed. Parent retains implementation authorization and every run. + +## P1 — HOLD for one contract repair + +Private positional sets, separate unchanged pairwise predicates, untouched prefix and literal-tail fallback are acceptable. Admission of the local `got` keys is a useful concrete improvement: a custom collision key could otherwise run equality code in the optimized tail. The proposal correctly avoids persistent reuse, bitmask substitution, cached verification answers, and replaying callbacks from a previously executed prefix. + +The remaining blocker is the claim that the whole `verify_map` lease follows the existing backend restriction. The existing backend states that its kernel calls run serially without mutation during each call. `verify_map` has no such bound native call over its all-pair loops. The longer invariant therefore needs explicit parent establishment and a limited supported-caller scope. + +Minimal repair: describe a **new scoped frozen-caller invariant**, not an inherited guarantee. Specify exactly how the parent grants a per-invocation capability for the privately constructed exact Checks/circuit at the original call site, which runtime conditions it relies upon, and when it denies that capability. The policy itself must be trusted and callback-free, not an arbitrary caller function invoked during admission. Missing capability or unsupported state selects the already-proposed literal tail. No generic detection of all Python aliases, process mutation, or adversarial signal handling is required or claimed. A declaration that the lease is present, without identifying its issuing boundary, is insufficient. + +Source-generated adapter preparation must authenticate the exact original prefix and fallback tail and isolate new helper names from the untouched reference module. Candidate and reference cannot share mutable globals that redirect the oracle to candidate behavior. Parent must price source preparation, admission, exact Fraction environment checks, ownership bookkeeping, controls and cleanup. Nothing in this review establishes measured saving. + +## P2 — ACCEPT FOR IMPLEMENTATION, correctness unproven + +First-occurrence `is` deduplication removes only repeated function records. Every separate global/class/native slot remains; distinct function objects sharing code remain distinct. The unchanged predicate and short-circuit order plus original anchored exception messages supports replacing successful `require` calls with failure-only branches. Empty-cell `ValueError` and attribute errors must propagate as before. + +The explicit adapter, constructor/wrapper/final boundaries and proposed differential controls cover the relevant design. Keep the factory installation candidate-only. Finalize wrapper closures before snapshot; do not rebuild a guard after drift to bless new values. P3's additional encoder owner/entry is a parent integration obligation and cannot disappear because P2's primary constructor mirrors the original two native entries. + +Implementation review must verify literal predicates/messages/order, record inventory, and the planned negative controls. No compiler alternative is approved by this decision. + +## P3 — ACCEPT FOR IMPLEMENTATION, correctness unproven + +A stateless exact-byte encoder with literal JSON fallback preserves the observation boundary without batching. Retaining `before`, original output validation, immediate original hash update, and byte/count order is the narrowest proposed route. Sorted JSON order is `call,result,us,vs`, which the proposal correctly distinguishes from the human schema label. + +The bounded domain fits comfortably below 8192 bytes: at most 192 unsigned 20-digit vector values, their separators, one 20-digit count and fixed punctuation. The implementation must still check every append, return no partial bytes, check conversion error indicators, and clear only expected overflow before fallback. The GIL remains held, borrowed values are consumed within owned argument lifetimes, and no aliases escape. + +Parent must choose and document one freshness arrangement before integration: merge encoder into the guarded native module and extend native entries, or add a separate exact native owner/entry check before arithmetic. Capture finalized bindings before guard initialization. Keep the ordinary frozen JSON-runtime assumption explicit; this proposal does not support arbitrary serializer monkeypatching. Fallback must still preserve negative/wide/direct-call shapes and decimal-limit exceptions. + +Implementation review needs exact record bytes and every prefix/error state, not just the final digest. New cold build/import/check/control costs remain unknown and paid. + +## Combined gate + +No identified arithmetic conflict among the three designs. Ownership differs naturally: sets per map invocation, guard per module binding, trace per stream. The main integration hazards are shared reference globals, P3 entry coverage, snapshots captured before final installation, changed fallback boundaries, and omitting new finite-control costs. Freeze separate baseline/candidate modules or processes, preserve full control union and old independent oracles, then let the parent execute the serial correctness queue. + +This is a source admission decision only. Individual complete pilots may justify integration without an individual 15% result; the combined complete wall and CPU/noise gates remain unchanged. + +## P1 revision 2 addendum — ACCEPT FOR IMPLEMENTATION + +The revised OWNERSHIP.md, RESEARCH.md and PROPOSAL.json resolve the design hold. They explicitly introduce a new whole-tail invariant, capture actual construction identities in the parent, reserve a one-use capability before prefix execution, admit actual state after the prefix, deny unsupported hooks/source conditions, avoid user policy callbacks, and expire on every exit. General calls retain literal fallback. Source-derived CALL-BUDGET.json correctly preserves both 10.58M intersection operations and the coefficient/equality work while removing 21,157,700 operand constructions for the stated complete input. + +Executable lease issuance, environment denial and source/Fraction admission remain implementation-review obligations, not verified facts. Cleanup requires care: Python exception tracebacks can retain frame locals. If the implementation promises to release all private sets on error, explicitly drop/clear the set sequence and active loop references in `finally`; ordinary propagation alone does not prove release. No extra performance threshold is introduced. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json b/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json new file mode 100644 index 0000000000..bb2af3cebb --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.json @@ -0,0 +1,48 @@ +{ + "schema": "h25-publication-source-review-v1", + "status": "SOURCE_ADMIT_SERIAL_DELIVERY_CHECKS", + "reviewer_execution": false, + "parent_guard_sha256": "c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d", + "wrapper_sha256": { + "archive_support.py": "eee90f3815f4bd90eb96152bc461ec968ffb91d47c990e77712e74f6677c51be", + "check_artifacts.py": "03d89a1df701305d37289de9a6bda4ac485da83ca43459d41de2bd4f78a50445", + "replay.py": "50901fc7de6bbb39067e46d27f653a80b4f9f47c762a3a6c597727d8d6fc4883", + "verify.py": "f0a5e3ab9c9521f02ef33bba0508bc75cc5b49c1e117f203ff02af614444ee11", + "verify_full.py": "2fa8b3c0bd28c6162fb08190241b1d3195e48616986cf3309e293402fc5c0c2e" + }, + "scientific_stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "frozen_runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "repaired_findings": [ + "Capture original unreaped root PID/start identity before poll/wait; reject changed generation thereafter", + "Enforce final stdout/stderr cap and stream-hash files without unbounded output reads" + ], + "source_contracts": [ + "Existing parent lock and campaign spent ledger", + "Fixed jobs and distinct delivery receipts", + "Exact 160 payload files plus fixed STAGE manifest", + "Git100644 accepted at publication; measured modes restored only externally", + "Unchanged runner source with HERE/TIMEOUT150 overrides", + "Complete old/new finite union; full historical anchor and assertion-on requirement", + "Authenticated source bootstrap and independent inherited canonical checker", + "External paths; marked-private success cleanup; failure evidence retained" + ], + "resource_limits": { + "inner_timeout_seconds": 150, + "outer_termination_threshold_seconds": 180, + "outer_grace_seconds": 2, + "sampled_tree_rss_bytes": 1073741824, + "output_bytes_each": 2097152, + "scope": "Observed descendants of the fixed awaited command tree; not general daemon containment or kernel memory enforcement" + }, + "remaining_source_blockers": [], + "required_runtime_validation": [ + "Manifest freeze and package source authentication", + "Serial normal/O finite, complete assertion-on replay and canonical transport", + "Readonly Git-free and Git100644 export compatibility", + "External-only writes, success cleanup and retained failure evidence", + "Campaign accounting and unchanged package custody", + "Actual hosted child interpreter and Fraction digest" + ], + "performance_samples_modified": false, + "new_performance_admission": false +} diff --git a/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.md b/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.md new file mode 100644 index 0000000000..0df3513542 --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/PUBLICATION-SOURCE-REVIEW.md @@ -0,0 +1,38 @@ +# Independent publication envelope source review + +**SOURCE_ADMIT_SERIAL_DELIVERY_CHECKS.** No remaining source blocker was found in the reviewed parent guard and five publication wrappers. This admits bounded delivery validation; it does not assert runtime success or create performance samples. Review used source reads, exact hashes and AST parsing only, without scientific imports, compilation, transport decoding or execution. + +## Exact reviewed sources + +| File | SHA256 | +| --- | --- | +| `publication_guard.py` | `c1722dabdfbd4c50b2e5a8bc8988dc3f1e02ec76b924361e432afce552abc33d` | +| `archive_support.py` | `eee90f3815f4bd90eb96152bc461ec968ffb91d47c990e77712e74f6677c51be` | +| `replay.py` | `50901fc7de6bbb39067e46d27f653a80b4f9f47c762a3a6c597727d8d6fc4883` | +| `verify.py` | `f0a5e3ab9c9521f02ef33bba0508bc75cc5b49c1e117f203ff02af614444ee11` | +| `verify_full.py` | `2fa8b3c0bd28c6162fb08190241b1d3195e48616986cf3309e293402fc5c0c2e` | +| `check_artifacts.py` | `03d89a1df701305d37289de9a6bda4ac485da83ca43459d41de2bd4f78a50445` | + +The five wrapper hashes match `publication/wrapper-source/SOURCE-READINESS.json`. The scientific stage remains `558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc`; its unchanged runner remains `b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be`. + +## Parent guard and resolved findings + +The guard uses the existing nonblocking campaign lock and sums all retained outer receipts, including failures. It permits only registered finite, optimized finite, full, canonical and registry jobs. Package bytes/modes are inventoried before and after, each attempt receives a fresh evidence directory, and delivery receipts explicitly set `performance_sample=false`. + +Two source findings were repaired before any reported delivery execution. First, unconditional root-PID re-admission could bypass generation tracking during cleanup. The final code captures the unreaped child immediately after creation, before any poll/wait can release its PID, then retains and compares start-time identities. Second, a final output burst could bypass live output-cap polling and trigger unbounded reads. Final file sizes now enforce STOP for oversize output; retained stdout/stderr and package files are hashed in bounded one-MiB blocks. + +Process traversal includes observed descendants in nested sessions. Cap handling signals their groups, rejects signalling the parent's own group, and performs final kill/wait cleanup. The outer threshold is 180 seconds or the remaining campaign allowance, followed by up to two seconds of graceful termination; the inner scientific timeout is 150 seconds. RSS enforcement is sampled at one GiB, with the usual limits of polling rather than kernel memory containment. This is a guard for the fixed awaited command tree, not a general daemon-containment proof. + +## Wrapper contracts + +Authentication checks the fixed stage identity, exact 160 declared payload files plus STAGE.json, every protected manifest entry, and the Python/C code census. Publication files may all arrive as Git `100644`. Only the new external copy receives declared file modes, readonly stage metadata and readonly directories. Package modes are neither assumed readonly nor modified. + +The copied runner is source-loaded after its exact hash check; only `HERE` and `TIMEOUT=150` are overridden. The runner still authenticates its own source and copied stage. Normal and optimized verifiers select the appropriate complete old/new finite union; full/replay jobs require assertions. B selects the original native baseline and C the combined adapter. Full outputs must match the historical anchor. The external one-job inner ledger supplements the existing parent campaign ledger and does not reset its accounting. + +Wrapper/support/checker modules are compiled from authenticated source bytes with distinct module names. The canonical wrapper invokes the unchanged inherited checker and its own distinct support, avoiding an import alias collision. No new transport or scientific implementation is generated. + +Evidence paths and temporary bases must be external to the package/repository before writes. Successful temporary verification workspaces are removed only after checks, with a matching ownership marker; only nonsymlink private directories become writable for removal. Explicit replay preserves successful evidence. Exceptions retain workspaces and attach their location. + +## Required execution evidence + +Parent must freeze a complete CODE-SOURCES manifest, then validate normal finite, optimized finite, full assertion-on correctness and canonical transport under the guard. Confirm readonly Git-free execution and a Git-export-style 100644 package, external writes, successful cleanup, failure retention, unchanged sources and campaign receipts. Hosted results must name the actual `/usr/bin/python3.12` child and its Fraction digest; the outer interpreter version alone is insufficient. These delivery checks do not replace the six already-qualified local samples or establish hosted performance, a selected-frontier change or a new kappa result. diff --git a/research/h25-bookkeeping/evidence/research/independent-review/REVIEW-GATES.json b/research/h25-bookkeeping/evidence/research/independent-review/REVIEW-GATES.json new file mode 100644 index 0000000000..6adfe64edd --- /dev/null +++ b/research/h25-bookkeeping/evidence/research/independent-review/REVIEW-GATES.json @@ -0,0 +1,210 @@ +{ + "schema_version": 1, + "review_status": "ALL_THREE_PRIMARY_DESIGNS_ADMITTED_IMPLEMENTATION_AND_MEASUREMENT_PENDING", + "review_date": "2026-10-28", + "execution_performed": false, + "baseline": { + "pr": 5995, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "arm": "Frozen full_driver.py --mode candidate; native C plus all original controls", + "older_python_arm_eligible_as_new_baseline": false, + "original_files_protected": 123, + "historical_timings_are_orientation_only": true + }, + "contract_sources": [ + "PLAN.md", + "PLAN.json", + "control/BASELINE.json", + "baseline/full_driver.py:144-346", + "baseline/engine/native_backend.py:1-386", + "baseline/engine/native_gf2.c:1-209", + "baseline/engine/finite_controls.py:1-456", + "baseline/engine/source/complex_circuit.py:219-348", + "baseline/engine/source/complex_network.py:90-120", + "baseline/anchor.json" + ], + "gates": [ + { + "id": "BASELINE_IDENTITY", + "status": "REQUIRED_AT_INTEGRATION", + "requirements": [ + "PR5995 native configuration, unchanged original controls and observations", + "New driver/source identity kept separate from immutable original closure and scientific anchor", + "Fresh same-session baseline; no old Python comparison or inherited speed percentage", + "Reference implementations cannot resolve candidate helpers through shared global mutations" + ] + }, + { + "id": "P1_SET_REUSE", + "status": "ACCEPT_REVISION_2_FOR_IMPLEMENTATION_CORRECTNESS_UNPROVEN", + "source_promising_route": "Per-invocation private sets constructed after untouched verify_map prefix; retain both original ordered all-pair predicates", + "blockers_to_resolve": [ + "Exact tuples and ints alone do not establish whole-tail ownership or exclude mutation through other fields/callbacks", + "Native per-kernel no-mutation policy cannot silently become a whole-verify_map lease", + "Fallback after prefix must not rerun prefix or change its exception ordering" + ], + "minimal_repairs": [ + "Define source-bound frozen caller ownership and callback-free optimized tail, with safe admission or literal tail fallback", + "No caller-visible or persistent sets, no reuse across mutated invocations", + "Preserve source predicates, coefficient tests, target order and exact original result" + ], + "new_controls": [ + "Valid bounded original-vs-candidate complete map results", + "Corrupt support topology, overlap, coefficient and expected target masks", + "Mutated triples between calls and unsupported subclass/custom/callback fixtures", + "Prefix executes once and prior failure ordering is unchanged", + "Independent intersection expectations do not reuse candidate cached-set helper" + ], + "costs_unknown": [ + "admission", + "source and ownership checks", + "set allocation and cleanup", + "new controls" + ] + }, + { + "id": "P2_RUNTIME_GUARDS", + "status": "ACCEPT_FOR_IMPLEMENTATION_CORRECTNESS_UNPROVEN", + "source_promising_route": "First-occurrence identity deduplication of function records plus failure-only error strings", + "retained_boundaries": [ + "RuntimeGuard initialization", + "every complement entry before trace/native/fallback", + "every nondegenerate entry before native/fallback", + "final full-driver check" + ], + "retained_checks": [ + "source module dispatch and namespace identity", + "Label type and MRO", + "every source global slot", + "every builtin slot and source shadow", + "class member count and every member identity", + "every distinct function code/globals/effective builtins/defaults/kwdefaults/closure", + "every captured closure cell and value", + "native module type and every native entry slot" + ], + "blockers": [ + "cached PASS or once-per-run freshness", + "deduplication by equality rather than identity", + "removing separate slot checks", + "changing first rejection ordering or executing modified callbacks" + ], + "new_controls": [ + "structural equality of old distinct record set and candidate records", + "each distinct field/cell/slot mutation rejected before both native and fallback", + "same RuntimeError message and first-failure ordering", + "zero modified helper calls and unchanged counters on rejection" + ], + "costs_unknown": [ + "guard construction and dedup", + "new controls", + "optional native guard build and ownership costs if proposed" + ] + }, + { + "id": "P3_TRACE_ENCODING", + "status": "ACCEPT_FOR_IMPLEMENTATION_CORRECTNESS_UNPROVEN", + "source_promising_route": "Stateless bounded native canonical-record bytes plus unchanged JSON fallback, immediate original hash update and counter order", + "retained_semantics": [ + "exact input admission", + "snapshot before arithmetic", + "ordered values and exact output list-or-None types", + "canonical sorted-key ASCII compact JSON plus newline", + "current call index", + "hasher update then bytes then count", + "immediate receipt and public hash prefix", + "prior prefix on validation/encoding failure", + "arbitrary-width fallback including decimal conversion error behavior" + ], + "blockers_to_resolve": [ + "native encoder entry missing freshness coverage", + "buffering across records while hasher/count/bytes remain visible", + "claimed changed-JSON-hook support without matching admission/fallback", + "holding mutable output/input aliases past the original after boundary" + ], + "new_controls": [ + "literal baseline record-byte equality", + "prefix receipt equality after every record", + "None versus empty list and reordered input/output negatives", + "bounds at 0, 2**64-1, 2**64 and vector length 64/65", + "negative and huge exact integers through fallback", + "bool/subclass/invalid output errors", + "encoding/hash-failure prefix and counter ordering", + "new encoder-entry drift rejection" + ], + "costs_unknown": [ + "cold compile/link/load", + "encoding and allocations", + "fallback admission", + "new freshness checks", + "new finite controls" + ] + }, + { + "id": "COMBINED_INTERACTION", + "status": "REQUIRED_AFTER_ALL_PROPOSALS", + "requirements": [ + "Finalize all wrappers and native/trace helpers before RuntimeGuard captures function and closure identities", + "Keep per-invocation set ownership, per-binding guard ownership and per-stream trace ownership distinct", + "No candidate replacement of baseline/reference helpers in common process/module environment", + "Retain full union of old and new controls, source checks, observations, cleanup and failure evidence", + "Verify exact source/import/certificate/stdout/typed return/witness/rank/complement anchor and full native coverage" + ] + }, + { + "id": "COMPLETE_COST_AND_PERFORMANCE", + "status": "UNMEASURED", + "parent_only_serial_queue": true, + "sequence": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "wall_reduction_minimum": 0.15, + "cpu_reduction_minimum": 0.15, + "each_median_saving_must_exceed_max_within_arm_range": true, + "individual_lane_reduction_minimum": null, + "complete_bill": [ + "cold process/import/copy/source custody", + "baseline native cold build/link/load", + "all original controls", + "new compilation/binding/admission/controls", + "original complete CLI and all retained observations", + "serialization/output/final checks", + "cleanup within declared harness boundary", + "all failed attempts in resource ledger" + ], + "excluded_claims": [ + "component timings establish complete gain", + "nested phase timings are additive", + "publication wrapper run is scientific performance sample", + "finite controls establish universal correctness", + "scoped stop completes an unmet combined performance target" + ] + } + ], + "required_execution_modes": { + "finite": [ + "normal", + "optimized" + ], + "complete_cli": "assertion-on" + }, + "review_limits": [ + "source-only mapping, no execution", + "current-main and bounded live overlap are parent-provided, not an exhaustive novelty proof", + "no general sandbox or concurrent-mutation theorem", + "all cost estimates remain unmeasured" + ], + "proposal_review_file": "PROPOSAL-REVIEW.json", + "p1_lease_contract": "P1-LEASE-CONTRACT.md", + "call_budget_review": { + "P2": "SOURCE_COUNTS_ACCEPTED", + "P3": "SOURCE_COUNTS_ACCEPTED", + "P1": "SOURCE_COUNTS_ACCEPTED", + "combined": "Parent must revise counts for changed guard or adapter interfaces; counts do not establish speed" + }, + "call_budget_review_file": "CALL-BUDGET-REVIEW.json" +} diff --git a/research/h25-bookkeeping/evidence/revisions/v1/PLAN.json b/research/h25-bookkeeping/evidence/revisions/v1/PLAN.json new file mode 100644 index 0000000000..9136f51cc0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/PLAN.json @@ -0,0 +1,154 @@ +{ + "schema_version": 1, + "title": "H25 bookkeeping optimization plan", + "authorization": "User explicitly requested all three priorities, concurrent agent swarming including research, and a goal to finish the tasks. Existing Chrome publication authorization continues.", + "baseline": { + "pr": 5995, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "arm": "PR5995 native C configuration with all original qualification controls; NOT the older Python-only arm", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "historical_wall_median": 28.63625624598353, + "historical_cpu_median": 28.46, + "historical_times_are_orientation_only": true, + "new_performance_claim_requires_fresh_same_session_baseline": true + }, + "target": { + "combined_wall_reduction_minimum": 0.15, + "combined_cpu_reduction_minimum": 0.15, + "individual_15_percent_requirement": false, + "scope": "complete frozen historical H25 qualification with retained observations" + }, + "lanes": [ + { + "id": "P1", + "priority": "Set reuse", + "agent": "bookkeeping_sets", + "ownership": "priorities/set-reuse/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Precompute private sets from admitted triples; retain every original pairwise intersection/equality check and fallback for unsupported inputs." + }, + { + "id": "P2", + "priority": "Runtime guards", + "agent": "bookkeeping_guards", + "ownership": "priorities/runtime-guards/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Deduplicate identical function records and build failure messages only on failure; keep every distinct freshness check at the same call boundary; assess a native implementation only if justified." + }, + { + "id": "P3", + "priority": "Trace encoding", + "agent": "bookkeeping_trace", + "ownership": "priorities/trace-encoding/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Reduce temporary tuples/dictionaries/JSON/bytes and hash crossings; retain canonical bytes, ordering, exact types, prefixes, counters and failure semantics." + }, + { + "id": "R", + "priority": "Independent contract review", + "agent": "bookkeeping_review", + "ownership": "research/independent-review/", + "first_deliverables": [ + "CONTRACT-MATRIX.md", + "REVIEW-GATES.json" + ], + "contract": "Independently review proposals, aliasing/callback/fallback/freshness/byte contracts, interference and added cost; no implementation ownership." + } + ], + "parent_ownership": [ + "control/", + "integration/", + "validation/", + "publication/", + "runtime/", + "stages/", + "PLAN.md", + "PLAN.json", + "TASK-BOARD.json", + "STATUS.json" + ], + "concurrency": { + "parallel": [ + "source and primary-source research", + "independent design and review", + "implementation in disjoint owned paths after gates", + "fixture/test design and metadata preparation" + ], + "serialized": [ + "compilation", + "scientific imports/corpus execution", + "correctness runs", + "profiling and benchmarks", + "shared integration", + "Chrome writes" + ], + "local_heavy_work_during_benchmarks": "prohibited", + "agent_model": "GPT-6-astra", + "reasoning_effort": "xhigh", + "initial_agents": 4, + "further_delegation_requires_parent_assignment": true + }, + "resource_policy": { + "wall_seconds_per_scientific_command": 180, + "sampled_process_group_rss_bytes": 1073741824, + "initial_feasibility_seconds": 600, + "shared_round_seconds": 1500, + "single_parent_owned_runner": true, + "automatic_retries": false, + "all_failed_attempts_count": true, + "old_ledgers_preserved": true + }, + "gates": [ + "G0 refreshed canonical guidance/live overlap/baseline and shared contract freeze", + "G1 parallel source research and independent review; measurable-headroom decision", + "G2 finite correctness and all new-control cost freeze for each candidate", + "G3 individual bounded full pilot comparisons, not component gain promises", + "G4 combined integration and fresh fixed BCCBBC comparison against PR5995 native baseline", + "G5 normal/O finite, assertion-on complete, readonly Git-free/export/source/metadata/commit checks", + "G6 focused Chrome publication, exact-head hosted CI and required handoff readbacks" + ], + "noise_rule": "Combined fresh baseline median minus candidate median must exceed max(baseline range,candidate range) separately for wall and CPU, AND both reductions >=15%; predeclare six cold BCCBBC processes and retain all samples.", + "completion": [ + "All three priorities have reviewed final dispositions: qualified integration or reproducible scoped stop", + "Combined >=15% complete wall AND CPU target and noise gates pass before calling the performance goal achieved", + "All outputs/types/coverage/independent oracles/source pins and full new costs retained", + "Useful artifacts published via Chrome with exact-head checks and handoffs; no merge/frontier change", + "No unfinished required work; target misses reported as unmet, never a fabricated win" + ], + "paused": [ + "kappa research", + "Work1/2 mathematical streams", + "unrelated feeds", + "automations" + ], + "initial_dispatch": "Source-only research and contract mapping; no compilers, numerical runs or implementation until the corresponding gate.", + "repeated_call_reduction": { + "required_for_all_priorities": true, + "deliverable": "CALL-BUDGET.json per priority plus one parent diagnostic call census when discriminating", + "fields": [ + "current calls", + "repeated inputs/state", + "safe equivalence/ownership basis", + "eliminated calls", + "retained semantic checks", + "replacement calls", + "new control and conversion costs", + "measurement/evidence boundary" + ], + "P1": "metadata/set constructors primary; loop fusion or intersection-result reuse separate research gate", + "P2": "identity dedup, equivalent inline failure paths and lazy messages; retain each distinct live check at same boundary", + "P3": "stateless per-record construction/encoding and crossings; immediate hash/counter semantics retained", + "integration": "reuse only proven admitted private metadata; no shared answers or cached PASS", + "no_standalone_call_count_speed_claim": true + } +} diff --git a/research/h25-bookkeeping/evidence/revisions/v1/PLAN.md b/research/h25-bookkeeping/evidence/revisions/v1/PLAN.md new file mode 100644 index 0000000000..0311ad905b --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/PLAN.md @@ -0,0 +1,102 @@ +# H25 bookkeeping optimization plan + +Complete the three bookkeeping priorities for the frozen historical H25 verifier: reuse triple sets, reduce runtime guard overhead, and reduce trace encoding allocations. Four Astra xhigh agents work concurrently on research, independent design, and disjoint implementation paths. The parent owns integration, every compiler/scientific run, and Chrome publication. + +## Baseline and success + +Use PR5995 publication `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, specifically its **native C configuration with the existing complete checks**, as the baseline. The older Python arm is not the baseline for a further gain. Its recorded 28.636256246-second wall and 28.46-second CPU medians provide orientation; a new claim requires fresh same-session baseline runs. Preserve the original package and its 123 protected files. + +The combined target is **at least a further 15% reduction in both complete wall and CPU time**, after every new control, conversion, compilation, binding, observation, serialization and cleanup cost. Individual priorities may contribute smaller increments. Never add percentages from separate components or earlier workloads. + +A priority is finished when it has an independently reviewed contract and either a correctness-validated implementation with its measured disposition, or a reproducible scoped negative finding. The performance goal is achieved only when all three priorities have final dispositions, the combined target and noise gates pass, and required delivery checks and handoffs are complete. If the target fails, report it as unmet and keep the goal incomplete; a stopped experiment is not a performance win. + +This work concerns the complete frozen historical H25 caller with retained observations. The old additional-15%-over-PR5864 objective is separate. Kappa research, Work1/2 mathematics, unrelated feeds and automations remain paused. + +## Concurrent swarm and ownership + +| Lane | Owner | Owned directory | First research question | +|---|---|---|---| +| P1 Set reuse | `bookkeeping_sets` | `priorities/set-reuse/` | Can private sets be constructed once per admitted triple while every original pairwise check and result remains identical? | +| P2 Runtime guards | `bookkeeping_guards` | `priorities/runtime-guards/` | Which duplicate identity records and successful-path message allocations can disappear while every distinct live check still occurs at the same boundary? | +| P3 Trace encoding | `bookkeeping_trace` | `priorities/trace-encoding/` | Can fewer temporary objects and crossings produce exactly the same canonical record bytes, prefix hashes, counters and errors? | +| R Independent review | `bookkeeping_review` | `research/independent-review/` | Do the designs preserve ownership, callbacks, fallbacks, check independence and a complete cost bill, both separately and in combination? | +| Parent coordination | Main agent | `control/`, `integration/`, `validation/`, `publication/`, `runtime/`, `stages/` | Which reviewed candidates deserve the next bounded run, and does the integrated result improve the complete verifier? | + +Start fresh compact GPT-6-astra agents at xhigh effort, keeping completed earlier agents idle. Reuse these new-round agents for later follow-ups. Assign additional agents only to a distinct named obligation and owned path. Every worker is told that others share the workspace, must not revert their edits, and must accommodate concurrent changes. Workers do not edit the baseline, shared harness, working plan or another lane's files. + +Research runs in parallel, including source inspection, bounded live overlap research, primary CPython/C-API documentation when needed, alternatives, fixture design and independent review. Implementation may also run concurrently after each design passes its gate, because the lane paths do not overlap. Shared adapter changes belong solely to the parent. Each lane supplies a written adapter contract before integration. + +Compilers, scientific imports, corpus generation/execution, finite correctness runs, profiles and performance measurements use **one parent-owned queue and execution lock**. Agents prepare source and fixtures rather than executing them. No local CPU- or memory-heavy work runs alongside timed processes. This preserves useful concurrency without contaminating measurements or producing competing artifact writers. Chrome writes also have one owner. + +## G0 Establish the shared contract + +1. Refresh canonical upstream main, compare current guidance and priority revision, and check live PR/discussion overlap before substantial implementation or experiments. Keep scientific baseline PR5995 frozen even if current main changes; record compatibility rather than silently migrating inputs. +2. Create an isolated branch/worktree from refreshed main. Populate the index from the base before staging; assert that the diff contains only the intended package. Preserve all previous checkouts, threads, failed attempts and ledgers. +3. Record the full baseline source closure, compiler/interpreter/environment, native configuration, full certificate/stdout, exact typed return, ordered witness/rank/complement identities and all existing controls. +4. Freeze a common interface and observation contract for the three candidates. Keep the original baseline/reference implementation distinct from candidate helpers. Do not let a baseline call silently use an optimized guard or encoder. Finalize replacement helper/trace bindings and runtime closure-cell identities before capturing guard state; no post-capture mutation. +5. Parent may run one bounded post-C attribution diagnostic if it can discriminate among these mechanisms. Treat profiled timings as diagnostic; do not scale nested profile totals into promised savings. + +Canonical main was freshly fetched during planning as `19fdb086ea96af9a9f87936a2b888e10af4ed810`, priority revision 8. Current live overlap is tracked separately in `control/UPSTREAM-REFRESH.json`. + +## G1 Parallel research and design + +Each priority produces `RESEARCH.md` and `PROPOSAL.json` with exact source pins, candidate and fallback contracts, removed work, retained work, new costs, negative controls, files to change, an independent comparison, open risks and a discriminating next test. Distinguish source-derived counts from measured timings. Research can reject a route without constructing it. + +**P1 Set reuse.** The two existing all-pair loops imply 21.16 million set constructions for 2,300 triples. Investigate one private set per triple, scoped to the actual invocation. Retain both original intersection predicates, target order, coefficient and equality checks, exceptions and witnesses. Establish admission and fallback for unsupported or mutable/callback-bearing inputs. This is metadata reuse, not reuse of a verification answer. Do not substitute a shared arithmetic oracle for the literal independent checks. + +**P2 Runtime guards.** The actual caller makes 298,644 native kernel calls with freshness checks. Begin with identity-based deduplication of repeated function records and failure-only message construction. Preserve every distinct function/global/builtin/descriptor/default/closure/native-entry check at its current call boundary, including before fallback. Never turn a per-call freshness check into a cached PASS or a once-per-run check. A C implementation is a separately costed option, requiring verified CPython APIs, correct reference/error handling and the same rejection behavior. + +**P3 Trace encoding.** All 238,685 ordered complement records and 55,839,507 canonical bytes remain observed. Explore reducing tuple/dictionary/string/byte allocations, a source-bound native encoder, or bounded buffers within one record. Completed records must immediately update the public hasher, byte count and call count; inter-call deferral is outside this plan. Preserve sorted-key JSON/ASCII/newline schema, arbitrary-width fallback, exact types and vector order, counters, intermediate receipts and failure boundaries. Neither sampling nor replacing the canonical schema is an optimization within this scope. + +The reviewer independently maps the common contract immediately, then reviews each proposal as it arrives. Report concrete defects and the smallest fixes. Do not demand another mathematical construction or invent an additional 15% hurdle for each lane. No implementation or scientific run passes the gate merely because unused resource budget remains. + +## Repeated call reduction across all three priorities + +Treat repeated calls as an explicit work item in every lane. The parent will collect a bounded diagnostic call census and each proposal must include a call budget: current calls and inputs, why repetition occurs, what can safely disappear, remaining semantic checks, replacement calls, added admission/conversion/validation work, and the evidence that makes reuse valid. Call counts support a design decision; they are not a promised wall or CPU saving. + +- **P1:** reduce repeated set construction and repeated materialization of the same admitted triple metadata. Keep the current two predicate loops and all required intersection/equality checks in the primary candidate. Sharing an intersection result or fusing the loops is a distinct optional research branch: it needs a separate independence, error-order and complete-cost review before implementation. +- **P2:** eliminate duplicate records of the same function identity, successful-path `require` helper dispatch and eager message construction where an equivalent inline failure path preserves behavior. Every distinct live freshness check still executes at its original boundary; no once-per-run guard or cached PASS. +- **P3:** reduce repeated serializer/helper calls, tuple/dictionary construction, conversions and Python/C transitions within each record. The primary native encoder can replace several record-building/encoding calls with one checked call. Completed records must still update the hasher and counters immediately; no deferred inter-call batching or sampled observations. +- **Integration:** inspect repeated preparation or conversion across adapters and, where ownership and freshness permit, pass already admitted metadata or batch dispatch into a private owner. Keep separate independent verification paths and all original output, fallback, mutation and failure semantics. Do not share mutable answers or PASS receipts between calls, backends or processes. + +Measure diagnostic calls separately from unprofiled qualification. Every eliminated-call claim must distinguish true deduplication, value reuse, batching and work merely moved into C. The complete candidate still pays for retained operations, new validation, marshalling, compilation and cleanup. Extend only on a source-supported benefit; avoid collecting another census that cannot change the next decision. + +## G2 Concurrent implementation and serial correctness + +After source/ownership/cost review, implement one primary candidate per lane in its owned path. Compare alternatives on source and cost first; execute an alternative only when new evidence distinguishes its mechanism. The parent freezes immutable stages before any run. + +Run relevant finite comparisons and negative controls in the numerical queue. Cover exact types, widths, ordering, changed inputs/bindings, mutable aliases, callback/reentry boundaries where supported, fallback, errors and cleanup. Keep the live independent dense/original checks and original full assertions. Optimized interpreter mode is for finite controls; full verification remains assertion-on. + +Freeze each candidate's complete validation bill before measuring it. Manual repairs get a new source/stage revision, retain the failed evidence and consume the same round budget. No automatic retries or timing rerolls. + +## G3 Individual complete pilots + +Schedule one complete baseline/candidate pair per source-admitted priority. Baseline B means PR5995 native C plus its unchanged controls; candidate C adds that lane and all of its new costs. Retain full outputs and every receipt. A micro improvement is not a complete improvement, and one pair is not a qualified individual factor. + +Use pilots to decide integration or a scoped stop. A noisy individual result may still support a documented combined test if a specific shared-cost or interaction argument justifies it; do not label its individual saving established. Expand individual repetitions only when needed for a standalone performance claim and funded by the declared budget. Preserve all unfavorable results. + +## G4 Combined integration and qualification + +The parent integrates compatible, correctness-approved variants behind the frozen common interface. The reviewer checks interaction hazards: shared state, aliasing, guard placement, trace prefixes, fallback, exception paths, C-module loading and any duplicated cost. Run the full union of old and new controls, with all new costs inside the candidate bill. + +Freeze source, environment, selection rules and the combined fixed cold sequence **B1 C1 C2 B2 B3 C3** before timing. Start with B1/C1 and complete the declared sequence only if the target is credible and correctness holds. Require fresh medians to improve at least 15% in both wall and CPU. Separately, each median saving must exceed the maximum of the baseline and candidate within-arm ranges for that metric. Retain every sample; instrumented diagnostics and publication checks are excluded from sample selection. + +No percentage is transferred from PR5995, PR5929, PR5864 or component pilots. If the combined result fails, record the actual outcome and reassess only a materially changed, independently reviewed mechanism; do not rerun the same timings hoping for a different answer. + +## G5 Delivery checks + +Validate finite normal/O modes, the complete assertion-on caller, read-only Git-free execution, external output locations and failure retention. Before deleting fresh private runtime copies, make only their private directories writable after all source checks; never chmod immutable package inputs. Avoid entry names such as `profile.py` that shadow standard-library modules. + +Check exact source/input manifests, raw ancestry, committed bytes and executable modes, declared inputs, canonical lossless transport, package metadata and export equality. Archive integrity/publication-wrapper costs are separately identified from the frozen scientific performance harness. A wrapper correctness run never replaces a performance sample or establishes a wrapper speed factor. + +## G6 Publication and completion + +Publish useful focused results through the authorized signed-in Chrome workflow, with exact pins, predecessor/license/AI credit, required template and seven-field handoffs. Do not grant maintainer secret access, merge a PR, or change the selected frontier. Read back PR text and the existing handoff index. Verify exact-head hosted planning and relevant package replay; keep hosted correctness separate from local performance. + +Record each lane's final disposition, combined target/noise outcome, all failures, remaining obligations and a compact checkpoint. Mark the goal complete only when every required task is delivered and the combined performance target passes. An unresolved target remains incomplete; apply the goal tool's blocking rules only at a genuine repeated impasse. + +## Resources and reporting + +Use one serial guarded runner: 180 seconds per scientific command, 1 GiB sampled process-group RSS, 600 seconds initial feasibility and 1,500 seconds total for this new round. The shared ledger includes profiles, compilation, finite and full runs, publication scientific replays and all failures. Prior ledgers remain unchanged. Crossing a cap stops the affected work; it does not produce a negative scientific theorem or complete the goal. + +Keep `TASK-BOARD.json`, `STATUS.json`, immutable stages and raw receipts current. Reassess after each source/cost gate, candidate result and integration result. Give concise progress updates and expose any blocker with its exact effect. No background feed work, automation or unrelated mathematical research is included. diff --git a/research/h25-bookkeeping/evidence/revisions/v1/STAGE.json b/research/h25-bookkeeping/evidence/revisions/v1/STAGE.json new file mode 100644 index 0000000000..e8c4359ffe --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/STAGE.json @@ -0,0 +1,633 @@ +{ + "baseline_arm": "native C, original controls and observations retained", + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e" + }, + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "baseline/CODE-SOURCES.json": { + "mode": 292, + "sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7" + }, + "baseline/README.md": { + "mode": 292, + "sha256": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64" + }, + "baseline/SOURCE-PINS.json": { + "mode": 292, + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" + }, + "baseline/SOURCES.json": { + "mode": 292, + "sha256": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a" + }, + "baseline/TASK.json": { + "mode": 292, + "sha256": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38" + }, + "baseline/VALIDATION.json": { + "mode": 292, + "sha256": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a" + }, + "baseline/VERIFY.json": { + "mode": 292, + "sha256": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78" + }, + "baseline/anchor.json": { + "mode": 292, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "baseline/archive_support.py": { + "mode": 292, + "sha256": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f" + }, + "baseline/check_artifacts.py": { + "mode": 292, + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "baseline/engine/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "baseline/engine/finite_controls.py": { + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "baseline/engine/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "baseline/engine/native_gf2.c": { + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "baseline/engine/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "baseline/engine/source/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/engine/source/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/evidence/COMPLETE-GATE.json": { + "mode": 292, + "sha256": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b" + }, + "baseline/evidence/ENVIRONMENT.json": { + "mode": 292, + "sha256": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384" + }, + "baseline/evidence/FIRST-PAIR-GATE.json": { + "mode": 292, + "sha256": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc" + }, + "baseline/evidence/FULL-PAIR-ADMISSION.json": { + "mode": 292, + "sha256": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829" + }, + "baseline/evidence/INDEPENDENT-REVIEW.md": { + "mode": 292, + "sha256": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f" + }, + "baseline/evidence/INPUT-COMMIT.json": { + "mode": 292, + "sha256": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b" + }, + "baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": { + "mode": 292, + "sha256": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa" + }, + "baseline/evidence/PLAN.json": { + "mode": 292, + "sha256": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813" + }, + "baseline/evidence/PROFILE-v1-FAILURE.json": { + "mode": 292, + "sha256": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f" + }, + "baseline/evidence/RESULTS.md": { + "mode": 292, + "sha256": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f" + }, + "baseline/evidence/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb" + }, + "baseline/evidence/UPSTREAM-REFRESH.json": { + "mode": 292, + "sha256": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693" + }, + "baseline/evidence/canonical/MANIFEST.json": { + "mode": 292, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "baseline/evidence/canonical/complement-transcript.json": { + "mode": 292, + "sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "baseline/evidence/canonical/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/evidence/canonical/full-return.lossless.json.gz": { + "mode": 292, + "sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "baseline/evidence/canonical/original-stdout.txt": { + "mode": 292, + "sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 292, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 292, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "baseline/evidence/publication-v1-failure/REVISION.json": { + "mode": 292, + "sha256": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8" + }, + "baseline/evidence/publication-v1-failure/receipt.json": { + "mode": 292, + "sha256": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a" + }, + "baseline/evidence/publication-v1-failure/stderr.txt": { + "mode": 292, + "sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515" + }, + "baseline/evidence/publication-v1-failure/stdout.txt": { + "mode": 292, + "sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342" + }, + "baseline/evidence/publication-v1-failure/usage.json": { + "mode": 292, + "sha256": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc" + }, + "baseline/evidence/publication-v1-failure/verify_full.py.txt": { + "mode": 292, + "sha256": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e" + }, + "baseline/evidence/runs/full-network-B1/receipt.json": { + "mode": 292, + "sha256": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27" + }, + "baseline/evidence/runs/full-network-B1/scientific-receipt.json": { + "mode": 292, + "sha256": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31" + }, + "baseline/evidence/runs/full-network-B1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B1/stdout.txt": { + "mode": 292, + "sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43" + }, + "baseline/evidence/runs/full-network-B1/usage.json": { + "mode": 292, + "sha256": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505" + }, + "baseline/evidence/runs/full-network-B2/receipt.json": { + "mode": 292, + "sha256": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d" + }, + "baseline/evidence/runs/full-network-B2/scientific-receipt.json": { + "mode": 292, + "sha256": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7" + }, + "baseline/evidence/runs/full-network-B2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B2/stdout.txt": { + "mode": 292, + "sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d" + }, + "baseline/evidence/runs/full-network-B2/usage.json": { + "mode": 292, + "sha256": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891" + }, + "baseline/evidence/runs/full-network-B3/receipt.json": { + "mode": 292, + "sha256": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506" + }, + "baseline/evidence/runs/full-network-B3/scientific-receipt.json": { + "mode": 292, + "sha256": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495" + }, + "baseline/evidence/runs/full-network-B3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B3/stdout.txt": { + "mode": 292, + "sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe" + }, + "baseline/evidence/runs/full-network-B3/usage.json": { + "mode": 292, + "sha256": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8" + }, + "baseline/evidence/runs/full-network-C1/receipt.json": { + "mode": 292, + "sha256": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934" + }, + "baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": { + "mode": 292, + "sha256": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342" + }, + "baseline/evidence/runs/full-network-C1/scientific-receipt.json": { + "mode": 292, + "sha256": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8" + }, + "baseline/evidence/runs/full-network-C1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C1/stdout.txt": { + "mode": 292, + "sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd" + }, + "baseline/evidence/runs/full-network-C1/usage.json": { + "mode": 292, + "sha256": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84" + }, + "baseline/evidence/runs/full-network-C2/receipt.json": { + "mode": 292, + "sha256": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73" + }, + "baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": { + "mode": 292, + "sha256": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969" + }, + "baseline/evidence/runs/full-network-C2/scientific-receipt.json": { + "mode": 292, + "sha256": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c" + }, + "baseline/evidence/runs/full-network-C2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C2/stdout.txt": { + "mode": 292, + "sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c" + }, + "baseline/evidence/runs/full-network-C2/usage.json": { + "mode": 292, + "sha256": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886" + }, + "baseline/evidence/runs/full-network-C3/receipt.json": { + "mode": 292, + "sha256": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce" + }, + "baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": { + "mode": 292, + "sha256": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237" + }, + "baseline/evidence/runs/full-network-C3/scientific-receipt.json": { + "mode": 292, + "sha256": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb" + }, + "baseline/evidence/runs/full-network-C3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C3/stdout.txt": { + "mode": 292, + "sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0" + }, + "baseline/evidence/runs/full-network-C3/usage.json": { + "mode": 292, + "sha256": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb" + }, + "baseline/evidence/runs/full-network-profile-v1/receipt.json": { + "mode": 292, + "sha256": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c" + }, + "baseline/evidence/runs/full-network-profile-v1/stderr.txt": { + "mode": 292, + "sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76" + }, + "baseline/evidence/runs/full-network-profile-v1/stdout.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v1/usage.json": { + "mode": 292, + "sha256": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78" + }, + "baseline/evidence/runs/full-network-profile-v2/receipt.json": { + "mode": 292, + "sha256": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf" + }, + "baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": { + "mode": 292, + "sha256": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a" + }, + "baseline/evidence/runs/full-network-profile-v2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v2/stdout.txt": { + "mode": 292, + "sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec" + }, + "baseline/evidence/runs/full-network-profile-v2/usage.json": { + "mode": 292, + "sha256": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b" + }, + "baseline/frozen/scripts/audit_short_guards.py": { + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "baseline/frozen/scripts/certify.py": { + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "baseline/frozen/scripts/compact_control_layer.py": { + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "baseline/frozen/scripts/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/frozen/scripts/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/frozen/scripts/exclusion_circuit.py": { + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "baseline/frozen/scripts/paired_exclusion_circuit.py": { + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "baseline/frozen/scripts/paired_network.py": { + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "baseline/frozen/scripts/prepare_layers.py": { + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "baseline/frozen/scripts/search_network.py": { + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "baseline/frozen/scripts/shared_point_circuit.py": { + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "baseline/frozen/scripts/shared_point_network.py": { + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "baseline/frozen/upstream/LICENSE": { + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "baseline/frozen/upstream/README.md": { + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "baseline/frozen/upstream/build/figures/multiplication-flow.tex": { + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "baseline/frozen/upstream/build/figures/proof-map.tex": { + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "baseline/frozen/upstream/build/main.tex": { + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "baseline/frozen/upstream/build/references.bib": { + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "baseline/frozen/upstream/build/sections/00-introduction.tex": { + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "baseline/frozen/upstream/build/sections/01-history.tex": { + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "baseline/frozen/upstream/build/sections/02-streams.tex": { + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "baseline/frozen/upstream/build/sections/03-motifs.tex": { + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "baseline/frozen/upstream/build/sections/04-swap.tex": { + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "baseline/frozen/upstream/build/sections/05-layers.tex": { + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "baseline/frozen/upstream/build/sections/06-transforms.tex": { + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "baseline/frozen/upstream/build/sections/07-resampling.tex": { + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "baseline/frozen/upstream/build/sections/08-assembly.tex": { + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": { + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "baseline/frozen/upstream/build/sections/10-transposition.tex": { + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": { + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "baseline/frozen/upstream/formalization.yaml": { + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "baseline/frozen/upstream/manifest.json": { + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + }, + "baseline/full_B.py": { + "mode": 292, + "sha256": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8" + }, + "baseline/full_C.py": { + "mode": 292, + "sha256": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4" + }, + "baseline/full_driver.py": { + "mode": 292, + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" + }, + "baseline/guard.py": { + "mode": 292, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline/reference/certificates/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/reference/certificates/selected-result.json": { + "mode": 292, + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "baseline/replay.py": { + "mode": 292, + "sha256": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90" + }, + "baseline/verify.py": { + "mode": 292, + "sha256": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b" + }, + "baseline/verify_full.py": { + "mode": 292, + "sha256": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + }, + "freeze_stage.py": { + "mode": 292, + "sha256": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/CALL-BUDGET.json": { + "mode": 292, + "sha256": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec" + }, + "priorities/runtime-guards/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605" + }, + "priorities/runtime-guards/PROPOSAL.json": { + "mode": 292, + "sha256": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d" + }, + "priorities/runtime-guards/RESEARCH.md": { + "mode": 292, + "sha256": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9" + }, + "priorities/runtime-guards/STATIC-CHECK.json": { + "mode": 292, + "sha256": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/CALL-BUDGET.json": { + "mode": 292, + "sha256": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5" + }, + "priorities/set-reuse/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7" + }, + "priorities/set-reuse/OWNERSHIP.md": { + "mode": 292, + "sha256": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099" + }, + "priorities/set-reuse/PROPOSAL.json": { + "mode": 292, + "sha256": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d" + }, + "priorities/set-reuse/RESEARCH.md": { + "mode": 292, + "sha256": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + }, + "priorities/trace-encoding/ADAPTER.md": { + "mode": 292, + "sha256": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f" + }, + "priorities/trace-encoding/CALL-BUDGET.json": { + "mode": 292, + "sha256": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab" + }, + "priorities/trace-encoding/PROPOSAL.json": { + "mode": 292, + "sha256": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d" + }, + "priorities/trace-encoding/RESEARCH.md": { + "mode": 292, + "sha256": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60" + }, + "priorities/trace-encoding/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + }, + "run_guarded.py": { + "mode": 292, + "sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + } + }, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "schema": "h25-bookkeeping-immutable-stage-v1", + "scientific_execution_during_freeze": false +} diff --git a/research/h25-bookkeeping/evidence/revisions/v1/integration/adapters.py b/research/h25-bookkeeping/evidence/revisions/v1/integration/adapters.py new file mode 100644 index 0000000000..96a1f52a0d --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/integration/adapters.py @@ -0,0 +1,214 @@ +"""Parent-owned integration; called only inside the serial scientific runner.""" +import hashlib +import importlib.util +import json +from pathlib import Path +import shlex +import subprocess +import sys +import sysconfig +from types import BuiltinFunctionType, ModuleType + + +def custody(root, lanes): + """Pay selected new source authentication inside every measured process.""" + selected = set() if lanes == 'none' else ({'sets', 'guards', 'trace'} if lanes == 'all' else {lanes}) + files = ['integration/full_driver.py', 'integration/adapters.py', 'integration/derive_driver.py', + 'integration/DERIVATION.json', 'PLAN.md', 'PLAN.json'] + for lane, directory in (('sets', 'set-reuse'), ('guards', 'runtime-guards'), ('trace', 'trace-encoding')): + if lane in selected: + files.extend(str(path.relative_to(root)) for path in sorted((root / 'priorities' / directory).iterdir()) + if path.is_file() and path.suffix in ('.py', '.c')) + manifest = json.loads((root / 'STAGE.json').read_bytes()) + result = {} + for name in files: + path = root / name + if path.is_symlink() or not path.is_file(): + raise RuntimeError('Missing or symlinked new source: ' + name) + row = {'sha256': hashlib.sha256(path.read_bytes()).hexdigest(), 'mode': path.stat().st_mode & 0o777} + if row != manifest['files'][name]: + raise RuntimeError('New source custody failed: ' + name) + result[name] = row + return result + + +def load(path, name): + if name in sys.modules: + raise RuntimeError('Isolated adapter name already imported: ' + name) + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError('Missing isolated adapter loader') + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + try: + spec.loader.exec_module(module) + except BaseException: + sys.modules.pop(name, None) + raise + return module + + +def build_encoder(source, directory): + if directory.exists(): + raise RuntimeError('Refusing to reuse a trace build directory') + directory.mkdir() + raw = source.read_bytes() + target = directory / ('_trace_encoding' + sysconfig.get_config_var('EXT_SUFFIX')) + command = shlex.split(sysconfig.get_config_var('CC') or 'cc') + [ + '-shared', '-fPIC', '-O3', '-std=c11', '-Wall', '-Wextra', '-Werror', + '-I' + sysconfig.get_paths()['include'], str(source), '-o', str(target)] + completed = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, timeout=90, check=False) + receipt = {'command': command, 'returncode': completed.returncode, + 'stdout': completed.stdout, 'stderr': completed.stderr, + 'source_sha256': hashlib.sha256(raw).hexdigest(), 'no_cached_binary': True} + (directory / 'build.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + if completed.returncode != 0 or source.read_bytes() != raw: + raise RuntimeError('Trace compilation or source custody failed; no retry') + receipt['extension_sha256'] = hashlib.sha256(target.read_bytes()).hexdigest() + module = load(target, '_trace_encoding') + (directory / 'build.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + return module, receipt + + +def extra_guard_type(base, backend, entries): + """Check the new encoder's owner/entry at every original guard boundary.""" + _type, _get = backend._TYPE, backend._DICT_GET + error = backend._RUNTIME_ERROR + for owner, name, function in entries: + if not (_type(owner) is ModuleType and _type(function) is BuiltinFunctionType and + function.__self__ is owner and _get(owner.__dict__, name) is function): + raise error('Invalid trace encoder owner or entry') + + class ExtendedGuard(base): + def __init__(self, module, label, native, original_functions): + self._h25_entries = entries + base.__init__(self, module, label, native, original_functions) + + def check(self): + base.check(self) + for owner, name, function in self._h25_entries: + if not (_type(owner) is ModuleType and _get(owner.__dict__, name) is function): + raise error('Runtime drift: trace encoder entry point ' + name) + + return ExtendedGuard + + +def prepare(root, backend, native, output, lanes, phases): + selected = set() if lanes == 'none' else ({'sets', 'guards', 'trace'} if lanes == 'all' else {lanes}) + if not selected <= {'sets', 'guards', 'trace'}: + raise RuntimeError('Unsupported frozen lane selection') + state = {'selected': selected, 'controls': {}, 'trace_type': backend.ComplementTrace, + 'set_binding': None, 'encoder_build': None, 'encoder': None} + if 'guards' in selected: + state['guard_adapter'] = load(root / 'priorities/runtime-guards/guard_candidate.py', '_h25_guard_candidate') + state['guard_controls'] = load(root / 'priorities/runtime-guards/guard_controls.py', '_h25_guard_controls') + state['reference_backend'] = load(Path(backend.__file__), '_h25_reference_backend') + backend.RuntimeGuard = state['guard_adapter'].make_runtime_guard(backend) + if 'trace' in selected: + directory = root / 'priorities/trace-encoding' + encoder, build = phases.call('trace_cold_compile_link_load', build_encoder, + directory / 'trace_encoder.c', output / 'trace-cold-build') + adapter = load(directory / 'trace_adapter.py', 'trace_adapter') + trace_type = adapter.make_trace_type(backend, encoder) + state.update(encoder=encoder, encoder_build=build, trace_type=trace_type, + trace_controls=load(directory / 'trace_controls.py', '_h25_trace_controls')) + backend.RuntimeGuard = extra_guard_type(backend.RuntimeGuard, backend, trace_type._h25_native_entries) + if 'sets' in selected: + directory = root / 'priorities/set-reuse' + state['set_adapter'] = load(directory / 'set_reuse.py', 'set_reuse') + state['set_controls'] = load(directory / 'finite_set_controls.py', '_h25_set_controls') + return state + + +def run_controls(state, backend, native, phases): + result = state['controls'] + if 'guards' in state['selected']: + result['guards'] = phases.call('new_guard_differential_controls', + state['guard_controls'].run_guard_controls, + state['reference_backend'], backend, native) + if 'trace' in state['selected']: + result['trace'] = phases.call('new_trace_original_differential_controls', + state['trace_controls'].run_controls, backend, state['encoder']) + result['trace_entry_freshness'] = phases.call('new_trace_entry_freshness_controls', + entry_controls, backend, native, state) + if 'sets' in state['selected']: + result['sets'] = phases.call('new_private_set_controls', + state['set_controls'].run_controls, backend, state['set_adapter']) + return result + + +def entry_controls(backend, native, state): + module = backend.load_source('_h25_trace_entry_controls') + trace = state['trace_type'](module.Label) + calls = [] + binding = backend.bind(module, native, calls, trace) + small, big = object.__new__(module.Label), object.__new__(module.Label) + small.basis, big.basis = {0: 1}, {0: 1, 1: 2} + original = state['encoder'].encode_record + outcomes = [] + before = (dict(binding['counters']), list(calls), trace.receipt()) + try: + state['encoder'].encode_record = lambda *args: b'corrupt' + for action in (binding['runtime_guard'].check, small.nondegenerate, lambda: small.complement_in(big)): + try: + action() + except RuntimeError as error: + if str(error) != 'Runtime drift: trace encoder entry point encode_record': + raise + outcomes.append(str(error)) + else: + raise RuntimeError('Changed trace entry was not rejected before arithmetic') + if (dict(binding['counters']), list(calls), trace.receipt()) != before: + raise RuntimeError('Changed trace entry executed arithmetic or observations') + finally: + state['encoder'].encode_record = original + binding['runtime_guard'].check() + return {'status': 'PASS', 'negative_actions': len(outcomes), 'rejected_before_arithmetic_and_observation': True} + + +def install_set(state, module): + if 'sets' not in state['selected']: + return + binding = state['set_adapter'].bind_verify_map(module) + module.Checks.verify_map = binding['verify_map'] + owner = binding['owner'] + circuit_init, checks_init = module.ComplexSideCircuit.__init__, module.Checks.__init__ + + def captured_circuit(self, *args, **kwargs): + circuit_init(self, *args, **kwargs) + owner.capture_c(self) + + def captured_checks(self, *args, **kwargs): + checks_init(self, *args, **kwargs) + owner.capture_checks(self) + + module.ComplexSideCircuit.__init__ = captured_circuit + module.Checks.__init__ = captured_checks + state['set_binding'] = binding + + +def seal(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].seal() + + +def arm(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].arm_cli() + + +def disarm(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].disarm_cli() + + +def receipt(state): + result = {'lanes': sorted(state['selected']), 'new_controls': state['controls'], + 'encoder_build': state['encoder_build'], + 'original_observer_retained_for_old_controls': True} + if state['set_binding'] is not None: + result['set_reuse'] = dict(state['set_binding']['receipt']) + if result['set_reuse']['fast_admissions'] != 1 or result['set_reuse']['fallback_calls'] != 0: + raise RuntimeError('Complete caller did not use the single admitted set-reuse lease') + return result diff --git a/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/IMPLEMENTATION.md b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/IMPLEMENTATION.md new file mode 100644 index 0000000000..81565dc741 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/IMPLEMENTATION.md @@ -0,0 +1,21 @@ +# P1 source implementation, pending parent execution + +`set_reuse.py` exposes `bind_verify_map(module)`, returning `verify_map`, `owner`, `receipt`, and the untouched original method. Supply an isolated candidate module before adding the parent's constructor or map phase wrappers. A separate unchanged module/process remains the reference. The factory authenticates source SHA/code shapes and the current pinned Fraction source; generates the original prefix and literal fallback from the frozen AST; adds only the private optimized tail; and retains the candidate module's live globals. Its temporary factory name is removed immediately. The lease owner is reachable through private closure cells and the returned parent binding, never stored on scientific instances or published as a module global. This is no protection against hostile introspection/native memory changes. + +Parent integration order: + +1. Load/authenticate the candidate scientific module and install the existing native backend. +2. Call `binding = bind_verify_map(circuit_module)` while `Checks` and `ComplexSideCircuit` retain their original source methods. +3. Install `binding['verify_map']` as `Checks.verify_map`. Install the usual phase wrappers and parent-owned constructor observation wrappers. After a successful original circuit constructor, call `owner.capture_c(self)`; after a successful original Checks constructor, call `owner.capture_checks(self)`. Constructor return values remain unchanged. +4. Call `owner.seal()` after all class/phase wrapper installation. Sealing records final class/function/closure identities, allowing no later wrapper replacement. Then call `owner.arm_cli()` immediately before the authenticated original assertion-on `runpy.run_path`. Construction captures occur inside this active interval. +5. In the enclosing parent `finally`, call `owner.disarm_cli()`. Preserve the original CLI return/stdout/witness/native guards and all original phase counts. Require the receipt to show one successful construction pair, one reservation/admission/expiry, zero fallback calls and 2300 private operand constructions for the complete H25 fast arm. Receipt fields are separate from scientific output. + +`reserve` consumes the one-use allowance at method entry before the prefix. Wrong Checks/circuit, missing/spent allowance, changed bindings and known hooks take the original whole method once. A reserved call executes the original prefix once, then `admit` examines actual exact triple and got-key/value shapes. Post-prefix denial executes the original tail AST once. Both optimized comprehensions still enumerate `c.triples` and independently form a new set intersection; only the operands are supplied by a private positional list. Additional outer enumeration and positional index lookups are new paid work. + +The cached left operand is a closure cell shared with the comprehensions. The `finally` block clears the operand list with an anchored builtin and sets both the list and left-operand cells to `None`, then expires the reservation. Generator loop variable `T` remains the original triple, so a retained traceback has no cached operand-set loop variable. There is no set cache on Checks, circuit, module or lease owner. Allocation failure is propagated without retry; exact allocation-failure timing is not promised. + +The new whole-tail condition remains independently parent-established: actual source-created identities in the fixed fresh CLI, callback-free admitted tail, no concurrent/reentrant mutator. Hook denial observes trace/profile/monitoring/GC callback/thread/signal state and never changes GC policy. It is not generic ownership detection. Ordinary API calls continue through literal fallback. + +`finite_set_controls.py` exposes `run_controls(backend, set_adapter)`, using the already loaded modules rather than relying on a `set_reuse` import path. The backend's trusted loader receives two distinct module names for original and candidate. Tiny raw fixture objects use an explicit test-only issuer rather than pretending to prove full CLI provenance. Controls cover all intersection sizes, duplicates/order, empty/large/negative integer cases, missing/wrong/used capability, reentry, prefix mutation/failure, callback-bearing tuple and got-key fallback, live set binding, hook denial, between-call mutation and retained-traceback cleanup. Parent runs both ordinary and `-O` finite controls; full qualification remains assertion-on. + +All binding/AST/Fraction authentication, lease capture/guards, hook queries, exact data scans, new enumeration/indexing, metadata allocation, finite controls and cleanup are in the complete candidate bill. Runtime and memory costs are unknown. No scientific import, compile, finite execution or measurement was performed by this worker while writing these files. Independent source review and parent serial correctness execution remain required. diff --git a/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/finite_set_controls.py b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/finite_set_controls.py new file mode 100644 index 0000000000..30a20e764c --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/finite_set_controls.py @@ -0,0 +1,422 @@ +"""Bounded P1 controls. Parent runner alone imports/executes this module. + +run_controls(backend, set_adapter) takes the existing trusted backend and the +already loaded set adapter; it performs no implicit module-name import. +The two module instances keep the literal reference independent. Tiny raw +fixtures use an explicitly trusted finite-fixture lease issuer; these fixtures +do not establish the complete CLI's constructor provenance. +""" +from __future__ import annotations + +import gc +import sys + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def typed(value): + if type(value) is dict: + return ("dict", tuple((typed(key), typed(item)) for key, item in value.items())) + if type(value) is list or type(value) is tuple: + return (type(value).__name__, tuple(typed(item) for item in value)) + return (type(value).__name__, value) + + +def outcome(function, checks): + try: + return ("value", typed(function(checks))) + except Exception as error: + return ("error", type(error).__name__, error.args) + + +def configure(module, circuit, triples, *, keep_list=False): + if keep_list: + circuit.triples[:] = triples + else: + circuit.triples = list(triples) + circuit.active = set() + circuit.args = [None] + circuit.support = [0] + circuit.pieces = [] + seen = set() + for target in circuit.triples: + if target in seen: + continue + seen.add(target) + for coefficient, predicate in ((module.Q(1, 2), lambda size: size == 0), + (module.Q(-1, 2), lambda size: size == 2)): + mask = sum(1 << index for index, other in enumerate(circuit.triples) + if predicate(len(set(target) & set(other)))) + if mask: + circuit.support.append(mask) + circuit.args.append(None) + circuit.pieces.append((target, len(circuit.support)-1, coefficient)) + + +def raw(module, triples): + circuit = object.__new__(module.ComplexSideCircuit) + configure(module, circuit, triples) + checks = object.__new__(module.Checks) + checks.c = circuit + return circuit, checks + + +class Prefix: + def __init__(self, events, action=None): + self.events = events + self.action = action + + def __iter__(self): + self.events.append("prefix") + if self.action is not None: + self.action() + return iter(()) + + +class RecursivePrefix: + def __init__(self, events): + self.events = events + self.action = None + self.entered = False + + def __iter__(self): + self.events.append("prefix") + if not self.entered: + self.entered = True + self.action() + return iter(()) + + +def run_controls(backend, set_adapter): + load_source = backend.load_source + bind_verify_map = set_adapter.bind_verify_map + oracle = load_source("_h25_set_controls_original") + candidate = load_source("_h25_set_controls_candidate") + original_candidate = candidate.Checks.verify_map + literal = oracle.Checks.verify_map + rows = [] + standard = [(0, 1, 2), (3, 4, 5), (0, 1, 3), (0, 4, 5)] + + def binding(): + candidate.Checks.verify_map = original_candidate + result = bind_verify_map(candidate) + candidate.Checks.verify_map = result["verify_map"] + result["owner"].seal() + return result + + def fixture_issue(result, circuit, checks): + # Explicit trusted test-only issuer. The full driver must use actual + # post-original-constructor captures, never raw fixture provenance. + owner = result["owner"] + owner.arm_cli() + need(owner.capture_c(circuit), "Fixture circuit capture failed") + need(owner.capture_checks(checks), "Fixture Checks capture failed") + + def compare(name, result, left, right, left_events=(), right_events=(), *, fast=0, fallbacks=1): + expected = outcome(literal, left) + actual = outcome(result["verify_map"], right) + need(actual == expected, "Set control outcome differs: " + name) + need(list(right_events) == list(left_events), "Set control callback order differs: " + name) + need(result["receipt"]["fast_admissions"] == fast, "Set control fast-path count differs: " + name) + need(result["receipt"]["fallback_calls"] == fallbacks, "Set control fallback count differs: " + name) + need(result["owner"].current is None, "Set control retained an active token: " + name) + rows.append({"name": name, "outcome": actual[0], "fast_admissions": fast, "fallback_calls": fallbacks}) + result["owner"].disarm_cli() + + # Exact values, all intersection sizes, duplication/order, and integer width. + for name, triples in ( + ("all-intersection-sizes", standard), + ("duplicate-positional-triples", standard + [standard[0]]), + ("reordered-triples", list(reversed(standard))), + ("negative-and-wide-integers", [(-5, 1 << 100, 9), (-5, 1 << 100, 10), (2, 3, 4)]), + ("empty-triples", [])): + result = binding() + _, left = raw(oracle, triples) + circuit, right = raw(candidate, triples) + fixture_issue(result, circuit, right) + compare(name, result, left, right, fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(triples), + "Set construction count differs from positional triple count") + need(result["receipt"]["reservations_expired"] == 1, "Successful lease did not expire") + + # No allowance: ordinary source method executes, including prefix once. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events), Prefix(right_events) + compare("no-allowance-prefix-once", result, left, right, left_events, right_events) + need(left_events == ["prefix"], "Missing-lease fixture did not cover prefix") + + # Correctly shaped objects cannot borrow another Checks identity. + result = binding() + _, left = raw(oracle, standard) + right_c, captured = raw(candidate, standard) + right = object.__new__(candidate.Checks) + right.c = right_c + fixture_issue(result, right_c, captured) + compare("wrong-checks-identity", result, left, right) + + result = binding() + _, left = raw(oracle, standard) + captured_c, right = raw(candidate, standard) + other_c, _ = raw(candidate, standard) + fixture_issue(result, captured_c, right) + right.c = other_c + compare("wrong-circuit-link", result, left, right) + + # Reservation is spent before a prefix can reenter the method. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = RecursivePrefix(left_events), RecursivePrefix(right_events) + left_c.active.action = lambda: literal(left) + right_c.active.action = lambda: result["verify_map"](right) + fixture_issue(result, right_c, right) + compare("prefix-reentry-single-reservation", result, left, right, left_events, right_events, + fast=1, fallbacks=1) + need(left_events == ["prefix", "prefix"] and result["receipt"]["reservations"] == 1, + "Recursive fixture did not consume one outer reservation") + + # The post-prefix state, not an earlier eager snapshot, supplies operands. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + changed = [(10, 11, 12), (10, 11, 13), (20, 21, 22)] + left_events, right_events = [], [] + left_c.active = Prefix(left_events, lambda: configure(oracle, left_c, changed, keep_list=True)) + right_c.active = Prefix(right_events, lambda: configure(candidate, right_c, changed, keep_list=True)) + fixture_issue(result, right_c, right) + compare("post-prefix-mutated-values", result, left, right, left_events, right_events, + fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(changed), + "Set cache preceded prefix mutation") + + # Prefix exceptions happen before set construction, even with a valid lease. + def fail_prefix(): + raise ValueError("prefix sentinel") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events, fail_prefix), Prefix(right_events, fail_prefix) + fixture_issue(result, right_c, right) + compare("failing-prefix-no-eager-cache", result, left, right, left_events, right_events, + fast=0, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == 0, "Failing prefix built sets") + + # Callback-bearing triple subclasses must use literal post-prefix tail. + def callback_triple(events, base): + class Triple(tuple): + def __iter__(self): + events.append("triple-iter") + return tuple.__iter__(self) + return Triple(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = callback_triple(left_events, standard[0]) + right_c.triples[0] = callback_triple(right_events, standard[0]) + fixture_issue(result, right_c, right) + compare("tuple-subclass-callback-fallback", result, left, right, left_events, right_events) + need(left_events, "Tuple callback fixture did not execute callbacks") + + def callback_integer(events, value): + class Integer(int): + def __hash__(self): + events.append("integer-hash") + return int.__hash__(self) + return Integer(value) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = (callback_integer(left_events, 0), 1, 2) + right_c.triples[0] = (callback_integer(right_events, 0), 1, 2) + fixture_issue(result, right_c, right) + compare("integer-subclass-hash-fallback", result, left, right, left_events, right_events) + need(left_events, "Integer callback fixture did not execute callbacks") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.triples[0] = (False, 1, 2) + right_c.triples[0] = (False, 1, 2) + fixture_issue(result, right_c, right) + compare("bool-member-exact-type-fallback", result, left, right) + + # The got dictionary can retain a hostile equality key from the prefix. + def collision_key(circuit, events, base): + class Target(tuple): + __hash__ = tuple.__hash__ + fired = False + + def __eq__(self, other): + events.append("collision-equality") + if not self.fired: + self.fired = True + circuit.triples.reverse() + return tuple.__eq__(self, other) + return Target(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + for circuit, events in ((left_c, left_events), (right_c, right_events)): + target, node, coefficient = circuit.pieces[0] + circuit.pieces[0] = (collision_key(circuit, events, target), node, coefficient) + fixture_issue(result, right_c, right) + compare("got-collision-key-fallback", result, left, right, left_events, right_events) + need(left_events, "Collision fixture did not reach custom equality") + + # Runtime source-global drift retains original live resolution in fallback. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + def logging_set(events): + def wrapped(values): + events.append("set") + return set(values) + return wrapped + oracle.set, candidate.set = logging_set(left_events), logging_set(right_events) + fixture_issue(result, right_c, right) + try: + compare("live-source-set-resolution", result, left, right, left_events, right_events) + need(len(left_events) == 4*len(standard)**2, "Literal fallback lost original set calls") + finally: + del oracle.set + del candidate.set + + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + original_q = candidate.Q + def logging_q(events): + def wrapped(*args): + events.append("Q") + return original_q(*args) + return wrapped + fixture_issue(result, right_c, right) + oracle.Q, candidate.Q = logging_q(left_events), logging_q(right_events) + try: + compare("live-Fraction-global-resolution", result, left, right, left_events, right_events) + need(left_events, "Fraction callback fixture did not execute callbacks") + finally: + oracle.Q = candidate.Q = original_q + + # The exact Fraction class is mutable: unchanged class identity alone is + # insufficient. A changed method after binding must deny optimization. + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + original_hash = original_q.__hash__ + hash_events = [] + def traced_hash(value): + hash_events.append("fraction-hash") + return original_hash(value) + original_q.__hash__ = traced_hash + try: + expected = outcome(literal, left) + expected_events = list(hash_events) + hash_events.clear() + actual = outcome(result["verify_map"], right) + need(actual == expected and hash_events == expected_events and hash_events, + "Changed Fraction method fallback differs") + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Changed Fraction method was admitted") + finally: + original_q.__hash__ = original_hash + result["owner"].disarm_cli() + rows.append({"name": "changed-Fraction-hash", "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # A used capability cannot cache values for a later invocation. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + need(outcome(result["verify_map"], right) == outcome(literal, left), "Initial leased call differs") + configure(oracle, left_c, changed) + configure(candidate, right_c, changed) + compare("used-capability-changed-later-input", result, left, right, fast=1, fallbacks=1) + need(result["receipt"]["private_operand_sets_constructed"] == len(standard), + "Used capability constructed a second private cache") + + # Observable known hooks deny optimization without changing hook policy. + for hook in ("trace", "profile", "gc-callback"): + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + def quiet_trace(frame, event, arg): + return quiet_trace + def quiet_gc(phase, info): + return None + if hook == "trace": + sys.settrace(quiet_trace) + elif hook == "profile": + sys.setprofile(quiet_trace) + else: + gc.callbacks.append(quiet_gc) + try: + actual = outcome(result["verify_map"], right) + finally: + if hook == "trace": + sys.settrace(None) + elif hook == "profile": + sys.setprofile(None) + else: + gc.callbacks.remove(quiet_gc) + need(actual == outcome(literal, left), "Hook-denied fallback differs: " + hook) + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Known hook was admitted: " + hook) + result["owner"].disarm_cli() + rows.append({"name": "known-hook-" + hook, "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # Deliberate tail assertion failure retains a traceback: cached operands + # must have been cleared/reset even while the frame itself remains live. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.support[1] ^= 1 << 20 + right_c.support[1] ^= 1 << 20 + fixture_issue(result, right_c, right) + expected = outcome(literal, left) + retained = None + try: + actual = ("value", typed(result["verify_map"](right))) + except Exception as error: + actual = ("error", type(error).__name__, error.args) + retained = error.__traceback__ + need(actual == expected, "Tail-failure outcome differs") + if not sys.flags.optimize: + need(actual[0] == "error" and actual[1] == "AssertionError", "Tail-failure fixture did not fail") + found = False + while retained is not None: + if retained.tb_frame.f_code is result["verify_map"].__code__: + found = True + values = retained.tb_frame.f_locals + need(values["_h25_sr_sets"] is None and values["_h25_sr_left"] is None, + "Retained traceback kept private cached operands") + retained = retained.tb_next + need(found, "Candidate traceback frame was not inspected") + need(result["owner"].current is None, "Tail error retained lease") + need(result["receipt"]["fast_admissions"] == 1, "Tail cleanup fixture did not use cached sets") + result["owner"].disarm_cli() + rows.append({"name": "traceback-cleanup", "outcome": actual[0], "fast_admissions": 1, "fallback_calls": 0}) + + candidate.Checks.verify_map = original_candidate + need(oracle.Checks.verify_map is literal, "Independent source reference was changed") + return {"status": "P1_FINITE_SET_CONTROLS_PASS", "optimize": sys.flags.optimize, + "cases": len(rows), "rows": rows, + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence"} diff --git a/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/set_reuse.py b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/set_reuse.py new file mode 100644 index 0000000000..89d6d32ab9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v1/priorities/set-reuse/set_reuse.py @@ -0,0 +1,451 @@ +"""Private operand-set reuse for one authenticated frozen full-caller phase. + +The parent owns the new whole-tail execution invariant. This is not inherited +from the native kernel guard and is not a generic alias/security detector. +Standalone, unsupported and unleased calls delegate the literal source. +No scientific module is imported here; the parent supplies an isolated module. +""" +from __future__ import annotations + +import _thread +import ast +import builtins +import copy +import fractions +import gc +import hashlib +from pathlib import Path +import signal +import sys +from types import CodeType, FunctionType, GetSetDescriptorType, MemberDescriptorType, ModuleType + +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +FRACTION_SHA256 = "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231" +_TYPE, _OBJECT, _DICT, _LIST, _TUPLE, _INT = type, object, dict, list, tuple, int +_LEN, _SET, _COMPILE = len, set, compile +_GET = dict.get +_OBJGET = object.__getattribute__ +_TYPEGET = type.__getattribute__ +_CLEAR = list.clear +_BUILTINS = builtins.__dict__ +_FRACTION = fractions.Fraction +_BUILTIN_NAMES = ("type", "object", "set", "len", "sum", "enumerate", "dict", + "int", "list", "tuple", "all", "range", "hash", "abs", "pow", + "isinstance", "super") +_BUILTIN_RECORD = tuple((name, _BUILTINS[name]) for name in _BUILTIN_NAMES) +_SOURCE_LOOKUPS = ("set", "len", "sum", "enumerate", "dict") + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +def _function_record(function): + if _TYPE(function) is not FunctionType: + return None + closure = function.__closure__ + cells = () if closure is None else _TUPLE((cell, cell.cell_contents) for cell in closure) + return (function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, closure, cells) + + +def _function_fresh(record): + function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells = record + if not (function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure): + return False + for cell, value in cells: + try: + if cell.cell_contents is not value: + return False + except ValueError: + return False + return True + + +def _ordinary_class(cls): + if _TYPE(cls) is not _TYPE or _TYPEGET(cls, "__mro__") != (cls, _OBJECT): + return False + attributes = _TYPEGET(cls, "__dict__") + if "__getattr__" in attributes or _TYPEGET(cls, "__getattribute__") is not _OBJECT.__getattribute__: + return False + if _TYPEGET(cls, "__new__") is not _OBJECT.__new__: + return False + for name in ("__dict__", "__weakref__"): + descriptor = attributes.get(name) + if _TYPE(descriptor) is not GetSetDescriptorType or descriptor.__objclass__ is not cls: + return False + return True + + +def _ordinary_dict(value, cls): + if _TYPE(value) is not cls or not _ordinary_class(cls): + return None + namespace = _OBJGET(value, "__dict__") + return namespace if _TYPE(namespace) is _DICT else None + + +def _triple(value): + return (_TYPE(value) is _TUPLE and _LEN(value) == 3 and + _TYPE(value[0]) is _INT and _TYPE(value[1]) is _INT and _TYPE(value[2]) is _INT) + + +def _hooks_clear(): + """Known instrumentation denial only; not a generic finalizer theorem.""" + if sys.gettrace() is not None or sys.getprofile() is not None: + return False + if _TYPE(gc.callbacks) is not _LIST or _LEN(gc.callbacks) != 0 or _thread._count() != 0: + return False + monitoring = getattr(sys, "monitoring", None) + if monitoring is not None: + for tool in range(6): + if monitoring.get_tool(tool) is not None: + return False + for number in signal.valid_signals(): + handler = signal.getsignal(number) + if handler is not signal.SIG_DFL and handler is not signal.SIG_IGN and handler is not signal.default_int_handler: + return False + return True + + +def _code_named(code, name): + return next(item for item in code.co_consts if _TYPE(item) is CodeType and item.co_name == name) + + +def _authenticate_function(function, expected, namespace): + _need(_TYPE(function) is FunctionType and function.__globals__ is namespace and + function.__builtins__ is _BUILTINS and function.__code__ == expected, + "Set reuse requires the exact original source function") + + +class _Token: + __slots__ = () + + +class _LeaseOwner: + """Parent-private one-call capability; only identity/state, never operand sets.""" + + def __init__(self, module, original, source_functions, class_names, receipt): + self.module = module + self.namespace = module.__dict__ + self.original = original + self.circuit_class = self.namespace["ComplexSideCircuit"] + self.checks_class = self.namespace["Checks"] + self.class_names = class_names + self.source_functions = source_functions + self.receipt = receipt + self.sealed = False + self.cli_active = False + self.used = False + self.current = None + self.circuit = self.checks = self.triples = None + self.class_records = () + self.function_records = () + self.fraction_globals = _TUPLE(fractions.__dict__.items()) + self.fraction_classes = _TUPLE((cls, _TYPEGET(cls, "__mro__"), + _TUPLE(_TYPEGET(cls, "__dict__").items())) + for cls in _FRACTION.__mro__ if cls is not _OBJECT) + self.math_gcd = fractions.math.gcd + self.rational = fractions.numbers.Rational + self.complex = fractions.numbers.Complex + self.hash_wrapper = fractions._hash_algorithm + self.hash_wrapped = fractions._hash_algorithm.__wrapped__ + fraction_functions = [] + for _, _, attributes in self.fraction_classes: + for _, value in attributes: + if _TYPE(value) is FunctionType: + fraction_functions.append(value) + elif _TYPE(value) is property: + fraction_functions.extend(item for item in (value.fget, value.fset, value.fdel) if item is not None) + fraction_functions.append(self.hash_wrapped) + self.fraction_functions = _TUPLE(_function_record(function) for function in fraction_functions) + + def seal(self): + """Parent calls once after installing all constructor/map phase wrappers.""" + _need(not self.sealed and not self.cli_active, "Set reuse owner already sealed or active") + classes = (self.circuit_class, self.checks_class) + records = [] + functions = _LIST(self.source_functions) + for cls, names in zip(classes, self.class_names): + _need(_ordinary_class(cls), "Set reuse requires ordinary frozen class dispatch") + attributes = _TYPEGET(cls, "__dict__") + _need(_SET(attributes) == names, "Set reuse class member shape changed") + records.append((cls, _TYPEGET(cls, "__mro__"), _TUPLE(attributes.items()))) + functions.extend(value for value in attributes.values() if _TYPE(value) is FunctionType) + self.class_records = _TUPLE(records) + self.function_records = _TUPLE(_function_record(function) for function in functions) + self.sealed = True + + def arm_cli(self): + """Parent attests the pinned fresh CLI; do not call for a generic API use.""" + _need(self.sealed and not self.cli_active and self.circuit is None and not self.used, + "Set reuse allowance cannot be reused") + self.cli_active = True + self.receipt["allowances_armed"] += 1 + + def capture_c(self, circuit): + """Called only after the parent-observed original constructor returns.""" + if not self.cli_active or self.circuit is not None or self.used: + return False + namespace = _ordinary_dict(circuit, self.circuit_class) + if namespace is None: + return False + triples = _GET(namespace, "triples") + if _TYPE(triples) is not _LIST: + return False + self.circuit, self.triples = circuit, triples + self.receipt["circuits_captured"] += 1 + return True + + def capture_checks(self, checks): + """Called only after the parent-observed original Checks init returns.""" + if not self.cli_active or self.circuit is None or self.checks is not None or self.used: + return False + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return False + self.checks = checks + self.receipt["checks_captured"] += 1 + return True + + def _fresh(self): + if (_TYPE(self.module) is not ModuleType or self.module.__dict__ is not self.namespace or + _GET(self.namespace, "Checks") is not self.checks_class or + _GET(self.namespace, "ComplexSideCircuit") is not self.circuit_class or + _GET(self.namespace, "Q") is not _FRACTION or + _GET(self.namespace, "__builtins__") is not _BUILTINS): + return False + for name, expected in _BUILTIN_RECORD: + if _GET(_BUILTINS, name) is not expected: + return False + for name in _SOURCE_LOOKUPS: + if name in self.namespace: + return False + for cls, mro, items in self.class_records + self.fraction_classes: + if _TYPEGET(cls, "__mro__") is not mro: + return False + attributes = _TYPEGET(cls, "__dict__") + if _LEN(attributes) != _LEN(items): + return False + for name, value in items: + if attributes.get(name) is not value: + return False + for record in self.function_records + self.fraction_functions: + if not _function_fresh(record): + return False + if _LEN(fractions.__dict__) != _LEN(self.fraction_globals): + return False + for name, value in self.fraction_globals: + if _GET(fractions.__dict__, name) is not value: + return False + return (fractions.math.gcd is self.math_gcd and + fractions.numbers.Rational is self.rational and + fractions.numbers.Complex is self.complex and + fractions._hash_algorithm is self.hash_wrapper and + self.hash_wrapper.__wrapped__ is self.hash_wrapped) + + def reserve(self, checks): + """Consumed before prefix; wrong or unleased objects get literal fallback.""" + self.receipt["entries"] += 1 + if not self.cli_active or self.used or self.current is not None or checks is not self.checks: + return None + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return None + self.used = True + if not self._fresh() or not _hooks_clear(): + return None + token = _Token() + self.current = token + self.receipt["reservations"] += 1 + return token + + def admit(self, token, checks, circuit, got): + """Called after the original prefix, using its actual local got mapping.""" + if (token is None or token is not self.current or not self.cli_active or + checks is not self.checks or circuit is not self.circuit or + not self._fresh() or not _hooks_clear()): + return False + check_dict = _ordinary_dict(checks, self.checks_class) + circuit_dict = _ordinary_dict(circuit, self.circuit_class) + if check_dict is None or circuit_dict is None or _GET(check_dict, "c") is not circuit: + return False + triples = _GET(circuit_dict, "triples") + if triples is not self.triples or _TYPE(triples) is not _LIST: + return False + for triple in triples: + if not _triple(triple): + return False + if _TYPE(got) is not _DICT: + return False + for key, value in got.items(): + if (_TYPE(key) is not _TUPLE or _LEN(key) != 2 or not _triple(key[0]) or + _TYPE(key[1]) is not _FRACTION or _TYPE(value) is not _INT): + return False + coefficient = key[1] + if (_TYPE(_OBJGET(coefficient, "_numerator")) is not _INT or + _TYPE(_OBJGET(coefficient, "_denominator")) is not _INT): + return False + self.receipt["fast_admissions"] += 1 + return True + + def fallback(self): + self.receipt["fallback_calls"] += 1 + + def constructed(self, count): + self.receipt["private_operand_sets_constructed"] += count + + def expire(self, token): + if token is not None and token is self.current: + self.current = None + self.receipt["reservations_expired"] += 1 + + def disarm_cli(self): + self.current = None + self.cli_active = False + self.circuit = self.checks = self.triples = None + + +def _fraction_source_check(): + raw = Path(fractions.__file__).read_bytes() + _need(hashlib.sha256(raw).hexdigest() == FRACTION_SHA256, "Set reuse Fraction source differs") + compiled = _COMPILE(raw, fractions.__file__, "exec", dont_inherit=True, optimize=sys.flags.optimize) + fraction_code = _code_named(compiled, "Fraction") + _need(_TYPEGET(_FRACTION, "__getattribute__") is _OBJECT.__getattribute__, + "Set reuse Fraction attribute dispatch differs") + for name in ("_numerator", "_denominator"): + descriptor = _TYPEGET(_FRACTION, name) + _need(_TYPE(descriptor) is MemberDescriptorType and descriptor.__objclass__ is _FRACTION, + "Set reuse Fraction slot descriptor differs") + _need(fractions.numbers.Rational is _FRACTION.__mro__[1] and + fractions.numbers.Complex in _FRACTION.__mro__, + "Set reuse Fraction number-class resolution differs") + for name in ("__new__", "__hash__", "__eq__"): + _authenticate_function(_TYPEGET(_FRACTION, name), _code_named(fraction_code, name), fractions.__dict__) + for name in ("numerator", "denominator"): + _authenticate_function(_TYPEGET(_FRACTION, name).fget, _code_named(fraction_code, name), fractions.__dict__) + _authenticate_function(fractions._hash_algorithm.__wrapped__, _code_named(compiled, "_hash_algorithm"), fractions.__dict__) + + +def _generate(module, method_ast, owner, original): + """Only original prefix/tail AST plus declared private bookkeeping changes.""" + _need(_LEN(method_ast.body) == 7 and _TYPE(method_ast.body[3]) is ast.For and + _TYPE(method_ast.body[4]) is ast.Assign and _TYPE(method_ast.body[5]) is ast.For, + "Unexpected pinned verify_map AST layout") + prefix = copy.deepcopy(method_ast.body[:4]) + fallback_tail = copy.deepcopy(method_ast.body[4:]) + template = ast.parse(''' +def _h25_sr_factory(_h25_sr_enter, _h25_sr_admit, _h25_sr_expire, _h25_sr_original, + _h25_sr_fallback, _h25_sr_constructed, _h25_sr_clear): + def verify_map(self): + _h25_sr_token = _h25_sr_enter(self) + _h25_sr_sets = None + _h25_sr_left = None + try: + if _h25_sr_token is None: + _h25_sr_fallback() + return _h25_sr_original(self) + _H25_PREFIX + if not _h25_sr_admit(_h25_sr_token, self, c, got): + _h25_sr_fallback() + _H25_FALLBACK + _h25_sr_sets = [set(T) for T in c.triples] + _h25_sr_constructed(len(_h25_sr_sets)) + nonzero = 0 + for _h25_sr_position, S in enumerate(c.triples): + _h25_sr_left = _h25_sr_sets[_h25_sr_position] + zero = sum(1 << i for i, T in enumerate(c.triples) + if not _h25_sr_left & _h25_sr_sets[i]) + two = sum(1 << i for i, T in enumerate(c.triples) + if len(_h25_sr_left & _h25_sr_sets[i]) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + finally: + if _h25_sr_sets is not None: + _h25_sr_clear(_h25_sr_sets) + _h25_sr_left = None + _h25_sr_sets = None + _h25_sr_expire(_h25_sr_token) + return verify_map +''') + method = template.body[0].body[0] + guarded = method.body[3] + _need(_TYPE(guarded) is ast.Try, "Internal set adapter AST layout changed") + replaced = [] + for statement in guarded.body: + if _TYPE(statement) is ast.Expr and _TYPE(statement.value) is ast.Name and statement.value.id == "_H25_PREFIX": + replaced.extend(prefix) + elif _TYPE(statement) is ast.If and statement.body and any( + _TYPE(item) is ast.Expr and _TYPE(item.value) is ast.Name and item.value.id == "_H25_FALLBACK" + for item in statement.body): + statement.body = statement.body[:1] + fallback_tail + replaced.append(statement) + else: + replaced.append(statement) + guarded.body = replaced + ast.fix_missing_locations(template) + namespace = module.__dict__ + name = "_h25_sr_factory" + _need(name not in namespace, "Set reuse helper name collision") + try: + exec(_COMPILE(template, "", "exec", dont_inherit=True, + optimize=sys.flags.optimize), namespace) + factory = namespace[name] + function = factory(owner.reserve, owner.admit, owner.expire, original, + owner.fallback, owner.constructed, _CLEAR) + finally: + namespace.pop(name, None) + return function + + +def bind_verify_map(module): + """Return verify_map/owner/receipt; parent installs, wraps, seals, then arms. + + This factory must receive an isolated candidate module. Keep the unchanged + baseline/reference in another module/process; existing globals are never + copied or rebound, so ordinary fallback retains live source resolution. + """ + _need(_TYPE(module) is ModuleType, "Set reuse needs an exact source module") + namespace = module.__dict__ + path = Path(namespace["__file__"]) + raw = path.read_bytes() + _need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Set reuse scientific source differs") + _need(_GET(namespace, "__builtins__") is _BUILTINS and _GET(namespace, "Q") is _FRACTION, + "Set reuse source calling environment differs") + for name, value in _BUILTIN_RECORD: + _need(_GET(_BUILTINS, name) is value, "Set reuse builtin identity differs") + for name in _SOURCE_LOOKUPS: + _need(name not in namespace, "Set reuse source shadows a builtin") + compiled = _COMPILE(raw, str(path), "exec", dont_inherit=True, optimize=sys.flags.optimize) + source_functions = [] + class_names = [] + for name in ("ComplexSideCircuit", "Checks"): + cls = namespace[name] + _need(_ordinary_class(cls), "Set reuse source class dispatch differs") + class_code = _code_named(compiled, name) + attributes = _TYPEGET(cls, "__dict__") + expected_names = {"__module__", "__doc__", "__dict__", "__weakref__"} + for code in class_code.co_consts: + if _TYPE(code) is CodeType: + expected_names.add(code.co_name) + function = attributes.get(code.co_name) + _authenticate_function(function, code, namespace) + source_functions.append(function) + _need(_SET(attributes) == expected_names, "Set reuse source class members differ") + class_names.append(expected_names) + _fraction_source_check() + original = namespace["Checks"].verify_map + parsed = ast.parse(raw, filename=str(path)) + checks_ast = next(item for item in parsed.body if _TYPE(item) is ast.ClassDef and item.name == "Checks") + method_ast = next(item for item in checks_ast.body if _TYPE(item) is ast.FunctionDef and item.name == "verify_map") + receipt = {"schema": "h25-private-set-reuse-v1", "source_sha256": SOURCE_SHA256, + "fraction_sha256": FRACTION_SHA256, "allowances_armed": 0, "circuits_captured": 0, + "checks_captured": 0, "entries": 0, "reservations": 0, "fast_admissions": 0, + "fallback_calls": 0, "private_operand_sets_constructed": 0, "reservations_expired": 0} + owner = _LeaseOwner(module, original, _TUPLE(source_functions), _TUPLE(class_names), receipt) + candidate = _generate(module, method_ast, owner, original) + return {"verify_map": candidate, "owner": owner, "receipt": receipt, "original": original} diff --git a/research/h25-bookkeeping/evidence/revisions/v2/PLAN.json b/research/h25-bookkeeping/evidence/revisions/v2/PLAN.json new file mode 100644 index 0000000000..9136f51cc0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/PLAN.json @@ -0,0 +1,154 @@ +{ + "schema_version": 1, + "title": "H25 bookkeeping optimization plan", + "authorization": "User explicitly requested all three priorities, concurrent agent swarming including research, and a goal to finish the tasks. Existing Chrome publication authorization continues.", + "baseline": { + "pr": 5995, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "arm": "PR5995 native C configuration with all original qualification controls; NOT the older Python-only arm", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "historical_wall_median": 28.63625624598353, + "historical_cpu_median": 28.46, + "historical_times_are_orientation_only": true, + "new_performance_claim_requires_fresh_same_session_baseline": true + }, + "target": { + "combined_wall_reduction_minimum": 0.15, + "combined_cpu_reduction_minimum": 0.15, + "individual_15_percent_requirement": false, + "scope": "complete frozen historical H25 qualification with retained observations" + }, + "lanes": [ + { + "id": "P1", + "priority": "Set reuse", + "agent": "bookkeeping_sets", + "ownership": "priorities/set-reuse/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Precompute private sets from admitted triples; retain every original pairwise intersection/equality check and fallback for unsupported inputs." + }, + { + "id": "P2", + "priority": "Runtime guards", + "agent": "bookkeeping_guards", + "ownership": "priorities/runtime-guards/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Deduplicate identical function records and build failure messages only on failure; keep every distinct freshness check at the same call boundary; assess a native implementation only if justified." + }, + { + "id": "P3", + "priority": "Trace encoding", + "agent": "bookkeeping_trace", + "ownership": "priorities/trace-encoding/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Reduce temporary tuples/dictionaries/JSON/bytes and hash crossings; retain canonical bytes, ordering, exact types, prefixes, counters and failure semantics." + }, + { + "id": "R", + "priority": "Independent contract review", + "agent": "bookkeeping_review", + "ownership": "research/independent-review/", + "first_deliverables": [ + "CONTRACT-MATRIX.md", + "REVIEW-GATES.json" + ], + "contract": "Independently review proposals, aliasing/callback/fallback/freshness/byte contracts, interference and added cost; no implementation ownership." + } + ], + "parent_ownership": [ + "control/", + "integration/", + "validation/", + "publication/", + "runtime/", + "stages/", + "PLAN.md", + "PLAN.json", + "TASK-BOARD.json", + "STATUS.json" + ], + "concurrency": { + "parallel": [ + "source and primary-source research", + "independent design and review", + "implementation in disjoint owned paths after gates", + "fixture/test design and metadata preparation" + ], + "serialized": [ + "compilation", + "scientific imports/corpus execution", + "correctness runs", + "profiling and benchmarks", + "shared integration", + "Chrome writes" + ], + "local_heavy_work_during_benchmarks": "prohibited", + "agent_model": "GPT-6-astra", + "reasoning_effort": "xhigh", + "initial_agents": 4, + "further_delegation_requires_parent_assignment": true + }, + "resource_policy": { + "wall_seconds_per_scientific_command": 180, + "sampled_process_group_rss_bytes": 1073741824, + "initial_feasibility_seconds": 600, + "shared_round_seconds": 1500, + "single_parent_owned_runner": true, + "automatic_retries": false, + "all_failed_attempts_count": true, + "old_ledgers_preserved": true + }, + "gates": [ + "G0 refreshed canonical guidance/live overlap/baseline and shared contract freeze", + "G1 parallel source research and independent review; measurable-headroom decision", + "G2 finite correctness and all new-control cost freeze for each candidate", + "G3 individual bounded full pilot comparisons, not component gain promises", + "G4 combined integration and fresh fixed BCCBBC comparison against PR5995 native baseline", + "G5 normal/O finite, assertion-on complete, readonly Git-free/export/source/metadata/commit checks", + "G6 focused Chrome publication, exact-head hosted CI and required handoff readbacks" + ], + "noise_rule": "Combined fresh baseline median minus candidate median must exceed max(baseline range,candidate range) separately for wall and CPU, AND both reductions >=15%; predeclare six cold BCCBBC processes and retain all samples.", + "completion": [ + "All three priorities have reviewed final dispositions: qualified integration or reproducible scoped stop", + "Combined >=15% complete wall AND CPU target and noise gates pass before calling the performance goal achieved", + "All outputs/types/coverage/independent oracles/source pins and full new costs retained", + "Useful artifacts published via Chrome with exact-head checks and handoffs; no merge/frontier change", + "No unfinished required work; target misses reported as unmet, never a fabricated win" + ], + "paused": [ + "kappa research", + "Work1/2 mathematical streams", + "unrelated feeds", + "automations" + ], + "initial_dispatch": "Source-only research and contract mapping; no compilers, numerical runs or implementation until the corresponding gate.", + "repeated_call_reduction": { + "required_for_all_priorities": true, + "deliverable": "CALL-BUDGET.json per priority plus one parent diagnostic call census when discriminating", + "fields": [ + "current calls", + "repeated inputs/state", + "safe equivalence/ownership basis", + "eliminated calls", + "retained semantic checks", + "replacement calls", + "new control and conversion costs", + "measurement/evidence boundary" + ], + "P1": "metadata/set constructors primary; loop fusion or intersection-result reuse separate research gate", + "P2": "identity dedup, equivalent inline failure paths and lazy messages; retain each distinct live check at same boundary", + "P3": "stateless per-record construction/encoding and crossings; immediate hash/counter semantics retained", + "integration": "reuse only proven admitted private metadata; no shared answers or cached PASS", + "no_standalone_call_count_speed_claim": true + } +} diff --git a/research/h25-bookkeeping/evidence/revisions/v2/PLAN.md b/research/h25-bookkeeping/evidence/revisions/v2/PLAN.md new file mode 100644 index 0000000000..0311ad905b --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/PLAN.md @@ -0,0 +1,102 @@ +# H25 bookkeeping optimization plan + +Complete the three bookkeeping priorities for the frozen historical H25 verifier: reuse triple sets, reduce runtime guard overhead, and reduce trace encoding allocations. Four Astra xhigh agents work concurrently on research, independent design, and disjoint implementation paths. The parent owns integration, every compiler/scientific run, and Chrome publication. + +## Baseline and success + +Use PR5995 publication `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, specifically its **native C configuration with the existing complete checks**, as the baseline. The older Python arm is not the baseline for a further gain. Its recorded 28.636256246-second wall and 28.46-second CPU medians provide orientation; a new claim requires fresh same-session baseline runs. Preserve the original package and its 123 protected files. + +The combined target is **at least a further 15% reduction in both complete wall and CPU time**, after every new control, conversion, compilation, binding, observation, serialization and cleanup cost. Individual priorities may contribute smaller increments. Never add percentages from separate components or earlier workloads. + +A priority is finished when it has an independently reviewed contract and either a correctness-validated implementation with its measured disposition, or a reproducible scoped negative finding. The performance goal is achieved only when all three priorities have final dispositions, the combined target and noise gates pass, and required delivery checks and handoffs are complete. If the target fails, report it as unmet and keep the goal incomplete; a stopped experiment is not a performance win. + +This work concerns the complete frozen historical H25 caller with retained observations. The old additional-15%-over-PR5864 objective is separate. Kappa research, Work1/2 mathematics, unrelated feeds and automations remain paused. + +## Concurrent swarm and ownership + +| Lane | Owner | Owned directory | First research question | +|---|---|---|---| +| P1 Set reuse | `bookkeeping_sets` | `priorities/set-reuse/` | Can private sets be constructed once per admitted triple while every original pairwise check and result remains identical? | +| P2 Runtime guards | `bookkeeping_guards` | `priorities/runtime-guards/` | Which duplicate identity records and successful-path message allocations can disappear while every distinct live check still occurs at the same boundary? | +| P3 Trace encoding | `bookkeeping_trace` | `priorities/trace-encoding/` | Can fewer temporary objects and crossings produce exactly the same canonical record bytes, prefix hashes, counters and errors? | +| R Independent review | `bookkeeping_review` | `research/independent-review/` | Do the designs preserve ownership, callbacks, fallbacks, check independence and a complete cost bill, both separately and in combination? | +| Parent coordination | Main agent | `control/`, `integration/`, `validation/`, `publication/`, `runtime/`, `stages/` | Which reviewed candidates deserve the next bounded run, and does the integrated result improve the complete verifier? | + +Start fresh compact GPT-6-astra agents at xhigh effort, keeping completed earlier agents idle. Reuse these new-round agents for later follow-ups. Assign additional agents only to a distinct named obligation and owned path. Every worker is told that others share the workspace, must not revert their edits, and must accommodate concurrent changes. Workers do not edit the baseline, shared harness, working plan or another lane's files. + +Research runs in parallel, including source inspection, bounded live overlap research, primary CPython/C-API documentation when needed, alternatives, fixture design and independent review. Implementation may also run concurrently after each design passes its gate, because the lane paths do not overlap. Shared adapter changes belong solely to the parent. Each lane supplies a written adapter contract before integration. + +Compilers, scientific imports, corpus generation/execution, finite correctness runs, profiles and performance measurements use **one parent-owned queue and execution lock**. Agents prepare source and fixtures rather than executing them. No local CPU- or memory-heavy work runs alongside timed processes. This preserves useful concurrency without contaminating measurements or producing competing artifact writers. Chrome writes also have one owner. + +## G0 Establish the shared contract + +1. Refresh canonical upstream main, compare current guidance and priority revision, and check live PR/discussion overlap before substantial implementation or experiments. Keep scientific baseline PR5995 frozen even if current main changes; record compatibility rather than silently migrating inputs. +2. Create an isolated branch/worktree from refreshed main. Populate the index from the base before staging; assert that the diff contains only the intended package. Preserve all previous checkouts, threads, failed attempts and ledgers. +3. Record the full baseline source closure, compiler/interpreter/environment, native configuration, full certificate/stdout, exact typed return, ordered witness/rank/complement identities and all existing controls. +4. Freeze a common interface and observation contract for the three candidates. Keep the original baseline/reference implementation distinct from candidate helpers. Do not let a baseline call silently use an optimized guard or encoder. Finalize replacement helper/trace bindings and runtime closure-cell identities before capturing guard state; no post-capture mutation. +5. Parent may run one bounded post-C attribution diagnostic if it can discriminate among these mechanisms. Treat profiled timings as diagnostic; do not scale nested profile totals into promised savings. + +Canonical main was freshly fetched during planning as `19fdb086ea96af9a9f87936a2b888e10af4ed810`, priority revision 8. Current live overlap is tracked separately in `control/UPSTREAM-REFRESH.json`. + +## G1 Parallel research and design + +Each priority produces `RESEARCH.md` and `PROPOSAL.json` with exact source pins, candidate and fallback contracts, removed work, retained work, new costs, negative controls, files to change, an independent comparison, open risks and a discriminating next test. Distinguish source-derived counts from measured timings. Research can reject a route without constructing it. + +**P1 Set reuse.** The two existing all-pair loops imply 21.16 million set constructions for 2,300 triples. Investigate one private set per triple, scoped to the actual invocation. Retain both original intersection predicates, target order, coefficient and equality checks, exceptions and witnesses. Establish admission and fallback for unsupported or mutable/callback-bearing inputs. This is metadata reuse, not reuse of a verification answer. Do not substitute a shared arithmetic oracle for the literal independent checks. + +**P2 Runtime guards.** The actual caller makes 298,644 native kernel calls with freshness checks. Begin with identity-based deduplication of repeated function records and failure-only message construction. Preserve every distinct function/global/builtin/descriptor/default/closure/native-entry check at its current call boundary, including before fallback. Never turn a per-call freshness check into a cached PASS or a once-per-run check. A C implementation is a separately costed option, requiring verified CPython APIs, correct reference/error handling and the same rejection behavior. + +**P3 Trace encoding.** All 238,685 ordered complement records and 55,839,507 canonical bytes remain observed. Explore reducing tuple/dictionary/string/byte allocations, a source-bound native encoder, or bounded buffers within one record. Completed records must immediately update the public hasher, byte count and call count; inter-call deferral is outside this plan. Preserve sorted-key JSON/ASCII/newline schema, arbitrary-width fallback, exact types and vector order, counters, intermediate receipts and failure boundaries. Neither sampling nor replacing the canonical schema is an optimization within this scope. + +The reviewer independently maps the common contract immediately, then reviews each proposal as it arrives. Report concrete defects and the smallest fixes. Do not demand another mathematical construction or invent an additional 15% hurdle for each lane. No implementation or scientific run passes the gate merely because unused resource budget remains. + +## Repeated call reduction across all three priorities + +Treat repeated calls as an explicit work item in every lane. The parent will collect a bounded diagnostic call census and each proposal must include a call budget: current calls and inputs, why repetition occurs, what can safely disappear, remaining semantic checks, replacement calls, added admission/conversion/validation work, and the evidence that makes reuse valid. Call counts support a design decision; they are not a promised wall or CPU saving. + +- **P1:** reduce repeated set construction and repeated materialization of the same admitted triple metadata. Keep the current two predicate loops and all required intersection/equality checks in the primary candidate. Sharing an intersection result or fusing the loops is a distinct optional research branch: it needs a separate independence, error-order and complete-cost review before implementation. +- **P2:** eliminate duplicate records of the same function identity, successful-path `require` helper dispatch and eager message construction where an equivalent inline failure path preserves behavior. Every distinct live freshness check still executes at its original boundary; no once-per-run guard or cached PASS. +- **P3:** reduce repeated serializer/helper calls, tuple/dictionary construction, conversions and Python/C transitions within each record. The primary native encoder can replace several record-building/encoding calls with one checked call. Completed records must still update the hasher and counters immediately; no deferred inter-call batching or sampled observations. +- **Integration:** inspect repeated preparation or conversion across adapters and, where ownership and freshness permit, pass already admitted metadata or batch dispatch into a private owner. Keep separate independent verification paths and all original output, fallback, mutation and failure semantics. Do not share mutable answers or PASS receipts between calls, backends or processes. + +Measure diagnostic calls separately from unprofiled qualification. Every eliminated-call claim must distinguish true deduplication, value reuse, batching and work merely moved into C. The complete candidate still pays for retained operations, new validation, marshalling, compilation and cleanup. Extend only on a source-supported benefit; avoid collecting another census that cannot change the next decision. + +## G2 Concurrent implementation and serial correctness + +After source/ownership/cost review, implement one primary candidate per lane in its owned path. Compare alternatives on source and cost first; execute an alternative only when new evidence distinguishes its mechanism. The parent freezes immutable stages before any run. + +Run relevant finite comparisons and negative controls in the numerical queue. Cover exact types, widths, ordering, changed inputs/bindings, mutable aliases, callback/reentry boundaries where supported, fallback, errors and cleanup. Keep the live independent dense/original checks and original full assertions. Optimized interpreter mode is for finite controls; full verification remains assertion-on. + +Freeze each candidate's complete validation bill before measuring it. Manual repairs get a new source/stage revision, retain the failed evidence and consume the same round budget. No automatic retries or timing rerolls. + +## G3 Individual complete pilots + +Schedule one complete baseline/candidate pair per source-admitted priority. Baseline B means PR5995 native C plus its unchanged controls; candidate C adds that lane and all of its new costs. Retain full outputs and every receipt. A micro improvement is not a complete improvement, and one pair is not a qualified individual factor. + +Use pilots to decide integration or a scoped stop. A noisy individual result may still support a documented combined test if a specific shared-cost or interaction argument justifies it; do not label its individual saving established. Expand individual repetitions only when needed for a standalone performance claim and funded by the declared budget. Preserve all unfavorable results. + +## G4 Combined integration and qualification + +The parent integrates compatible, correctness-approved variants behind the frozen common interface. The reviewer checks interaction hazards: shared state, aliasing, guard placement, trace prefixes, fallback, exception paths, C-module loading and any duplicated cost. Run the full union of old and new controls, with all new costs inside the candidate bill. + +Freeze source, environment, selection rules and the combined fixed cold sequence **B1 C1 C2 B2 B3 C3** before timing. Start with B1/C1 and complete the declared sequence only if the target is credible and correctness holds. Require fresh medians to improve at least 15% in both wall and CPU. Separately, each median saving must exceed the maximum of the baseline and candidate within-arm ranges for that metric. Retain every sample; instrumented diagnostics and publication checks are excluded from sample selection. + +No percentage is transferred from PR5995, PR5929, PR5864 or component pilots. If the combined result fails, record the actual outcome and reassess only a materially changed, independently reviewed mechanism; do not rerun the same timings hoping for a different answer. + +## G5 Delivery checks + +Validate finite normal/O modes, the complete assertion-on caller, read-only Git-free execution, external output locations and failure retention. Before deleting fresh private runtime copies, make only their private directories writable after all source checks; never chmod immutable package inputs. Avoid entry names such as `profile.py` that shadow standard-library modules. + +Check exact source/input manifests, raw ancestry, committed bytes and executable modes, declared inputs, canonical lossless transport, package metadata and export equality. Archive integrity/publication-wrapper costs are separately identified from the frozen scientific performance harness. A wrapper correctness run never replaces a performance sample or establishes a wrapper speed factor. + +## G6 Publication and completion + +Publish useful focused results through the authorized signed-in Chrome workflow, with exact pins, predecessor/license/AI credit, required template and seven-field handoffs. Do not grant maintainer secret access, merge a PR, or change the selected frontier. Read back PR text and the existing handoff index. Verify exact-head hosted planning and relevant package replay; keep hosted correctness separate from local performance. + +Record each lane's final disposition, combined target/noise outcome, all failures, remaining obligations and a compact checkpoint. Mark the goal complete only when every required task is delivered and the combined performance target passes. An unresolved target remains incomplete; apply the goal tool's blocking rules only at a genuine repeated impasse. + +## Resources and reporting + +Use one serial guarded runner: 180 seconds per scientific command, 1 GiB sampled process-group RSS, 600 seconds initial feasibility and 1,500 seconds total for this new round. The shared ledger includes profiles, compilation, finite and full runs, publication scientific replays and all failures. Prior ledgers remain unchanged. Crossing a cap stops the affected work; it does not produce a negative scientific theorem or complete the goal. + +Keep `TASK-BOARD.json`, `STATUS.json`, immutable stages and raw receipts current. Reassess after each source/cost gate, candidate result and integration result. Give concise progress updates and expose any blocker with its exact effect. No background feed work, automation or unrelated mathematical research is included. diff --git a/research/h25-bookkeeping/evidence/revisions/v2/STAGE.json b/research/h25-bookkeeping/evidence/revisions/v2/STAGE.json new file mode 100644 index 0000000000..f5682e6303 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/STAGE.json @@ -0,0 +1,633 @@ +{ + "baseline_arm": "native C, original controls and observations retained", + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e" + }, + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "baseline/CODE-SOURCES.json": { + "mode": 292, + "sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7" + }, + "baseline/README.md": { + "mode": 292, + "sha256": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64" + }, + "baseline/SOURCE-PINS.json": { + "mode": 292, + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" + }, + "baseline/SOURCES.json": { + "mode": 292, + "sha256": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a" + }, + "baseline/TASK.json": { + "mode": 292, + "sha256": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38" + }, + "baseline/VALIDATION.json": { + "mode": 292, + "sha256": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a" + }, + "baseline/VERIFY.json": { + "mode": 292, + "sha256": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78" + }, + "baseline/anchor.json": { + "mode": 292, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "baseline/archive_support.py": { + "mode": 292, + "sha256": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f" + }, + "baseline/check_artifacts.py": { + "mode": 292, + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "baseline/engine/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "baseline/engine/finite_controls.py": { + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "baseline/engine/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "baseline/engine/native_gf2.c": { + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "baseline/engine/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "baseline/engine/source/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/engine/source/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/evidence/COMPLETE-GATE.json": { + "mode": 292, + "sha256": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b" + }, + "baseline/evidence/ENVIRONMENT.json": { + "mode": 292, + "sha256": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384" + }, + "baseline/evidence/FIRST-PAIR-GATE.json": { + "mode": 292, + "sha256": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc" + }, + "baseline/evidence/FULL-PAIR-ADMISSION.json": { + "mode": 292, + "sha256": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829" + }, + "baseline/evidence/INDEPENDENT-REVIEW.md": { + "mode": 292, + "sha256": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f" + }, + "baseline/evidence/INPUT-COMMIT.json": { + "mode": 292, + "sha256": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b" + }, + "baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": { + "mode": 292, + "sha256": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa" + }, + "baseline/evidence/PLAN.json": { + "mode": 292, + "sha256": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813" + }, + "baseline/evidence/PROFILE-v1-FAILURE.json": { + "mode": 292, + "sha256": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f" + }, + "baseline/evidence/RESULTS.md": { + "mode": 292, + "sha256": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f" + }, + "baseline/evidence/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb" + }, + "baseline/evidence/UPSTREAM-REFRESH.json": { + "mode": 292, + "sha256": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693" + }, + "baseline/evidence/canonical/MANIFEST.json": { + "mode": 292, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "baseline/evidence/canonical/complement-transcript.json": { + "mode": 292, + "sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "baseline/evidence/canonical/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/evidence/canonical/full-return.lossless.json.gz": { + "mode": 292, + "sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "baseline/evidence/canonical/original-stdout.txt": { + "mode": 292, + "sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 292, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 292, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "baseline/evidence/publication-v1-failure/REVISION.json": { + "mode": 292, + "sha256": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8" + }, + "baseline/evidence/publication-v1-failure/receipt.json": { + "mode": 292, + "sha256": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a" + }, + "baseline/evidence/publication-v1-failure/stderr.txt": { + "mode": 292, + "sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515" + }, + "baseline/evidence/publication-v1-failure/stdout.txt": { + "mode": 292, + "sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342" + }, + "baseline/evidence/publication-v1-failure/usage.json": { + "mode": 292, + "sha256": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc" + }, + "baseline/evidence/publication-v1-failure/verify_full.py.txt": { + "mode": 292, + "sha256": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e" + }, + "baseline/evidence/runs/full-network-B1/receipt.json": { + "mode": 292, + "sha256": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27" + }, + "baseline/evidence/runs/full-network-B1/scientific-receipt.json": { + "mode": 292, + "sha256": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31" + }, + "baseline/evidence/runs/full-network-B1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B1/stdout.txt": { + "mode": 292, + "sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43" + }, + "baseline/evidence/runs/full-network-B1/usage.json": { + "mode": 292, + "sha256": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505" + }, + "baseline/evidence/runs/full-network-B2/receipt.json": { + "mode": 292, + "sha256": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d" + }, + "baseline/evidence/runs/full-network-B2/scientific-receipt.json": { + "mode": 292, + "sha256": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7" + }, + "baseline/evidence/runs/full-network-B2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B2/stdout.txt": { + "mode": 292, + "sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d" + }, + "baseline/evidence/runs/full-network-B2/usage.json": { + "mode": 292, + "sha256": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891" + }, + "baseline/evidence/runs/full-network-B3/receipt.json": { + "mode": 292, + "sha256": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506" + }, + "baseline/evidence/runs/full-network-B3/scientific-receipt.json": { + "mode": 292, + "sha256": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495" + }, + "baseline/evidence/runs/full-network-B3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B3/stdout.txt": { + "mode": 292, + "sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe" + }, + "baseline/evidence/runs/full-network-B3/usage.json": { + "mode": 292, + "sha256": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8" + }, + "baseline/evidence/runs/full-network-C1/receipt.json": { + "mode": 292, + "sha256": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934" + }, + "baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": { + "mode": 292, + "sha256": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342" + }, + "baseline/evidence/runs/full-network-C1/scientific-receipt.json": { + "mode": 292, + "sha256": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8" + }, + "baseline/evidence/runs/full-network-C1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C1/stdout.txt": { + "mode": 292, + "sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd" + }, + "baseline/evidence/runs/full-network-C1/usage.json": { + "mode": 292, + "sha256": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84" + }, + "baseline/evidence/runs/full-network-C2/receipt.json": { + "mode": 292, + "sha256": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73" + }, + "baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": { + "mode": 292, + "sha256": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969" + }, + "baseline/evidence/runs/full-network-C2/scientific-receipt.json": { + "mode": 292, + "sha256": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c" + }, + "baseline/evidence/runs/full-network-C2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C2/stdout.txt": { + "mode": 292, + "sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c" + }, + "baseline/evidence/runs/full-network-C2/usage.json": { + "mode": 292, + "sha256": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886" + }, + "baseline/evidence/runs/full-network-C3/receipt.json": { + "mode": 292, + "sha256": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce" + }, + "baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": { + "mode": 292, + "sha256": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237" + }, + "baseline/evidence/runs/full-network-C3/scientific-receipt.json": { + "mode": 292, + "sha256": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb" + }, + "baseline/evidence/runs/full-network-C3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C3/stdout.txt": { + "mode": 292, + "sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0" + }, + "baseline/evidence/runs/full-network-C3/usage.json": { + "mode": 292, + "sha256": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb" + }, + "baseline/evidence/runs/full-network-profile-v1/receipt.json": { + "mode": 292, + "sha256": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c" + }, + "baseline/evidence/runs/full-network-profile-v1/stderr.txt": { + "mode": 292, + "sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76" + }, + "baseline/evidence/runs/full-network-profile-v1/stdout.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v1/usage.json": { + "mode": 292, + "sha256": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78" + }, + "baseline/evidence/runs/full-network-profile-v2/receipt.json": { + "mode": 292, + "sha256": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf" + }, + "baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": { + "mode": 292, + "sha256": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a" + }, + "baseline/evidence/runs/full-network-profile-v2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v2/stdout.txt": { + "mode": 292, + "sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec" + }, + "baseline/evidence/runs/full-network-profile-v2/usage.json": { + "mode": 292, + "sha256": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b" + }, + "baseline/frozen/scripts/audit_short_guards.py": { + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "baseline/frozen/scripts/certify.py": { + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "baseline/frozen/scripts/compact_control_layer.py": { + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "baseline/frozen/scripts/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/frozen/scripts/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/frozen/scripts/exclusion_circuit.py": { + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "baseline/frozen/scripts/paired_exclusion_circuit.py": { + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "baseline/frozen/scripts/paired_network.py": { + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "baseline/frozen/scripts/prepare_layers.py": { + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "baseline/frozen/scripts/search_network.py": { + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "baseline/frozen/scripts/shared_point_circuit.py": { + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "baseline/frozen/scripts/shared_point_network.py": { + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "baseline/frozen/upstream/LICENSE": { + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "baseline/frozen/upstream/README.md": { + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "baseline/frozen/upstream/build/figures/multiplication-flow.tex": { + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "baseline/frozen/upstream/build/figures/proof-map.tex": { + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "baseline/frozen/upstream/build/main.tex": { + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "baseline/frozen/upstream/build/references.bib": { + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "baseline/frozen/upstream/build/sections/00-introduction.tex": { + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "baseline/frozen/upstream/build/sections/01-history.tex": { + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "baseline/frozen/upstream/build/sections/02-streams.tex": { + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "baseline/frozen/upstream/build/sections/03-motifs.tex": { + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "baseline/frozen/upstream/build/sections/04-swap.tex": { + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "baseline/frozen/upstream/build/sections/05-layers.tex": { + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "baseline/frozen/upstream/build/sections/06-transforms.tex": { + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "baseline/frozen/upstream/build/sections/07-resampling.tex": { + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "baseline/frozen/upstream/build/sections/08-assembly.tex": { + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": { + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "baseline/frozen/upstream/build/sections/10-transposition.tex": { + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": { + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "baseline/frozen/upstream/formalization.yaml": { + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "baseline/frozen/upstream/manifest.json": { + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + }, + "baseline/full_B.py": { + "mode": 292, + "sha256": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8" + }, + "baseline/full_C.py": { + "mode": 292, + "sha256": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4" + }, + "baseline/full_driver.py": { + "mode": 292, + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" + }, + "baseline/guard.py": { + "mode": 292, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline/reference/certificates/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/reference/certificates/selected-result.json": { + "mode": 292, + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "baseline/replay.py": { + "mode": 292, + "sha256": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90" + }, + "baseline/verify.py": { + "mode": 292, + "sha256": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b" + }, + "baseline/verify_full.py": { + "mode": 292, + "sha256": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + }, + "freeze_stage.py": { + "mode": 292, + "sha256": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/CALL-BUDGET.json": { + "mode": 292, + "sha256": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec" + }, + "priorities/runtime-guards/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605" + }, + "priorities/runtime-guards/PROPOSAL.json": { + "mode": 292, + "sha256": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d" + }, + "priorities/runtime-guards/RESEARCH.md": { + "mode": 292, + "sha256": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9" + }, + "priorities/runtime-guards/STATIC-CHECK.json": { + "mode": 292, + "sha256": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/CALL-BUDGET.json": { + "mode": 292, + "sha256": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5" + }, + "priorities/set-reuse/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "6cee9300d40b4d32a5b0f398f77f8f84d361b67d496911cc925f3484a59470f7" + }, + "priorities/set-reuse/OWNERSHIP.md": { + "mode": 292, + "sha256": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099" + }, + "priorities/set-reuse/PROPOSAL.json": { + "mode": 292, + "sha256": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d" + }, + "priorities/set-reuse/RESEARCH.md": { + "mode": 292, + "sha256": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + }, + "priorities/trace-encoding/ADAPTER.md": { + "mode": 292, + "sha256": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f" + }, + "priorities/trace-encoding/CALL-BUDGET.json": { + "mode": 292, + "sha256": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab" + }, + "priorities/trace-encoding/PROPOSAL.json": { + "mode": 292, + "sha256": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d" + }, + "priorities/trace-encoding/RESEARCH.md": { + "mode": 292, + "sha256": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60" + }, + "priorities/trace-encoding/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + }, + "run_guarded.py": { + "mode": 292, + "sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + } + }, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "schema": "h25-bookkeeping-immutable-stage-v1", + "scientific_execution_during_freeze": false +} diff --git a/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/IMPLEMENTATION.md b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/IMPLEMENTATION.md new file mode 100644 index 0000000000..81565dc741 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/IMPLEMENTATION.md @@ -0,0 +1,21 @@ +# P1 source implementation, pending parent execution + +`set_reuse.py` exposes `bind_verify_map(module)`, returning `verify_map`, `owner`, `receipt`, and the untouched original method. Supply an isolated candidate module before adding the parent's constructor or map phase wrappers. A separate unchanged module/process remains the reference. The factory authenticates source SHA/code shapes and the current pinned Fraction source; generates the original prefix and literal fallback from the frozen AST; adds only the private optimized tail; and retains the candidate module's live globals. Its temporary factory name is removed immediately. The lease owner is reachable through private closure cells and the returned parent binding, never stored on scientific instances or published as a module global. This is no protection against hostile introspection/native memory changes. + +Parent integration order: + +1. Load/authenticate the candidate scientific module and install the existing native backend. +2. Call `binding = bind_verify_map(circuit_module)` while `Checks` and `ComplexSideCircuit` retain their original source methods. +3. Install `binding['verify_map']` as `Checks.verify_map`. Install the usual phase wrappers and parent-owned constructor observation wrappers. After a successful original circuit constructor, call `owner.capture_c(self)`; after a successful original Checks constructor, call `owner.capture_checks(self)`. Constructor return values remain unchanged. +4. Call `owner.seal()` after all class/phase wrapper installation. Sealing records final class/function/closure identities, allowing no later wrapper replacement. Then call `owner.arm_cli()` immediately before the authenticated original assertion-on `runpy.run_path`. Construction captures occur inside this active interval. +5. In the enclosing parent `finally`, call `owner.disarm_cli()`. Preserve the original CLI return/stdout/witness/native guards and all original phase counts. Require the receipt to show one successful construction pair, one reservation/admission/expiry, zero fallback calls and 2300 private operand constructions for the complete H25 fast arm. Receipt fields are separate from scientific output. + +`reserve` consumes the one-use allowance at method entry before the prefix. Wrong Checks/circuit, missing/spent allowance, changed bindings and known hooks take the original whole method once. A reserved call executes the original prefix once, then `admit` examines actual exact triple and got-key/value shapes. Post-prefix denial executes the original tail AST once. Both optimized comprehensions still enumerate `c.triples` and independently form a new set intersection; only the operands are supplied by a private positional list. Additional outer enumeration and positional index lookups are new paid work. + +The cached left operand is a closure cell shared with the comprehensions. The `finally` block clears the operand list with an anchored builtin and sets both the list and left-operand cells to `None`, then expires the reservation. Generator loop variable `T` remains the original triple, so a retained traceback has no cached operand-set loop variable. There is no set cache on Checks, circuit, module or lease owner. Allocation failure is propagated without retry; exact allocation-failure timing is not promised. + +The new whole-tail condition remains independently parent-established: actual source-created identities in the fixed fresh CLI, callback-free admitted tail, no concurrent/reentrant mutator. Hook denial observes trace/profile/monitoring/GC callback/thread/signal state and never changes GC policy. It is not generic ownership detection. Ordinary API calls continue through literal fallback. + +`finite_set_controls.py` exposes `run_controls(backend, set_adapter)`, using the already loaded modules rather than relying on a `set_reuse` import path. The backend's trusted loader receives two distinct module names for original and candidate. Tiny raw fixture objects use an explicit test-only issuer rather than pretending to prove full CLI provenance. Controls cover all intersection sizes, duplicates/order, empty/large/negative integer cases, missing/wrong/used capability, reentry, prefix mutation/failure, callback-bearing tuple and got-key fallback, live set binding, hook denial, between-call mutation and retained-traceback cleanup. Parent runs both ordinary and `-O` finite controls; full qualification remains assertion-on. + +All binding/AST/Fraction authentication, lease capture/guards, hook queries, exact data scans, new enumeration/indexing, metadata allocation, finite controls and cleanup are in the complete candidate bill. Runtime and memory costs are unknown. No scientific import, compile, finite execution or measurement was performed by this worker while writing these files. Independent source review and parent serial correctness execution remain required. diff --git a/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/finite_set_controls.py b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/finite_set_controls.py new file mode 100644 index 0000000000..30a20e764c --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/finite_set_controls.py @@ -0,0 +1,422 @@ +"""Bounded P1 controls. Parent runner alone imports/executes this module. + +run_controls(backend, set_adapter) takes the existing trusted backend and the +already loaded set adapter; it performs no implicit module-name import. +The two module instances keep the literal reference independent. Tiny raw +fixtures use an explicitly trusted finite-fixture lease issuer; these fixtures +do not establish the complete CLI's constructor provenance. +""" +from __future__ import annotations + +import gc +import sys + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def typed(value): + if type(value) is dict: + return ("dict", tuple((typed(key), typed(item)) for key, item in value.items())) + if type(value) is list or type(value) is tuple: + return (type(value).__name__, tuple(typed(item) for item in value)) + return (type(value).__name__, value) + + +def outcome(function, checks): + try: + return ("value", typed(function(checks))) + except Exception as error: + return ("error", type(error).__name__, error.args) + + +def configure(module, circuit, triples, *, keep_list=False): + if keep_list: + circuit.triples[:] = triples + else: + circuit.triples = list(triples) + circuit.active = set() + circuit.args = [None] + circuit.support = [0] + circuit.pieces = [] + seen = set() + for target in circuit.triples: + if target in seen: + continue + seen.add(target) + for coefficient, predicate in ((module.Q(1, 2), lambda size: size == 0), + (module.Q(-1, 2), lambda size: size == 2)): + mask = sum(1 << index for index, other in enumerate(circuit.triples) + if predicate(len(set(target) & set(other)))) + if mask: + circuit.support.append(mask) + circuit.args.append(None) + circuit.pieces.append((target, len(circuit.support)-1, coefficient)) + + +def raw(module, triples): + circuit = object.__new__(module.ComplexSideCircuit) + configure(module, circuit, triples) + checks = object.__new__(module.Checks) + checks.c = circuit + return circuit, checks + + +class Prefix: + def __init__(self, events, action=None): + self.events = events + self.action = action + + def __iter__(self): + self.events.append("prefix") + if self.action is not None: + self.action() + return iter(()) + + +class RecursivePrefix: + def __init__(self, events): + self.events = events + self.action = None + self.entered = False + + def __iter__(self): + self.events.append("prefix") + if not self.entered: + self.entered = True + self.action() + return iter(()) + + +def run_controls(backend, set_adapter): + load_source = backend.load_source + bind_verify_map = set_adapter.bind_verify_map + oracle = load_source("_h25_set_controls_original") + candidate = load_source("_h25_set_controls_candidate") + original_candidate = candidate.Checks.verify_map + literal = oracle.Checks.verify_map + rows = [] + standard = [(0, 1, 2), (3, 4, 5), (0, 1, 3), (0, 4, 5)] + + def binding(): + candidate.Checks.verify_map = original_candidate + result = bind_verify_map(candidate) + candidate.Checks.verify_map = result["verify_map"] + result["owner"].seal() + return result + + def fixture_issue(result, circuit, checks): + # Explicit trusted test-only issuer. The full driver must use actual + # post-original-constructor captures, never raw fixture provenance. + owner = result["owner"] + owner.arm_cli() + need(owner.capture_c(circuit), "Fixture circuit capture failed") + need(owner.capture_checks(checks), "Fixture Checks capture failed") + + def compare(name, result, left, right, left_events=(), right_events=(), *, fast=0, fallbacks=1): + expected = outcome(literal, left) + actual = outcome(result["verify_map"], right) + need(actual == expected, "Set control outcome differs: " + name) + need(list(right_events) == list(left_events), "Set control callback order differs: " + name) + need(result["receipt"]["fast_admissions"] == fast, "Set control fast-path count differs: " + name) + need(result["receipt"]["fallback_calls"] == fallbacks, "Set control fallback count differs: " + name) + need(result["owner"].current is None, "Set control retained an active token: " + name) + rows.append({"name": name, "outcome": actual[0], "fast_admissions": fast, "fallback_calls": fallbacks}) + result["owner"].disarm_cli() + + # Exact values, all intersection sizes, duplication/order, and integer width. + for name, triples in ( + ("all-intersection-sizes", standard), + ("duplicate-positional-triples", standard + [standard[0]]), + ("reordered-triples", list(reversed(standard))), + ("negative-and-wide-integers", [(-5, 1 << 100, 9), (-5, 1 << 100, 10), (2, 3, 4)]), + ("empty-triples", [])): + result = binding() + _, left = raw(oracle, triples) + circuit, right = raw(candidate, triples) + fixture_issue(result, circuit, right) + compare(name, result, left, right, fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(triples), + "Set construction count differs from positional triple count") + need(result["receipt"]["reservations_expired"] == 1, "Successful lease did not expire") + + # No allowance: ordinary source method executes, including prefix once. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events), Prefix(right_events) + compare("no-allowance-prefix-once", result, left, right, left_events, right_events) + need(left_events == ["prefix"], "Missing-lease fixture did not cover prefix") + + # Correctly shaped objects cannot borrow another Checks identity. + result = binding() + _, left = raw(oracle, standard) + right_c, captured = raw(candidate, standard) + right = object.__new__(candidate.Checks) + right.c = right_c + fixture_issue(result, right_c, captured) + compare("wrong-checks-identity", result, left, right) + + result = binding() + _, left = raw(oracle, standard) + captured_c, right = raw(candidate, standard) + other_c, _ = raw(candidate, standard) + fixture_issue(result, captured_c, right) + right.c = other_c + compare("wrong-circuit-link", result, left, right) + + # Reservation is spent before a prefix can reenter the method. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = RecursivePrefix(left_events), RecursivePrefix(right_events) + left_c.active.action = lambda: literal(left) + right_c.active.action = lambda: result["verify_map"](right) + fixture_issue(result, right_c, right) + compare("prefix-reentry-single-reservation", result, left, right, left_events, right_events, + fast=1, fallbacks=1) + need(left_events == ["prefix", "prefix"] and result["receipt"]["reservations"] == 1, + "Recursive fixture did not consume one outer reservation") + + # The post-prefix state, not an earlier eager snapshot, supplies operands. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + changed = [(10, 11, 12), (10, 11, 13), (20, 21, 22)] + left_events, right_events = [], [] + left_c.active = Prefix(left_events, lambda: configure(oracle, left_c, changed, keep_list=True)) + right_c.active = Prefix(right_events, lambda: configure(candidate, right_c, changed, keep_list=True)) + fixture_issue(result, right_c, right) + compare("post-prefix-mutated-values", result, left, right, left_events, right_events, + fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(changed), + "Set cache preceded prefix mutation") + + # Prefix exceptions happen before set construction, even with a valid lease. + def fail_prefix(): + raise ValueError("prefix sentinel") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events, fail_prefix), Prefix(right_events, fail_prefix) + fixture_issue(result, right_c, right) + compare("failing-prefix-no-eager-cache", result, left, right, left_events, right_events, + fast=0, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == 0, "Failing prefix built sets") + + # Callback-bearing triple subclasses must use literal post-prefix tail. + def callback_triple(events, base): + class Triple(tuple): + def __iter__(self): + events.append("triple-iter") + return tuple.__iter__(self) + return Triple(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = callback_triple(left_events, standard[0]) + right_c.triples[0] = callback_triple(right_events, standard[0]) + fixture_issue(result, right_c, right) + compare("tuple-subclass-callback-fallback", result, left, right, left_events, right_events) + need(left_events, "Tuple callback fixture did not execute callbacks") + + def callback_integer(events, value): + class Integer(int): + def __hash__(self): + events.append("integer-hash") + return int.__hash__(self) + return Integer(value) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = (callback_integer(left_events, 0), 1, 2) + right_c.triples[0] = (callback_integer(right_events, 0), 1, 2) + fixture_issue(result, right_c, right) + compare("integer-subclass-hash-fallback", result, left, right, left_events, right_events) + need(left_events, "Integer callback fixture did not execute callbacks") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.triples[0] = (False, 1, 2) + right_c.triples[0] = (False, 1, 2) + fixture_issue(result, right_c, right) + compare("bool-member-exact-type-fallback", result, left, right) + + # The got dictionary can retain a hostile equality key from the prefix. + def collision_key(circuit, events, base): + class Target(tuple): + __hash__ = tuple.__hash__ + fired = False + + def __eq__(self, other): + events.append("collision-equality") + if not self.fired: + self.fired = True + circuit.triples.reverse() + return tuple.__eq__(self, other) + return Target(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + for circuit, events in ((left_c, left_events), (right_c, right_events)): + target, node, coefficient = circuit.pieces[0] + circuit.pieces[0] = (collision_key(circuit, events, target), node, coefficient) + fixture_issue(result, right_c, right) + compare("got-collision-key-fallback", result, left, right, left_events, right_events) + need(left_events, "Collision fixture did not reach custom equality") + + # Runtime source-global drift retains original live resolution in fallback. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + def logging_set(events): + def wrapped(values): + events.append("set") + return set(values) + return wrapped + oracle.set, candidate.set = logging_set(left_events), logging_set(right_events) + fixture_issue(result, right_c, right) + try: + compare("live-source-set-resolution", result, left, right, left_events, right_events) + need(len(left_events) == 4*len(standard)**2, "Literal fallback lost original set calls") + finally: + del oracle.set + del candidate.set + + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + original_q = candidate.Q + def logging_q(events): + def wrapped(*args): + events.append("Q") + return original_q(*args) + return wrapped + fixture_issue(result, right_c, right) + oracle.Q, candidate.Q = logging_q(left_events), logging_q(right_events) + try: + compare("live-Fraction-global-resolution", result, left, right, left_events, right_events) + need(left_events, "Fraction callback fixture did not execute callbacks") + finally: + oracle.Q = candidate.Q = original_q + + # The exact Fraction class is mutable: unchanged class identity alone is + # insufficient. A changed method after binding must deny optimization. + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + original_hash = original_q.__hash__ + hash_events = [] + def traced_hash(value): + hash_events.append("fraction-hash") + return original_hash(value) + original_q.__hash__ = traced_hash + try: + expected = outcome(literal, left) + expected_events = list(hash_events) + hash_events.clear() + actual = outcome(result["verify_map"], right) + need(actual == expected and hash_events == expected_events and hash_events, + "Changed Fraction method fallback differs") + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Changed Fraction method was admitted") + finally: + original_q.__hash__ = original_hash + result["owner"].disarm_cli() + rows.append({"name": "changed-Fraction-hash", "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # A used capability cannot cache values for a later invocation. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + need(outcome(result["verify_map"], right) == outcome(literal, left), "Initial leased call differs") + configure(oracle, left_c, changed) + configure(candidate, right_c, changed) + compare("used-capability-changed-later-input", result, left, right, fast=1, fallbacks=1) + need(result["receipt"]["private_operand_sets_constructed"] == len(standard), + "Used capability constructed a second private cache") + + # Observable known hooks deny optimization without changing hook policy. + for hook in ("trace", "profile", "gc-callback"): + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + def quiet_trace(frame, event, arg): + return quiet_trace + def quiet_gc(phase, info): + return None + if hook == "trace": + sys.settrace(quiet_trace) + elif hook == "profile": + sys.setprofile(quiet_trace) + else: + gc.callbacks.append(quiet_gc) + try: + actual = outcome(result["verify_map"], right) + finally: + if hook == "trace": + sys.settrace(None) + elif hook == "profile": + sys.setprofile(None) + else: + gc.callbacks.remove(quiet_gc) + need(actual == outcome(literal, left), "Hook-denied fallback differs: " + hook) + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Known hook was admitted: " + hook) + result["owner"].disarm_cli() + rows.append({"name": "known-hook-" + hook, "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # Deliberate tail assertion failure retains a traceback: cached operands + # must have been cleared/reset even while the frame itself remains live. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.support[1] ^= 1 << 20 + right_c.support[1] ^= 1 << 20 + fixture_issue(result, right_c, right) + expected = outcome(literal, left) + retained = None + try: + actual = ("value", typed(result["verify_map"](right))) + except Exception as error: + actual = ("error", type(error).__name__, error.args) + retained = error.__traceback__ + need(actual == expected, "Tail-failure outcome differs") + if not sys.flags.optimize: + need(actual[0] == "error" and actual[1] == "AssertionError", "Tail-failure fixture did not fail") + found = False + while retained is not None: + if retained.tb_frame.f_code is result["verify_map"].__code__: + found = True + values = retained.tb_frame.f_locals + need(values["_h25_sr_sets"] is None and values["_h25_sr_left"] is None, + "Retained traceback kept private cached operands") + retained = retained.tb_next + need(found, "Candidate traceback frame was not inspected") + need(result["owner"].current is None, "Tail error retained lease") + need(result["receipt"]["fast_admissions"] == 1, "Tail cleanup fixture did not use cached sets") + result["owner"].disarm_cli() + rows.append({"name": "traceback-cleanup", "outcome": actual[0], "fast_admissions": 1, "fallback_calls": 0}) + + candidate.Checks.verify_map = original_candidate + need(oracle.Checks.verify_map is literal, "Independent source reference was changed") + return {"status": "P1_FINITE_SET_CONTROLS_PASS", "optimize": sys.flags.optimize, + "cases": len(rows), "rows": rows, + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence"} diff --git a/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/set_reuse.py b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/set_reuse.py new file mode 100644 index 0000000000..89d6d32ab9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v2/priorities/set-reuse/set_reuse.py @@ -0,0 +1,451 @@ +"""Private operand-set reuse for one authenticated frozen full-caller phase. + +The parent owns the new whole-tail execution invariant. This is not inherited +from the native kernel guard and is not a generic alias/security detector. +Standalone, unsupported and unleased calls delegate the literal source. +No scientific module is imported here; the parent supplies an isolated module. +""" +from __future__ import annotations + +import _thread +import ast +import builtins +import copy +import fractions +import gc +import hashlib +from pathlib import Path +import signal +import sys +from types import CodeType, FunctionType, GetSetDescriptorType, MemberDescriptorType, ModuleType + +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +FRACTION_SHA256 = "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231" +_TYPE, _OBJECT, _DICT, _LIST, _TUPLE, _INT = type, object, dict, list, tuple, int +_LEN, _SET, _COMPILE = len, set, compile +_GET = dict.get +_OBJGET = object.__getattribute__ +_TYPEGET = type.__getattribute__ +_CLEAR = list.clear +_BUILTINS = builtins.__dict__ +_FRACTION = fractions.Fraction +_BUILTIN_NAMES = ("type", "object", "set", "len", "sum", "enumerate", "dict", + "int", "list", "tuple", "all", "range", "hash", "abs", "pow", + "isinstance", "super") +_BUILTIN_RECORD = tuple((name, _BUILTINS[name]) for name in _BUILTIN_NAMES) +_SOURCE_LOOKUPS = ("set", "len", "sum", "enumerate", "dict") + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +def _function_record(function): + if _TYPE(function) is not FunctionType: + return None + closure = function.__closure__ + cells = () if closure is None else _TUPLE((cell, cell.cell_contents) for cell in closure) + return (function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, closure, cells) + + +def _function_fresh(record): + function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells = record + if not (function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure): + return False + for cell, value in cells: + try: + if cell.cell_contents is not value: + return False + except ValueError: + return False + return True + + +def _ordinary_class(cls): + if _TYPE(cls) is not _TYPE or _TYPEGET(cls, "__mro__") != (cls, _OBJECT): + return False + attributes = _TYPEGET(cls, "__dict__") + if "__getattr__" in attributes or _TYPEGET(cls, "__getattribute__") is not _OBJECT.__getattribute__: + return False + if _TYPEGET(cls, "__new__") is not _OBJECT.__new__: + return False + for name in ("__dict__", "__weakref__"): + descriptor = attributes.get(name) + if _TYPE(descriptor) is not GetSetDescriptorType or descriptor.__objclass__ is not cls: + return False + return True + + +def _ordinary_dict(value, cls): + if _TYPE(value) is not cls or not _ordinary_class(cls): + return None + namespace = _OBJGET(value, "__dict__") + return namespace if _TYPE(namespace) is _DICT else None + + +def _triple(value): + return (_TYPE(value) is _TUPLE and _LEN(value) == 3 and + _TYPE(value[0]) is _INT and _TYPE(value[1]) is _INT and _TYPE(value[2]) is _INT) + + +def _hooks_clear(): + """Known instrumentation denial only; not a generic finalizer theorem.""" + if sys.gettrace() is not None or sys.getprofile() is not None: + return False + if _TYPE(gc.callbacks) is not _LIST or _LEN(gc.callbacks) != 0 or _thread._count() != 0: + return False + monitoring = getattr(sys, "monitoring", None) + if monitoring is not None: + for tool in range(6): + if monitoring.get_tool(tool) is not None: + return False + for number in signal.valid_signals(): + handler = signal.getsignal(number) + if handler is not signal.SIG_DFL and handler is not signal.SIG_IGN and handler is not signal.default_int_handler: + return False + return True + + +def _code_named(code, name): + return next(item for item in code.co_consts if _TYPE(item) is CodeType and item.co_name == name) + + +def _authenticate_function(function, expected, namespace): + _need(_TYPE(function) is FunctionType and function.__globals__ is namespace and + function.__builtins__ is _BUILTINS and function.__code__ == expected, + "Set reuse requires the exact original source function") + + +class _Token: + __slots__ = () + + +class _LeaseOwner: + """Parent-private one-call capability; only identity/state, never operand sets.""" + + def __init__(self, module, original, source_functions, class_names, receipt): + self.module = module + self.namespace = module.__dict__ + self.original = original + self.circuit_class = self.namespace["ComplexSideCircuit"] + self.checks_class = self.namespace["Checks"] + self.class_names = class_names + self.source_functions = source_functions + self.receipt = receipt + self.sealed = False + self.cli_active = False + self.used = False + self.current = None + self.circuit = self.checks = self.triples = None + self.class_records = () + self.function_records = () + self.fraction_globals = _TUPLE(fractions.__dict__.items()) + self.fraction_classes = _TUPLE((cls, _TYPEGET(cls, "__mro__"), + _TUPLE(_TYPEGET(cls, "__dict__").items())) + for cls in _FRACTION.__mro__ if cls is not _OBJECT) + self.math_gcd = fractions.math.gcd + self.rational = fractions.numbers.Rational + self.complex = fractions.numbers.Complex + self.hash_wrapper = fractions._hash_algorithm + self.hash_wrapped = fractions._hash_algorithm.__wrapped__ + fraction_functions = [] + for _, _, attributes in self.fraction_classes: + for _, value in attributes: + if _TYPE(value) is FunctionType: + fraction_functions.append(value) + elif _TYPE(value) is property: + fraction_functions.extend(item for item in (value.fget, value.fset, value.fdel) if item is not None) + fraction_functions.append(self.hash_wrapped) + self.fraction_functions = _TUPLE(_function_record(function) for function in fraction_functions) + + def seal(self): + """Parent calls once after installing all constructor/map phase wrappers.""" + _need(not self.sealed and not self.cli_active, "Set reuse owner already sealed or active") + classes = (self.circuit_class, self.checks_class) + records = [] + functions = _LIST(self.source_functions) + for cls, names in zip(classes, self.class_names): + _need(_ordinary_class(cls), "Set reuse requires ordinary frozen class dispatch") + attributes = _TYPEGET(cls, "__dict__") + _need(_SET(attributes) == names, "Set reuse class member shape changed") + records.append((cls, _TYPEGET(cls, "__mro__"), _TUPLE(attributes.items()))) + functions.extend(value for value in attributes.values() if _TYPE(value) is FunctionType) + self.class_records = _TUPLE(records) + self.function_records = _TUPLE(_function_record(function) for function in functions) + self.sealed = True + + def arm_cli(self): + """Parent attests the pinned fresh CLI; do not call for a generic API use.""" + _need(self.sealed and not self.cli_active and self.circuit is None and not self.used, + "Set reuse allowance cannot be reused") + self.cli_active = True + self.receipt["allowances_armed"] += 1 + + def capture_c(self, circuit): + """Called only after the parent-observed original constructor returns.""" + if not self.cli_active or self.circuit is not None or self.used: + return False + namespace = _ordinary_dict(circuit, self.circuit_class) + if namespace is None: + return False + triples = _GET(namespace, "triples") + if _TYPE(triples) is not _LIST: + return False + self.circuit, self.triples = circuit, triples + self.receipt["circuits_captured"] += 1 + return True + + def capture_checks(self, checks): + """Called only after the parent-observed original Checks init returns.""" + if not self.cli_active or self.circuit is None or self.checks is not None or self.used: + return False + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return False + self.checks = checks + self.receipt["checks_captured"] += 1 + return True + + def _fresh(self): + if (_TYPE(self.module) is not ModuleType or self.module.__dict__ is not self.namespace or + _GET(self.namespace, "Checks") is not self.checks_class or + _GET(self.namespace, "ComplexSideCircuit") is not self.circuit_class or + _GET(self.namespace, "Q") is not _FRACTION or + _GET(self.namespace, "__builtins__") is not _BUILTINS): + return False + for name, expected in _BUILTIN_RECORD: + if _GET(_BUILTINS, name) is not expected: + return False + for name in _SOURCE_LOOKUPS: + if name in self.namespace: + return False + for cls, mro, items in self.class_records + self.fraction_classes: + if _TYPEGET(cls, "__mro__") is not mro: + return False + attributes = _TYPEGET(cls, "__dict__") + if _LEN(attributes) != _LEN(items): + return False + for name, value in items: + if attributes.get(name) is not value: + return False + for record in self.function_records + self.fraction_functions: + if not _function_fresh(record): + return False + if _LEN(fractions.__dict__) != _LEN(self.fraction_globals): + return False + for name, value in self.fraction_globals: + if _GET(fractions.__dict__, name) is not value: + return False + return (fractions.math.gcd is self.math_gcd and + fractions.numbers.Rational is self.rational and + fractions.numbers.Complex is self.complex and + fractions._hash_algorithm is self.hash_wrapper and + self.hash_wrapper.__wrapped__ is self.hash_wrapped) + + def reserve(self, checks): + """Consumed before prefix; wrong or unleased objects get literal fallback.""" + self.receipt["entries"] += 1 + if not self.cli_active or self.used or self.current is not None or checks is not self.checks: + return None + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return None + self.used = True + if not self._fresh() or not _hooks_clear(): + return None + token = _Token() + self.current = token + self.receipt["reservations"] += 1 + return token + + def admit(self, token, checks, circuit, got): + """Called after the original prefix, using its actual local got mapping.""" + if (token is None or token is not self.current or not self.cli_active or + checks is not self.checks or circuit is not self.circuit or + not self._fresh() or not _hooks_clear()): + return False + check_dict = _ordinary_dict(checks, self.checks_class) + circuit_dict = _ordinary_dict(circuit, self.circuit_class) + if check_dict is None or circuit_dict is None or _GET(check_dict, "c") is not circuit: + return False + triples = _GET(circuit_dict, "triples") + if triples is not self.triples or _TYPE(triples) is not _LIST: + return False + for triple in triples: + if not _triple(triple): + return False + if _TYPE(got) is not _DICT: + return False + for key, value in got.items(): + if (_TYPE(key) is not _TUPLE or _LEN(key) != 2 or not _triple(key[0]) or + _TYPE(key[1]) is not _FRACTION or _TYPE(value) is not _INT): + return False + coefficient = key[1] + if (_TYPE(_OBJGET(coefficient, "_numerator")) is not _INT or + _TYPE(_OBJGET(coefficient, "_denominator")) is not _INT): + return False + self.receipt["fast_admissions"] += 1 + return True + + def fallback(self): + self.receipt["fallback_calls"] += 1 + + def constructed(self, count): + self.receipt["private_operand_sets_constructed"] += count + + def expire(self, token): + if token is not None and token is self.current: + self.current = None + self.receipt["reservations_expired"] += 1 + + def disarm_cli(self): + self.current = None + self.cli_active = False + self.circuit = self.checks = self.triples = None + + +def _fraction_source_check(): + raw = Path(fractions.__file__).read_bytes() + _need(hashlib.sha256(raw).hexdigest() == FRACTION_SHA256, "Set reuse Fraction source differs") + compiled = _COMPILE(raw, fractions.__file__, "exec", dont_inherit=True, optimize=sys.flags.optimize) + fraction_code = _code_named(compiled, "Fraction") + _need(_TYPEGET(_FRACTION, "__getattribute__") is _OBJECT.__getattribute__, + "Set reuse Fraction attribute dispatch differs") + for name in ("_numerator", "_denominator"): + descriptor = _TYPEGET(_FRACTION, name) + _need(_TYPE(descriptor) is MemberDescriptorType and descriptor.__objclass__ is _FRACTION, + "Set reuse Fraction slot descriptor differs") + _need(fractions.numbers.Rational is _FRACTION.__mro__[1] and + fractions.numbers.Complex in _FRACTION.__mro__, + "Set reuse Fraction number-class resolution differs") + for name in ("__new__", "__hash__", "__eq__"): + _authenticate_function(_TYPEGET(_FRACTION, name), _code_named(fraction_code, name), fractions.__dict__) + for name in ("numerator", "denominator"): + _authenticate_function(_TYPEGET(_FRACTION, name).fget, _code_named(fraction_code, name), fractions.__dict__) + _authenticate_function(fractions._hash_algorithm.__wrapped__, _code_named(compiled, "_hash_algorithm"), fractions.__dict__) + + +def _generate(module, method_ast, owner, original): + """Only original prefix/tail AST plus declared private bookkeeping changes.""" + _need(_LEN(method_ast.body) == 7 and _TYPE(method_ast.body[3]) is ast.For and + _TYPE(method_ast.body[4]) is ast.Assign and _TYPE(method_ast.body[5]) is ast.For, + "Unexpected pinned verify_map AST layout") + prefix = copy.deepcopy(method_ast.body[:4]) + fallback_tail = copy.deepcopy(method_ast.body[4:]) + template = ast.parse(''' +def _h25_sr_factory(_h25_sr_enter, _h25_sr_admit, _h25_sr_expire, _h25_sr_original, + _h25_sr_fallback, _h25_sr_constructed, _h25_sr_clear): + def verify_map(self): + _h25_sr_token = _h25_sr_enter(self) + _h25_sr_sets = None + _h25_sr_left = None + try: + if _h25_sr_token is None: + _h25_sr_fallback() + return _h25_sr_original(self) + _H25_PREFIX + if not _h25_sr_admit(_h25_sr_token, self, c, got): + _h25_sr_fallback() + _H25_FALLBACK + _h25_sr_sets = [set(T) for T in c.triples] + _h25_sr_constructed(len(_h25_sr_sets)) + nonzero = 0 + for _h25_sr_position, S in enumerate(c.triples): + _h25_sr_left = _h25_sr_sets[_h25_sr_position] + zero = sum(1 << i for i, T in enumerate(c.triples) + if not _h25_sr_left & _h25_sr_sets[i]) + two = sum(1 << i for i, T in enumerate(c.triples) + if len(_h25_sr_left & _h25_sr_sets[i]) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + finally: + if _h25_sr_sets is not None: + _h25_sr_clear(_h25_sr_sets) + _h25_sr_left = None + _h25_sr_sets = None + _h25_sr_expire(_h25_sr_token) + return verify_map +''') + method = template.body[0].body[0] + guarded = method.body[3] + _need(_TYPE(guarded) is ast.Try, "Internal set adapter AST layout changed") + replaced = [] + for statement in guarded.body: + if _TYPE(statement) is ast.Expr and _TYPE(statement.value) is ast.Name and statement.value.id == "_H25_PREFIX": + replaced.extend(prefix) + elif _TYPE(statement) is ast.If and statement.body and any( + _TYPE(item) is ast.Expr and _TYPE(item.value) is ast.Name and item.value.id == "_H25_FALLBACK" + for item in statement.body): + statement.body = statement.body[:1] + fallback_tail + replaced.append(statement) + else: + replaced.append(statement) + guarded.body = replaced + ast.fix_missing_locations(template) + namespace = module.__dict__ + name = "_h25_sr_factory" + _need(name not in namespace, "Set reuse helper name collision") + try: + exec(_COMPILE(template, "", "exec", dont_inherit=True, + optimize=sys.flags.optimize), namespace) + factory = namespace[name] + function = factory(owner.reserve, owner.admit, owner.expire, original, + owner.fallback, owner.constructed, _CLEAR) + finally: + namespace.pop(name, None) + return function + + +def bind_verify_map(module): + """Return verify_map/owner/receipt; parent installs, wraps, seals, then arms. + + This factory must receive an isolated candidate module. Keep the unchanged + baseline/reference in another module/process; existing globals are never + copied or rebound, so ordinary fallback retains live source resolution. + """ + _need(_TYPE(module) is ModuleType, "Set reuse needs an exact source module") + namespace = module.__dict__ + path = Path(namespace["__file__"]) + raw = path.read_bytes() + _need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Set reuse scientific source differs") + _need(_GET(namespace, "__builtins__") is _BUILTINS and _GET(namespace, "Q") is _FRACTION, + "Set reuse source calling environment differs") + for name, value in _BUILTIN_RECORD: + _need(_GET(_BUILTINS, name) is value, "Set reuse builtin identity differs") + for name in _SOURCE_LOOKUPS: + _need(name not in namespace, "Set reuse source shadows a builtin") + compiled = _COMPILE(raw, str(path), "exec", dont_inherit=True, optimize=sys.flags.optimize) + source_functions = [] + class_names = [] + for name in ("ComplexSideCircuit", "Checks"): + cls = namespace[name] + _need(_ordinary_class(cls), "Set reuse source class dispatch differs") + class_code = _code_named(compiled, name) + attributes = _TYPEGET(cls, "__dict__") + expected_names = {"__module__", "__doc__", "__dict__", "__weakref__"} + for code in class_code.co_consts: + if _TYPE(code) is CodeType: + expected_names.add(code.co_name) + function = attributes.get(code.co_name) + _authenticate_function(function, code, namespace) + source_functions.append(function) + _need(_SET(attributes) == expected_names, "Set reuse source class members differ") + class_names.append(expected_names) + _fraction_source_check() + original = namespace["Checks"].verify_map + parsed = ast.parse(raw, filename=str(path)) + checks_ast = next(item for item in parsed.body if _TYPE(item) is ast.ClassDef and item.name == "Checks") + method_ast = next(item for item in checks_ast.body if _TYPE(item) is ast.FunctionDef and item.name == "verify_map") + receipt = {"schema": "h25-private-set-reuse-v1", "source_sha256": SOURCE_SHA256, + "fraction_sha256": FRACTION_SHA256, "allowances_armed": 0, "circuits_captured": 0, + "checks_captured": 0, "entries": 0, "reservations": 0, "fast_admissions": 0, + "fallback_calls": 0, "private_operand_sets_constructed": 0, "reservations_expired": 0} + owner = _LeaseOwner(module, original, _TUPLE(source_functions), _TUPLE(class_names), receipt) + candidate = _generate(module, method_ast, owner, original) + return {"verify_map": candidate, "owner": owner, "receipt": receipt, "original": original} diff --git a/research/h25-bookkeeping/evidence/revisions/v3/STAGE.json b/research/h25-bookkeeping/evidence/revisions/v3/STAGE.json new file mode 100644 index 0000000000..847ef9a6f5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v3/STAGE.json @@ -0,0 +1,637 @@ +{ + "baseline_arm": "native C, original controls and observations retained", + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e" + }, + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "baseline/CODE-SOURCES.json": { + "mode": 292, + "sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7" + }, + "baseline/README.md": { + "mode": 292, + "sha256": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64" + }, + "baseline/SOURCE-PINS.json": { + "mode": 292, + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" + }, + "baseline/SOURCES.json": { + "mode": 292, + "sha256": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a" + }, + "baseline/TASK.json": { + "mode": 292, + "sha256": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38" + }, + "baseline/VALIDATION.json": { + "mode": 292, + "sha256": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a" + }, + "baseline/VERIFY.json": { + "mode": 292, + "sha256": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78" + }, + "baseline/anchor.json": { + "mode": 292, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "baseline/archive_support.py": { + "mode": 292, + "sha256": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f" + }, + "baseline/check_artifacts.py": { + "mode": 292, + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "baseline/engine/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "baseline/engine/finite_controls.py": { + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "baseline/engine/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "baseline/engine/native_gf2.c": { + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "baseline/engine/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "baseline/engine/source/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/engine/source/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/evidence/COMPLETE-GATE.json": { + "mode": 292, + "sha256": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b" + }, + "baseline/evidence/ENVIRONMENT.json": { + "mode": 292, + "sha256": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384" + }, + "baseline/evidence/FIRST-PAIR-GATE.json": { + "mode": 292, + "sha256": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc" + }, + "baseline/evidence/FULL-PAIR-ADMISSION.json": { + "mode": 292, + "sha256": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829" + }, + "baseline/evidence/INDEPENDENT-REVIEW.md": { + "mode": 292, + "sha256": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f" + }, + "baseline/evidence/INPUT-COMMIT.json": { + "mode": 292, + "sha256": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b" + }, + "baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": { + "mode": 292, + "sha256": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa" + }, + "baseline/evidence/PLAN.json": { + "mode": 292, + "sha256": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813" + }, + "baseline/evidence/PROFILE-v1-FAILURE.json": { + "mode": 292, + "sha256": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f" + }, + "baseline/evidence/RESULTS.md": { + "mode": 292, + "sha256": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f" + }, + "baseline/evidence/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb" + }, + "baseline/evidence/UPSTREAM-REFRESH.json": { + "mode": 292, + "sha256": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693" + }, + "baseline/evidence/canonical/MANIFEST.json": { + "mode": 292, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "baseline/evidence/canonical/complement-transcript.json": { + "mode": 292, + "sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "baseline/evidence/canonical/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/evidence/canonical/full-return.lossless.json.gz": { + "mode": 292, + "sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "baseline/evidence/canonical/original-stdout.txt": { + "mode": 292, + "sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 292, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 292, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "baseline/evidence/publication-v1-failure/REVISION.json": { + "mode": 292, + "sha256": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8" + }, + "baseline/evidence/publication-v1-failure/receipt.json": { + "mode": 292, + "sha256": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a" + }, + "baseline/evidence/publication-v1-failure/stderr.txt": { + "mode": 292, + "sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515" + }, + "baseline/evidence/publication-v1-failure/stdout.txt": { + "mode": 292, + "sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342" + }, + "baseline/evidence/publication-v1-failure/usage.json": { + "mode": 292, + "sha256": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc" + }, + "baseline/evidence/publication-v1-failure/verify_full.py.txt": { + "mode": 292, + "sha256": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e" + }, + "baseline/evidence/runs/full-network-B1/receipt.json": { + "mode": 292, + "sha256": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27" + }, + "baseline/evidence/runs/full-network-B1/scientific-receipt.json": { + "mode": 292, + "sha256": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31" + }, + "baseline/evidence/runs/full-network-B1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B1/stdout.txt": { + "mode": 292, + "sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43" + }, + "baseline/evidence/runs/full-network-B1/usage.json": { + "mode": 292, + "sha256": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505" + }, + "baseline/evidence/runs/full-network-B2/receipt.json": { + "mode": 292, + "sha256": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d" + }, + "baseline/evidence/runs/full-network-B2/scientific-receipt.json": { + "mode": 292, + "sha256": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7" + }, + "baseline/evidence/runs/full-network-B2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B2/stdout.txt": { + "mode": 292, + "sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d" + }, + "baseline/evidence/runs/full-network-B2/usage.json": { + "mode": 292, + "sha256": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891" + }, + "baseline/evidence/runs/full-network-B3/receipt.json": { + "mode": 292, + "sha256": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506" + }, + "baseline/evidence/runs/full-network-B3/scientific-receipt.json": { + "mode": 292, + "sha256": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495" + }, + "baseline/evidence/runs/full-network-B3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B3/stdout.txt": { + "mode": 292, + "sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe" + }, + "baseline/evidence/runs/full-network-B3/usage.json": { + "mode": 292, + "sha256": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8" + }, + "baseline/evidence/runs/full-network-C1/receipt.json": { + "mode": 292, + "sha256": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934" + }, + "baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": { + "mode": 292, + "sha256": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342" + }, + "baseline/evidence/runs/full-network-C1/scientific-receipt.json": { + "mode": 292, + "sha256": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8" + }, + "baseline/evidence/runs/full-network-C1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C1/stdout.txt": { + "mode": 292, + "sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd" + }, + "baseline/evidence/runs/full-network-C1/usage.json": { + "mode": 292, + "sha256": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84" + }, + "baseline/evidence/runs/full-network-C2/receipt.json": { + "mode": 292, + "sha256": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73" + }, + "baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": { + "mode": 292, + "sha256": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969" + }, + "baseline/evidence/runs/full-network-C2/scientific-receipt.json": { + "mode": 292, + "sha256": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c" + }, + "baseline/evidence/runs/full-network-C2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C2/stdout.txt": { + "mode": 292, + "sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c" + }, + "baseline/evidence/runs/full-network-C2/usage.json": { + "mode": 292, + "sha256": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886" + }, + "baseline/evidence/runs/full-network-C3/receipt.json": { + "mode": 292, + "sha256": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce" + }, + "baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": { + "mode": 292, + "sha256": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237" + }, + "baseline/evidence/runs/full-network-C3/scientific-receipt.json": { + "mode": 292, + "sha256": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb" + }, + "baseline/evidence/runs/full-network-C3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C3/stdout.txt": { + "mode": 292, + "sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0" + }, + "baseline/evidence/runs/full-network-C3/usage.json": { + "mode": 292, + "sha256": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb" + }, + "baseline/evidence/runs/full-network-profile-v1/receipt.json": { + "mode": 292, + "sha256": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c" + }, + "baseline/evidence/runs/full-network-profile-v1/stderr.txt": { + "mode": 292, + "sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76" + }, + "baseline/evidence/runs/full-network-profile-v1/stdout.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v1/usage.json": { + "mode": 292, + "sha256": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78" + }, + "baseline/evidence/runs/full-network-profile-v2/receipt.json": { + "mode": 292, + "sha256": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf" + }, + "baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": { + "mode": 292, + "sha256": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a" + }, + "baseline/evidence/runs/full-network-profile-v2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v2/stdout.txt": { + "mode": 292, + "sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec" + }, + "baseline/evidence/runs/full-network-profile-v2/usage.json": { + "mode": 292, + "sha256": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b" + }, + "baseline/frozen/scripts/audit_short_guards.py": { + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "baseline/frozen/scripts/certify.py": { + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "baseline/frozen/scripts/compact_control_layer.py": { + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "baseline/frozen/scripts/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/frozen/scripts/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/frozen/scripts/exclusion_circuit.py": { + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "baseline/frozen/scripts/paired_exclusion_circuit.py": { + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "baseline/frozen/scripts/paired_network.py": { + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "baseline/frozen/scripts/prepare_layers.py": { + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "baseline/frozen/scripts/search_network.py": { + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "baseline/frozen/scripts/shared_point_circuit.py": { + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "baseline/frozen/scripts/shared_point_network.py": { + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "baseline/frozen/upstream/LICENSE": { + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "baseline/frozen/upstream/README.md": { + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "baseline/frozen/upstream/build/figures/multiplication-flow.tex": { + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "baseline/frozen/upstream/build/figures/proof-map.tex": { + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "baseline/frozen/upstream/build/main.tex": { + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "baseline/frozen/upstream/build/references.bib": { + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "baseline/frozen/upstream/build/sections/00-introduction.tex": { + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "baseline/frozen/upstream/build/sections/01-history.tex": { + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "baseline/frozen/upstream/build/sections/02-streams.tex": { + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "baseline/frozen/upstream/build/sections/03-motifs.tex": { + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "baseline/frozen/upstream/build/sections/04-swap.tex": { + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "baseline/frozen/upstream/build/sections/05-layers.tex": { + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "baseline/frozen/upstream/build/sections/06-transforms.tex": { + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "baseline/frozen/upstream/build/sections/07-resampling.tex": { + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "baseline/frozen/upstream/build/sections/08-assembly.tex": { + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": { + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "baseline/frozen/upstream/build/sections/10-transposition.tex": { + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": { + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "baseline/frozen/upstream/formalization.yaml": { + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "baseline/frozen/upstream/manifest.json": { + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + }, + "baseline/full_B.py": { + "mode": 292, + "sha256": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8" + }, + "baseline/full_C.py": { + "mode": 292, + "sha256": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4" + }, + "baseline/full_driver.py": { + "mode": 292, + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" + }, + "baseline/guard.py": { + "mode": 292, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline/reference/certificates/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/reference/certificates/selected-result.json": { + "mode": 292, + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "baseline/replay.py": { + "mode": 292, + "sha256": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90" + }, + "baseline/verify.py": { + "mode": 292, + "sha256": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b" + }, + "baseline/verify_full.py": { + "mode": 292, + "sha256": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + }, + "freeze_stage.py": { + "mode": 292, + "sha256": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/CALL-BUDGET.json": { + "mode": 292, + "sha256": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec" + }, + "priorities/runtime-guards/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605" + }, + "priorities/runtime-guards/PROPOSAL.json": { + "mode": 292, + "sha256": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d" + }, + "priorities/runtime-guards/RESEARCH.md": { + "mode": 292, + "sha256": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9" + }, + "priorities/runtime-guards/STATIC-CHECK.json": { + "mode": 292, + "sha256": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/CALL-BUDGET.json": { + "mode": 292, + "sha256": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5" + }, + "priorities/set-reuse/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "f3966bebe186a90729deaa0c5c4630b355637a5bb17e9deea8d8f2239078210a" + }, + "priorities/set-reuse/OWNERSHIP.md": { + "mode": 292, + "sha256": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099" + }, + "priorities/set-reuse/PROPOSAL.json": { + "mode": 292, + "sha256": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d" + }, + "priorities/set-reuse/RESEARCH.md": { + "mode": 292, + "sha256": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8" + }, + "priorities/set-reuse/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "9013633e144dc03c5ccb73c241fb116b4914138d6be691c2884bcc5c068d6bcd" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + }, + "priorities/trace-encoding/ADAPTER.md": { + "mode": 292, + "sha256": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f" + }, + "priorities/trace-encoding/CALL-BUDGET.json": { + "mode": 292, + "sha256": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab" + }, + "priorities/trace-encoding/PROPOSAL.json": { + "mode": 292, + "sha256": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d" + }, + "priorities/trace-encoding/RESEARCH.md": { + "mode": 292, + "sha256": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60" + }, + "priorities/trace-encoding/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + }, + "run_guarded.py": { + "mode": 292, + "sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + } + }, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "schema": "h25-bookkeeping-immutable-stage-v1", + "scientific_execution_during_freeze": false +} diff --git a/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/IMPLEMENTATION.md b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/IMPLEMENTATION.md new file mode 100644 index 0000000000..b6053d70e2 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/IMPLEMENTATION.md @@ -0,0 +1,27 @@ +# P1 source implementation, revision 3 controls pending parent execution + +`set_reuse.py` exposes `bind_verify_map(module)`, returning `verify_map`, `owner`, `receipt`, and the untouched original method. Supply an isolated candidate module before adding the parent's constructor or map phase wrappers. A separate unchanged module/process remains the reference. The factory authenticates source SHA/code shapes and the current pinned Fraction source; generates the original prefix and literal fallback from the frozen AST; adds only the private optimized tail; and retains the candidate module's live globals. Its temporary factory name is removed immediately. The lease owner is reachable through private closure cells and the returned parent binding, never stored on scientific instances or published as a module global. This is no protection against hostile introspection/native memory changes. + +Parent integration order: + +1. Load/authenticate the candidate scientific module and install the existing native backend. +2. Call `binding = bind_verify_map(circuit_module)` while `Checks` and `ComplexSideCircuit` retain their original source methods. +3. Install `binding['verify_map']` as `Checks.verify_map`. Install the usual phase wrappers and parent-owned constructor observation wrappers. After a successful original circuit constructor, call `owner.capture_c(self)`; after a successful original Checks constructor, call `owner.capture_checks(self)`. Constructor return values remain unchanged. +4. Call `owner.seal()` after all class/phase wrapper installation. Sealing records final class/function/closure identities, allowing no later wrapper replacement. Then call `owner.arm_cli()` immediately before the authenticated original assertion-on `runpy.run_path`. Construction captures occur inside this active interval. +5. In the enclosing parent `finally`, call `owner.disarm_cli()`. Preserve the original CLI return/stdout/witness/native guards and all original phase counts. Require the receipt to show one successful construction pair, one reservation/admission/expiry, zero fallback calls and 2300 private operand constructions for the complete H25 fast arm. Receipt fields are separate from scientific output. + +`reserve` consumes the one-use allowance at method entry before the prefix. Wrong Checks/circuit, missing/spent allowance, changed bindings and known hooks take the original whole method once. A reserved call executes the original prefix once, then `admit` examines actual exact triple and got-key/value shapes. Post-prefix denial executes the original tail AST once. Both optimized comprehensions still enumerate `c.triples` and independently form a new set intersection; only the operands are supplied by a private positional list. Additional outer enumeration and positional index lookups are new paid work. + +The cached left operand is a closure cell shared with the comprehensions. The `finally` block clears the operand list with an anchored builtin and sets both the list and left-operand cells to `None`, then expires the reservation. Generator loop variable `T` remains the original triple, so a retained traceback has no cached operand-set loop variable. There is no set cache on Checks, circuit, module or lease owner. Allocation failure is propagated without retry; exact allocation-failure timing is not promised. + +The new whole-tail condition remains independently parent-established: actual source-created identities in the fixed fresh CLI, callback-free admitted tail, no concurrent/reentrant mutator. Hook denial observes trace/profile/monitoring/GC callback/thread/signal state and never changes GC policy. It is not generic ownership detection. Ordinary API calls continue through literal fallback. + +`finite_set_controls.py` exposes `run_controls(backend, set_adapter)`, using the already loaded modules rather than relying on a `set_reuse` import path. The backend's trusted loader receives two distinct module names for original and candidate. Tiny raw fixture objects use an explicit test-only issuer rather than pretending to prove full CLI provenance. Controls cover all intersection sizes, duplicates/order, empty/large/negative integer cases, missing/wrong/used capability, reentry, prefix mutation/failure, callback-bearing tuple and got-key fallback, live set binding, hook denial, between-call mutation and retained-traceback cleanup. Parent runs both ordinary and `-O` finite controls; full qualification remains assertion-on. + +All binding/AST/Fraction authentication, lease capture/guards, hook queries, exact data scans, new enumeration/indexing, metadata allocation, finite controls and cleanup are in the complete candidate bill. Runtime and memory costs are unknown. No scientific import, compile, finite execution or measurement was performed by this worker while writing these files. Independent source review and parent serial correctness execution remain required. + +## Retained optimized-mode fixture failure and revision 3 + +Parent reports normal finite controls passed for immutable stage v2. The parent-owned `finite-P1-O-v2` run stopped after 2.8227 seconds with `RuntimeError: Collision fixture did not reach custom equality`; its raw stderr remains at `runtime/runs/finite-P1-O-v2/stderr.txt`. This was a fixture-expectation error: the relevant collision lookup occurs inside the original tail assertion, so `-O` correctly removes it. The exact original/candidate outcome and callback-list comparison had already matched before the unconditional callback-presence requirement failed. + +Revision 3 changes only the collision fixture's callback-presence expectation and the later Q-constructor fixture's equivalent assertion-only expectation. Normal mode still requires observed callbacks. Optimized mode explicitly requires empty event lists from both original and candidate, while preserving their existing exact differential outcomes/events, fast/fallback counts and all other controls. The Q correction is source-derived: every original `verify_map` Q constructor call appears inside an assertion. `set_reuse.py` is unchanged. Immutable v1/v2, the failed receipt, elapsed resource cost and original performance target remain untouched. This worker performed only source edits and static AST parsing; parent reruns and review are pending. diff --git a/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/SOURCE-READINESS.json b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/SOURCE-READINESS.json new file mode 100644 index 0000000000..cf3fbdad62 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/SOURCE-READINESS.json @@ -0,0 +1,34 @@ +{ + "schema": "h25-set-source-readiness-v1", + "revision": 3, + "status": "CONTROL_ONLY_REPAIR_READY_FOR_REVIEW_AND_PARENT_SERIAL_EXECUTION", + "interface": {"adapter": "bind_verify_map(module)", "controls": "run_controls(backend, set_adapter)"}, + "files": { + "set_reuse.py": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "finite_set_controls.py": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "IMPLEMENTATION.md": "f3966bebe186a90729deaa0c5c4630b355637a5bb17e9deea8d8f2239078210a" + }, + "previous_control_sha256": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231", + "retained_failure": { + "run": "finite-P1-O-v2", + "stderr": "runtime/runs/finite-P1-O-v2/stderr.txt", + "reported_wall_seconds": 2.8227, + "error": "RuntimeError: Collision fixture did not reach custom equality", + "cause": "Control required a callback from an original assertion that optimized interpreter mode removes", + "normal_finite_v2": "PASS reported by parent", + "raw_evidence_and_cost_preserved": true + }, + "repair": { + "adapter_changed": false, + "controls_removed": 0, + "unconditional_differential_comparisons_retained": true, + "normal_expectation": "Collision equality and Q-constructor callback fixtures still require nonempty original events and exactly equal candidate events", + "optimized_expectation": "Both fixtures explicitly require empty original and candidate event lists, because the relevant source calls are assertion-only; exact output/error and fallback/token comparisons remain", + "second_fixture_basis": "Static source inspection: all verify_map Q(...) calls occur inside prefix/tail assertions" + }, + "worker_validation": {"static_ast_parse": "PASS", "scientific_imports": 0, "compilations_or_executions": 0, "correctness_runs": 0, "timed_runs": 0}, + "pending": ["Independent review of control-only repair", "Parent serial normal/O finite execution", "Subsequent full-caller correctness and performance gates"], + "immutable_stages_modified": [], + "performance_claim": null, + "combined_target_unchanged": "At least 15 percent further complete wall AND CPU saving versus fresh PR5995 native baseline, with declared noise gates" +} diff --git a/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/finite_set_controls.py b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/finite_set_controls.py new file mode 100644 index 0000000000..2f373a8089 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/finite_set_controls.py @@ -0,0 +1,432 @@ +"""Bounded P1 controls. Parent runner alone imports/executes this module. + +run_controls(backend, set_adapter) takes the existing trusted backend and the +already loaded set adapter; it performs no implicit module-name import. +The two module instances keep the literal reference independent. Tiny raw +fixtures use an explicitly trusted finite-fixture lease issuer; these fixtures +do not establish the complete CLI's constructor provenance. +""" +from __future__ import annotations + +import gc +import sys + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def typed(value): + if type(value) is dict: + return ("dict", tuple((typed(key), typed(item)) for key, item in value.items())) + if type(value) is list or type(value) is tuple: + return (type(value).__name__, tuple(typed(item) for item in value)) + return (type(value).__name__, value) + + +def outcome(function, checks): + try: + return ("value", typed(function(checks))) + except Exception as error: + return ("error", type(error).__name__, error.args) + + +def configure(module, circuit, triples, *, keep_list=False): + if keep_list: + circuit.triples[:] = triples + else: + circuit.triples = list(triples) + circuit.active = set() + circuit.args = [None] + circuit.support = [0] + circuit.pieces = [] + seen = set() + for target in circuit.triples: + if target in seen: + continue + seen.add(target) + for coefficient, predicate in ((module.Q(1, 2), lambda size: size == 0), + (module.Q(-1, 2), lambda size: size == 2)): + mask = sum(1 << index for index, other in enumerate(circuit.triples) + if predicate(len(set(target) & set(other)))) + if mask: + circuit.support.append(mask) + circuit.args.append(None) + circuit.pieces.append((target, len(circuit.support)-1, coefficient)) + + +def raw(module, triples): + circuit = object.__new__(module.ComplexSideCircuit) + configure(module, circuit, triples) + checks = object.__new__(module.Checks) + checks.c = circuit + return circuit, checks + + +class Prefix: + def __init__(self, events, action=None): + self.events = events + self.action = action + + def __iter__(self): + self.events.append("prefix") + if self.action is not None: + self.action() + return iter(()) + + +class RecursivePrefix: + def __init__(self, events): + self.events = events + self.action = None + self.entered = False + + def __iter__(self): + self.events.append("prefix") + if not self.entered: + self.entered = True + self.action() + return iter(()) + + +def run_controls(backend, set_adapter): + load_source = backend.load_source + bind_verify_map = set_adapter.bind_verify_map + oracle = load_source("_h25_set_controls_original") + candidate = load_source("_h25_set_controls_candidate") + original_candidate = candidate.Checks.verify_map + literal = oracle.Checks.verify_map + rows = [] + standard = [(0, 1, 2), (3, 4, 5), (0, 1, 3), (0, 4, 5)] + + def binding(): + candidate.Checks.verify_map = original_candidate + result = bind_verify_map(candidate) + candidate.Checks.verify_map = result["verify_map"] + result["owner"].seal() + return result + + def fixture_issue(result, circuit, checks): + # Explicit trusted test-only issuer. The full driver must use actual + # post-original-constructor captures, never raw fixture provenance. + owner = result["owner"] + owner.arm_cli() + need(owner.capture_c(circuit), "Fixture circuit capture failed") + need(owner.capture_checks(checks), "Fixture Checks capture failed") + + def compare(name, result, left, right, left_events=(), right_events=(), *, fast=0, fallbacks=1): + expected = outcome(literal, left) + actual = outcome(result["verify_map"], right) + need(actual == expected, "Set control outcome differs: " + name) + need(list(right_events) == list(left_events), "Set control callback order differs: " + name) + need(result["receipt"]["fast_admissions"] == fast, "Set control fast-path count differs: " + name) + need(result["receipt"]["fallback_calls"] == fallbacks, "Set control fallback count differs: " + name) + need(result["owner"].current is None, "Set control retained an active token: " + name) + rows.append({"name": name, "outcome": actual[0], "fast_admissions": fast, "fallback_calls": fallbacks}) + result["owner"].disarm_cli() + + # Exact values, all intersection sizes, duplication/order, and integer width. + for name, triples in ( + ("all-intersection-sizes", standard), + ("duplicate-positional-triples", standard + [standard[0]]), + ("reordered-triples", list(reversed(standard))), + ("negative-and-wide-integers", [(-5, 1 << 100, 9), (-5, 1 << 100, 10), (2, 3, 4)]), + ("empty-triples", [])): + result = binding() + _, left = raw(oracle, triples) + circuit, right = raw(candidate, triples) + fixture_issue(result, circuit, right) + compare(name, result, left, right, fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(triples), + "Set construction count differs from positional triple count") + need(result["receipt"]["reservations_expired"] == 1, "Successful lease did not expire") + + # No allowance: ordinary source method executes, including prefix once. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events), Prefix(right_events) + compare("no-allowance-prefix-once", result, left, right, left_events, right_events) + need(left_events == ["prefix"], "Missing-lease fixture did not cover prefix") + + # Correctly shaped objects cannot borrow another Checks identity. + result = binding() + _, left = raw(oracle, standard) + right_c, captured = raw(candidate, standard) + right = object.__new__(candidate.Checks) + right.c = right_c + fixture_issue(result, right_c, captured) + compare("wrong-checks-identity", result, left, right) + + result = binding() + _, left = raw(oracle, standard) + captured_c, right = raw(candidate, standard) + other_c, _ = raw(candidate, standard) + fixture_issue(result, captured_c, right) + right.c = other_c + compare("wrong-circuit-link", result, left, right) + + # Reservation is spent before a prefix can reenter the method. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = RecursivePrefix(left_events), RecursivePrefix(right_events) + left_c.active.action = lambda: literal(left) + right_c.active.action = lambda: result["verify_map"](right) + fixture_issue(result, right_c, right) + compare("prefix-reentry-single-reservation", result, left, right, left_events, right_events, + fast=1, fallbacks=1) + need(left_events == ["prefix", "prefix"] and result["receipt"]["reservations"] == 1, + "Recursive fixture did not consume one outer reservation") + + # The post-prefix state, not an earlier eager snapshot, supplies operands. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + changed = [(10, 11, 12), (10, 11, 13), (20, 21, 22)] + left_events, right_events = [], [] + left_c.active = Prefix(left_events, lambda: configure(oracle, left_c, changed, keep_list=True)) + right_c.active = Prefix(right_events, lambda: configure(candidate, right_c, changed, keep_list=True)) + fixture_issue(result, right_c, right) + compare("post-prefix-mutated-values", result, left, right, left_events, right_events, + fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(changed), + "Set cache preceded prefix mutation") + + # Prefix exceptions happen before set construction, even with a valid lease. + def fail_prefix(): + raise ValueError("prefix sentinel") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events, fail_prefix), Prefix(right_events, fail_prefix) + fixture_issue(result, right_c, right) + compare("failing-prefix-no-eager-cache", result, left, right, left_events, right_events, + fast=0, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == 0, "Failing prefix built sets") + + # Callback-bearing triple subclasses must use literal post-prefix tail. + def callback_triple(events, base): + class Triple(tuple): + def __iter__(self): + events.append("triple-iter") + return tuple.__iter__(self) + return Triple(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = callback_triple(left_events, standard[0]) + right_c.triples[0] = callback_triple(right_events, standard[0]) + fixture_issue(result, right_c, right) + compare("tuple-subclass-callback-fallback", result, left, right, left_events, right_events) + need(left_events, "Tuple callback fixture did not execute callbacks") + + def callback_integer(events, value): + class Integer(int): + def __hash__(self): + events.append("integer-hash") + return int.__hash__(self) + return Integer(value) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = (callback_integer(left_events, 0), 1, 2) + right_c.triples[0] = (callback_integer(right_events, 0), 1, 2) + fixture_issue(result, right_c, right) + compare("integer-subclass-hash-fallback", result, left, right, left_events, right_events) + need(left_events, "Integer callback fixture did not execute callbacks") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.triples[0] = (False, 1, 2) + right_c.triples[0] = (False, 1, 2) + fixture_issue(result, right_c, right) + compare("bool-member-exact-type-fallback", result, left, right) + + # The got dictionary can retain a hostile equality key from the prefix. + def collision_key(circuit, events, base): + class Target(tuple): + __hash__ = tuple.__hash__ + fired = False + + def __eq__(self, other): + events.append("collision-equality") + if not self.fired: + self.fired = True + circuit.triples.reverse() + return tuple.__eq__(self, other) + return Target(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + for circuit, events in ((left_c, left_events), (right_c, right_events)): + target, node, coefficient = circuit.pieces[0] + circuit.pieces[0] = (collision_key(circuit, events, target), node, coefficient) + fixture_issue(result, right_c, right) + compare("got-collision-key-fallback", result, left, right, left_events, right_events) + if sys.flags.optimize: + # This fixture's collision lookup is in the original tail assert. + need(left_events == [] and right_events == [], + "Optimized collision fixture unexpectedly executed assertion-only equality") + else: + need(left_events, "Collision fixture did not reach custom equality") + + # Runtime source-global drift retains original live resolution in fallback. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + def logging_set(events): + def wrapped(values): + events.append("set") + return set(values) + return wrapped + oracle.set, candidate.set = logging_set(left_events), logging_set(right_events) + fixture_issue(result, right_c, right) + try: + compare("live-source-set-resolution", result, left, right, left_events, right_events) + need(len(left_events) == 4*len(standard)**2, "Literal fallback lost original set calls") + finally: + del oracle.set + del candidate.set + + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + original_q = candidate.Q + def logging_q(events): + def wrapped(*args): + events.append("Q") + return original_q(*args) + return wrapped + fixture_issue(result, right_c, right) + oracle.Q, candidate.Q = logging_q(left_events), logging_q(right_events) + try: + compare("live-Fraction-global-resolution", result, left, right, left_events, right_events) + if sys.flags.optimize: + # Every original verify_map Q(...) call is inside an assert. + need(left_events == [] and right_events == [], + "Optimized Fraction fixture unexpectedly executed assertion-only constructors") + else: + need(left_events, "Fraction callback fixture did not execute callbacks") + finally: + oracle.Q = candidate.Q = original_q + + # The exact Fraction class is mutable: unchanged class identity alone is + # insufficient. A changed method after binding must deny optimization. + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + original_hash = original_q.__hash__ + hash_events = [] + def traced_hash(value): + hash_events.append("fraction-hash") + return original_hash(value) + original_q.__hash__ = traced_hash + try: + expected = outcome(literal, left) + expected_events = list(hash_events) + hash_events.clear() + actual = outcome(result["verify_map"], right) + need(actual == expected and hash_events == expected_events and hash_events, + "Changed Fraction method fallback differs") + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Changed Fraction method was admitted") + finally: + original_q.__hash__ = original_hash + result["owner"].disarm_cli() + rows.append({"name": "changed-Fraction-hash", "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # A used capability cannot cache values for a later invocation. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + need(outcome(result["verify_map"], right) == outcome(literal, left), "Initial leased call differs") + configure(oracle, left_c, changed) + configure(candidate, right_c, changed) + compare("used-capability-changed-later-input", result, left, right, fast=1, fallbacks=1) + need(result["receipt"]["private_operand_sets_constructed"] == len(standard), + "Used capability constructed a second private cache") + + # Observable known hooks deny optimization without changing hook policy. + for hook in ("trace", "profile", "gc-callback"): + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + def quiet_trace(frame, event, arg): + return quiet_trace + def quiet_gc(phase, info): + return None + if hook == "trace": + sys.settrace(quiet_trace) + elif hook == "profile": + sys.setprofile(quiet_trace) + else: + gc.callbacks.append(quiet_gc) + try: + actual = outcome(result["verify_map"], right) + finally: + if hook == "trace": + sys.settrace(None) + elif hook == "profile": + sys.setprofile(None) + else: + gc.callbacks.remove(quiet_gc) + need(actual == outcome(literal, left), "Hook-denied fallback differs: " + hook) + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Known hook was admitted: " + hook) + result["owner"].disarm_cli() + rows.append({"name": "known-hook-" + hook, "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # Deliberate tail assertion failure retains a traceback: cached operands + # must have been cleared/reset even while the frame itself remains live. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.support[1] ^= 1 << 20 + right_c.support[1] ^= 1 << 20 + fixture_issue(result, right_c, right) + expected = outcome(literal, left) + retained = None + try: + actual = ("value", typed(result["verify_map"](right))) + except Exception as error: + actual = ("error", type(error).__name__, error.args) + retained = error.__traceback__ + need(actual == expected, "Tail-failure outcome differs") + if not sys.flags.optimize: + need(actual[0] == "error" and actual[1] == "AssertionError", "Tail-failure fixture did not fail") + found = False + while retained is not None: + if retained.tb_frame.f_code is result["verify_map"].__code__: + found = True + values = retained.tb_frame.f_locals + need(values["_h25_sr_sets"] is None and values["_h25_sr_left"] is None, + "Retained traceback kept private cached operands") + retained = retained.tb_next + need(found, "Candidate traceback frame was not inspected") + need(result["owner"].current is None, "Tail error retained lease") + need(result["receipt"]["fast_admissions"] == 1, "Tail cleanup fixture did not use cached sets") + result["owner"].disarm_cli() + rows.append({"name": "traceback-cleanup", "outcome": actual[0], "fast_admissions": 1, "fallback_calls": 0}) + + candidate.Checks.verify_map = original_candidate + need(oracle.Checks.verify_map is literal, "Independent source reference was changed") + return {"status": "P1_FINITE_SET_CONTROLS_PASS", "optimize": sys.flags.optimize, + "cases": len(rows), "rows": rows, + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence"} diff --git a/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/set_reuse.py b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/set_reuse.py new file mode 100644 index 0000000000..89d6d32ab9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/revisions/v3/priorities/set-reuse/set_reuse.py @@ -0,0 +1,451 @@ +"""Private operand-set reuse for one authenticated frozen full-caller phase. + +The parent owns the new whole-tail execution invariant. This is not inherited +from the native kernel guard and is not a generic alias/security detector. +Standalone, unsupported and unleased calls delegate the literal source. +No scientific module is imported here; the parent supplies an isolated module. +""" +from __future__ import annotations + +import _thread +import ast +import builtins +import copy +import fractions +import gc +import hashlib +from pathlib import Path +import signal +import sys +from types import CodeType, FunctionType, GetSetDescriptorType, MemberDescriptorType, ModuleType + +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +FRACTION_SHA256 = "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231" +_TYPE, _OBJECT, _DICT, _LIST, _TUPLE, _INT = type, object, dict, list, tuple, int +_LEN, _SET, _COMPILE = len, set, compile +_GET = dict.get +_OBJGET = object.__getattribute__ +_TYPEGET = type.__getattribute__ +_CLEAR = list.clear +_BUILTINS = builtins.__dict__ +_FRACTION = fractions.Fraction +_BUILTIN_NAMES = ("type", "object", "set", "len", "sum", "enumerate", "dict", + "int", "list", "tuple", "all", "range", "hash", "abs", "pow", + "isinstance", "super") +_BUILTIN_RECORD = tuple((name, _BUILTINS[name]) for name in _BUILTIN_NAMES) +_SOURCE_LOOKUPS = ("set", "len", "sum", "enumerate", "dict") + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +def _function_record(function): + if _TYPE(function) is not FunctionType: + return None + closure = function.__closure__ + cells = () if closure is None else _TUPLE((cell, cell.cell_contents) for cell in closure) + return (function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, closure, cells) + + +def _function_fresh(record): + function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells = record + if not (function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure): + return False + for cell, value in cells: + try: + if cell.cell_contents is not value: + return False + except ValueError: + return False + return True + + +def _ordinary_class(cls): + if _TYPE(cls) is not _TYPE or _TYPEGET(cls, "__mro__") != (cls, _OBJECT): + return False + attributes = _TYPEGET(cls, "__dict__") + if "__getattr__" in attributes or _TYPEGET(cls, "__getattribute__") is not _OBJECT.__getattribute__: + return False + if _TYPEGET(cls, "__new__") is not _OBJECT.__new__: + return False + for name in ("__dict__", "__weakref__"): + descriptor = attributes.get(name) + if _TYPE(descriptor) is not GetSetDescriptorType or descriptor.__objclass__ is not cls: + return False + return True + + +def _ordinary_dict(value, cls): + if _TYPE(value) is not cls or not _ordinary_class(cls): + return None + namespace = _OBJGET(value, "__dict__") + return namespace if _TYPE(namespace) is _DICT else None + + +def _triple(value): + return (_TYPE(value) is _TUPLE and _LEN(value) == 3 and + _TYPE(value[0]) is _INT and _TYPE(value[1]) is _INT and _TYPE(value[2]) is _INT) + + +def _hooks_clear(): + """Known instrumentation denial only; not a generic finalizer theorem.""" + if sys.gettrace() is not None or sys.getprofile() is not None: + return False + if _TYPE(gc.callbacks) is not _LIST or _LEN(gc.callbacks) != 0 or _thread._count() != 0: + return False + monitoring = getattr(sys, "monitoring", None) + if monitoring is not None: + for tool in range(6): + if monitoring.get_tool(tool) is not None: + return False + for number in signal.valid_signals(): + handler = signal.getsignal(number) + if handler is not signal.SIG_DFL and handler is not signal.SIG_IGN and handler is not signal.default_int_handler: + return False + return True + + +def _code_named(code, name): + return next(item for item in code.co_consts if _TYPE(item) is CodeType and item.co_name == name) + + +def _authenticate_function(function, expected, namespace): + _need(_TYPE(function) is FunctionType and function.__globals__ is namespace and + function.__builtins__ is _BUILTINS and function.__code__ == expected, + "Set reuse requires the exact original source function") + + +class _Token: + __slots__ = () + + +class _LeaseOwner: + """Parent-private one-call capability; only identity/state, never operand sets.""" + + def __init__(self, module, original, source_functions, class_names, receipt): + self.module = module + self.namespace = module.__dict__ + self.original = original + self.circuit_class = self.namespace["ComplexSideCircuit"] + self.checks_class = self.namespace["Checks"] + self.class_names = class_names + self.source_functions = source_functions + self.receipt = receipt + self.sealed = False + self.cli_active = False + self.used = False + self.current = None + self.circuit = self.checks = self.triples = None + self.class_records = () + self.function_records = () + self.fraction_globals = _TUPLE(fractions.__dict__.items()) + self.fraction_classes = _TUPLE((cls, _TYPEGET(cls, "__mro__"), + _TUPLE(_TYPEGET(cls, "__dict__").items())) + for cls in _FRACTION.__mro__ if cls is not _OBJECT) + self.math_gcd = fractions.math.gcd + self.rational = fractions.numbers.Rational + self.complex = fractions.numbers.Complex + self.hash_wrapper = fractions._hash_algorithm + self.hash_wrapped = fractions._hash_algorithm.__wrapped__ + fraction_functions = [] + for _, _, attributes in self.fraction_classes: + for _, value in attributes: + if _TYPE(value) is FunctionType: + fraction_functions.append(value) + elif _TYPE(value) is property: + fraction_functions.extend(item for item in (value.fget, value.fset, value.fdel) if item is not None) + fraction_functions.append(self.hash_wrapped) + self.fraction_functions = _TUPLE(_function_record(function) for function in fraction_functions) + + def seal(self): + """Parent calls once after installing all constructor/map phase wrappers.""" + _need(not self.sealed and not self.cli_active, "Set reuse owner already sealed or active") + classes = (self.circuit_class, self.checks_class) + records = [] + functions = _LIST(self.source_functions) + for cls, names in zip(classes, self.class_names): + _need(_ordinary_class(cls), "Set reuse requires ordinary frozen class dispatch") + attributes = _TYPEGET(cls, "__dict__") + _need(_SET(attributes) == names, "Set reuse class member shape changed") + records.append((cls, _TYPEGET(cls, "__mro__"), _TUPLE(attributes.items()))) + functions.extend(value for value in attributes.values() if _TYPE(value) is FunctionType) + self.class_records = _TUPLE(records) + self.function_records = _TUPLE(_function_record(function) for function in functions) + self.sealed = True + + def arm_cli(self): + """Parent attests the pinned fresh CLI; do not call for a generic API use.""" + _need(self.sealed and not self.cli_active and self.circuit is None and not self.used, + "Set reuse allowance cannot be reused") + self.cli_active = True + self.receipt["allowances_armed"] += 1 + + def capture_c(self, circuit): + """Called only after the parent-observed original constructor returns.""" + if not self.cli_active or self.circuit is not None or self.used: + return False + namespace = _ordinary_dict(circuit, self.circuit_class) + if namespace is None: + return False + triples = _GET(namespace, "triples") + if _TYPE(triples) is not _LIST: + return False + self.circuit, self.triples = circuit, triples + self.receipt["circuits_captured"] += 1 + return True + + def capture_checks(self, checks): + """Called only after the parent-observed original Checks init returns.""" + if not self.cli_active or self.circuit is None or self.checks is not None or self.used: + return False + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return False + self.checks = checks + self.receipt["checks_captured"] += 1 + return True + + def _fresh(self): + if (_TYPE(self.module) is not ModuleType or self.module.__dict__ is not self.namespace or + _GET(self.namespace, "Checks") is not self.checks_class or + _GET(self.namespace, "ComplexSideCircuit") is not self.circuit_class or + _GET(self.namespace, "Q") is not _FRACTION or + _GET(self.namespace, "__builtins__") is not _BUILTINS): + return False + for name, expected in _BUILTIN_RECORD: + if _GET(_BUILTINS, name) is not expected: + return False + for name in _SOURCE_LOOKUPS: + if name in self.namespace: + return False + for cls, mro, items in self.class_records + self.fraction_classes: + if _TYPEGET(cls, "__mro__") is not mro: + return False + attributes = _TYPEGET(cls, "__dict__") + if _LEN(attributes) != _LEN(items): + return False + for name, value in items: + if attributes.get(name) is not value: + return False + for record in self.function_records + self.fraction_functions: + if not _function_fresh(record): + return False + if _LEN(fractions.__dict__) != _LEN(self.fraction_globals): + return False + for name, value in self.fraction_globals: + if _GET(fractions.__dict__, name) is not value: + return False + return (fractions.math.gcd is self.math_gcd and + fractions.numbers.Rational is self.rational and + fractions.numbers.Complex is self.complex and + fractions._hash_algorithm is self.hash_wrapper and + self.hash_wrapper.__wrapped__ is self.hash_wrapped) + + def reserve(self, checks): + """Consumed before prefix; wrong or unleased objects get literal fallback.""" + self.receipt["entries"] += 1 + if not self.cli_active or self.used or self.current is not None or checks is not self.checks: + return None + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return None + self.used = True + if not self._fresh() or not _hooks_clear(): + return None + token = _Token() + self.current = token + self.receipt["reservations"] += 1 + return token + + def admit(self, token, checks, circuit, got): + """Called after the original prefix, using its actual local got mapping.""" + if (token is None or token is not self.current or not self.cli_active or + checks is not self.checks or circuit is not self.circuit or + not self._fresh() or not _hooks_clear()): + return False + check_dict = _ordinary_dict(checks, self.checks_class) + circuit_dict = _ordinary_dict(circuit, self.circuit_class) + if check_dict is None or circuit_dict is None or _GET(check_dict, "c") is not circuit: + return False + triples = _GET(circuit_dict, "triples") + if triples is not self.triples or _TYPE(triples) is not _LIST: + return False + for triple in triples: + if not _triple(triple): + return False + if _TYPE(got) is not _DICT: + return False + for key, value in got.items(): + if (_TYPE(key) is not _TUPLE or _LEN(key) != 2 or not _triple(key[0]) or + _TYPE(key[1]) is not _FRACTION or _TYPE(value) is not _INT): + return False + coefficient = key[1] + if (_TYPE(_OBJGET(coefficient, "_numerator")) is not _INT or + _TYPE(_OBJGET(coefficient, "_denominator")) is not _INT): + return False + self.receipt["fast_admissions"] += 1 + return True + + def fallback(self): + self.receipt["fallback_calls"] += 1 + + def constructed(self, count): + self.receipt["private_operand_sets_constructed"] += count + + def expire(self, token): + if token is not None and token is self.current: + self.current = None + self.receipt["reservations_expired"] += 1 + + def disarm_cli(self): + self.current = None + self.cli_active = False + self.circuit = self.checks = self.triples = None + + +def _fraction_source_check(): + raw = Path(fractions.__file__).read_bytes() + _need(hashlib.sha256(raw).hexdigest() == FRACTION_SHA256, "Set reuse Fraction source differs") + compiled = _COMPILE(raw, fractions.__file__, "exec", dont_inherit=True, optimize=sys.flags.optimize) + fraction_code = _code_named(compiled, "Fraction") + _need(_TYPEGET(_FRACTION, "__getattribute__") is _OBJECT.__getattribute__, + "Set reuse Fraction attribute dispatch differs") + for name in ("_numerator", "_denominator"): + descriptor = _TYPEGET(_FRACTION, name) + _need(_TYPE(descriptor) is MemberDescriptorType and descriptor.__objclass__ is _FRACTION, + "Set reuse Fraction slot descriptor differs") + _need(fractions.numbers.Rational is _FRACTION.__mro__[1] and + fractions.numbers.Complex in _FRACTION.__mro__, + "Set reuse Fraction number-class resolution differs") + for name in ("__new__", "__hash__", "__eq__"): + _authenticate_function(_TYPEGET(_FRACTION, name), _code_named(fraction_code, name), fractions.__dict__) + for name in ("numerator", "denominator"): + _authenticate_function(_TYPEGET(_FRACTION, name).fget, _code_named(fraction_code, name), fractions.__dict__) + _authenticate_function(fractions._hash_algorithm.__wrapped__, _code_named(compiled, "_hash_algorithm"), fractions.__dict__) + + +def _generate(module, method_ast, owner, original): + """Only original prefix/tail AST plus declared private bookkeeping changes.""" + _need(_LEN(method_ast.body) == 7 and _TYPE(method_ast.body[3]) is ast.For and + _TYPE(method_ast.body[4]) is ast.Assign and _TYPE(method_ast.body[5]) is ast.For, + "Unexpected pinned verify_map AST layout") + prefix = copy.deepcopy(method_ast.body[:4]) + fallback_tail = copy.deepcopy(method_ast.body[4:]) + template = ast.parse(''' +def _h25_sr_factory(_h25_sr_enter, _h25_sr_admit, _h25_sr_expire, _h25_sr_original, + _h25_sr_fallback, _h25_sr_constructed, _h25_sr_clear): + def verify_map(self): + _h25_sr_token = _h25_sr_enter(self) + _h25_sr_sets = None + _h25_sr_left = None + try: + if _h25_sr_token is None: + _h25_sr_fallback() + return _h25_sr_original(self) + _H25_PREFIX + if not _h25_sr_admit(_h25_sr_token, self, c, got): + _h25_sr_fallback() + _H25_FALLBACK + _h25_sr_sets = [set(T) for T in c.triples] + _h25_sr_constructed(len(_h25_sr_sets)) + nonzero = 0 + for _h25_sr_position, S in enumerate(c.triples): + _h25_sr_left = _h25_sr_sets[_h25_sr_position] + zero = sum(1 << i for i, T in enumerate(c.triples) + if not _h25_sr_left & _h25_sr_sets[i]) + two = sum(1 << i for i, T in enumerate(c.triples) + if len(_h25_sr_left & _h25_sr_sets[i]) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + finally: + if _h25_sr_sets is not None: + _h25_sr_clear(_h25_sr_sets) + _h25_sr_left = None + _h25_sr_sets = None + _h25_sr_expire(_h25_sr_token) + return verify_map +''') + method = template.body[0].body[0] + guarded = method.body[3] + _need(_TYPE(guarded) is ast.Try, "Internal set adapter AST layout changed") + replaced = [] + for statement in guarded.body: + if _TYPE(statement) is ast.Expr and _TYPE(statement.value) is ast.Name and statement.value.id == "_H25_PREFIX": + replaced.extend(prefix) + elif _TYPE(statement) is ast.If and statement.body and any( + _TYPE(item) is ast.Expr and _TYPE(item.value) is ast.Name and item.value.id == "_H25_FALLBACK" + for item in statement.body): + statement.body = statement.body[:1] + fallback_tail + replaced.append(statement) + else: + replaced.append(statement) + guarded.body = replaced + ast.fix_missing_locations(template) + namespace = module.__dict__ + name = "_h25_sr_factory" + _need(name not in namespace, "Set reuse helper name collision") + try: + exec(_COMPILE(template, "", "exec", dont_inherit=True, + optimize=sys.flags.optimize), namespace) + factory = namespace[name] + function = factory(owner.reserve, owner.admit, owner.expire, original, + owner.fallback, owner.constructed, _CLEAR) + finally: + namespace.pop(name, None) + return function + + +def bind_verify_map(module): + """Return verify_map/owner/receipt; parent installs, wraps, seals, then arms. + + This factory must receive an isolated candidate module. Keep the unchanged + baseline/reference in another module/process; existing globals are never + copied or rebound, so ordinary fallback retains live source resolution. + """ + _need(_TYPE(module) is ModuleType, "Set reuse needs an exact source module") + namespace = module.__dict__ + path = Path(namespace["__file__"]) + raw = path.read_bytes() + _need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Set reuse scientific source differs") + _need(_GET(namespace, "__builtins__") is _BUILTINS and _GET(namespace, "Q") is _FRACTION, + "Set reuse source calling environment differs") + for name, value in _BUILTIN_RECORD: + _need(_GET(_BUILTINS, name) is value, "Set reuse builtin identity differs") + for name in _SOURCE_LOOKUPS: + _need(name not in namespace, "Set reuse source shadows a builtin") + compiled = _COMPILE(raw, str(path), "exec", dont_inherit=True, optimize=sys.flags.optimize) + source_functions = [] + class_names = [] + for name in ("ComplexSideCircuit", "Checks"): + cls = namespace[name] + _need(_ordinary_class(cls), "Set reuse source class dispatch differs") + class_code = _code_named(compiled, name) + attributes = _TYPEGET(cls, "__dict__") + expected_names = {"__module__", "__doc__", "__dict__", "__weakref__"} + for code in class_code.co_consts: + if _TYPE(code) is CodeType: + expected_names.add(code.co_name) + function = attributes.get(code.co_name) + _authenticate_function(function, code, namespace) + source_functions.append(function) + _need(_SET(attributes) == expected_names, "Set reuse source class members differ") + class_names.append(expected_names) + _fraction_source_check() + original = namespace["Checks"].verify_map + parsed = ast.parse(raw, filename=str(path)) + checks_ast = next(item for item in parsed.body if _TYPE(item) is ast.ClassDef and item.name == "Checks") + method_ast = next(item for item in checks_ast.body if _TYPE(item) is ast.FunctionDef and item.name == "verify_map") + receipt = {"schema": "h25-private-set-reuse-v1", "source_sha256": SOURCE_SHA256, + "fraction_sha256": FRACTION_SHA256, "allowances_armed": 0, "circuits_captured": 0, + "checks_captured": 0, "entries": 0, "reservations": 0, "fast_admissions": 0, + "fallback_calls": 0, "private_operand_sets_constructed": 0, "reservations_expired": 0} + owner = _LeaseOwner(module, original, _TUPLE(source_functions), _TUPLE(class_names), receipt) + candidate = _generate(module, method_ast, owner, original) + return {"verify_map": candidate, "owner": owner, "receipt": receipt, "original": original} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/START.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/START.json new file mode 100644 index 0000000000..0b1fda07b0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/START.json @@ -0,0 +1,21 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-O-v2/science", + "--lanes", + "sets", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-sets", + "label": "finite-P1-O-v2", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 116.10572314390447, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json new file mode 100644 index 0000000000..85adb4074b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/receipt.json @@ -0,0 +1,36 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-O-v2/science", + "--lanes", + "sets", + "--finite-only" + ], + "exit": 1, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-sets", + "label": "finite-P1-O-v2", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 73912320, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 116.10572314390447, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "STOP", + "stderr_bytes": 1896, + "stderr_sha256": "cf857d5af2231a0240d4932eae3fff889f05ce4229e514593566a46696e0e710", + "stdout_bytes": 0, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "termination": null, + "usage": { + "raw": "Command exited with non-zero status 1\n{\"user_seconds\":2.68,\"system_seconds\":0.07,\"kernel_max_rss_kib\":40744,\"exit\":1}\n" + }, + "wall_seconds": 2.8227231420460157 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/stderr.txt new file mode 100644 index 0000000000..1c5a6df912 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/stderr.txt @@ -0,0 +1,19 @@ +Traceback (most recent call last): + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", line 387, in + main() + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", line 216, in main + phases.call("all_new_controls", adapters.run_controls, extensions, backend, native, phases) + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", line 124, in call + return function(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/adapters.py", line 136, in run_controls + result['sets'] = phases.call('new_private_set_controls', + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", line 124, in call + return function(*args, **kwargs) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/priorities/set-reuse/finite_set_controls.py", line 278, in run_controls + need(left_events, "Collision fixture did not reach custom equality") + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/priorities/set-reuse/finite_set_controls.py", line 16, in need + raise RuntimeError(message) +RuntimeError: Collision fixture did not reach custom equality diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/usage.json new file mode 100644 index 0000000000..f2eb1ebd11 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v2/usage.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"user_seconds":2.68,"system_seconds":0.07,"kernel_max_rss_kib":40744,"exit":1} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/START.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/START.json new file mode 100644 index 0000000000..3d0f97266e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/START.json @@ -0,0 +1,21 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-O-v3/science", + "--lanes", + "sets", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-sets", + "label": "finite-P1-O-v3", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 121.3779959299718, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json new file mode 100644 index 0000000000..2e94299748 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/receipt.json @@ -0,0 +1,39 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-O-v3/science", + "--lanes", + "sets", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-sets", + "label": "finite-P1-O-v3", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 72200192, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 121.3779959299718, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 6748, + "stdout_sha256": "54821a17869e76d98a8d51edd51d9aba251c08c53a3bf0217c40bc8528290671", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40556, + "system_seconds": 0.06, + "user_seconds": 2.43 + }, + "wall_seconds": 2.5653694639913738 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json new file mode 100644 index 0000000000..11e11f896e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/scientific-receipt.json @@ -0,0 +1,295 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "sets", + "new_controls": { + "sets": { + "cases": 23, + "optimize": 1, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "value" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "status": "P1_FINITE_SET_CONTROLS_PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + } + }, + "optimized": 1, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.01965860500000005, + "wall_seconds": 0.019655790994875133 + }, + "unchanged_python": { + "cpu_seconds": 0.1302057620000001, + "wall_seconds": 0.13021284900605679 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.224291, + "wall_seconds": 1.2249007900245488 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6362190000000003, + "wall_seconds": 0.6366366950096563 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.218061, + "wall_seconds": 0.23428329703165218 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004165999999999975, + "wall_seconds": 0.004165766993537545 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0013169999999999848, + "wall_seconds": 0.0013156079803593457 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010459999999999914, + "wall_seconds": 0.0010448709945194423 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.00536600000000001, + "wall_seconds": 0.024310235981829464 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005986000000000019, + "wall_seconds": 0.005985359020996839 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.008865000000000012, + "wall_seconds": 0.008992884017061442 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6362029999999999, + "wall_seconds": 0.6366187499952503 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/stdout.txt new file mode 100644 index 0000000000..1b766b78ac --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "sets", "new_controls": {"sets": {"cases": 23, "optimize": 1, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "value"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "status": "P1_FINITE_SET_CONTROLS_PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29"}}, "optimized": 1, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.01965860500000005, "wall_seconds": 0.019655790994875133}, "unchanged_python": {"cpu_seconds": 0.1302057620000001, "wall_seconds": 0.13021284900605679}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.224291, "wall_seconds": 1.2249007900245488}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.6362190000000003, "wall_seconds": 0.6366366950096563}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.218061, "wall_seconds": 0.23428329703165218}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004165999999999975, "wall_seconds": 0.004165766993537545}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0013169999999999848, "wall_seconds": 0.0013156079803593457}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010459999999999914, "wall_seconds": 0.0010448709945194423}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.00536600000000001, "wall_seconds": 0.024310235981829464}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005986000000000019, "wall_seconds": 0.005985359020996839}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.008865000000000012, "wall_seconds": 0.008992884017061442}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6362029999999999, "wall_seconds": 0.6366187499952503}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/usage.json new file mode 100644 index 0000000000..29df7d8ab2 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-O-v3/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.43,"system_seconds":0.06,"kernel_max_rss_kib":40556,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/START.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/START.json new file mode 100644 index 0000000000..fb6368ae66 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/START.json @@ -0,0 +1,20 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-normal-v2/science", + "--lanes", + "sets", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-sets", + "label": "finite-P1-normal-v2", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 113.68655481893802, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json new file mode 100644 index 0000000000..dc7c972a6f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/receipt.json @@ -0,0 +1,38 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-normal-v2/science", + "--lanes", + "sets", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-sets", + "label": "finite-P1-normal-v2", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 66068480, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 113.68655481893802, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 6743, + "stdout_sha256": "6d25ad7b7ff81b7df3a263a32ad3ce1176d21ff05b55e0dcb64e422e31a10be5", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40572, + "system_seconds": 0.06, + "user_seconds": 2.25 + }, + "wall_seconds": 2.4191683249664493 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json new file mode 100644 index 0000000000..d8dd9a05a4 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/scientific-receipt.json @@ -0,0 +1,295 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "sets", + "new_controls": { + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "status": "P1_FINITE_SET_CONTROLS_PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + } + }, + "optimized": 0, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.0314991200000001, + "wall_seconds": 0.03149619197938591 + }, + "unchanged_python": { + "cpu_seconds": 0.18727651300000003, + "wall_seconds": 0.18725708400597796 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.327391, + "wall_seconds": 1.3311079979757778 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6276170000000001, + "wall_seconds": 0.6280938370036893 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21053499999999997, + "wall_seconds": 0.21032129699597135 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004899000000000001, + "wall_seconds": 0.004897885024547577 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001354000000000001, + "wall_seconds": 0.001353109022602439 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011039999999999939, + "wall_seconds": 0.0011037829681299627 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004935000000000009, + "wall_seconds": 0.004933107004035264 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005940999999999995, + "wall_seconds": 0.00593889900483191 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.011851, + "wall_seconds": 0.011869085021317005 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6276030000000001, + "wall_seconds": 0.628075958986301 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/stdout.txt new file mode 100644 index 0000000000..6432e9da83 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "sets", "new_controls": {"sets": {"cases": 23, "optimize": 0, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "error"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "status": "P1_FINITE_SET_CONTROLS_PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639"}, "PLAN.md": {"mode": 292, "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "2c481c74cbf85edc1734b3d139cc665ec731b0910317cb2636da57b423844231"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.0314991200000001, "wall_seconds": 0.03149619197938591}, "unchanged_python": {"cpu_seconds": 0.18727651300000003, "wall_seconds": 0.18725708400597796}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.327391, "wall_seconds": 1.3311079979757778}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.6276170000000001, "wall_seconds": 0.6280938370036893}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21053499999999997, "wall_seconds": 0.21032129699597135}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004899000000000001, "wall_seconds": 0.004897885024547577}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001354000000000001, "wall_seconds": 0.001353109022602439}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011039999999999939, "wall_seconds": 0.0011037829681299627}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004935000000000009, "wall_seconds": 0.004933107004035264}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005940999999999995, "wall_seconds": 0.00593889900483191}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.011851, "wall_seconds": 0.011869085021317005}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6276030000000001, "wall_seconds": 0.628075958986301}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/usage.json new file mode 100644 index 0000000000..3675fd0392 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v2/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.25,"system_seconds":0.06,"kernel_max_rss_kib":40572,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/START.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/START.json new file mode 100644 index 0000000000..f4a2da91b4 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/START.json @@ -0,0 +1,20 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-normal-v3/science", + "--lanes", + "sets", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-sets", + "label": "finite-P1-normal-v3", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 118.92844628595049, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json new file mode 100644 index 0000000000..69f6d2e5d8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/receipt.json @@ -0,0 +1,38 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P1-normal-v3/science", + "--lanes", + "sets", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-sets", + "label": "finite-P1-normal-v3", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 68870144, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 118.92844628595049, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 6734, + "stdout_sha256": "46b26672e3262d518abffa352829094da7e5276dce36e1725eb1ed2aeb4f4c50", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40608, + "system_seconds": 0.06, + "user_seconds": 2.24 + }, + "wall_seconds": 2.4495496440213174 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json new file mode 100644 index 0000000000..6ed2191693 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/scientific-receipt.json @@ -0,0 +1,295 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "sets", + "new_controls": { + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "status": "P1_FINITE_SET_CONTROLS_PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + } + }, + "optimized": 0, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.026003785999999973, + "wall_seconds": 0.026000763988122344 + }, + "unchanged_python": { + "cpu_seconds": 0.17878021200000005, + "wall_seconds": 0.17880262900143862 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.33302, + "wall_seconds": 1.3347687269560993 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.5923129999999996, + "wall_seconds": 0.5923138450016268 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.203164, + "wall_seconds": 0.20319324400043115 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005373000000000003, + "wall_seconds": 0.005372519954107702 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.002232999999999999, + "wall_seconds": 0.002230573969427496 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.001579999999999998, + "wall_seconds": 0.06596495199482888 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.006447999999999995, + "wall_seconds": 0.043731756042689085 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.011241999999999988, + "wall_seconds": 0.011250056035351008 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.00997300000000001, + "wall_seconds": 0.009969702980015427 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.592298, + "wall_seconds": 0.5922973009874113 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/stdout.txt new file mode 100644 index 0000000000..4020f3616f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "sets", "new_controls": {"sets": {"cases": 23, "optimize": 0, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "error"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "status": "P1_FINITE_SET_CONTROLS_PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.026003785999999973, "wall_seconds": 0.026000763988122344}, "unchanged_python": {"cpu_seconds": 0.17878021200000005, "wall_seconds": 0.17880262900143862}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.33302, "wall_seconds": 1.3347687269560993}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.5923129999999996, "wall_seconds": 0.5923138450016268}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.203164, "wall_seconds": 0.20319324400043115}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005373000000000003, "wall_seconds": 0.005372519954107702}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.002232999999999999, "wall_seconds": 0.002230573969427496}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.001579999999999998, "wall_seconds": 0.06596495199482888}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.006447999999999995, "wall_seconds": 0.043731756042689085}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.011241999999999988, "wall_seconds": 0.011250056035351008}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.00997300000000001, "wall_seconds": 0.009969702980015427}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.592298, "wall_seconds": 0.5922973009874113}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/usage.json new file mode 100644 index 0000000000..cd1d18c454 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P1-normal-v3/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.24,"system_seconds":0.06,"kernel_max_rss_kib":40608,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/START.json b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/START.json new file mode 100644 index 0000000000..83bc491d36 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/START.json @@ -0,0 +1,21 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P2-O-v1/science", + "--lanes", + "guards", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-guards", + "label": "finite-P2-O-v1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 1.7826307810028084, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json new file mode 100644 index 0000000000..97816feb57 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/receipt.json @@ -0,0 +1,39 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P2-O-v1/science", + "--lanes", + "guards", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-guards", + "label": "finite-P2-O-v1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 74149888, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 1.7826307810028084, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5393, + "stdout_sha256": "710b9ebcb967d964191a367142e20d93ba5134ebac3181770b04f572c7730265", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40464, + "system_seconds": 0.08, + "user_seconds": 1.93 + }, + "wall_seconds": 2.0360284139751457 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json new file mode 100644 index 0000000000..7adbaff293 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/scientific-receipt.json @@ -0,0 +1,194 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "guards", + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + } + }, + "optimized": 1, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.013746988000000071, + "wall_seconds": 0.013785088958684355 + }, + "unchanged_python": { + "cpu_seconds": 0.13004445900000006, + "wall_seconds": 0.13007982401177287 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.206166, + "wall_seconds": 1.2069550140295178 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.10562800000000006, + "wall_seconds": 0.1057130609988235 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.228798, + "wall_seconds": 0.22885661001782864 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005815000000000015, + "wall_seconds": 0.005814462958369404 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0016780000000000128, + "wall_seconds": 0.0016764390165917575 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0014579999999999593, + "wall_seconds": 0.0014562309952452779 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.006942999999999977, + "wall_seconds": 0.00694246799685061 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.008638000000000007, + "wall_seconds": 0.00863588898209855 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.009790999999999994, + "wall_seconds": 0.009787901013623923 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.10561299999999996, + "wall_seconds": 0.10569327900884673 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/stdout.txt new file mode 100644 index 0000000000..e641b63d1f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "guards", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639"}, "PLAN.md": {"mode": 292, "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}}, "optimized": 1, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.013746988000000071, "wall_seconds": 0.013785088958684355}, "unchanged_python": {"cpu_seconds": 0.13004445900000006, "wall_seconds": 0.13007982401177287}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.206166, "wall_seconds": 1.2069550140295178}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.10562800000000006, "wall_seconds": 0.1057130609988235}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.228798, "wall_seconds": 0.22885661001782864}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005815000000000015, "wall_seconds": 0.005814462958369404}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0016780000000000128, "wall_seconds": 0.0016764390165917575}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0014579999999999593, "wall_seconds": 0.0014562309952452779}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.006942999999999977, "wall_seconds": 0.00694246799685061}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.008638000000000007, "wall_seconds": 0.00863588898209855}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.009790999999999994, "wall_seconds": 0.009787901013623923}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.10561299999999996, "wall_seconds": 0.10569327900884673}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/usage.json new file mode 100644 index 0000000000..ed97f9885e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-O-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.93,"system_seconds":0.08,"kernel_max_rss_kib":40464,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/START.json b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/START.json new file mode 100644 index 0000000000..65dd89b776 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/START.json @@ -0,0 +1,20 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P2-normal-v1/science", + "--lanes", + "guards", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-guards", + "label": "finite-P2-normal-v1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 0.0, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json new file mode 100644 index 0000000000..eb89cf18b5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/receipt.json @@ -0,0 +1,38 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P2-normal-v1/science", + "--lanes", + "guards", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-guards", + "label": "finite-P2-normal-v1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 66531328, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 0.0, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5406, + "stdout_sha256": "9cf8d1295b34d378784070092e03aa302224e7b503ead3ea80b5a1ac456689b4", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40628, + "system_seconds": 0.05, + "user_seconds": 1.69 + }, + "wall_seconds": 1.7826307810028084 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json new file mode 100644 index 0000000000..15e1ab8b14 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/scientific-receipt.json @@ -0,0 +1,194 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "guards", + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + } + }, + "optimized": 0, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.012289875000000006, + "wall_seconds": 0.012321866990532726 + }, + "unchanged_python": { + "cpu_seconds": 0.13491190400000008, + "wall_seconds": 0.13500335300341249 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.310613, + "wall_seconds": 1.3116404610336758 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.09970499999999971, + "wall_seconds": 0.09971432498423383 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.19528200000000004, + "wall_seconds": 0.19506486097816378 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005057000000000006, + "wall_seconds": 0.005056558002252132 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0012790000000000024, + "wall_seconds": 0.0012783820275217295 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010700000000000015, + "wall_seconds": 0.0010691949864849448 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004920999999999995, + "wall_seconds": 0.004919457016512752 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005776000000000003, + "wall_seconds": 0.005775664001703262 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.010581000000000063, + "wall_seconds": 0.01057820301502943 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.09969200000000011, + "wall_seconds": 0.09969795495271683 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/stdout.txt new file mode 100644 index 0000000000..ce34ef306b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "guards", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639"}, "PLAN.md": {"mode": 292, "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.012289875000000006, "wall_seconds": 0.012321866990532726}, "unchanged_python": {"cpu_seconds": 0.13491190400000008, "wall_seconds": 0.13500335300341249}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.310613, "wall_seconds": 1.3116404610336758}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.09970499999999971, "wall_seconds": 0.09971432498423383}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.19528200000000004, "wall_seconds": 0.19506486097816378}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005057000000000006, "wall_seconds": 0.005056558002252132}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0012790000000000024, "wall_seconds": 0.0012783820275217295}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010700000000000015, "wall_seconds": 0.0010691949864849448}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004920999999999995, "wall_seconds": 0.004919457016512752}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005776000000000003, "wall_seconds": 0.005775664001703262}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.010581000000000063, "wall_seconds": 0.01057820301502943}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.09969200000000011, "wall_seconds": 0.09969795495271683}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/usage.json new file mode 100644 index 0000000000..e2d83fee70 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P2-normal-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.69,"system_seconds":0.05,"kernel_max_rss_kib":40628,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/START.json b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/START.json new file mode 100644 index 0000000000..2d4ce5c4af --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/START.json @@ -0,0 +1,21 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P3-O-v1/science", + "--lanes", + "trace", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-trace", + "label": "finite-P3-O-v1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 5.672952123975847, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json new file mode 100644 index 0000000000..0caea67ad8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/receipt.json @@ -0,0 +1,39 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P3-O-v1/science", + "--lanes", + "trace", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-trace", + "label": "finite-P3-O-v1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 59969536, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 5.672952123975847, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5847, + "stdout_sha256": "4a724dedb485cda71a10b96cf20910099ba659c9a42159ee80c5631802e4b948", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40408, + "system_seconds": 0.08, + "user_seconds": 2.03 + }, + "wall_seconds": 2.2229915109928697 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json new file mode 100644 index 0000000000..bca97809cf --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/scientific-receipt.json @@ -0,0 +1,194 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "trace", + "new_controls": { + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 3, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "optimized": 1, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.027329595999999956, + "wall_seconds": 0.0273380329599604 + }, + "unchanged_python": { + "cpu_seconds": 0.14992656500000012, + "wall_seconds": 0.1499318330315873 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.268808, + "wall_seconds": 1.2689404929988086 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.029958999999999847, + "wall_seconds": 0.03011857095407322 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20209899999999997, + "wall_seconds": 0.20193614496383816 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005218999999999974, + "wall_seconds": 0.005218392994720489 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0014299999999999868, + "wall_seconds": 0.001428065006621182 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010690000000000421, + "wall_seconds": 0.001066214987076819 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005652000000000046, + "wall_seconds": 0.00565109500894323 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006684999999999969, + "wall_seconds": 0.00668423599563539 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.18136299999999994, + "wall_seconds": 0.1812293289694935 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.018674999999999997, + "wall_seconds": 0.018831791006959975 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.011251999999999818, + "wall_seconds": 0.011248308001086116 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.17659199999999997, + "wall_seconds": 0.17645975603954867 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/stdout.txt new file mode 100644 index 0000000000..2442110758 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "trace", "new_controls": {"trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 3, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639"}, "PLAN.md": {"mode": 292, "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 1, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.027329595999999956, "wall_seconds": 0.0273380329599604}, "unchanged_python": {"cpu_seconds": 0.14992656500000012, "wall_seconds": 0.1499318330315873}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.268808, "wall_seconds": 1.2689404929988086}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.029958999999999847, "wall_seconds": 0.03011857095407322}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20209899999999997, "wall_seconds": 0.20193614496383816}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005218999999999974, "wall_seconds": 0.005218392994720489}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0014299999999999868, "wall_seconds": 0.001428065006621182}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010690000000000421, "wall_seconds": 0.001066214987076819}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005652000000000046, "wall_seconds": 0.00565109500894323}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006684999999999969, "wall_seconds": 0.00668423599563539}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.18136299999999994, "wall_seconds": 0.1812293289694935}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.018674999999999997, "wall_seconds": 0.018831791006959975}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.011251999999999818, "wall_seconds": 0.011248308001086116}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.17659199999999997, "wall_seconds": 0.17645975603954867}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/usage.json new file mode 100644 index 0000000000..2c5587722b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-O-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.03,"system_seconds":0.08,"kernel_max_rss_kib":40408,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/START.json b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/START.json new file mode 100644 index 0000000000..a26e710e3c --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/START.json @@ -0,0 +1,20 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P3-normal-v1/science", + "--lanes", + "trace", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-trace", + "label": "finite-P3-normal-v1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 3.818659194977954, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json new file mode 100644 index 0000000000..3c2c13ef1f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/receipt.json @@ -0,0 +1,38 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v1/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-P3-normal-v1/science", + "--lanes", + "trace", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-trace", + "label": "finite-P3-normal-v1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 66887680, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 3.818659194977954, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5851, + "stdout_sha256": "c98b3d8b61543d4f36d58d4f4afb51f8cf1091a7da8b4b2c16fa479df490e65f", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40628, + "system_seconds": 0.1, + "user_seconds": 1.73 + }, + "wall_seconds": 1.8542929289978929 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json new file mode 100644 index 0000000000..d0d6dbf4e7 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/scientific-receipt.json @@ -0,0 +1,194 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "trace", + "new_controls": { + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 3, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "optimized": 0, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.021254090000000003, + "wall_seconds": 0.02125159796560183 + }, + "unchanged_python": { + "cpu_seconds": 0.1285824339999999, + "wall_seconds": 0.12858684995444492 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.244215, + "wall_seconds": 1.244274739001412 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.025459999999999816, + "wall_seconds": 0.02545965398894623 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21954899999999994, + "wall_seconds": 0.21926352800801396 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005865999999999996, + "wall_seconds": 0.005867265979759395 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0012709999999999944, + "wall_seconds": 0.0012702970416285098 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011099999999999999, + "wall_seconds": 0.0011091299820691347 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004484999999999996, + "wall_seconds": 0.004483495024032891 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005947000000000001, + "wall_seconds": 0.005946923978626728 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.21632899999999994, + "wall_seconds": 0.21691366896266118 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.015459000000000334, + "wall_seconds": 0.01545581198297441 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.009978000000000264, + "wall_seconds": 0.009975763969123363 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20990400000000003, + "wall_seconds": 0.21049061097437516 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/stdout.txt new file mode 100644 index 0000000000..f22c9bfca0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "trace", "new_controls": {"trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 3, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639"}, "PLAN.md": {"mode": 292, "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "71dd4d0f9d27b867b8926ef227f2196a662dceae4ef6a585e96cda9e41120e72"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.021254090000000003, "wall_seconds": 0.02125159796560183}, "unchanged_python": {"cpu_seconds": 0.1285824339999999, "wall_seconds": 0.12858684995444492}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.244215, "wall_seconds": 1.244274739001412}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.025459999999999816, "wall_seconds": 0.02545965398894623}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21954899999999994, "wall_seconds": 0.21926352800801396}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005865999999999996, "wall_seconds": 0.005867265979759395}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0012709999999999944, "wall_seconds": 0.0012702970416285098}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011099999999999999, "wall_seconds": 0.0011091299820691347}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004484999999999996, "wall_seconds": 0.004483495024032891}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005947000000000001, "wall_seconds": 0.005946923978626728}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.21632899999999994, "wall_seconds": 0.21691366896266118}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.015459000000000334, "wall_seconds": 0.01545581198297441}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.009978000000000264, "wall_seconds": 0.009975763969123363}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20990400000000003, "wall_seconds": 0.21049061097437516}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/usage.json b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/usage.json new file mode 100644 index 0000000000..6df122d77f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-P3-normal-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.73,"system_seconds":0.10,"kernel_max_rss_kib":40628,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/START.json b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/START.json new file mode 100644 index 0000000000..358f30c39e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/START.json @@ -0,0 +1,21 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-combined-O-v4/science", + "--lanes", + "all", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-all", + "label": "finite-combined-O-v4", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 180.0312632669229, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json new file mode 100644 index 0000000000..0e7421542e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/receipt.json @@ -0,0 +1,39 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "-O", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-combined-O-v4/science", + "--lanes", + "all", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-O-all", + "label": "finite-combined-O-v4", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 74674176, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 180.0312632669229, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 10870, + "stdout_sha256": "60a5980d3e05919c5b0f4aad5f91648edfde7cc2bebbbab5175b3d3f6b6ee50c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40608, + "system_seconds": 0.09, + "user_seconds": 2.78 + }, + "wall_seconds": 2.948608194012195 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json new file mode 100644 index 0000000000..f3104629a4 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/scientific-receipt.json @@ -0,0 +1,437 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "all", + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + }, + "sets": { + "cases": 23, + "optimize": 1, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "value" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "source_pin_policy_cases": [ + { + "digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "outcome": "recognized" + }, + { + "digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "outcome": "recognized" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "StringSubclass", + "outcome": "rejected" + } + ], + "status": "P1_FINITE_SET_CONTROLS_PASS" + }, + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "optimized": 1, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.014080306000000098, + "wall_seconds": 0.014106853981502354 + }, + "unchanged_python": { + "cpu_seconds": 0.184045271, + "wall_seconds": 0.1843323369976133 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.2240270000000002, + "wall_seconds": 1.2264409950003028 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.799912, + "wall_seconds": 0.807241479982622 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20315500000000009, + "wall_seconds": 0.20296699699247256 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004852000000000023, + "wall_seconds": 0.004850407014600933 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0014020000000000143, + "wall_seconds": 0.0014003310352563858 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0012770000000000281, + "wall_seconds": 0.0012762430123984814 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0063950000000000395, + "wall_seconds": 0.05449354404117912 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007766000000000023, + "wall_seconds": 0.007765375019516796 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.21781499999999998, + "wall_seconds": 0.21764930000063032 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.12901399999999974, + "wall_seconds": 0.12922954704845324 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6453900000000004, + "wall_seconds": 0.6524971130420454 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.01570700000000036, + "wall_seconds": 0.01570390199776739 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.009758000000000155, + "wall_seconds": 0.009754956990946084 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.1919590000000001, + "wall_seconds": 0.19179668399738148 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/stdout.txt new file mode 100644 index 0000000000..aa8045923b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "all", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}, "sets": {"cases": 23, "optimize": 1, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "value"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "source_pin_policy_cases": [{"digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "outcome": "recognized"}, {"digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "outcome": "recognized"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "StringSubclass", "outcome": "rejected"}], "status": "P1_FINITE_SET_CONTROLS_PASS"}, "trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 5, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}, "priorities/set-reuse/cpython-3.12.15-fractions.py": {"mode": 292, "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 1, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.014080306000000098, "wall_seconds": 0.014106853981502354}, "unchanged_python": {"cpu_seconds": 0.184045271, "wall_seconds": 0.1843323369976133}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2240270000000002, "wall_seconds": 1.2264409950003028}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.799912, "wall_seconds": 0.807241479982622}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20315500000000009, "wall_seconds": 0.20296699699247256}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004852000000000023, "wall_seconds": 0.004850407014600933}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0014020000000000143, "wall_seconds": 0.0014003310352563858}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0012770000000000281, "wall_seconds": 0.0012762430123984814}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.0063950000000000395, "wall_seconds": 0.05449354404117912}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007766000000000023, "wall_seconds": 0.007765375019516796}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.21781499999999998, "wall_seconds": 0.21764930000063032}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.12901399999999974, "wall_seconds": 0.12922954704845324}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6453900000000004, "wall_seconds": 0.6524971130420454}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.01570700000000036, "wall_seconds": 0.01570390199776739}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.009758000000000155, "wall_seconds": 0.009754956990946084}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.1919590000000001, "wall_seconds": 0.19179668399738148}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/usage.json b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/usage.json new file mode 100644 index 0000000000..86a130b556 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-O-v4/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.78,"system_seconds":0.09,"kernel_max_rss_kib":40608,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/START.json b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/START.json new file mode 100644 index 0000000000..bf99ff9896 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/START.json @@ -0,0 +1,20 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-combined-normal-v4/science", + "--lanes", + "all", + "--finite-only" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-all", + "label": "finite-combined-normal-v4", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 177.46565306693083, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json new file mode 100644 index 0000000000..5686df2fb3 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/receipt.json @@ -0,0 +1,38 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/finite-combined-normal-v4/science", + "--lanes", + "all", + "--finite-only" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "finite-all", + "label": "finite-combined-normal-v4", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 67174400, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 177.46565306693083, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 10859, + "stdout_sha256": "241b2cc4eae112b7ba568b035c955f56fd88726f10053a556d100bca8b3e539f", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 40572, + "system_seconds": 0.08, + "user_seconds": 2.38 + }, + "wall_seconds": 2.5656101999920793 +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json new file mode 100644 index 0000000000..a331e570aa --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/scientific-receipt.json @@ -0,0 +1,437 @@ +{ + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "lanes": "all", + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + }, + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "source_pin_policy_cases": [ + { + "digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "outcome": "recognized" + }, + { + "digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "outcome": "recognized" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "StringSubclass", + "outcome": "rejected" + } + ], + "status": "P1_FINITE_SET_CONTROLS_PASS" + }, + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "optimized": 0, + "original_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.013130058999999972, + "wall_seconds": 0.013127650017850101 + }, + "unchanged_python": { + "cpu_seconds": 0.164903751, + "wall_seconds": 0.16490979603258893 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.1985360000000003, + "wall_seconds": 1.198630279977806 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6979289999999996, + "wall_seconds": 0.6983124000253156 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.22234099999999996, + "wall_seconds": 0.23054650804260746 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004646999999999998, + "wall_seconds": 0.004645140026696026 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001236999999999995, + "wall_seconds": 0.001236273965332657 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011919999999999986, + "wall_seconds": 0.0011905879946425557 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004608000000000001, + "wall_seconds": 0.004606049042195082 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005773, + "wall_seconds": 0.0057720119948498905 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.20786300000000008, + "wall_seconds": 0.20784253103192896 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.12398499999999979, + "wall_seconds": 0.12399375805398449 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.5426769999999996, + "wall_seconds": 0.5430313469842076 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.017736999999999892, + "wall_seconds": 0.01773295196471736 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.013484999999999747, + "wall_seconds": 0.013496141997165978 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.174529, + "wall_seconds": 0.17451206099940464 + } + }, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "status": "H25_BOOKKEEPING_FINITE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/stderr.txt b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/stdout.txt b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/stdout.txt new file mode 100644 index 0000000000..004d39aef8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/stdout.txt @@ -0,0 +1 @@ +{"driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", "lanes": "all", "new_controls": {"guards": {"comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", "counts": {"binding_modes": 2, "mutation_action_pairs": 1659, "mutation_pairs": 237, "same_code_distinct_controls": 4, "source_loads": 4, "stable_action_pairs": 14}, "inventories": {"traced": {"candidate": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 11, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 14, "distinct_functions": 11, "records": 13, "same_code_distinct_function_rejected": true}}, "untraced": {"candidate": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 10, "same_code_distinct_function_rejected": true}, "reference": {"captured_cell_reads": 12, "distinct_functions": 10, "records": 13, "same_code_distinct_function_rejected": true}}}, "old_finite_controls_still_required": true, "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4"}, "sets": {"cases": 23, "optimize": 0, "rows": [{"fallback_calls": 0, "fast_admissions": 1, "name": "all-intersection-sizes", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "duplicate-positional-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "reordered-triples", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "negative-and-wide-integers", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "empty-triples", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "no-allowance-prefix-once", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-checks-identity", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "wrong-circuit-link", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "prefix-reentry-single-reservation", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "post-prefix-mutated-values", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 0, "name": "failing-prefix-no-eager-cache", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "tuple-subclass-callback-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "integer-subclass-hash-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "bool-member-exact-type-fallback", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "got-collision-key-fallback", "outcome": "error"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-source-set-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "live-Fraction-global-resolution", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "changed-Fraction-hash", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 1, "name": "used-capability-changed-later-input", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-trace", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-profile", "outcome": "value"}, {"fallback_calls": 1, "fast_admissions": 0, "name": "known-hook-gc-callback", "outcome": "value"}, {"fallback_calls": 0, "fast_admissions": 1, "name": "traceback-cleanup", "outcome": "error"}], "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", "source_pin_policy_cases": [{"digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "outcome": "recognized"}, {"digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "outcome": "recognized"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "str", "outcome": "rejected"}, {"input_type": "StringSubclass", "outcome": "rejected"}], "status": "P1_FINITE_SET_CONTROLS_PASS"}, "trace": {"comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", "counts": {"before_pairs": 7, "byte_and_prefix_pairs": 55, "digit_limit_pairs": 5, "error_pairs": 18, "factory_rejections": 3, "native_admitted": 17, "native_argument_errors": 5, "native_fallback": 30, "no_alias_checks": 2, "source_module_loads": 1}, "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", "ordered_fixture_stream": {"calls": 20, "canonical_stream_bytes": 5926, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55"}, "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", "timing_claim": null}, "trace_entry_freshness": {"negative_actions": 5, "rejected_before_arithmetic_and_observation": true, "status": "PASS"}}, "new_source_custody": {"PLAN.json": {"mode": 292, "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63"}, "PLAN.md": {"mode": 292, "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106"}, "integration/DERIVATION.json": {"mode": 292, "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256"}, "integration/adapters.py": {"mode": 292, "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94"}, "integration/derive_driver.py": {"mode": 292, "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a"}, "integration/full_driver.py": {"mode": 292, "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1"}, "priorities/runtime-guards/guard_candidate.py": {"mode": 292, "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29"}, "priorities/runtime-guards/guard_controls.py": {"mode": 292, "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291"}, "priorities/set-reuse/cpython-3.12.15-fractions.py": {"mode": 292, "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0"}, "priorities/set-reuse/finite_set_controls.py": {"mode": 292, "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919"}, "priorities/set-reuse/set_reuse.py": {"mode": 292, "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d"}, "priorities/trace-encoding/trace_adapter.py": {"mode": 292, "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60"}, "priorities/trace-encoding/trace_controls.py": {"mode": 292, "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447"}, "priorities/trace-encoding/trace_encoder.c": {"mode": 292, "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e"}}, "optimized": 0, "original_controls": {"counts": {"binding_rejections": 3, "boundary_cases": 17, "fallback_cases": 38, "gram_cases": 621, "oracle_negative_controls": 2, "ordered_complements": 5344, "real_label_permutations": 24}, "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", "micro": {"native_with_conversion": {"cpu_seconds": 0.013130058999999972, "wall_seconds": 0.013127650017850101}, "unchanged_python": {"cpu_seconds": 0.164903751, "wall_seconds": 0.16490979603258893}}, "micro_fixtures": 4, "micro_repetitions": 128, "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", "native_and_fallback_calls": {"complement_fallback": 30, "complement_native": 5875, "gram_fallback": 20, "gram_native": 1638}, "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "v2_controls": {"complement_fixture_stream": {"calls": 7, "canonical_stream_bytes": 597, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"}, "counts": {"class_dispatch_rejections": 2, "effective_builtins_rejections": 2, "native_proxy_rejections": 1, "postbind_drift_rejections": 25, "prebind_shadow_rejections": 10, "real_builtin_drift_rejections": 2, "trace_negative_controls": 4, "trace_pairs": 7}, "modified_helper_invocations": 0, "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}}, "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.1985360000000003, "wall_seconds": 1.198630279977806}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.6979289999999996, "wall_seconds": 0.6983124000253156}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.22234099999999996, "wall_seconds": 0.23054650804260746}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004646999999999998, "wall_seconds": 0.004645140026696026}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001236999999999995, "wall_seconds": 0.001236273965332657}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011919999999999986, "wall_seconds": 0.0011905879946425557}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004608000000000001, "wall_seconds": 0.004606049042195082}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005773, "wall_seconds": 0.0057720119948498905}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.20786300000000008, "wall_seconds": 0.20784253103192896}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.12398499999999979, "wall_seconds": 0.12399375805398449}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.5426769999999996, "wall_seconds": 0.5430313469842076}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.017736999999999892, "wall_seconds": 0.01773295196471736}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.013484999999999747, "wall_seconds": 0.013496141997165978}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.174529, "wall_seconds": 0.17451206099940464}}, "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", "status": "H25_BOOKKEEPING_FINITE_PASS"} diff --git a/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/usage.json b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/usage.json new file mode 100644 index 0000000000..862a9e9e69 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/finite-combined-normal-v4/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.38,"system_seconds":0.08,"kernel_max_rss_kib":40572,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/START.json new file mode 100644 index 0000000000..87d03c7a21 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P1-B", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 123.94336539396318, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json new file mode 100644 index 0000000000..8e9f10b9cc --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P1-B", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 408940544, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 123.94336539396318, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4491, + "stdout_sha256": "3f38611cd867d086b277311db0ee0caa362823924f0ec5210fcd37c94a679d64", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454612, + "system_seconds": 0.37, + "user_seconds": 27.85 + }, + "wall_seconds": 28.382591002970003 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json new file mode 100644 index 0000000000..f1b9851782 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.02172477100000003, + "wall_seconds": 0.02172213396988809 + }, + "unchanged_python": { + "cpu_seconds": 0.16305995000000006, + "wall_seconds": 0.16305769002065063 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.2616889999999998, + "wall_seconds": 1.2617629030137323 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 4.744040779769421e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 6.700000000003925e-05, + "wall_seconds": 6.679404759779572e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0045839999999999215, + "wall_seconds": 0.004583823028951883 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20010299999999998, + "wall_seconds": 0.19992186303716153 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.007112000000000007, + "wall_seconds": 0.0071097760228440166 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00551900000000001, + "wall_seconds": 0.005518399004358798 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0035129999999998773, + "wall_seconds": 0.003510445007123053 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4348100000000006, + "wall_seconds": 0.43492381897522137 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 24.411706, + "wall_seconds": 24.457610110985115 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0014409999999999978, + "wall_seconds": 0.0014397150371223688 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0015030000000000043, + "wall_seconds": 0.0015013430383987725 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0074749999999999955, + "wall_seconds": 0.018194630043581128 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.000482999999999123, + "wall_seconds": 0.000482838018797338 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.324539999999999, + "wall_seconds": 1.3348224349902011 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.008418000000000009, + "wall_seconds": 0.008417651988565922 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 8.999999999925734e-06, + "wall_seconds": 9.040988516062498e-06 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00023799999999596366, + "wall_seconds": 0.00023886997951194644 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002338999999999203, + "wall_seconds": 0.0023384980158880353 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 5.78700564801693e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 3.999999999892978e-06, + "wall_seconds": 4.152010660618544e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.94527, + "wall_seconds": 1.9455506770173088 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 15.203065999999994, + "wall_seconds": 15.239565623982344 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.464871000000001, + "wall_seconds": 5.469126544950996 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.3333130000000004, + "wall_seconds": 1.3380481349886395 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 27.819705, + "process_wall_seconds_before_receipt": 27.86506157502299, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-B/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/stdout.txt new file mode 100644 index 0000000000..9754b152db --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 27.819705, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2616889999999998, "wall_seconds": 1.2617629030137323}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 4.744040779769421e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 6.700000000003925e-05, "wall_seconds": 6.679404759779572e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.0045839999999999215, "wall_seconds": 0.004583823028951883}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20010299999999998, "wall_seconds": 0.19992186303716153}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.007112000000000007, "wall_seconds": 0.0071097760228440166}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.00551900000000001, "wall_seconds": 0.005518399004358798}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0035129999999998773, "wall_seconds": 0.003510445007123053}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4348100000000006, "wall_seconds": 0.43492381897522137}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 24.411706, "wall_seconds": 24.457610110985115}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0014409999999999978, "wall_seconds": 0.0014397150371223688}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0015030000000000043, "wall_seconds": 0.0015013430383987725}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.0074749999999999955, "wall_seconds": 0.018194630043581128}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.000482999999999123, "wall_seconds": 0.000482838018797338}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.324539999999999, "wall_seconds": 1.3348224349902011}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.008418000000000009, "wall_seconds": 0.008417651988565922}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 8.999999999925734e-06, "wall_seconds": 9.040988516062498e-06}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00023799999999596366, "wall_seconds": 0.00023886997951194644}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002338999999999203, "wall_seconds": 0.0023384980158880353}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 5.78700564801693e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 3.999999999892978e-06, "wall_seconds": 4.152010660618544e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.94527, "wall_seconds": 1.9455506770173088}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 15.203065999999994, "wall_seconds": 15.239565623982344}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.464871000000001, "wall_seconds": 5.469126544950996}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.3333130000000004, "wall_seconds": 1.3380481349886395}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 27.86506157502299} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-B/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/usage.json new file mode 100644 index 0000000000..508f5c8081 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-B/usage.json @@ -0,0 +1 @@ +{"user_seconds":27.85,"system_seconds":0.37,"kernel_max_rss_kib":454612,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/START.json new file mode 100644 index 0000000000..89053111b1 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science", + "--lanes", + "sets" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-sets", + "label": "pilot-P1-C", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 152.32595639693318, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json new file mode 100644 index 0000000000..bde4a6111b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v3/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science", + "--lanes", + "sets" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-sets", + "label": "pilot-P1-C", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 409726976, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 152.32595639693318, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4582, + "stdout_sha256": "bcf96193669ff3ab3585bb48cf1e3b7c3e298a32a92dcee5d46289fbad3d103b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 455408, + "system_seconds": 0.31, + "user_seconds": 24.76 + }, + "wall_seconds": 25.139696669997647 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json new file mode 100644 index 0000000000..af40e56a8d --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/scientific-receipt.json @@ -0,0 +1,675 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [ + "sets" + ], + "new_controls": { + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "status": "P1_FINITE_SET_CONTROLS_PASS" + } + }, + "original_observer_retained_for_old_controls": true, + "set_reuse": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + } + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.026414943000000024, + "wall_seconds": 0.02641219599172473 + }, + "unchanged_python": { + "cpu_seconds": 0.1465022589999999, + "wall_seconds": 0.1482576910057105 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "sets", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.257701, + "wall_seconds": 1.259587112988811 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6242570000000005, + "wall_seconds": 0.6243691379786469 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.49999999998252e-05, + "wall_seconds": 7.504498353227973e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00418099999999999, + "wall_seconds": 0.004180816002190113 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.18872499999999998, + "wall_seconds": 0.18851520703174174 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.009848999999999997, + "wall_seconds": 0.00984711799537763 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005606999999999987, + "wall_seconds": 0.005607002996839583 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0033639999999999226, + "wall_seconds": 0.003362049988936633 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.47609499999999993, + "wall_seconds": 0.4760942800203338 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 20.802455000000002, + "wall_seconds": 20.802733752992935 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0014500000000000068, + "wall_seconds": 0.0014482350088655949 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010729999999999906, + "wall_seconds": 0.0010727880289778113 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0053440000000000015, + "wall_seconds": 0.005343747965525836 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.000460000000000349, + "wall_seconds": 0.000458956987131387 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2083970000000015, + "wall_seconds": 1.2099500700132921 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006277999999999999, + "wall_seconds": 0.006277505948673934 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.010259000000000018, + "wall_seconds": 0.01027884503128007 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6242410000000003, + "wall_seconds": 0.6243495260132477 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.0001430000000013365, + "wall_seconds": 0.0001450799754820764 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0023890000000008627, + "wall_seconds": 0.0023877189960330725 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 0.020347000000000115, + "wall_seconds": 0.020343167008832097 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 6.4000000000064e-05, + "wall_seconds": 6.412900984287262e-05 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.862507, + "wall_seconds": 1.862620803003665 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.688652999999999, + "wall_seconds": 14.688761650002562 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 2.462987, + "wall_seconds": 2.4630331629887223 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.277984, + "wall_seconds": 1.277979990991298 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 24.684104, + "process_wall_seconds_before_receipt": 24.664720783999655, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P1-C/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/stdout.txt new file mode 100644 index 0000000000..fd7c4a0650 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 24.684104, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.257701, "wall_seconds": 1.259587112988811}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.6242570000000005, "wall_seconds": 0.6243691379786469}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.49999999998252e-05, "wall_seconds": 7.504498353227973e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.00418099999999999, "wall_seconds": 0.004180816002190113}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.18872499999999998, "wall_seconds": 0.18851520703174174}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.009848999999999997, "wall_seconds": 0.00984711799537763}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005606999999999987, "wall_seconds": 0.005607002996839583}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0033639999999999226, "wall_seconds": 0.003362049988936633}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.47609499999999993, "wall_seconds": 0.4760942800203338}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 20.802455000000002, "wall_seconds": 20.802733752992935}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0014500000000000068, "wall_seconds": 0.0014482350088655949}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010729999999999906, "wall_seconds": 0.0010727880289778113}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.0053440000000000015, "wall_seconds": 0.005343747965525836}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.000460000000000349, "wall_seconds": 0.000458956987131387}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2083970000000015, "wall_seconds": 1.2099500700132921}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006277999999999999, "wall_seconds": 0.006277505948673934}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.010259000000000018, "wall_seconds": 0.01027884503128007}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6242410000000003, "wall_seconds": 0.6243495260132477}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.0001430000000013365, "wall_seconds": 0.0001450799754820764}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0023890000000008627, "wall_seconds": 0.0023877189960330725}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 0.020347000000000115, "wall_seconds": 0.020343167008832097}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 6.4000000000064e-05, "wall_seconds": 6.412900984287262e-05}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.862507, "wall_seconds": 1.862620803003665}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.688652999999999, "wall_seconds": 14.688761650002562}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 2.462987, "wall_seconds": 2.4630331629887223}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.277984, "wall_seconds": 1.277979990991298}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 24.664720783999655} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P1-C/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/usage.json new file mode 100644 index 0000000000..755b0e1614 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P1-C/usage.json @@ -0,0 +1 @@ +{"user_seconds":24.76,"system_seconds":0.31,"kernel_max_rss_kib":455408,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/START.json new file mode 100644 index 0000000000..79c1752b14 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P2-B", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 7.895943634968717, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json new file mode 100644 index 0000000000..f7e363e115 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P2-B", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 408883200, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 7.895943634968717, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4474, + "stdout_sha256": "7f4ad570bc105d6f02e37ceebab6dbea884e65c29390391f2b8255ca175afe43", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454584, + "system_seconds": 0.33, + "user_seconds": 27.46 + }, + "wall_seconds": 27.908136366982944 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json new file mode 100644 index 0000000000..8fbcaa56a9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.02363889600000002, + "wall_seconds": 0.023636850994080305 + }, + "unchanged_python": { + "cpu_seconds": 0.17766791199999998, + "wall_seconds": 0.17766527697676793 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.255844, + "wall_seconds": 1.2561563510098495 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000254801e-06, + "wall_seconds": 4.718021955341101e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 6.600000000034356e-05, + "wall_seconds": 6.563204806298018e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005973000000000006, + "wall_seconds": 0.005973276973236352 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.23026300000000002, + "wall_seconds": 0.23129619704559445 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.009642999999999624, + "wall_seconds": 0.009640024974942207 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004482, + "wall_seconds": 0.00448146800044924 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003530000000000033, + "wall_seconds": 0.003527062013745308 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.468124, + "wall_seconds": 0.468144080019556 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 23.871750000000002, + "wall_seconds": 23.883507166989148 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0012550000000000061, + "wall_seconds": 0.0012542050099000335 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010429999999999953, + "wall_seconds": 0.0010425969958305359 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004733000000000001, + "wall_seconds": 0.0047307159984484315 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004820000000016478, + "wall_seconds": 0.00048121000872924924 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.4418250000000015, + "wall_seconds": 1.4518079939880408 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.005701999999999999, + "wall_seconds": 0.005701958958525211 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 8.000000000008e-06, + "wall_seconds": 7.782015018165112e-06 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.0002519999999996969, + "wall_seconds": 0.0002531500067561865 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0027500000000024727, + "wall_seconds": 0.0027506669866852462 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 9.999999999621423e-06, + "wall_seconds": 9.796000085771084e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 3.9999999996709334e-06, + "wall_seconds": 4.110042937099934e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.9367829999999997, + "wall_seconds": 1.9369178829947487 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.574593000000002, + "wall_seconds": 14.581201071036048 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.629250000000001, + "wall_seconds": 5.63418376998743 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.231982999999996, + "wall_seconds": 1.2320286830072291 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 27.415922, + "process_wall_seconds_before_receipt": 27.42072495899629, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-B/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/stdout.txt new file mode 100644 index 0000000000..74e4fa1a90 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 27.415922, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.255844, "wall_seconds": 1.2561563510098495}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 5.000000000254801e-06, "wall_seconds": 4.718021955341101e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 6.600000000034356e-05, "wall_seconds": 6.563204806298018e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.005973000000000006, "wall_seconds": 0.005973276973236352}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.23026300000000002, "wall_seconds": 0.23129619704559445}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.009642999999999624, "wall_seconds": 0.009640024974942207}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004482, "wall_seconds": 0.00448146800044924}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003530000000000033, "wall_seconds": 0.003527062013745308}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.468124, "wall_seconds": 0.468144080019556}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 23.871750000000002, "wall_seconds": 23.883507166989148}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0012550000000000061, "wall_seconds": 0.0012542050099000335}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010429999999999953, "wall_seconds": 0.0010425969958305359}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004733000000000001, "wall_seconds": 0.0047307159984484315}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004820000000016478, "wall_seconds": 0.00048121000872924924}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.4418250000000015, "wall_seconds": 1.4518079939880408}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.005701999999999999, "wall_seconds": 0.005701958958525211}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 8.000000000008e-06, "wall_seconds": 7.782015018165112e-06}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.0002519999999996969, "wall_seconds": 0.0002531500067561865}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0027500000000024727, "wall_seconds": 0.0027506669866852462}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 9.999999999621423e-06, "wall_seconds": 9.796000085771084e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 3.9999999996709334e-06, "wall_seconds": 4.110042937099934e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.9367829999999997, "wall_seconds": 1.9369178829947487}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.574593000000002, "wall_seconds": 14.581201071036048}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.629250000000001, "wall_seconds": 5.63418376998743}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.231982999999996, "wall_seconds": 1.2320286830072291}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 27.42072495899629} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-B/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/usage.json new file mode 100644 index 0000000000..0b9ac02ff9 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-B/usage.json @@ -0,0 +1 @@ +{"user_seconds":27.46,"system_seconds":0.33,"kernel_max_rss_kib":454584,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/START.json new file mode 100644 index 0000000000..393bd213e5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science", + "--lanes", + "guards" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-guards", + "label": "pilot-P2-C", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 35.80408000195166, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json new file mode 100644 index 0000000000..6d50883126 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science", + "--lanes", + "guards" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-guards", + "label": "pilot-P2-C", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 409055232, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 35.80408000195166, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4602, + "stdout_sha256": "542a9e3ec430d7d74f15467a261f29bcb58c0d25782e7c4dd3311185c1c12b8e", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454768, + "system_seconds": 0.33, + "user_seconds": 25.29 + }, + "wall_seconds": 25.734568614978343 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json new file mode 100644 index 0000000000..df2123fa3f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/scientific-receipt.json @@ -0,0 +1,560 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [ + "guards" + ], + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + } + }, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.014002213000000041, + "wall_seconds": 0.013999465969391167 + }, + "unchanged_python": { + "cpu_seconds": 0.16115248299999996, + "wall_seconds": 0.16121150797698647 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "guards", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.270472, + "wall_seconds": 1.2718698700191453 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.10191300000000014, + "wall_seconds": 0.10191201098496094 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 0.00010500000000002174, + "wall_seconds": 0.00010378699516877532 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005688000000000137, + "wall_seconds": 0.005688156990800053 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21930099999999997, + "wall_seconds": 0.21916811005212367 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.00727499999999992, + "wall_seconds": 0.007272974005900323 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00441699999999999, + "wall_seconds": 0.0044162150006741285 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004801000000000055, + "wall_seconds": 0.004798976995516568 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4238279999999994, + "wall_seconds": 0.4238570319721475 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 21.874031, + "wall_seconds": 21.881579643988516 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.002347999999999996, + "wall_seconds": 0.002345570013858378 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0016490000000000116, + "wall_seconds": 0.0016535030445083976 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.007052999999999997, + "wall_seconds": 0.007049628009553999 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.00044899999999969964, + "wall_seconds": 0.00044748198706656694 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1704319999999981, + "wall_seconds": 1.1734563789796084 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007053999999999998, + "wall_seconds": 0.007052111031953245 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.01691400000000004, + "wall_seconds": 0.016910238016862422 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.10189700000000013, + "wall_seconds": 0.10189274203730747 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.000150999999998902, + "wall_seconds": 0.00015197601169347763 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0019759999999990896, + "wall_seconds": 0.0019768960191868246 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 5.3730327636003494e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 5.210982635617256e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.026961, + "wall_seconds": 2.027301778027322 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 12.793493, + "wall_seconds": 12.799088458006736 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.427784, + "wall_seconds": 5.429211599985138 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.1716599999999957, + "wall_seconds": 1.1717996229999699 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 25.227052999999998, + "process_wall_seconds_before_receipt": 25.22017758298898, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P2-C/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/stdout.txt new file mode 100644 index 0000000000..7145328725 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 25.227052999999998, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.270472, "wall_seconds": 1.2718698700191453}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.10191300000000014, "wall_seconds": 0.10191201098496094}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 0.00010500000000002174, "wall_seconds": 0.00010378699516877532}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.005688000000000137, "wall_seconds": 0.005688156990800053}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21930099999999997, "wall_seconds": 0.21916811005212367}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.00727499999999992, "wall_seconds": 0.007272974005900323}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.00441699999999999, "wall_seconds": 0.0044162150006741285}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.004801000000000055, "wall_seconds": 0.004798976995516568}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4238279999999994, "wall_seconds": 0.4238570319721475}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 21.874031, "wall_seconds": 21.881579643988516}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.002347999999999996, "wall_seconds": 0.002345570013858378}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0016490000000000116, "wall_seconds": 0.0016535030445083976}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.007052999999999997, "wall_seconds": 0.007049628009553999}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.00044899999999969964, "wall_seconds": 0.00044748198706656694}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1704319999999981, "wall_seconds": 1.1734563789796084}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007053999999999998, "wall_seconds": 0.007052111031953245}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.01691400000000004, "wall_seconds": 0.016910238016862422}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.10189700000000013, "wall_seconds": 0.10189274203730747}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.000150999999998902, "wall_seconds": 0.00015197601169347763}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0019759999999990896, "wall_seconds": 0.0019768960191868246}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 5.3730327636003494e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 5.210982635617256e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.026961, "wall_seconds": 2.027301778027322}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 12.793493, "wall_seconds": 12.799088458006736}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.427784, "wall_seconds": 5.429211599985138}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.1716599999999957, "wall_seconds": 1.1717996229999699}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 25.22017758298898} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P2-C/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/usage.json new file mode 100644 index 0000000000..cbe06856c0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P2-C/usage.json @@ -0,0 +1 @@ +{"user_seconds":25.29,"system_seconds":0.33,"kernel_max_rss_kib":454768,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/START.json new file mode 100644 index 0000000000..f3f8f4da0f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P3-B", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 61.538648616930004, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json new file mode 100644 index 0000000000..8a5fbd51d8 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "pilot-P3-B", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 440586240, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 61.538648616930004, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4500, + "stdout_sha256": "d04f1289c66f2680f84d4c2e0bc0aff0e956f55604a562b01297944f981be11b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454792, + "system_seconds": 0.34, + "user_seconds": 26.67 + }, + "wall_seconds": 27.07822590402793 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json new file mode 100644 index 0000000000..439b1861df --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.020013917999999964, + "wall_seconds": 0.0200116679770872 + }, + "unchanged_python": { + "cpu_seconds": 0.13928151899999996, + "wall_seconds": 0.1396669250098057 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.2318000000000002, + "wall_seconds": 1.2321837699855678 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 5.3399708122015e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.200000000029405e-05, + "wall_seconds": 7.154804188758135e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004547000000000079, + "wall_seconds": 0.0045483389985747635 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.19775600000000002, + "wall_seconds": 0.19752026197966188 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.007776999999999923, + "wall_seconds": 0.0077735259546898305 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.007873000000000005, + "wall_seconds": 0.007870982983149588 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003161999999999887, + "wall_seconds": 0.0031613389728590846 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.40226200000000034, + "wall_seconds": 0.40267902601044625 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 23.408355999999998, + "wall_seconds": 23.417632811993826 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0018470000000000153, + "wall_seconds": 0.0021213270374573767 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011489999999999972, + "wall_seconds": 0.0011480019893497229 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005273, + "wall_seconds": 0.00527150696143508 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004460000000001685, + "wall_seconds": 0.0004443430225364864 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2101420000000012, + "wall_seconds": 1.2132013700320385 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007068999999999999, + "wall_seconds": 0.007068531995173544 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 9.000000000036756e-06, + "wall_seconds": 8.811999578028917e-06 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00013800000000330215, + "wall_seconds": 0.00014003401156514883 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002085999999998478, + "wall_seconds": 0.0020854879985563457 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 9.000000000147779e-06, + "wall_seconds": 8.871022146195173e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 3.999999999892978e-06, + "wall_seconds": 4.147994332015514e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.867625, + "wall_seconds": 1.868964581983164 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.447283000000002, + "wall_seconds": 14.452809199981857 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.453989999999999, + "wall_seconds": 5.455464276019484 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.2089329999999947, + "wall_seconds": 1.2094359250040725 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 26.629517999999997, + "process_wall_seconds_before_receipt": 26.620011746010277, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-B/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/stdout.txt new file mode 100644 index 0000000000..a48e775061 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 26.629517999999997, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2318000000000002, "wall_seconds": 1.2321837699855678}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 5.3399708122015e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.200000000029405e-05, "wall_seconds": 7.154804188758135e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004547000000000079, "wall_seconds": 0.0045483389985747635}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.19775600000000002, "wall_seconds": 0.19752026197966188}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.007776999999999923, "wall_seconds": 0.0077735259546898305}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.007873000000000005, "wall_seconds": 0.007870982983149588}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003161999999999887, "wall_seconds": 0.0031613389728590846}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.40226200000000034, "wall_seconds": 0.40267902601044625}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 23.408355999999998, "wall_seconds": 23.417632811993826}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0018470000000000153, "wall_seconds": 0.0021213270374573767}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011489999999999972, "wall_seconds": 0.0011480019893497229}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005273, "wall_seconds": 0.00527150696143508}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004460000000001685, "wall_seconds": 0.0004443430225364864}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2101420000000012, "wall_seconds": 1.2132013700320385}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007068999999999999, "wall_seconds": 0.007068531995173544}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 9.000000000036756e-06, "wall_seconds": 8.811999578028917e-06}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00013800000000330215, "wall_seconds": 0.00014003401156514883}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002085999999998478, "wall_seconds": 0.0020854879985563457}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 9.000000000147779e-06, "wall_seconds": 8.871022146195173e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 3.999999999892978e-06, "wall_seconds": 4.147994332015514e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.867625, "wall_seconds": 1.868964581983164}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.447283000000002, "wall_seconds": 14.452809199981857}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.453989999999999, "wall_seconds": 5.455464276019484}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.2089329999999947, "wall_seconds": 1.2094359250040725}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 26.620011746010277} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-B/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/usage.json new file mode 100644 index 0000000000..a38877958a --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-B/usage.json @@ -0,0 +1 @@ +{"user_seconds":26.67,"system_seconds":0.34,"kernel_max_rss_kib":454792,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/START.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/START.json new file mode 100644 index 0000000000..d8f02a559b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science", + "--lanes", + "trace" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-trace", + "label": "pilot-P3-C", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 88.61687452095794, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json new file mode 100644 index 0000000000..70bb086d36 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science", + "--lanes", + "trace" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-trace", + "label": "pilot-P3-C", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 456237056, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 88.61687452095794, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4857, + "stdout_sha256": "e270d9bf87b21bef57fb0346e073008b5bbc398071e58a4d616f1a875a0e3e89", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454588, + "system_seconds": 0.33, + "user_seconds": 24.65 + }, + "wall_seconds": 25.069680297980085 +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json new file mode 100644 index 0000000000..3c52a51bcc --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/scientific-receipt.json @@ -0,0 +1,581 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v2/priorities/trace-encoding/trace_encoder.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/trace-cold-build/_trace_encoding.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "3ffd86da783901651f5d9df7cee29644959b5ad82573b47d9ec92c8d98be3eee", + "no_cached_binary": true, + "returncode": 0, + "source_sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "stderr": "", + "stdout": "" + }, + "lanes": [ + "trace" + ], + "new_controls": { + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.01979268200000006, + "wall_seconds": 0.019789941958151758 + }, + "unchanged_python": { + "cpu_seconds": 0.133233571, + "wall_seconds": 0.13340389297809452 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "trace", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "e9dba9c23f9048ec9c563bcc6e1eac5d132d649c1e7c521b114339f1ba4d3639" + }, + "PLAN.md": { + "mode": 292, + "sha256": "0dc18b28a9016b7544a46b8983ff7a8ab969762be412916d60eb12ee1112d0c5" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.262946, + "wall_seconds": 1.2632501370389946 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.02495499999999984, + "wall_seconds": 0.024954689026344568 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 6.600000000034356e-05, + "wall_seconds": 6.56010233797133e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005675000000000097, + "wall_seconds": 0.005675307009369135 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.229019, + "wall_seconds": 0.22874344000592828 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.008922000000000097, + "wall_seconds": 0.00892044504871592 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.006607000000000002, + "wall_seconds": 0.006606039998587221 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005373000000000072, + "wall_seconds": 0.005369489022996277 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.47768999999999995, + "wall_seconds": 0.47776355099631473 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 21.008093999999996, + "wall_seconds": 21.013503061956726 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.002147999999999997, + "wall_seconds": 0.002146349987015128 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.001119999999999996, + "wall_seconds": 0.0011188689968548715 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005593000000000001, + "wall_seconds": 0.009792471013497561 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.00046299999999632746, + "wall_seconds": 0.0004624199937097728 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.26952, + "wall_seconds": 1.270267440006137 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007493000000000007, + "wall_seconds": 0.00749262300087139 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.18979499999999994, + "wall_seconds": 0.18966919102240354 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.01587000000000005, + "wall_seconds": 0.015867507958319038 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.00906600000000024, + "wall_seconds": 0.009063894976861775 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00015699999999796432, + "wall_seconds": 0.00015842303400859237 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0020530000000000825, + "wall_seconds": 0.002052325988188386 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 4.000000000115023e-06, + "wall_seconds": 4.531990271061659e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 5.999999999950489e-06, + "wall_seconds": 6.493995897471905e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.905377, + "wall_seconds": 1.9056295490008779 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.18431399999999998, + "wall_seconds": 0.18418926000595093 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 11.951772999999998, + "wall_seconds": 11.955834418011364 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.52508, + "wall_seconds": 5.525827331002802 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.115952, + "wall_seconds": 1.1162088990095071 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 24.59932, + "process_wall_seconds_before_receipt": 24.582813735993113, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/pilot-P3-C/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/stderr.txt b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/stdout.txt b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/stdout.txt new file mode 100644 index 0000000000..a94384e2ce --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 24.59932, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.262946, "wall_seconds": 1.2632501370389946}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.02495499999999984, "wall_seconds": 0.024954689026344568}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 6.600000000034356e-05, "wall_seconds": 6.56010233797133e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.005675000000000097, "wall_seconds": 0.005675307009369135}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.229019, "wall_seconds": 0.22874344000592828}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.008922000000000097, "wall_seconds": 0.00892044504871592}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.006607000000000002, "wall_seconds": 0.006606039998587221}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.005373000000000072, "wall_seconds": 0.005369489022996277}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.47768999999999995, "wall_seconds": 0.47776355099631473}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 21.008093999999996, "wall_seconds": 21.013503061956726}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.002147999999999997, "wall_seconds": 0.002146349987015128}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.001119999999999996, "wall_seconds": 0.0011188689968548715}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005593000000000001, "wall_seconds": 0.009792471013497561}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.00046299999999632746, "wall_seconds": 0.0004624199937097728}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.26952, "wall_seconds": 1.270267440006137}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007493000000000007, "wall_seconds": 0.00749262300087139}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.18979499999999994, "wall_seconds": 0.18966919102240354}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.01587000000000005, "wall_seconds": 0.015867507958319038}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.00906600000000024, "wall_seconds": 0.009063894976861775}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00015699999999796432, "wall_seconds": 0.00015842303400859237}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0020530000000000825, "wall_seconds": 0.002052325988188386}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 4.000000000115023e-06, "wall_seconds": 4.531990271061659e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.999999999950489e-06, "wall_seconds": 6.493995897471905e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.905377, "wall_seconds": 1.9056295490008779}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.18431399999999998, "wall_seconds": 0.18418926000595093}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 11.951772999999998, "wall_seconds": 11.955834418011364}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.52508, "wall_seconds": 5.525827331002802}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.115952, "wall_seconds": 1.1162088990095071}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 24.582813735993113} diff --git a/research/h25-bookkeeping/evidence/runs/pilot-P3-C/usage.json b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/usage.json new file mode 100644 index 0000000000..7d4f4c5e29 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/pilot-P3-C/usage.json @@ -0,0 +1 @@ +{"user_seconds":24.65,"system_seconds":0.33,"kernel_max_rss_kib":454588,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/START.json b/research/h25-bookkeeping/evidence/runs/qual-B1/START.json new file mode 100644 index 0000000000..79d454da7c --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B1/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 182.9798714609351, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json new file mode 100644 index 0000000000..40e189e4ea --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B1/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 408956928, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 182.9798714609351, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4460, + "stdout_sha256": "bca8ab8b35591f3c6204751ecf41f430ea81e91a2eea37767a8731f8e81a1517", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454704, + "system_seconds": 0.31, + "user_seconds": 26.78 + }, + "wall_seconds": 27.16858759697061 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json new file mode 100644 index 0000000000..e9a595d870 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B1/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.02165867399999999, + "wall_seconds": 0.021655989054124802 + }, + "unchanged_python": { + "cpu_seconds": 0.15575600600000006, + "wall_seconds": 0.1557540509966202 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.337621, + "wall_seconds": 1.3380101769580506 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 4.139961674809456e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 6.4000000000064e-05, + "wall_seconds": 6.264302646741271e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004201000000000121, + "wall_seconds": 0.004201199975796044 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21715399999999999, + "wall_seconds": 0.22601343895075843 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.007606000000000002, + "wall_seconds": 0.007603727979585528 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.007063, + "wall_seconds": 0.007062011049129069 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003265999999999991, + "wall_seconds": 0.0032641099533066154 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.3916780000000002, + "wall_seconds": 0.39185234799515456 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 23.298188, + "wall_seconds": 23.303970993030816 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0024079999999999935, + "wall_seconds": 0.002405785024166107 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0016439999999999927, + "wall_seconds": 0.001642318966332823 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.007730000000000001, + "wall_seconds": 0.007728606986347586 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004120000000007451, + "wall_seconds": 0.00041179003892466426 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2339860000000016, + "wall_seconds": 1.2368798080133274 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.009061000000000007, + "wall_seconds": 0.009058113966602832 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 1.1000000000038757e-05, + "wall_seconds": 1.0552990715950727e-05 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.000128000000000128, + "wall_seconds": 0.00013148196740075946 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0019830000000027326, + "wall_seconds": 0.001981898967642337 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 5.999999999950489e-06, + "wall_seconds": 6.137997843325138e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 4.999999999810711e-06, + "wall_seconds": 5.359994247555733e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.850051, + "wall_seconds": 1.8501074989908375 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.452268000000002, + "wall_seconds": 14.456829616974574 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.333269, + "wall_seconds": 5.334219664975535 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.242602999999999, + "wall_seconds": 1.2426257859915495 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 26.720916, + "process_wall_seconds_before_receipt": 26.716538757958915, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B1/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-B1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-B1/stdout.txt new file mode 100644 index 0000000000..5252aa349a --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B1/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 26.720916, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.337621, "wall_seconds": 1.3380101769580506}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 4.139961674809456e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 6.4000000000064e-05, "wall_seconds": 6.264302646741271e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004201000000000121, "wall_seconds": 0.004201199975796044}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21715399999999999, "wall_seconds": 0.22601343895075843}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.007606000000000002, "wall_seconds": 0.007603727979585528}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.007063, "wall_seconds": 0.007062011049129069}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003265999999999991, "wall_seconds": 0.0032641099533066154}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.3916780000000002, "wall_seconds": 0.39185234799515456}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 23.298188, "wall_seconds": 23.303970993030816}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0024079999999999935, "wall_seconds": 0.002405785024166107}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0016439999999999927, "wall_seconds": 0.001642318966332823}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.007730000000000001, "wall_seconds": 0.007728606986347586}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004120000000007451, "wall_seconds": 0.00041179003892466426}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2339860000000016, "wall_seconds": 1.2368798080133274}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.009061000000000007, "wall_seconds": 0.009058113966602832}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 1.1000000000038757e-05, "wall_seconds": 1.0552990715950727e-05}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.000128000000000128, "wall_seconds": 0.00013148196740075946}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0019830000000027326, "wall_seconds": 0.001981898967642337}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 5.999999999950489e-06, "wall_seconds": 6.137997843325138e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 4.999999999810711e-06, "wall_seconds": 5.359994247555733e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.850051, "wall_seconds": 1.8501074989908375}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.452268000000002, "wall_seconds": 14.456829616974574}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.333269, "wall_seconds": 5.334219664975535}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.242602999999999, "wall_seconds": 1.2426257859915495}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 26.716538757958915} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B1/usage.json b/research/h25-bookkeeping/evidence/runs/qual-B1/usage.json new file mode 100644 index 0000000000..55d06f73e3 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B1/usage.json @@ -0,0 +1 @@ +{"user_seconds":26.78,"system_seconds":0.31,"kernel_max_rss_kib":454704,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/START.json b/research/h25-bookkeeping/evidence/runs/qual-B2/START.json new file mode 100644 index 0000000000..5889a5950b --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B2/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B2", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 252.80483457492664, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json new file mode 100644 index 0000000000..04833439fb --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B2/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B2", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 408764416, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 252.80483457492664, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4486, + "stdout_sha256": "865bf7226a10c8e9904fa67bf16c329b9fb5dbb0e577bf49cb55e718a5c255a7", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454480, + "system_seconds": 0.36, + "user_seconds": 26.94 + }, + "wall_seconds": 27.378558369004168 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json new file mode 100644 index 0000000000..54609764c1 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B2/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.023338144999999866, + "wall_seconds": 0.023335231991950423 + }, + "unchanged_python": { + "cpu_seconds": 0.1411273150000001, + "wall_seconds": 0.14113610098138452 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.3584789999999998, + "wall_seconds": 1.3586771989939734 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 5.999999999950489e-06, + "wall_seconds": 5.675014108419418e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 0.00011300000000025179, + "wall_seconds": 0.00011226598871871829 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005360000000000031, + "wall_seconds": 0.005359895003493875 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.195027, + "wall_seconds": 0.1948074380052276 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.008915000000000006, + "wall_seconds": 0.008913085970561951 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004899999999999988, + "wall_seconds": 0.004899588995613158 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0043079999999999785, + "wall_seconds": 0.004305551992729306 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.5232109999999985, + "wall_seconds": 0.5286992559558712 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 23.509595, + "wall_seconds": 23.534212823025882 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001351000000000005, + "wall_seconds": 0.0013510999851860106 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011140000000000039, + "wall_seconds": 0.00111356598790735 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005319999999999991, + "wall_seconds": 0.005318289971910417 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.00047200000000202635, + "wall_seconds": 0.00047179398825392127 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2217769999999994, + "wall_seconds": 1.222272758022882 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006487, + "wall_seconds": 0.006487272039521486 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 8.999999999981245e-06, + "wall_seconds": 8.001981768757105e-06 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00015100000000245473, + "wall_seconds": 0.00015369598986580968 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0020679999999977383, + "wall_seconds": 0.002068254048936069 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 5.999999999950489e-06, + "wall_seconds": 5.749985575675964e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 4.74101398140192e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.9840760000000002, + "wall_seconds": 1.9945139790070243 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.359736000000002, + "wall_seconds": 14.366735673043877 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.346764000000003, + "wall_seconds": 5.348323938029353 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.263649000000001, + "wall_seconds": 1.2637638140004128 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 26.917156000000002, + "process_wall_seconds_before_receipt": 26.91697679000208, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B2/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-B2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-B2/stdout.txt new file mode 100644 index 0000000000..35e4da61c3 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B2/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 26.917156000000002, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.3584789999999998, "wall_seconds": 1.3586771989939734}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 5.999999999950489e-06, "wall_seconds": 5.675014108419418e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 0.00011300000000025179, "wall_seconds": 0.00011226598871871829}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.005360000000000031, "wall_seconds": 0.005359895003493875}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.195027, "wall_seconds": 0.1948074380052276}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.008915000000000006, "wall_seconds": 0.008913085970561951}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004899999999999988, "wall_seconds": 0.004899588995613158}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0043079999999999785, "wall_seconds": 0.004305551992729306}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.5232109999999985, "wall_seconds": 0.5286992559558712}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 23.509595, "wall_seconds": 23.534212823025882}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001351000000000005, "wall_seconds": 0.0013510999851860106}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011140000000000039, "wall_seconds": 0.00111356598790735}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005319999999999991, "wall_seconds": 0.005318289971910417}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.00047200000000202635, "wall_seconds": 0.00047179398825392127}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2217769999999994, "wall_seconds": 1.222272758022882}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006487, "wall_seconds": 0.006487272039521486}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 8.999999999981245e-06, "wall_seconds": 8.001981768757105e-06}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00015100000000245473, "wall_seconds": 0.00015369598986580968}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0020679999999977383, "wall_seconds": 0.002068254048936069}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 5.999999999950489e-06, "wall_seconds": 5.749985575675964e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 4.74101398140192e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.9840760000000002, "wall_seconds": 1.9945139790070243}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.359736000000002, "wall_seconds": 14.366735673043877}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.346764000000003, "wall_seconds": 5.348323938029353}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.263649000000001, "wall_seconds": 1.2637638140004128}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 26.91697679000208} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B2/usage.json b/research/h25-bookkeeping/evidence/runs/qual-B2/usage.json new file mode 100644 index 0000000000..79843296f4 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B2/usage.json @@ -0,0 +1 @@ +{"user_seconds":26.94,"system_seconds":0.36,"kernel_max_rss_kib":454480,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/START.json b/research/h25-bookkeeping/evidence/runs/qual-B3/START.json new file mode 100644 index 0000000000..f1ca98b3e7 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B3/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science", + "--lanes", + "none" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B3", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 280.1833929439308, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json new file mode 100644 index 0000000000..9ba6da6ef6 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B3/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science", + "--lanes", + "none" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-none", + "label": "qual-B3", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 450019328, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 280.1833929439308, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 4481, + "stdout_sha256": "6b709607dba67b762bbf52e0480a55b9e8d372a04110d7e5d0e51a4bade383ed", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 455044, + "system_seconds": 0.32, + "user_seconds": 26.74 + }, + "wall_seconds": 27.14340792701114 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json new file mode 100644 index 0000000000..f2b899fc56 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B3/scientific-receipt.json @@ -0,0 +1,499 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": null, + "lanes": [], + "new_controls": {}, + "original_observer_retained_for_old_controls": true + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.03392529799999999, + "wall_seconds": 0.03392305801389739 + }, + "unchanged_python": { + "cpu_seconds": 0.14929923099999998, + "wall_seconds": 0.14930192095926031 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "none", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.2501680000000002, + "wall_seconds": 1.2501766179921106 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 4.000000000115023e-06, + "wall_seconds": 4.189030732959509e-06 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 6.90000000003188e-05, + "wall_seconds": 6.821902934461832e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003962000000000243, + "wall_seconds": 0.003962911025155336 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20154099999999997, + "wall_seconds": 0.20154438901226968 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.006297999999999915, + "wall_seconds": 0.006296391016803682 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0048900000000000055, + "wall_seconds": 0.004890509007964283 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00302200000000008, + "wall_seconds": 0.0030207399977371097 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4303239999999997, + "wall_seconds": 0.4303165550227277 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 23.461115, + "wall_seconds": 23.461305815028027 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001350999999999991, + "wall_seconds": 0.0013504140079021454 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0016130000000000033, + "wall_seconds": 0.022131619974970818 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.004978999999999997, + "wall_seconds": 0.0049781459965743124 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004750000000015575, + "wall_seconds": 0.00047434604493901134 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1513120000000008, + "wall_seconds": 1.1514020310132764 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006272, + "wall_seconds": 0.006270930985920131 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 1.2000000000012001e-05, + "wall_seconds": 1.2417032849043608e-05 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00015100000000245473, + "wall_seconds": 0.0001540189841762185 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002203000000005062, + "wall_seconds": 0.002201450988650322 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 5.000000000032756e-06, + "wall_seconds": 4.5140041038393974e-06 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 4.000000000115023e-06, + "wall_seconds": 3.7259887903928757e-06 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.886127, + "wall_seconds": 1.8861802829778753 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 14.532898000000001, + "wall_seconds": 14.532945956976619 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.340949999999999, + "wall_seconds": 5.341021160013042 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.2398019999999974, + "wall_seconds": 1.239813658001367 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 26.67371, + "process_wall_seconds_before_receipt": 26.669321132998448, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-B3/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-B3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-B3/stdout.txt new file mode 100644 index 0000000000..adb72a5d0f --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B3/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 26.67371, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2501680000000002, "wall_seconds": 1.2501766179921106}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 4.000000000115023e-06, "wall_seconds": 4.189030732959509e-06}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 6.90000000003188e-05, "wall_seconds": 6.821902934461832e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.003962000000000243, "wall_seconds": 0.003962911025155336}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20154099999999997, "wall_seconds": 0.20154438901226968}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.006297999999999915, "wall_seconds": 0.006296391016803682}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.0048900000000000055, "wall_seconds": 0.004890509007964283}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.00302200000000008, "wall_seconds": 0.0030207399977371097}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4303239999999997, "wall_seconds": 0.4303165550227277}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 23.461115, "wall_seconds": 23.461305815028027}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001350999999999991, "wall_seconds": 0.0013504140079021454}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0016130000000000033, "wall_seconds": 0.022131619974970818}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.004978999999999997, "wall_seconds": 0.0049781459965743124}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004750000000015575, "wall_seconds": 0.00047434604493901134}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1513120000000008, "wall_seconds": 1.1514020310132764}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006272, "wall_seconds": 0.006270930985920131}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 1.2000000000012001e-05, "wall_seconds": 1.2417032849043608e-05}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00015100000000245473, "wall_seconds": 0.0001540189841762185}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002203000000005062, "wall_seconds": 0.002201450988650322}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 5.000000000032756e-06, "wall_seconds": 4.5140041038393974e-06}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 4.000000000115023e-06, "wall_seconds": 3.7259887903928757e-06}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.886127, "wall_seconds": 1.8861802829778753}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 14.532898000000001, "wall_seconds": 14.532945956976619}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.340949999999999, "wall_seconds": 5.341021160013042}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.2398019999999974, "wall_seconds": 1.239813658001367}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 26.669321132998448} diff --git a/research/h25-bookkeeping/evidence/runs/qual-B3/usage.json b/research/h25-bookkeeping/evidence/runs/qual-B3/usage.json new file mode 100644 index 0000000000..e0e06eaf82 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-B3/usage.json @@ -0,0 +1 @@ +{"user_seconds":26.74,"system_seconds":0.32,"kernel_max_rss_kib":455044,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/START.json b/research/h25-bookkeeping/evidence/runs/qual-C1/START.json new file mode 100644 index 0000000000..12c9574d6e --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C1/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science", + "--lanes", + "all" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C1", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 210.1484590579057, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json new file mode 100644 index 0000000000..0bd237fc06 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C1/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science", + "--lanes", + "all" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C1", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 435585024, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 210.1484590579057, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5150, + "stdout_sha256": "f4a724dc92d23ad1ee261f51e6b6eaa7b0d0b2df130ea8ac42f26868600c030d", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 455412, + "system_seconds": 0.33, + "user_seconds": 21.09 + }, + "wall_seconds": 21.477875709999353 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json new file mode 100644 index 0000000000..23f2e7a629 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C1/scientific-receipt.json @@ -0,0 +1,841 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/priorities/trace-encoding/trace_encoder.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/trace-cold-build/_trace_encoding.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "c5cd3802f3b72522e6af1f3bf6d0ae0485c523649074179d07821377396dadc9", + "no_cached_binary": true, + "returncode": 0, + "source_sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "stderr": "", + "stdout": "" + }, + "lanes": [ + "guards", + "sets", + "trace" + ], + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + }, + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "source_pin_policy_cases": [ + { + "digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "outcome": "recognized" + }, + { + "digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "outcome": "recognized" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "StringSubclass", + "outcome": "rejected" + } + ], + "status": "P1_FINITE_SET_CONTROLS_PASS" + }, + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "original_observer_retained_for_old_controls": true, + "set_reuse": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "fraction_source_profile": "recorded-local-cpython-3.12.3", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + } + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.01610692300000005, + "wall_seconds": 0.016104165988508612 + }, + "unchanged_python": { + "cpu_seconds": 0.154959065, + "wall_seconds": 0.1550776790245436 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "all", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.252446, + "wall_seconds": 1.2579121100134216 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.766786, + "wall_seconds": 0.7669961669598706 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 9.19999999995369e-05, + "wall_seconds": 9.025901090353727e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004568999999999601, + "wall_seconds": 0.004569232987705618 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21056199999999997, + "wall_seconds": 0.21066047495696694 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.0069870000000000765, + "wall_seconds": 0.006985037005506456 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005658999999999997, + "wall_seconds": 0.005658599024172872 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0035080000000000666, + "wall_seconds": 0.0035057449713349342 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4409030000000005, + "wall_seconds": 0.441194674000144 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 16.763014, + "wall_seconds": 16.773728871019557 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0019780000000000075, + "wall_seconds": 0.001977614010684192 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0011150000000000049, + "wall_seconds": 0.0011141870054416358 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005072000000000007, + "wall_seconds": 0.00507091503823176 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0006449999999986744, + "wall_seconds": 0.0006441230070777237 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1744839999999996, + "wall_seconds": 1.1744856049772352 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0075879999999999975, + "wall_seconds": 0.007593463989906013 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.20031500000000008, + "wall_seconds": 0.20013855898287147 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.10602200000000006, + "wall_seconds": 0.10605262505123392 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6319999999999999, + "wall_seconds": 0.6321715770172887 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.016398000000000135, + "wall_seconds": 0.01639481703750789 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.012319999999999887, + "wall_seconds": 0.012318552995566279 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00014799999999937086, + "wall_seconds": 0.0001501900260336697 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002171000000000589, + "wall_seconds": 0.002171581028960645 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 0.022978000000000165, + "wall_seconds": 0.022974761959630996 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 7.00000000000145e-05, + "wall_seconds": 7.054803427308798e-05 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.0059400000000007, + "wall_seconds": 2.006828175042756 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.17236200000000007, + "wall_seconds": 0.17218814697116613 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 10.476424000000002, + "wall_seconds": 10.4769893969642 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 2.5915869999999996, + "wall_seconds": 2.6005497979931533 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.2080249999999992, + "wall_seconds": 1.2080158410244621 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 21.010048, + "process_wall_seconds_before_receipt": 21.019202177005354, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C1/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-C1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-C1/stdout.txt new file mode 100644 index 0000000000..e58bf524af --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C1/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 21.010048, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.252446, "wall_seconds": 1.2579121100134216}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.766786, "wall_seconds": 0.7669961669598706}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 9.19999999995369e-05, "wall_seconds": 9.025901090353727e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004568999999999601, "wall_seconds": 0.004569232987705618}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21056199999999997, "wall_seconds": 0.21066047495696694}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.0069870000000000765, "wall_seconds": 0.006985037005506456}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.005658999999999997, "wall_seconds": 0.005658599024172872}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0035080000000000666, "wall_seconds": 0.0035057449713349342}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4409030000000005, "wall_seconds": 0.441194674000144}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 16.763014, "wall_seconds": 16.773728871019557}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0019780000000000075, "wall_seconds": 0.001977614010684192}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0011150000000000049, "wall_seconds": 0.0011141870054416358}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005072000000000007, "wall_seconds": 0.00507091503823176}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0006449999999986744, "wall_seconds": 0.0006441230070777237}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1744839999999996, "wall_seconds": 1.1744856049772352}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.0075879999999999975, "wall_seconds": 0.007593463989906013}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.20031500000000008, "wall_seconds": 0.20013855898287147}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.10602200000000006, "wall_seconds": 0.10605262505123392}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6319999999999999, "wall_seconds": 0.6321715770172887}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.016398000000000135, "wall_seconds": 0.01639481703750789}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.012319999999999887, "wall_seconds": 0.012318552995566279}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00014799999999937086, "wall_seconds": 0.0001501900260336697}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002171000000000589, "wall_seconds": 0.002171581028960645}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 0.022978000000000165, "wall_seconds": 0.022974761959630996}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 7.00000000000145e-05, "wall_seconds": 7.054803427308798e-05}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.0059400000000007, "wall_seconds": 2.006828175042756}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.17236200000000007, "wall_seconds": 0.17218814697116613}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 10.476424000000002, "wall_seconds": 10.4769893969642}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 2.5915869999999996, "wall_seconds": 2.6005497979931533}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.2080249999999992, "wall_seconds": 1.2080158410244621}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 21.019202177005354} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C1/usage.json b/research/h25-bookkeeping/evidence/runs/qual-C1/usage.json new file mode 100644 index 0000000000..f91b51b498 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C1/usage.json @@ -0,0 +1 @@ +{"user_seconds":21.09,"system_seconds":0.33,"kernel_max_rss_kib":455412,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/START.json b/research/h25-bookkeeping/evidence/runs/qual-C2/START.json new file mode 100644 index 0000000000..616a52c7b2 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C2/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science", + "--lanes", + "all" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C2", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 231.62633476790506, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json new file mode 100644 index 0000000000..210ba6c969 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C2/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science", + "--lanes", + "all" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C2", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 447225856, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 231.62633476790506, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5166, + "stdout_sha256": "476620742ff72624caea3b8bf075f65f72e404ea28f986a29d680360d590c269", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 455132, + "system_seconds": 0.34, + "user_seconds": 20.79 + }, + "wall_seconds": 21.17849980702158 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json new file mode 100644 index 0000000000..8b79697f18 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C2/scientific-receipt.json @@ -0,0 +1,841 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/priorities/trace-encoding/trace_encoder.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/trace-cold-build/_trace_encoding.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "c5cd3802f3b72522e6af1f3bf6d0ae0485c523649074179d07821377396dadc9", + "no_cached_binary": true, + "returncode": 0, + "source_sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "stderr": "", + "stdout": "" + }, + "lanes": [ + "guards", + "sets", + "trace" + ], + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + }, + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "source_pin_policy_cases": [ + { + "digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "outcome": "recognized" + }, + { + "digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "outcome": "recognized" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "StringSubclass", + "outcome": "rejected" + } + ], + "status": "P1_FINITE_SET_CONTROLS_PASS" + }, + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "original_observer_retained_for_old_controls": true, + "set_reuse": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "fraction_source_profile": "recorded-local-cpython-3.12.3", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + } + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.017030625999999938, + "wall_seconds": 0.017027736001182348 + }, + "unchanged_python": { + "cpu_seconds": 0.17410596599999995, + "wall_seconds": 0.17424083303194493 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "all", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.3561389999999998, + "wall_seconds": 1.3579570070141926 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.7855400000000001, + "wall_seconds": 0.7855396519880742 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.800000000024454e-05, + "wall_seconds": 7.82220158725977e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00447099999999967, + "wall_seconds": 0.004470780026167631 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.19983700000000001, + "wall_seconds": 0.21070887095993385 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.012032999999999738, + "wall_seconds": 0.012031060992740095 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004890999999999993, + "wall_seconds": 0.004890652024187148 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003439000000000192, + "wall_seconds": 0.003446325019467622 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4556510000000005, + "wall_seconds": 0.4557240440044552 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 16.340914000000005, + "wall_seconds": 16.347088259994052 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001478000000000007, + "wall_seconds": 0.0014776079915463924 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0012500000000000011, + "wall_seconds": 0.001249050023034215 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005154999999999993, + "wall_seconds": 0.005152982019353658 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.00044899999999969964, + "wall_seconds": 0.0004481340292841196 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.191942000000001, + "wall_seconds": 1.1942859969567508 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006434999999999996, + "wall_seconds": 0.0064337109797634184 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.21439199999999997, + "wall_seconds": 0.21426571399206296 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.09486900000000009, + "wall_seconds": 0.09486497298348695 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.6642040000000002, + "wall_seconds": 0.6642028780188411 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.014911000000000119, + "wall_seconds": 0.01490613998612389 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.011502000000000123, + "wall_seconds": 0.011499899963382632 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00015500000000301384, + "wall_seconds": 0.0001571719767525792 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002061999999998676, + "wall_seconds": 0.002061298000626266 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 0.026181000000000232, + "wall_seconds": 0.026178396015893668 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 5.9000000000253294e-05, + "wall_seconds": 5.779101047664881e-05 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.8258319999999997, + "wall_seconds": 1.82696237397613 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.186732, + "wall_seconds": 0.1866085110232234 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 10.282083000000004, + "wall_seconds": 10.286123291996773 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 2.4379680000000006, + "wall_seconds": 2.4385724759777077 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.3073569999999997, + "wall_seconds": 1.3076567529933527 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 20.771774, + "process_wall_seconds_before_receipt": 20.76834416599013, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C2/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-C2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-C2/stdout.txt new file mode 100644 index 0000000000..4f884c3344 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C2/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 20.771774, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.3561389999999998, "wall_seconds": 1.3579570070141926}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.7855400000000001, "wall_seconds": 0.7855396519880742}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.800000000024454e-05, "wall_seconds": 7.82220158725977e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.00447099999999967, "wall_seconds": 0.004470780026167631}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.19983700000000001, "wall_seconds": 0.21070887095993385}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.012032999999999738, "wall_seconds": 0.012031060992740095}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.004890999999999993, "wall_seconds": 0.004890652024187148}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003439000000000192, "wall_seconds": 0.003446325019467622}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4556510000000005, "wall_seconds": 0.4557240440044552}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 16.340914000000005, "wall_seconds": 16.347088259994052}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001478000000000007, "wall_seconds": 0.0014776079915463924}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0012500000000000011, "wall_seconds": 0.001249050023034215}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005154999999999993, "wall_seconds": 0.005152982019353658}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.00044899999999969964, "wall_seconds": 0.0004481340292841196}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.191942000000001, "wall_seconds": 1.1942859969567508}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006434999999999996, "wall_seconds": 0.0064337109797634184}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.21439199999999997, "wall_seconds": 0.21426571399206296}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.09486900000000009, "wall_seconds": 0.09486497298348695}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.6642040000000002, "wall_seconds": 0.6642028780188411}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.014911000000000119, "wall_seconds": 0.01490613998612389}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.011502000000000123, "wall_seconds": 0.011499899963382632}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00015500000000301384, "wall_seconds": 0.0001571719767525792}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002061999999998676, "wall_seconds": 0.002061298000626266}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 0.026181000000000232, "wall_seconds": 0.026178396015893668}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.9000000000253294e-05, "wall_seconds": 5.779101047664881e-05}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.8258319999999997, "wall_seconds": 1.82696237397613}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.186732, "wall_seconds": 0.1866085110232234}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 10.282083000000004, "wall_seconds": 10.286123291996773}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 2.4379680000000006, "wall_seconds": 2.4385724759777077}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.3073569999999997, "wall_seconds": 1.3076567529933527}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 20.76834416599013} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C2/usage.json b/research/h25-bookkeeping/evidence/runs/qual-C2/usage.json new file mode 100644 index 0000000000..07cd194349 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C2/usage.json @@ -0,0 +1 @@ +{"user_seconds":20.79,"system_seconds":0.34,"kernel_max_rss_kib":455132,"exit":0} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/START.json b/research/h25-bookkeeping/evidence/runs/qual-C3/START.json new file mode 100644 index 0000000000..266418c2fd --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C3/START.json @@ -0,0 +1,19 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science", + "--lanes", + "all" + ], + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C3", + "phase_cap_seconds": 600, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "spent_before_seconds": 307.32680087094195, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json new file mode 100644 index 0000000000..d6b8457722 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C3/receipt.json @@ -0,0 +1,37 @@ +{ + "budget_phase_sha256": "47a2923d9ae996d6b5162f685c02c30722689d8c929ce769df9e5e3572217bad", + "command": [ + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/integration/full_driver.py", + "--output", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science", + "--lanes", + "all" + ], + "exit": 0, + "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "job": "full-all", + "label": "qual-C3", + "phase_cap_seconds": 600, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "sampled_process_group_rss_bytes": 409182208, + "source_bytes_and_modes_unchanged": true, + "spent_before_seconds": 307.32680087094195, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 5135, + "stdout_sha256": "86ff5045c99f0f0a2ee34119ab5d0eeb86b59249140be8158dfb21c02bda4b19", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 454940, + "system_seconds": 0.37, + "user_seconds": 22.9 + }, + "wall_seconds": 24.77310694300104 +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json b/research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json new file mode 100644 index 0000000000..55cd5b57d0 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C3/scientific-receipt.json @@ -0,0 +1,841 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bookkeeping": { + "encoder_build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/stages/v4/priorities/trace-encoding/trace_encoder.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/trace-cold-build/_trace_encoding.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "c5cd3802f3b72522e6af1f3bf6d0ae0485c523649074179d07821377396dadc9", + "no_cached_binary": true, + "returncode": 0, + "source_sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "stderr": "", + "stdout": "" + }, + "lanes": [ + "guards", + "sets", + "trace" + ], + "new_controls": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + }, + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "source_pin_policy_cases": [ + { + "digest": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "outcome": "recognized" + }, + { + "digest": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "outcome": "recognized" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "str", + "outcome": "rejected" + }, + { + "input_type": "StringSubclass", + "outcome": "rejected" + } + ], + "status": "P1_FINITE_SET_CONTROLS_PASS" + }, + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "original_observer_retained_for_old_controls": true, + "set_reuse": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "fraction_source_profile": "recorded-local-cpython-3.12.3", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + } + }, + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/compiler-tmp", + "driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.02393069399999992, + "wall_seconds": 0.023994378047063947 + }, + "unchanged_python": { + "cpu_seconds": 0.21553247600000014, + "wall_seconds": 0.21875503502087668 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "lanes": "all", + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5995, + "new_source_custody": { + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + } + }, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.8772820000000001, + "wall_seconds": 2.514427608984988 + }, + "all_new_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.9268149999999999, + "wall_seconds": 0.9411304869572632 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 0.00010700000000074539, + "wall_seconds": 0.00010770797962322831 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0040640000000000676, + "wall_seconds": 0.004064548993483186 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21219100000000002, + "wall_seconds": 0.2130317940027453 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.006280999999999981, + "wall_seconds": 0.006279110966715962 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0056739999999999985, + "wall_seconds": 0.005672465020325035 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003934000000000104, + "wall_seconds": 0.003932172025088221 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.6892349999999992, + "wall_seconds": 1.0522296210401691 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 17.737040999999998, + "wall_seconds": 18.334613448008895 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.001349000000000003, + "wall_seconds": 0.0013477570028044283 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0013989999999999975, + "wall_seconds": 0.0013983839889988303 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.006952, + "wall_seconds": 0.028437900997232646 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.000506999999998925, + "wall_seconds": 0.0005064879660494626 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1872550000000004, + "wall_seconds": 1.187409393955022 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006641000000000001, + "wall_seconds": 0.006640066974796355 + }, + "new_adapter_preparation": { + "calls": 1, + "cpu_seconds_with_children": 0.299198, + "wall_seconds": 0.4270384940318763 + }, + "new_guard_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.17821199999999982, + "wall_seconds": 0.17861083196476102 + }, + "new_private_set_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.7062360000000001, + "wall_seconds": 0.7198600989650004 + }, + "new_trace_entry_freshness_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.025257000000000307, + "wall_seconds": 0.02525285299634561 + }, + "new_trace_original_differential_controls": { + "calls": 1, + "cpu_seconds_with_children": 0.017062000000000133, + "wall_seconds": 0.017343307030387223 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00021499999999718966, + "wall_seconds": 0.00021740497322753072 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002124000000002013, + "wall_seconds": 0.0021316889906302094 + }, + "private_set_adapter_installation": { + "calls": 1, + "cpu_seconds_with_children": 0.019987999999999673, + "wall_seconds": 0.01998300402192399 + }, + "private_set_lease_sealing": { + "calls": 1, + "cpu_seconds_with_children": 5.100000000002325e-05, + "wall_seconds": 5.067099118605256e-05 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.1028730000000007, + "wall_seconds": 2.176472573017236 + }, + "trace_cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.257851, + "wall_seconds": 0.3387994390213862 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 10.512439, + "wall_seconds": 10.514725325978361 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 3.1972050000000003, + "wall_seconds": 3.355586013989523 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.1927699999999994, + "wall_seconds": 1.1929622900206596 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 22.89319, + "process_wall_seconds_before_receipt": 24.272685058007482, + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/runs/qual-C3/science/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/stderr.txt b/research/h25-bookkeeping/evidence/runs/qual-C3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/stdout.txt b/research/h25-bookkeeping/evidence/runs/qual-C3/stdout.txt new file mode 100644 index 0000000000..07585fa0c6 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C3/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 22.89319, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.8772820000000001, "wall_seconds": 2.514427608984988}, "all_new_controls": {"calls": 1, "cpu_seconds_with_children": 0.9268149999999999, "wall_seconds": 0.9411304869572632}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 0.00010700000000074539, "wall_seconds": 0.00010770797962322831}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.0040640000000000676, "wall_seconds": 0.004064548993483186}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21219100000000002, "wall_seconds": 0.2130317940027453}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.006280999999999981, "wall_seconds": 0.006279110966715962}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.0056739999999999985, "wall_seconds": 0.005672465020325035}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003934000000000104, "wall_seconds": 0.003932172025088221}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.6892349999999992, "wall_seconds": 1.0522296210401691}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 17.737040999999998, "wall_seconds": 18.334613448008895}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.001349000000000003, "wall_seconds": 0.0013477570028044283}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0013989999999999975, "wall_seconds": 0.0013983839889988303}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.006952, "wall_seconds": 0.028437900997232646}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.000506999999998925, "wall_seconds": 0.0005064879660494626}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1872550000000004, "wall_seconds": 1.187409393955022}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006641000000000001, "wall_seconds": 0.006640066974796355}, "new_adapter_preparation": {"calls": 1, "cpu_seconds_with_children": 0.299198, "wall_seconds": 0.4270384940318763}, "new_guard_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.17821199999999982, "wall_seconds": 0.17861083196476102}, "new_private_set_controls": {"calls": 1, "cpu_seconds_with_children": 0.7062360000000001, "wall_seconds": 0.7198600989650004}, "new_trace_entry_freshness_controls": {"calls": 1, "cpu_seconds_with_children": 0.025257000000000307, "wall_seconds": 0.02525285299634561}, "new_trace_original_differential_controls": {"calls": 1, "cpu_seconds_with_children": 0.017062000000000133, "wall_seconds": 0.017343307030387223}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00021499999999718966, "wall_seconds": 0.00021740497322753072}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002124000000002013, "wall_seconds": 0.0021316889906302094}, "private_set_adapter_installation": {"calls": 1, "cpu_seconds_with_children": 0.019987999999999673, "wall_seconds": 0.01998300402192399}, "private_set_lease_sealing": {"calls": 1, "cpu_seconds_with_children": 5.100000000002325e-05, "wall_seconds": 5.067099118605256e-05}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.1028730000000007, "wall_seconds": 2.176472573017236}, "trace_cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.257851, "wall_seconds": 0.3387994390213862}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 10.512439, "wall_seconds": 10.514725325978361}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 3.1972050000000003, "wall_seconds": 3.355586013989523}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.1927699999999994, "wall_seconds": 1.1929622900206596}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 24.272685058007482} diff --git a/research/h25-bookkeeping/evidence/runs/qual-C3/usage.json b/research/h25-bookkeeping/evidence/runs/qual-C3/usage.json new file mode 100644 index 0000000000..7f64324b27 --- /dev/null +++ b/research/h25-bookkeeping/evidence/runs/qual-C3/usage.json @@ -0,0 +1 @@ +{"user_seconds":22.90,"system_seconds":0.37,"kernel_max_rss_kib":454940,"exit":0} diff --git a/research/h25-bookkeeping/evidence/validation/CALL-CENSUS-PILOTS.json b/research/h25-bookkeeping/evidence/validation/CALL-CENSUS-PILOTS.json new file mode 100644 index 0000000000..333c85436a --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/CALL-CENSUS-PILOTS.json @@ -0,0 +1,74 @@ +{ + "P1": { + "both_loops_retained": true, + "constructors_removed": 21157700, + "intersection_operations_retained": 10580000, + "lease_receipt": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "private_set_constructors_observed": 2300, + "scope": "verify_map tail only", + "set_constructors_reference": 21160000, + "triples": 2300 + }, + "P2": { + "candidate_records_observed_in_traced_control": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "eager_messages_removed_at_native_entries_source": 8959320, + "eager_messages_removed_per_check_source": 30, + "fresh_checks_at_every_original_boundary": true, + "native_entry_boundaries": 298644, + "reference_records_observed_in_traced_control": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + }, + "require_dispatches_removed_at_native_entries_source": 18217284, + "require_dispatches_removed_per_supported_check_source": 61, + "scope": "original full-caller native entry boundaries; excludes finite/setup/final overhead, which remains paid in complete receipts" + }, + "P3": { + "admission_reasoning": "Each full complement used original bounded native domain with zero arithmetic fallback; exact before snapshots share that <=64 row/u64 domain, count<2^64 and result exact list/None. New byte/prefix/error fixtures compare unchanged original observer.", + "canonical_bytes": 55839507, + "full_records": 238685, + "hash_updates_and_counter_order_unchanged": true, + "new_native_record_calls_per_admitted_record": 1, + "old_temp_dict_constructions_per_record": 2, + "old_temp_dict_constructions_removed_at_admitted_records_source": 477370, + "scope": "complement observer after for admitted native-domain records", + "stream_sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838", + "work_moved_into_C_is_still_charged": true + }, + "combined_performance_target": "UNTESTED: do not add pilot percentages", + "kind": "Source-derived hot-path arithmetic tied to live bounded controls and complete native/lease receipts; not an instrumented call profile or standalone saving", + "overhead_and_exclusions": [ + "Private ownership/source/Fraction/admission scans", + "Every distinct runtime freshness predicate and all failure paths", + "New encoder owner/entry checks, two cold native builds, conversion/formatting/bytes", + "Old independent dense/original controls plus complete new union", + "Same independent arithmetic, witnesses, full certificate/stdout/types/order", + "No inter-call batching, cached PASS, loop fusion or changed hash/schema" + ], + "pilot_receipts": [ + "validation/P1-PILOT.json", + "validation/P2-PILOT.json", + "validation/P3-PILOT.json" + ], + "schema": "h25-bookkeeping-source-and-live-boundary-census-v1" +} diff --git a/research/h25-bookkeeping/evidence/validation/CALL-CENSUS.json b/research/h25-bookkeeping/evidence/validation/CALL-CENSUS.json new file mode 100644 index 0000000000..46842076ab --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/CALL-CENSUS.json @@ -0,0 +1,77 @@ +{ + "P1": { + "both_loops_retained": true, + "constructors_removed": 21157700, + "intersection_operations_retained": 10580000, + "lease_receipt": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "fraction_source_profile": "recorded-local-cpython-3.12.3", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "private_set_constructors_observed": 2300, + "scope": "verify_map tail only", + "set_constructors_reference": 21160000, + "triples": 2300 + }, + "P2": { + "candidate_records_observed_in_traced_control": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "eager_messages_removed_at_native_entries_source": 8959320, + "eager_messages_removed_per_check_source": 30, + "fresh_checks_at_every_original_boundary": true, + "native_entry_boundaries": 298644, + "reference_records_observed_in_traced_control": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + }, + "require_dispatches_removed_at_native_entries_source": 18217284, + "require_dispatches_removed_per_supported_check_source": 61, + "scope": "original full-caller native entry boundaries; excludes finite/setup/final overhead, which remains paid in complete receipts" + }, + "P3": { + "admission_reasoning": "Each full complement used original bounded native domain with zero arithmetic fallback; exact before snapshots share that <=64 row/u64 domain, count<2^64 and result exact list/None. New byte/prefix/error fixtures compare unchanged original observer.", + "canonical_bytes": 55839507, + "full_records": 238685, + "hash_updates_and_counter_order_unchanged": true, + "new_native_record_calls_per_admitted_record": 1, + "old_temp_dict_constructions_per_record": 2, + "old_temp_dict_constructions_removed_at_admitted_records_source": 477370, + "scope": "complement observer after for admitted native-domain records", + "stream_sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838", + "work_moved_into_C_is_still_charged": true + }, + "combined_performance_receipt": "validation/COMBINED-GATE.json", + "combined_performance_target": "COMBINED_15_PERCENT_BOTH_METRICS_AND_NOISE_PASS", + "evidence_revision": "Final census source arithmetic is now bound to v4qual-C1; original prequalification pilot census remains CALL-CENSUS-PILOTS.json", + "kind": "Source-derived hot-path arithmetic tied to live bounded controls and complete native/lease receipts; not an instrumented call profile or standalone saving", + "overhead_and_exclusions": [ + "Private ownership/source/Fraction/admission scans", + "Every distinct runtime freshness predicate and all failure paths", + "New encoder owner/entry checks, two cold native builds, conversion/formatting/bytes", + "Old independent dense/original controls plus complete new union", + "Same independent arithmetic, witnesses, full certificate/stdout/types/order", + "No inter-call batching, cached PASS, loop fusion or changed hash/schema" + ], + "pilot_receipts": [ + "validation/P1-PILOT.json", + "validation/P2-PILOT.json", + "validation/P3-PILOT.json" + ], + "schema": "h25-bookkeeping-source-and-live-boundary-census-v1" +} diff --git a/research/h25-bookkeeping/evidence/validation/COMBINED-FIRST-PAIR.json b/research/h25-bookkeeping/evidence/validation/COMBINED-FIRST-PAIR.json new file mode 100644 index 0000000000..948f76a289 --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/COMBINED-FIRST-PAIR.json @@ -0,0 +1,59 @@ +{ + "all_new_controls_and_cold_builds_billed": true, + "every_sample_retained": true, + "full_anchor_equal": true, + "metrics": { + "cpu": { + "baseline": [ + 27.09 + ], + "baseline_median": 27.09, + "candidate": [ + 21.419999999999998 + ], + "candidate_median": 21.419999999999998, + "max_within_arm_range": 0.0, + "noise_pass": true, + "reduction_percent": 20.930232558139544, + "saving": 5.670000000000002, + "target_pass": true + }, + "wall": { + "baseline": [ + 27.16858759697061 + ], + "baseline_median": 27.16858759697061, + "candidate": [ + 21.477875709999353 + ], + "candidate_median": 21.477875709999353, + "max_within_arm_range": 0.0, + "noise_pass": true, + "reduction_percent": 20.945924651621535, + "saving": 5.690711886971258, + "target_pass": true + } + }, + "publication_and_hosted_validation_remain_separate": true, + "qualified_factor": false, + "rules_sha256": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "samples": [ + { + "arm": "B", + "cpu": 27.09, + "label": "qual-B1", + "spent_before": 182.9798714609351, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 27.16858759697061 + }, + { + "arm": "C", + "cpu": 21.419999999999998, + "label": "qual-C1", + "spent_before": 210.1484590579057, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 21.477875709999353 + } + ], + "status": "FIRST_PAIR_CREDIBLE_CONTINUE" +} diff --git a/research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json b/research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json new file mode 100644 index 0000000000..7bf77ad826 --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/COMBINED-GATE.json @@ -0,0 +1,99 @@ +{ + "all_new_controls_and_cold_builds_billed": true, + "every_sample_retained": true, + "full_anchor_equal": true, + "metrics": { + "cpu": { + "baseline": [ + 27.09, + 27.3, + 27.06 + ], + "baseline_median": 27.09, + "candidate": [ + 21.419999999999998, + 21.13, + 23.27 + ], + "candidate_median": 21.419999999999998, + "max_within_arm_range": 2.1400000000000006, + "noise_pass": true, + "reduction_percent": 20.930232558139544, + "saving": 5.670000000000002, + "target_pass": true + }, + "wall": { + "baseline": [ + 27.16858759697061, + 27.378558369004168, + 27.14340792701114 + ], + "baseline_median": 27.16858759697061, + "candidate": [ + 21.477875709999353, + 21.17849980702158, + 24.77310694300104 + ], + "candidate_median": 21.477875709999353, + "max_within_arm_range": 3.5946071359794587, + "noise_pass": true, + "reduction_percent": 20.945924651621535, + "saving": 5.690711886971258, + "target_pass": true + } + }, + "publication_and_hosted_validation_remain_separate": true, + "qualified_factor": true, + "rules_sha256": "cc361a051b6c61e3f9b2d032273fde3436c17060b32541da2c47f531269edefd", + "samples": [ + { + "arm": "B", + "cpu": 27.09, + "label": "qual-B1", + "spent_before": 182.9798714609351, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 27.16858759697061 + }, + { + "arm": "C", + "cpu": 21.419999999999998, + "label": "qual-C1", + "spent_before": 210.1484590579057, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 21.477875709999353 + }, + { + "arm": "C", + "cpu": 21.13, + "label": "qual-C2", + "spent_before": 231.62633476790506, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 21.17849980702158 + }, + { + "arm": "B", + "cpu": 27.3, + "label": "qual-B2", + "spent_before": 252.80483457492664, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 27.378558369004168 + }, + { + "arm": "B", + "cpu": 27.06, + "label": "qual-B3", + "spent_before": 280.1833929439308, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 27.14340792701114 + }, + { + "arm": "C", + "cpu": 23.27, + "label": "qual-C3", + "spent_before": 307.32680087094195, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "wall": 24.77310694300104 + } + ], + "status": "COMBINED_15_PERCENT_BOTH_METRICS_AND_NOISE_PASS" +} diff --git a/research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json b/research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json new file mode 100644 index 0000000000..5b4da96c29 --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/P1-O-v2-STOP.json @@ -0,0 +1,10 @@ +{ + "status": "RETAINED_CONTROL_FIXTURE_FAILURE", + "run": "runtime/runs/finite-P1-O-v2", + "wall_seconds": 2.8227231420460157, + "source_stage": "v2", + "error": "Collision fixture did not reach custom equality", + "source_owner_repair_requested": true, + "review_required_before_new_stage": true, + "no_automatic_retry": true +} diff --git a/research/h25-bookkeeping/evidence/validation/P1-PILOT.json b/research/h25-bookkeeping/evidence/validation/P1-PILOT.json new file mode 100644 index 0000000000..f927cab487 --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/P1-PILOT.json @@ -0,0 +1,177 @@ +{ + "all_new_controls_paid": true, + "baseline_cpu": 28.220000000000002, + "baseline_wall": 28.382591002970003, + "candidate_cpu": 25.07, + "candidate_wall": 25.139696669997647, + "cpu_reduction_percent": 11.16229624379873, + "individual_priority_has_no_separate15percent_requirement": true, + "later_exact_fraction_allowlist_portability_revision_requires_new_source_gate_and_combined_finite_union": true, + "new_control_receipt": { + "sets": { + "cases": 23, + "optimize": 0, + "rows": [ + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "all-intersection-sizes", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "duplicate-positional-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "reordered-triples", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "negative-and-wide-integers", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "empty-triples", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "no-allowance-prefix-once", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-checks-identity", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "wrong-circuit-link", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "prefix-reentry-single-reservation", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "post-prefix-mutated-values", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 0, + "name": "failing-prefix-no-eager-cache", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "tuple-subclass-callback-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "integer-subclass-hash-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "bool-member-exact-type-fallback", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "got-collision-key-fallback", + "outcome": "error" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-source-set-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "live-Fraction-global-resolution", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "changed-Fraction-hash", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 1, + "name": "used-capability-changed-later-input", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-trace", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-profile", + "outcome": "value" + }, + { + "fallback_calls": 1, + "fast_admissions": 0, + "name": "known-hook-gc-callback", + "outcome": "value" + }, + { + "fallback_calls": 0, + "fast_admissions": 1, + "name": "traceback-cleanup", + "outcome": "error" + } + ], + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence", + "status": "P1_FINITE_SET_CONTROLS_PASS" + } + }, + "priority": "P1", + "science_exactly_identical": true, + "set_receipt": { + "allowances_armed": 1, + "checks_captured": 1, + "circuits_captured": 1, + "entries": 1, + "fallback_calls": 0, + "fast_admissions": 1, + "fraction_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "private_operand_sets_constructed": 2300, + "reservations": 1, + "reservations_expired": 1, + "schema": "h25-private-set-reuse-v1", + "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "CORRECT_COMPLETE_PILOT_IMPROVEMENT_NOT_QUALIFIED_FACTOR", + "wall_reduction_percent": 11.425645856761324 +} diff --git a/research/h25-bookkeeping/evidence/validation/P2-PILOT.json b/research/h25-bookkeeping/evidence/validation/P2-PILOT.json new file mode 100644 index 0000000000..8673c0699e --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/P2-PILOT.json @@ -0,0 +1,61 @@ +{ + "all_new_controls_paid": true, + "baseline_cpu": 27.79, + "baseline_wall": 27.908136366982944, + "candidate_cpu": 25.619999999999997, + "candidate_wall": 25.734568614978343, + "cpu_reduction_percent": 7.808564231738046, + "individual_priority_has_no_separate15percent_requirement": true, + "new_control_receipt": { + "guards": { + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "counts": { + "binding_modes": 2, + "mutation_action_pairs": 1659, + "mutation_pairs": 237, + "same_code_distinct_controls": 4, + "source_loads": 4, + "stable_action_pairs": 14 + }, + "inventories": { + "traced": { + "candidate": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 11, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 14, + "distinct_functions": 11, + "records": 13, + "same_code_distinct_function_rejected": true + } + }, + "untraced": { + "candidate": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 10, + "same_code_distinct_function_rejected": true + }, + "reference": { + "captured_cell_reads": 12, + "distinct_functions": 10, + "records": 13, + "same_code_distinct_function_rejected": true + } + } + }, + "old_finite_controls_still_required": true, + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation", + "status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", + "transcript_sha256": "82a0477dfdd3d30f48e290b4d616e6c591d80e1ffebc036abfcea22626b0b2a4" + } + }, + "priority": "P2", + "science_exactly_identical": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "CORRECT_COMPLETE_PILOT_IMPROVEMENT_NOT_QUALIFIED_FACTOR", + "wall_reduction_percent": 7.7882941498596985 +} diff --git a/research/h25-bookkeeping/evidence/validation/P3-PILOT.json b/research/h25-bookkeeping/evidence/validation/P3-PILOT.json new file mode 100644 index 0000000000..1d154f5cf5 --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/P3-PILOT.json @@ -0,0 +1,47 @@ +{ + "all_new_controls_paid": true, + "baseline_cpu": 27.01, + "baseline_wall": 27.07822590402793, + "candidate_cpu": 24.979999999999997, + "candidate_wall": 25.069680297980085, + "cpu_reduction_percent": 7.5157349129952085, + "individual_priority_has_no_separate15percent_requirement": true, + "new_control_receipt": { + "trace": { + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "counts": { + "before_pairs": 7, + "byte_and_prefix_pairs": 55, + "digit_limit_pairs": 5, + "error_pairs": 18, + "factory_rejections": 3, + "native_admitted": 17, + "native_argument_errors": 5, + "native_fallback": 30, + "no_alias_checks": 2, + "source_module_loads": 1 + }, + "fixture_sha256": "8ccd1c97a80a3932e24748b75cbd7d60a070eace31cf56fed9e9819120dea284", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "ordered_fixture_stream": { + "calls": 20, + "canonical_stream_bytes": 5926, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "9d601330d82aab41e0fb90606cd37fb75d7d96addd315797c8372e492e474b55" + }, + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "timing_claim": null + }, + "trace_entry_freshness": { + "negative_actions": 5, + "rejected_before_arithmetic_and_observation": true, + "status": "PASS" + } + }, + "priority": "P3", + "science_exactly_identical": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "CORRECT_COMPLETE_PILOT_IMPROVEMENT_NOT_QUALIFIED_FACTOR", + "wall_reduction_percent": 7.417567211259113 +} diff --git a/research/h25-bookkeeping/evidence/validation/RUN-INDEX.json b/research/h25-bookkeeping/evidence/validation/RUN-INDEX.json new file mode 100644 index 0000000000..b447d0675e --- /dev/null +++ b/research/h25-bookkeeping/evidence/validation/RUN-INDEX.json @@ -0,0 +1,270 @@ +{ + "failed_attempts": 1, + "runs": [ + { + "cpu": 2.75, + "has_complete_science_anchor": false, + "label": "finite-P1-O-v2", + "lanes": null, + "science_status": null, + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "STOP", + "termination": null, + "wall": 2.8227231420460157 + }, + { + "cpu": 2.49, + "has_complete_science_anchor": false, + "label": "finite-P1-O-v3", + "lanes": "sets", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "termination": null, + "wall": 2.5653694639913738 + }, + { + "cpu": 2.31, + "has_complete_science_anchor": false, + "label": "finite-P1-normal-v2", + "lanes": "sets", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "termination": null, + "wall": 2.4191683249664493 + }, + { + "cpu": 2.3000000000000003, + "has_complete_science_anchor": false, + "label": "finite-P1-normal-v3", + "lanes": "sets", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "termination": null, + "wall": 2.4495496440213174 + }, + { + "cpu": 2.01, + "has_complete_science_anchor": false, + "label": "finite-P2-O-v1", + "lanes": "guards", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "termination": null, + "wall": 2.0360284139751457 + }, + { + "cpu": 1.74, + "has_complete_science_anchor": false, + "label": "finite-P2-normal-v1", + "lanes": "guards", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "termination": null, + "wall": 1.7826307810028084 + }, + { + "cpu": 2.11, + "has_complete_science_anchor": false, + "label": "finite-P3-O-v1", + "lanes": "trace", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "termination": null, + "wall": 2.2229915109928697 + }, + { + "cpu": 1.83, + "has_complete_science_anchor": false, + "label": "finite-P3-normal-v1", + "lanes": "trace", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "c82bcca68f0a240c9711174c63ca56502992f1a303cb3720a6fd58d3e42ef492", + "status": "PASS", + "termination": null, + "wall": 1.8542929289978929 + }, + { + "cpu": 2.8699999999999997, + "has_complete_science_anchor": false, + "label": "finite-combined-O-v4", + "lanes": "all", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 2.948608194012195 + }, + { + "cpu": 2.46, + "has_complete_science_anchor": false, + "label": "finite-combined-normal-v4", + "lanes": "all", + "science_status": "H25_BOOKKEEPING_FINITE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 2.5656101999920793 + }, + { + "cpu": 28.220000000000002, + "has_complete_science_anchor": true, + "label": "pilot-P1-B", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "termination": null, + "wall": 28.382591002970003 + }, + { + "cpu": 25.07, + "has_complete_science_anchor": true, + "label": "pilot-P1-C", + "lanes": "sets", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "8fcc70ecd519bdd342a673b42501840f8dc2e2c80954c8a7063bd7d121d85a6a", + "status": "PASS", + "termination": null, + "wall": 25.139696669997647 + }, + { + "cpu": 27.79, + "has_complete_science_anchor": true, + "label": "pilot-P2-B", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "termination": null, + "wall": 27.908136366982944 + }, + { + "cpu": 25.619999999999997, + "has_complete_science_anchor": true, + "label": "pilot-P2-C", + "lanes": "guards", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "termination": null, + "wall": 25.734568614978343 + }, + { + "cpu": 27.01, + "has_complete_science_anchor": true, + "label": "pilot-P3-B", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "termination": null, + "wall": 27.07822590402793 + }, + { + "cpu": 24.979999999999997, + "has_complete_science_anchor": true, + "label": "pilot-P3-C", + "lanes": "trace", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "a5247fa20f7fe4fa4a2ce50c845da4b482dbb1f2dbc0a2c128d3406baedb96be", + "status": "PASS", + "termination": null, + "wall": 25.069680297980085 + }, + { + "cpu": 27.09, + "has_complete_science_anchor": true, + "label": "qual-B1", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 27.16858759697061 + }, + { + "cpu": 27.3, + "has_complete_science_anchor": true, + "label": "qual-B2", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 27.378558369004168 + }, + { + "cpu": 27.06, + "has_complete_science_anchor": true, + "label": "qual-B3", + "lanes": "none", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 27.14340792701114 + }, + { + "cpu": 21.419999999999998, + "has_complete_science_anchor": true, + "label": "qual-C1", + "lanes": "all", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 21.477875709999353 + }, + { + "cpu": 21.13, + "has_complete_science_anchor": true, + "label": "qual-C2", + "lanes": "all", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 21.17849980702158 + }, + { + "cpu": 23.27, + "has_complete_science_anchor": true, + "label": "qual-C3", + "lanes": "all", + "science_status": "FULL_NETWORK_COMPLETE_PASS", + "source_unchanged": true, + "stage_sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "status": "PASS", + "termination": null, + "wall": 24.77310694300104 + } + ], + "spent_seconds": 332.099907813943 +} diff --git a/research/h25-bookkeeping/payload/JOBS.json b/research/h25-bookkeeping/payload/JOBS.json new file mode 100644 index 0000000000..49d1480a1c --- /dev/null +++ b/research/h25-bookkeeping/payload/JOBS.json @@ -0,0 +1,67 @@ +{ + "finite-O-all": { + "finite_only": true, + "lanes": "all", + "optimized": true + }, + "finite-O-guards": { + "finite_only": true, + "lanes": "guards", + "optimized": true + }, + "finite-O-none": { + "finite_only": true, + "lanes": "none", + "optimized": true + }, + "finite-O-sets": { + "finite_only": true, + "lanes": "sets", + "optimized": true + }, + "finite-O-trace": { + "finite_only": true, + "lanes": "trace", + "optimized": true + }, + "finite-all": { + "finite_only": true, + "lanes": "all" + }, + "finite-guards": { + "finite_only": true, + "lanes": "guards" + }, + "finite-none": { + "finite_only": true, + "lanes": "none" + }, + "finite-sets": { + "finite_only": true, + "lanes": "sets" + }, + "finite-trace": { + "finite_only": true, + "lanes": "trace" + }, + "full-all": { + "finite_only": false, + "lanes": "all" + }, + "full-guards": { + "finite_only": false, + "lanes": "guards" + }, + "full-none": { + "finite_only": false, + "lanes": "none" + }, + "full-sets": { + "finite_only": false, + "lanes": "sets" + }, + "full-trace": { + "finite_only": false, + "lanes": "trace" + } +} diff --git a/research/h25-bookkeeping/payload/PLAN.json b/research/h25-bookkeeping/payload/PLAN.json new file mode 100644 index 0000000000..d955bea194 --- /dev/null +++ b/research/h25-bookkeeping/payload/PLAN.json @@ -0,0 +1,155 @@ +{ + "schema_version": 1, + "title": "H25 bookkeeping optimization plan", + "authorization": "User explicitly requested all three priorities, concurrent agent swarming including research, and a goal to finish the tasks. Existing Chrome publication authorization continues.", + "baseline": { + "pr": 5995, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "arm": "PR5995 native C configuration with all original qualification controls; NOT the older Python-only arm", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "historical_wall_median": 28.63625624598353, + "historical_cpu_median": 28.46, + "historical_times_are_orientation_only": true, + "new_performance_claim_requires_fresh_same_session_baseline": true + }, + "target": { + "combined_wall_reduction_minimum": 0.15, + "combined_cpu_reduction_minimum": 0.15, + "individual_15_percent_requirement": false, + "scope": "complete frozen historical H25 qualification with retained observations" + }, + "lanes": [ + { + "id": "P1", + "priority": "Set reuse", + "agent": "bookkeeping_sets", + "ownership": "priorities/set-reuse/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Precompute private sets from admitted triples; retain every original pairwise intersection/equality check and fallback for unsupported inputs." + }, + { + "id": "P2", + "priority": "Runtime guards", + "agent": "bookkeeping_guards", + "ownership": "priorities/runtime-guards/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Deduplicate identical function records and build failure messages only on failure; keep every distinct freshness check at the same call boundary; assess a native implementation only if justified." + }, + { + "id": "P3", + "priority": "Trace encoding", + "agent": "bookkeeping_trace", + "ownership": "priorities/trace-encoding/", + "first_deliverables": [ + "RESEARCH.md", + "PROPOSAL.json" + ], + "contract": "Reduce temporary tuples/dictionaries/JSON/bytes and hash crossings; retain canonical bytes, ordering, exact types, prefixes, counters and failure semantics." + }, + { + "id": "R", + "priority": "Independent contract review", + "agent": "bookkeeping_review", + "ownership": "research/independent-review/", + "first_deliverables": [ + "CONTRACT-MATRIX.md", + "REVIEW-GATES.json" + ], + "contract": "Independently review proposals, aliasing/callback/fallback/freshness/byte contracts, interference and added cost; no implementation ownership." + } + ], + "parent_ownership": [ + "control/", + "integration/", + "validation/", + "publication/", + "runtime/", + "stages/", + "PLAN.md", + "PLAN.json", + "TASK-BOARD.json", + "STATUS.json" + ], + "concurrency": { + "parallel": [ + "source and primary-source research", + "independent design and review", + "implementation in disjoint owned paths after gates", + "fixture/test design and metadata preparation" + ], + "serialized": [ + "compilation", + "scientific imports/corpus execution", + "correctness runs", + "profiling and benchmarks", + "shared integration", + "Chrome writes" + ], + "local_heavy_work_during_benchmarks": "prohibited", + "agent_model": "GPT-6-astra", + "reasoning_effort": "xhigh", + "initial_agents": 4, + "further_delegation_requires_parent_assignment": true + }, + "resource_policy": { + "wall_seconds_per_scientific_command": 180, + "sampled_process_group_rss_bytes": 1073741824, + "initial_feasibility_seconds": 600, + "shared_round_seconds": 1500, + "single_parent_owned_runner": true, + "automatic_retries": false, + "all_failed_attempts_count": true, + "old_ledgers_preserved": true + }, + "gates": [ + "G0 refreshed canonical guidance/live overlap/baseline and shared contract freeze", + "G1 parallel source research and independent review; measurable-headroom decision", + "G2 finite correctness and all new-control cost freeze for each candidate", + "G3 individual bounded full pilot comparisons, not component gain promises", + "G4 combined integration and fresh fixed BCCBBC comparison against PR5995 native baseline", + "G5 normal/O finite, assertion-on complete, readonly Git-free/export/source/metadata/commit checks", + "G6 focused Chrome publication, exact-head hosted CI and required handoff readbacks" + ], + "noise_rule": "Combined fresh baseline median minus candidate median must exceed max(baseline range,candidate range) separately for wall and CPU, AND both reductions >=15%; predeclare six cold BCCBBC processes and retain all samples.", + "completion": [ + "All three priorities have reviewed final dispositions: qualified integration or reproducible scoped stop", + "Combined >=15% complete wall AND CPU target and noise gates pass before calling the performance goal achieved", + "All outputs/types/coverage/independent oracles/source pins and full new costs retained", + "Useful artifacts published via Chrome with exact-head checks and handoffs; no merge/frontier change", + "No unfinished required work; target misses reported as unmet, never a fabricated win" + ], + "paused": [ + "kappa research", + "Work1/2 mathematical streams", + "unrelated feeds", + "automations" + ], + "initial_dispatch": "Source-only research and contract mapping; no compilers, numerical runs or implementation until the corresponding gate.", + "repeated_call_reduction": { + "required_for_all_priorities": true, + "deliverable": "CALL-BUDGET.json per priority plus one parent diagnostic call census when discriminating", + "fields": [ + "current calls", + "repeated inputs/state", + "safe equivalence/ownership basis", + "eliminated calls", + "retained semantic checks", + "replacement calls", + "new control and conversion costs", + "measurement/evidence boundary" + ], + "P1": "metadata/set constructors primary; loop fusion or intersection-result reuse separate research gate", + "P2": "identity dedup, equivalent inline failure paths and lazy messages; retain each distinct live check at same boundary", + "P3": "stateless per-record construction/encoding and crossings; immediate hash/counter semantics retained", + "integration": "reuse only proven admitted private metadata; no shared answers or cached PASS", + "no_standalone_call_count_speed_claim": true, + "coordination": "One parent inventory/upstream refresh/run index; batch independent bounded reads; reuse source gates only while exact digests/dependencies match; external refresh at publication/CI boundaries with revision waits; no reuse of live scientific PASS or declared cold costs" + } +} diff --git a/research/h25-bookkeeping/payload/PLAN.md b/research/h25-bookkeeping/payload/PLAN.md new file mode 100644 index 0000000000..17bddb6c78 --- /dev/null +++ b/research/h25-bookkeeping/payload/PLAN.md @@ -0,0 +1,104 @@ +# H25 bookkeeping optimization plan + +Complete the three bookkeeping priorities for the frozen historical H25 verifier: reuse triple sets, reduce runtime guard overhead, and reduce trace encoding allocations. Four Astra xhigh agents work concurrently on research, independent design, and disjoint implementation paths. The parent owns integration, every compiler/scientific run, and Chrome publication. + +## Baseline and success + +Use PR5995 publication `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, specifically its **native C configuration with the existing complete checks**, as the baseline. The older Python arm is not the baseline for a further gain. Its recorded 28.636256246-second wall and 28.46-second CPU medians provide orientation; a new claim requires fresh same-session baseline runs. Preserve the original package and its 123 protected files. + +The combined target is **at least a further 15% reduction in both complete wall and CPU time**, after every new control, conversion, compilation, binding, observation, serialization and cleanup cost. Individual priorities may contribute smaller increments. Never add percentages from separate components or earlier workloads. + +A priority is finished when it has an independently reviewed contract and either a correctness-validated implementation with its measured disposition, or a reproducible scoped negative finding. The performance goal is achieved only when all three priorities have final dispositions, the combined target and noise gates pass, and required delivery checks and handoffs are complete. If the target fails, report it as unmet and keep the goal incomplete; a stopped experiment is not a performance win. + +This work concerns the complete frozen historical H25 caller with retained observations. The old additional-15%-over-PR5864 objective is separate. Kappa research, Work1/2 mathematics, unrelated feeds and automations remain paused. + +## Concurrent swarm and ownership + +| Lane | Owner | Owned directory | First research question | +|---|---|---|---| +| P1 Set reuse | `bookkeeping_sets` | `priorities/set-reuse/` | Can private sets be constructed once per admitted triple while every original pairwise check and result remains identical? | +| P2 Runtime guards | `bookkeeping_guards` | `priorities/runtime-guards/` | Which duplicate identity records and successful-path message allocations can disappear while every distinct live check still occurs at the same boundary? | +| P3 Trace encoding | `bookkeeping_trace` | `priorities/trace-encoding/` | Can fewer temporary objects and crossings produce exactly the same canonical record bytes, prefix hashes, counters and errors? | +| R Independent review | `bookkeeping_review` | `research/independent-review/` | Do the designs preserve ownership, callbacks, fallbacks, check independence and a complete cost bill, both separately and in combination? | +| Parent coordination | Main agent | `control/`, `integration/`, `validation/`, `publication/`, `runtime/`, `stages/` | Which reviewed candidates deserve the next bounded run, and does the integrated result improve the complete verifier? | + +Start fresh compact GPT-6-astra agents at xhigh effort, keeping completed earlier agents idle. Reuse these new-round agents for later follow-ups. Assign additional agents only to a distinct named obligation and owned path. Every worker is told that others share the workspace, must not revert their edits, and must accommodate concurrent changes. Workers do not edit the baseline, shared harness, working plan or another lane's files. + +Research runs in parallel, including source inspection, bounded live overlap research, primary CPython/C-API documentation when needed, alternatives, fixture design and independent review. Implementation may also run concurrently after each design passes its gate, because the lane paths do not overlap. Shared adapter changes belong solely to the parent. Each lane supplies a written adapter contract before integration. + +Compilers, scientific imports, corpus generation/execution, finite correctness runs, profiles and performance measurements use **one parent-owned queue and execution lock**. Agents prepare source and fixtures rather than executing them. No local CPU- or memory-heavy work runs alongside timed processes. This preserves useful concurrency without contaminating measurements or producing competing artifact writers. Chrome writes also have one owner. + +## G0 Establish the shared contract + +1. Refresh canonical upstream main, compare current guidance and priority revision, and check live PR/discussion overlap before substantial implementation or experiments. Keep scientific baseline PR5995 frozen even if current main changes; record compatibility rather than silently migrating inputs. +2. Create an isolated branch/worktree from refreshed main. Populate the index from the base before staging; assert that the diff contains only the intended package. Preserve all previous checkouts, threads, failed attempts and ledgers. +3. Record the full baseline source closure, compiler/interpreter/environment, native configuration, full certificate/stdout, exact typed return, ordered witness/rank/complement identities and all existing controls. +4. Freeze a common interface and observation contract for the three candidates. Keep the original baseline/reference implementation distinct from candidate helpers. Do not let a baseline call silently use an optimized guard or encoder. Finalize replacement helper/trace bindings and runtime closure-cell identities before capturing guard state; no post-capture mutation. +5. Parent may run one bounded post-C attribution diagnostic if it can discriminate among these mechanisms. Treat profiled timings as diagnostic; do not scale nested profile totals into promised savings. + +Canonical main was freshly fetched during planning as `19fdb086ea96af9a9f87936a2b888e10af4ed810`, priority revision 8. Current live overlap is tracked separately in `control/UPSTREAM-REFRESH.json`. + +## G1 Parallel research and design + +Each priority produces `RESEARCH.md` and `PROPOSAL.json` with exact source pins, candidate and fallback contracts, removed work, retained work, new costs, negative controls, files to change, an independent comparison, open risks and a discriminating next test. Distinguish source-derived counts from measured timings. Research can reject a route without constructing it. + +**P1 Set reuse.** The two existing all-pair loops imply 21.16 million set constructions for 2,300 triples. Investigate one private set per triple, scoped to the actual invocation. Retain both original intersection predicates, target order, coefficient and equality checks, exceptions and witnesses. Establish admission and fallback for unsupported or mutable/callback-bearing inputs. This is metadata reuse, not reuse of a verification answer. Do not substitute a shared arithmetic oracle for the literal independent checks. + +**P2 Runtime guards.** The actual caller makes 298,644 native kernel calls with freshness checks. Begin with identity-based deduplication of repeated function records and failure-only message construction. Preserve every distinct function/global/builtin/descriptor/default/closure/native-entry check at its current call boundary, including before fallback. Never turn a per-call freshness check into a cached PASS or a once-per-run check. A C implementation is a separately costed option, requiring verified CPython APIs, correct reference/error handling and the same rejection behavior. + +**P3 Trace encoding.** All 238,685 ordered complement records and 55,839,507 canonical bytes remain observed. Explore reducing tuple/dictionary/string/byte allocations, a source-bound native encoder, or bounded buffers within one record. Completed records must immediately update the public hasher, byte count and call count; inter-call deferral is outside this plan. Preserve sorted-key JSON/ASCII/newline schema, arbitrary-width fallback, exact types and vector order, counters, intermediate receipts and failure boundaries. Neither sampling nor replacing the canonical schema is an optimization within this scope. + +The reviewer independently maps the common contract immediately, then reviews each proposal as it arrives. Report concrete defects and the smallest fixes. Do not demand another mathematical construction or invent an additional 15% hurdle for each lane. No implementation or scientific run passes the gate merely because unused resource budget remains. + +## Repeated call reduction across all three priorities + +Treat repeated calls as an explicit work item in every lane. The parent will collect a bounded diagnostic call census and each proposal must include a call budget: current calls and inputs, why repetition occurs, what can safely disappear, remaining semantic checks, replacement calls, added admission/conversion/validation work, and the evidence that makes reuse valid. Call counts support a design decision; they are not a promised wall or CPU saving. + +- **P1:** reduce repeated set construction and repeated materialization of the same admitted triple metadata. Keep the current two predicate loops and all required intersection/equality checks in the primary candidate. Sharing an intersection result or fusing the loops is a distinct optional research branch: it needs a separate independence, error-order and complete-cost review before implementation. +- **P2:** eliminate duplicate records of the same function identity, successful-path `require` helper dispatch and eager message construction where an equivalent inline failure path preserves behavior. Every distinct live freshness check still executes at its original boundary; no once-per-run guard or cached PASS. +- **P3:** reduce repeated serializer/helper calls, tuple/dictionary construction, conversions and Python/C transitions within each record. The primary native encoder can replace several record-building/encoding calls with one checked call. Completed records must still update the hasher and counters immediately; no deferred inter-call batching or sampled observations. +- **Integration:** inspect repeated preparation or conversion across adapters and, where ownership and freshness permit, pass already admitted metadata or batch dispatch into a private owner. Keep separate independent verification paths and all original output, fallback, mutation and failure semantics. Do not share mutable answers or PASS receipts between calls, backends or processes. + +Measure diagnostic calls separately from unprofiled qualification. Every eliminated-call claim must distinguish true deduplication, value reuse, batching and work merely moved into C. The complete candidate still pays for retained operations, new validation, marshalling, compilation and cleanup. Extend only on a source-supported benefit; avoid collecting another census that cannot change the next decision. + +Reduce repeated coordination/tool calls too. The parent owns one shared source inventory, upstream refresh and run index; workers refer to those records instead of each repeating the same fetch or scan. Batch independent bounded reads, reuse an established browser session, and collect agent updates at task boundaries. Reuse source-review results only while their exact source digests and dependencies match; a changed file or dependency invalidates its affected gate. Refresh live external state at the relevant publication/CI boundary and wait for revisions instead of repeatedly polling unchanged state. Use the retained run index for status reports instead of re-reading large logs. This coordination reuse never substitutes for live scientific guards, independent reference paths, required negative controls, or the cold builds and fresh processes included in the declared performance bill. + +## G2 Concurrent implementation and serial correctness + +After source/ownership/cost review, implement one primary candidate per lane in its owned path. Compare alternatives on source and cost first; execute an alternative only when new evidence distinguishes its mechanism. The parent freezes immutable stages before any run. + +Run relevant finite comparisons and negative controls in the numerical queue. Cover exact types, widths, ordering, changed inputs/bindings, mutable aliases, callback/reentry boundaries where supported, fallback, errors and cleanup. Keep the live independent dense/original checks and original full assertions. Optimized interpreter mode is for finite controls; full verification remains assertion-on. + +Freeze each candidate's complete validation bill before measuring it. Manual repairs get a new source/stage revision, retain the failed evidence and consume the same round budget. No automatic retries or timing rerolls. + +## G3 Individual complete pilots + +Schedule one complete baseline/candidate pair per source-admitted priority. Baseline B means PR5995 native C plus its unchanged controls; candidate C adds that lane and all of its new costs. Retain full outputs and every receipt. A micro improvement is not a complete improvement, and one pair is not a qualified individual factor. + +Use pilots to decide integration or a scoped stop. A noisy individual result may still support a documented combined test if a specific shared-cost or interaction argument justifies it; do not label its individual saving established. Expand individual repetitions only when needed for a standalone performance claim and funded by the declared budget. Preserve all unfavorable results. + +## G4 Combined integration and qualification + +The parent integrates compatible, correctness-approved variants behind the frozen common interface. The reviewer checks interaction hazards: shared state, aliasing, guard placement, trace prefixes, fallback, exception paths, C-module loading and any duplicated cost. Run the full union of old and new controls, with all new costs inside the candidate bill. + +Freeze source, environment, selection rules and the combined fixed cold sequence **B1 C1 C2 B2 B3 C3** before timing. Start with B1/C1 and complete the declared sequence only if the target is credible and correctness holds. Require fresh medians to improve at least 15% in both wall and CPU. Separately, each median saving must exceed the maximum of the baseline and candidate within-arm ranges for that metric. Retain every sample; instrumented diagnostics and publication checks are excluded from sample selection. + +No percentage is transferred from PR5995, PR5929, PR5864 or component pilots. If the combined result fails, record the actual outcome and reassess only a materially changed, independently reviewed mechanism; do not rerun the same timings hoping for a different answer. + +## G5 Delivery checks + +Validate finite normal/O modes, the complete assertion-on caller, read-only Git-free execution, external output locations and failure retention. Before deleting fresh private runtime copies, make only their private directories writable after all source checks; never chmod immutable package inputs. Avoid entry names such as `profile.py` that shadow standard-library modules. + +Check exact source/input manifests, raw ancestry, committed bytes and executable modes, declared inputs, canonical lossless transport, package metadata and export equality. Archive integrity/publication-wrapper costs are separately identified from the frozen scientific performance harness. A wrapper correctness run never replaces a performance sample or establishes a wrapper speed factor. + +## G6 Publication and completion + +Publish useful focused results through the authorized signed-in Chrome workflow, with exact pins, predecessor/license/AI credit, required template and seven-field handoffs. Do not grant maintainer secret access, merge a PR, or change the selected frontier. Read back PR text and the existing handoff index. Verify exact-head hosted planning and relevant package replay; keep hosted correctness separate from local performance. + +Record each lane's final disposition, combined target/noise outcome, all failures, remaining obligations and a compact checkpoint. Mark the goal complete only when every required task is delivered and the combined performance target passes. An unresolved target remains incomplete; apply the goal tool's blocking rules only at a genuine repeated impasse. + +## Resources and reporting + +Use one serial guarded runner: 180 seconds per scientific command, 1 GiB sampled process-group RSS, 600 seconds initial feasibility and 1,500 seconds total for this new round. The shared ledger includes profiles, compilation, finite and full runs, publication scientific replays and all failures. Prior ledgers remain unchanged. Crossing a cap stops the affected work; it does not produce a negative scientific theorem or complete the goal. + +Keep `TASK-BOARD.json`, `STATUS.json`, immutable stages and raw receipts current. Reassess after each source/cost gate, candidate result and integration result. Give concise progress updates and expose any blocker with its exact effect. No background feed work, automation or unrelated mathematical research is included. diff --git a/research/h25-bookkeeping/payload/STAGE.json b/research/h25-bookkeeping/payload/STAGE.json new file mode 100644 index 0000000000..4f4294e84c --- /dev/null +++ b/research/h25-bookkeeping/payload/STAGE.json @@ -0,0 +1,649 @@ +{ + "baseline_arm": "native C, original controls and observations retained", + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "9add67e9d756928f65afe11c55125a86672a79942350389bd0626e3c7963ce7e" + }, + "PLAN.json": { + "mode": 292, + "sha256": "8cf40547e843a7a8cee37f9605a477e8c48561f9cb66c55c587f3dcc2df9fe63" + }, + "PLAN.md": { + "mode": 292, + "sha256": "afead2d57340b6acd90eda53cb3e2847d2607cc2bd0d51c8495e738fe34c7106" + }, + "baseline/CODE-SOURCES.json": { + "mode": 292, + "sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7" + }, + "baseline/README.md": { + "mode": 292, + "sha256": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64" + }, + "baseline/SOURCE-PINS.json": { + "mode": 292, + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" + }, + "baseline/SOURCES.json": { + "mode": 292, + "sha256": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a" + }, + "baseline/TASK.json": { + "mode": 292, + "sha256": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38" + }, + "baseline/VALIDATION.json": { + "mode": 292, + "sha256": "57276f66428aa11d1d8757384a93b16549d64e9c28fa59d904f07b37092e231a" + }, + "baseline/VERIFY.json": { + "mode": 292, + "sha256": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78" + }, + "baseline/anchor.json": { + "mode": 292, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "baseline/archive_support.py": { + "mode": 292, + "sha256": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f" + }, + "baseline/check_artifacts.py": { + "mode": 292, + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "baseline/engine/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "baseline/engine/finite_controls.py": { + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "baseline/engine/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "baseline/engine/native_gf2.c": { + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "baseline/engine/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "baseline/engine/source/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/engine/source/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/evidence/COMPLETE-GATE.json": { + "mode": 292, + "sha256": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b" + }, + "baseline/evidence/ENVIRONMENT.json": { + "mode": 292, + "sha256": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384" + }, + "baseline/evidence/FIRST-PAIR-GATE.json": { + "mode": 292, + "sha256": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc" + }, + "baseline/evidence/FULL-PAIR-ADMISSION.json": { + "mode": 292, + "sha256": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829" + }, + "baseline/evidence/INDEPENDENT-REVIEW.md": { + "mode": 292, + "sha256": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f" + }, + "baseline/evidence/INPUT-COMMIT.json": { + "mode": 292, + "sha256": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b" + }, + "baseline/evidence/LOCAL-INPUT-INDEX-STOP.json": { + "mode": 292, + "sha256": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa" + }, + "baseline/evidence/PLAN.json": { + "mode": 292, + "sha256": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813" + }, + "baseline/evidence/PROFILE-v1-FAILURE.json": { + "mode": 292, + "sha256": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f" + }, + "baseline/evidence/RESULTS.md": { + "mode": 292, + "sha256": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f" + }, + "baseline/evidence/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb" + }, + "baseline/evidence/UPSTREAM-REFRESH.json": { + "mode": 292, + "sha256": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693" + }, + "baseline/evidence/canonical/MANIFEST.json": { + "mode": 292, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "baseline/evidence/canonical/complement-transcript.json": { + "mode": 292, + "sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "baseline/evidence/canonical/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/evidence/canonical/full-return.lossless.json.gz": { + "mode": 292, + "sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "baseline/evidence/canonical/original-stdout.txt": { + "mode": 292, + "sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 292, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 292, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "baseline/evidence/publication-v1-failure/REVISION.json": { + "mode": 292, + "sha256": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8" + }, + "baseline/evidence/publication-v1-failure/receipt.json": { + "mode": 292, + "sha256": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a" + }, + "baseline/evidence/publication-v1-failure/stderr.txt": { + "mode": 292, + "sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515" + }, + "baseline/evidence/publication-v1-failure/stdout.txt": { + "mode": 292, + "sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342" + }, + "baseline/evidence/publication-v1-failure/usage.json": { + "mode": 292, + "sha256": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc" + }, + "baseline/evidence/publication-v1-failure/verify_full.py.txt": { + "mode": 292, + "sha256": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e" + }, + "baseline/evidence/runs/full-network-B1/receipt.json": { + "mode": 292, + "sha256": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27" + }, + "baseline/evidence/runs/full-network-B1/scientific-receipt.json": { + "mode": 292, + "sha256": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31" + }, + "baseline/evidence/runs/full-network-B1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B1/stdout.txt": { + "mode": 292, + "sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43" + }, + "baseline/evidence/runs/full-network-B1/usage.json": { + "mode": 292, + "sha256": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505" + }, + "baseline/evidence/runs/full-network-B2/receipt.json": { + "mode": 292, + "sha256": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d" + }, + "baseline/evidence/runs/full-network-B2/scientific-receipt.json": { + "mode": 292, + "sha256": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7" + }, + "baseline/evidence/runs/full-network-B2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B2/stdout.txt": { + "mode": 292, + "sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d" + }, + "baseline/evidence/runs/full-network-B2/usage.json": { + "mode": 292, + "sha256": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891" + }, + "baseline/evidence/runs/full-network-B3/receipt.json": { + "mode": 292, + "sha256": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506" + }, + "baseline/evidence/runs/full-network-B3/scientific-receipt.json": { + "mode": 292, + "sha256": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495" + }, + "baseline/evidence/runs/full-network-B3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-B3/stdout.txt": { + "mode": 292, + "sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe" + }, + "baseline/evidence/runs/full-network-B3/usage.json": { + "mode": 292, + "sha256": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8" + }, + "baseline/evidence/runs/full-network-C1/receipt.json": { + "mode": 292, + "sha256": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934" + }, + "baseline/evidence/runs/full-network-C1/scientific-finite-controls.json": { + "mode": 292, + "sha256": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342" + }, + "baseline/evidence/runs/full-network-C1/scientific-receipt.json": { + "mode": 292, + "sha256": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8" + }, + "baseline/evidence/runs/full-network-C1/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C1/stdout.txt": { + "mode": 292, + "sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd" + }, + "baseline/evidence/runs/full-network-C1/usage.json": { + "mode": 292, + "sha256": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84" + }, + "baseline/evidence/runs/full-network-C2/receipt.json": { + "mode": 292, + "sha256": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73" + }, + "baseline/evidence/runs/full-network-C2/scientific-finite-controls.json": { + "mode": 292, + "sha256": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969" + }, + "baseline/evidence/runs/full-network-C2/scientific-receipt.json": { + "mode": 292, + "sha256": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c" + }, + "baseline/evidence/runs/full-network-C2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C2/stdout.txt": { + "mode": 292, + "sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c" + }, + "baseline/evidence/runs/full-network-C2/usage.json": { + "mode": 292, + "sha256": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886" + }, + "baseline/evidence/runs/full-network-C3/receipt.json": { + "mode": 292, + "sha256": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce" + }, + "baseline/evidence/runs/full-network-C3/scientific-finite-controls.json": { + "mode": 292, + "sha256": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237" + }, + "baseline/evidence/runs/full-network-C3/scientific-receipt.json": { + "mode": 292, + "sha256": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb" + }, + "baseline/evidence/runs/full-network-C3/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-C3/stdout.txt": { + "mode": 292, + "sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0" + }, + "baseline/evidence/runs/full-network-C3/usage.json": { + "mode": 292, + "sha256": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb" + }, + "baseline/evidence/runs/full-network-profile-v1/receipt.json": { + "mode": 292, + "sha256": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c" + }, + "baseline/evidence/runs/full-network-profile-v1/stderr.txt": { + "mode": 292, + "sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76" + }, + "baseline/evidence/runs/full-network-profile-v1/stdout.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v1/usage.json": { + "mode": 292, + "sha256": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78" + }, + "baseline/evidence/runs/full-network-profile-v2/receipt.json": { + "mode": 292, + "sha256": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf" + }, + "baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json": { + "mode": 292, + "sha256": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a" + }, + "baseline/evidence/runs/full-network-profile-v2/stderr.txt": { + "mode": 292, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline/evidence/runs/full-network-profile-v2/stdout.txt": { + "mode": 292, + "sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec" + }, + "baseline/evidence/runs/full-network-profile-v2/usage.json": { + "mode": 292, + "sha256": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b" + }, + "baseline/frozen/scripts/audit_short_guards.py": { + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "baseline/frozen/scripts/certify.py": { + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "baseline/frozen/scripts/compact_control_layer.py": { + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "baseline/frozen/scripts/complex_circuit.py": { + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "baseline/frozen/scripts/complex_network.py": { + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "baseline/frozen/scripts/exclusion_circuit.py": { + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "baseline/frozen/scripts/paired_exclusion_circuit.py": { + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "baseline/frozen/scripts/paired_network.py": { + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "baseline/frozen/scripts/prepare_layers.py": { + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "baseline/frozen/scripts/search_network.py": { + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "baseline/frozen/scripts/shared_point_circuit.py": { + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "baseline/frozen/scripts/shared_point_network.py": { + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "baseline/frozen/upstream/LICENSE": { + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "baseline/frozen/upstream/README.md": { + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "baseline/frozen/upstream/build/figures/multiplication-flow.tex": { + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "baseline/frozen/upstream/build/figures/proof-map.tex": { + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "baseline/frozen/upstream/build/main.tex": { + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "baseline/frozen/upstream/build/references.bib": { + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "baseline/frozen/upstream/build/sections/00-introduction.tex": { + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "baseline/frozen/upstream/build/sections/01-history.tex": { + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "baseline/frozen/upstream/build/sections/02-streams.tex": { + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "baseline/frozen/upstream/build/sections/03-motifs.tex": { + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "baseline/frozen/upstream/build/sections/04-swap.tex": { + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "baseline/frozen/upstream/build/sections/05-layers.tex": { + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "baseline/frozen/upstream/build/sections/06-transforms.tex": { + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "baseline/frozen/upstream/build/sections/07-resampling.tex": { + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "baseline/frozen/upstream/build/sections/08-assembly.tex": { + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex": { + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "baseline/frozen/upstream/build/sections/10-transposition.tex": { + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex": { + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "baseline/frozen/upstream/formalization.yaml": { + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "baseline/frozen/upstream/manifest.json": { + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + }, + "baseline/full_B.py": { + "mode": 292, + "sha256": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8" + }, + "baseline/full_C.py": { + "mode": 292, + "sha256": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4" + }, + "baseline/full_driver.py": { + "mode": 292, + "sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" + }, + "baseline/guard.py": { + "mode": 292, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline/reference/certificates/complex-network.json": { + "mode": 292, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "baseline/reference/certificates/selected-result.json": { + "mode": 292, + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "baseline/replay.py": { + "mode": 292, + "sha256": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90" + }, + "baseline/verify.py": { + "mode": 292, + "sha256": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b" + }, + "baseline/verify_full.py": { + "mode": 292, + "sha256": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + }, + "freeze_stage.py": { + "mode": 292, + "sha256": "f04157cf32d42d3e738ecb2e444fff4b588f1b45276d7cd6ac0bc1445c5ebeec" + }, + "integration/DERIVATION.json": { + "mode": 292, + "sha256": "6a1b9148c48fe9016a3dc98c1aec339fba3efe73f421ecac2d3cb12d87c53256" + }, + "integration/adapters.py": { + "mode": 292, + "sha256": "f7ca7f4f03ac63c1a95ba42f06149543211566de5e29f487a3dc4d08c5ee9b94" + }, + "integration/derive_driver.py": { + "mode": 292, + "sha256": "a18d312e6992786fa7b2cf8a613eea068e0ad282ff684d03781a5928bde2692a" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "priorities/runtime-guards/CALL-BUDGET.json": { + "mode": 292, + "sha256": "74d62c6ca7790fb6f087b1312029ae9f6a00beca6a6a9b12a1a80afc3df15fec" + }, + "priorities/runtime-guards/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605" + }, + "priorities/runtime-guards/PROPOSAL.json": { + "mode": 292, + "sha256": "f6da354ca6e6dc1647b8aa78ebb0cb4fe84af8ca13deafa851ad527e7124451d" + }, + "priorities/runtime-guards/RESEARCH.md": { + "mode": 292, + "sha256": "58a3497b7586f7b9c173867abadcffa71a587c01a80abcb376b9109428e1b5e9" + }, + "priorities/runtime-guards/STATIC-CHECK.json": { + "mode": 292, + "sha256": "4587e1ef1102eff216de65f9db111f1bacb393a1e509fd9fcf6a2d2a9ebd3160" + }, + "priorities/runtime-guards/guard_candidate.py": { + "mode": 292, + "sha256": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29" + }, + "priorities/runtime-guards/guard_controls.py": { + "mode": 292, + "sha256": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "priorities/set-reuse/CALL-BUDGET.json": { + "mode": 292, + "sha256": "2d6a50081b4d6f13cba9c7afcaed9c46c5d7c6cba6ed9da60eebcd1d4f1bacd5" + }, + "priorities/set-reuse/IMPLEMENTATION.md": { + "mode": 292, + "sha256": "6b0a86226046bc421134f18a0cd77ebc4d5dce07e0feb3b67de8c2a852856452" + }, + "priorities/set-reuse/OWNERSHIP.md": { + "mode": 292, + "sha256": "ca2ad5a604aed35b6e29132aee32ccad318885c0c844e3c71a3986bf937ba099" + }, + "priorities/set-reuse/PORTABILITY-SOURCE.json": { + "mode": 292, + "sha256": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82" + }, + "priorities/set-reuse/PORTABILITY.md": { + "mode": 292, + "sha256": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1" + }, + "priorities/set-reuse/PROPOSAL.json": { + "mode": 292, + "sha256": "b9e3edff540fb0fa9f679e868a8fbcc2a6072d1a00d263b11757e60d0abca55d" + }, + "priorities/set-reuse/RESEARCH.md": { + "mode": 292, + "sha256": "e722b267cf86574f0c62846156ce6a049f0cf539f3eba1de48d9b1ec58f22bc8" + }, + "priorities/set-reuse/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "4ac8964004938d4d02840e135254b3bc1a57c0cc3f1018ed50909bf79a1cb556" + }, + "priorities/set-reuse/cpython-3.12.15-fractions.py": { + "mode": 292, + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0" + }, + "priorities/set-reuse/finite_set_controls.py": { + "mode": 292, + "sha256": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919" + }, + "priorities/set-reuse/set_reuse.py": { + "mode": 292, + "sha256": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d" + }, + "priorities/trace-encoding/ADAPTER.md": { + "mode": 292, + "sha256": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f" + }, + "priorities/trace-encoding/CALL-BUDGET.json": { + "mode": 292, + "sha256": "917d6ec6a8327e785e48b119c47df26f49091f83bf2b7414383d4cc3cad71aab" + }, + "priorities/trace-encoding/PROPOSAL.json": { + "mode": 292, + "sha256": "ba8c9852a8c82fc96099aade07dcd56989fec998dc9acbb9b39d90e1898dc50d" + }, + "priorities/trace-encoding/RESEARCH.md": { + "mode": 292, + "sha256": "aca1bbf6047d5300e4f813ef2cab0a7a9197ea50c5f62e7d77b4c60eba207d60" + }, + "priorities/trace-encoding/SOURCE-READINESS.json": { + "mode": 292, + "sha256": "23afdefab937a1da4ed46676940fab2e897aad5e76996c3002928040f00244df" + }, + "priorities/trace-encoding/trace_adapter.py": { + "mode": 292, + "sha256": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60" + }, + "priorities/trace-encoding/trace_controls.py": { + "mode": 292, + "sha256": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447" + }, + "priorities/trace-encoding/trace_encoder.c": { + "mode": 292, + "sha256": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e" + }, + "run_guarded.py": { + "mode": 292, + "sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be" + } + }, + "runner_sha256": "b74366a925dd44c0e95a7ad87aa1505cbdcad9fefcb9360d77d6459679f102be", + "schema": "h25-bookkeeping-immutable-stage-v1", + "scientific_execution_during_freeze": false +} diff --git a/research/h25-bookkeeping/payload/baseline/CODE-SOURCES.json b/research/h25-bookkeeping/payload/baseline/CODE-SOURCES.json new file mode 100644 index 0000000000..cacb2a0c7d --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/CODE-SOURCES.json @@ -0,0 +1,143 @@ +{ + "coverage": "Every current immutable package file, including README/TASK, all executable source, all 42 immutable ancestor inputs, measured full driver/anchor/guard, fixed SOURCES/VERIFY metadata, all canonical transport and all eight original run records. Byte identity permits Git 0644 and readonly 0444 modes; measured source modes remain checked before/after each run.", + "evidence_binding": "Canonical payload logical hashes bind to immutable anchor; transport manifest retains archive-container hashes. Original performance receipts, profile failure and local-input-index stop are immutable historical evidence, not reused PASS inputs. CODE authentication is additional packaging/transport cost and is not part of a bare-CLI performance claim.", + "excluded_mutable": [ + "CODE-SOURCES.json", + "VALIDATION.json", + "PUBLICATION-STATUS.json" + ], + "exclusion_reasons": { + "CODE-SOURCES.json": "Self-referential manifest; authenticate its exact bytes through committed package identity.", + "PUBLICATION-STATUS.json": "Reserved optional parent-owned publication/hosted-CI status; absent at freeze and never a scientific PASS substitute.", + "VALIDATION.json": "Parent-owned fresh publication-check status; never a scientific PASS substitute." + }, + "file_count": 117, + "files": { + "README.md": "654841654eb8f88c6ad80f5cebb424548a8c2236f237869434e03d6a83eeaa64", + "SOURCE-PINS.json": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "SOURCES.json": "ef4ceeef85aaa99a8c859e227ce2f75b1c421571e7e8ac235096ba49d375231a", + "TASK.json": "ad8f73482b2c4b9361f8989326715a943d4981fce21d6871bd4f2f8fc6fc4b38", + "VERIFY.json": "3c003082b10da57a213694de649e9097c79bf0dbfe9197c2bd11a8ffecb8cd78", + "anchor.json": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "archive_support.py": "825093689fea974ec5cb88a133d73715b9f2d50da60a53a4efabeecc92bff63f", + "check_artifacts.py": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f", + "engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "engine/finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "engine/native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "engine/native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "engine/profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "engine/source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "evidence/COMPLETE-GATE.json": "7754b29600bede1e0fe553b1cac324e7934c9fddf37988295758b33c1def094b", + "evidence/ENVIRONMENT.json": "4918c9ec4329426934e9ede063443449bf506f6adeb47bcef2dc07df279db384", + "evidence/FIRST-PAIR-GATE.json": "72b996e102a16f0c9188d761ba2e7d67e7dc1c049c49eee419f2aede5d1fc9bc", + "evidence/FULL-PAIR-ADMISSION.json": "03f45f5805095357143a9650c8c1c87e549e0635e388c7f1ed5f5315a4606829", + "evidence/INDEPENDENT-REVIEW.md": "ea6afa3a610379d1a499513ed772afceb502883ede31c05a2da1ac7d50562b2f", + "evidence/INPUT-COMMIT.json": "895c4ab09ce14b12d3fa658d6be3fd3ea561117d22ec07b106dd78832131428b", + "evidence/LOCAL-INPUT-INDEX-STOP.json": "49a246a34440f29c31844dabaf8429237c14efcfdecf8786e6585a75573099aa", + "evidence/PLAN.json": "0eca7918e548fc080a9d773ac8c5d416d422fb9b4bc46e2c42bd802e218da813", + "evidence/PROFILE-v1-FAILURE.json": "399f182d37f0fae525c5eacc58e3c6cf96a370647cbeed693a46b80aafa8127f", + "evidence/RESULTS.md": "b4e339d46da3639b028579134b52c5e2fc5b38a838a05317cc20e3b4bacb094f", + "evidence/SOURCE-DESIGN.md": "609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb", + "evidence/UPSTREAM-REFRESH.json": "43983db67b72244c58b30780086846fa771525ee6e5c70b9187605a365d4b693", + "evidence/canonical/MANIFEST.json": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "evidence/canonical/complement-transcript.json": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8", + "evidence/canonical/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "evidence/canonical/full-return.lossless.json.gz": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2", + "evidence/canonical/original-stdout.txt": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "evidence/canonical/rank-trace.json.gz": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "evidence/canonical/witness.json.gz": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "evidence/publication-v1-failure/REVISION.json": "d62dc4890189a23c56920bf83f33ce54568489cd5595a6ee51805179222cb5b8", + "evidence/publication-v1-failure/receipt.json": "92765dc5ef0d28bc8830fdd1ce6388a38dd9986a7d29ebf2bd9a362d231d2b4a", + "evidence/publication-v1-failure/stderr.txt": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515", + "evidence/publication-v1-failure/stdout.txt": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342", + "evidence/publication-v1-failure/usage.json": "3f6041fd2731e9551108507c3ca417e521ffb6ab50c4ac5e5489474311e0d7bc", + "evidence/publication-v1-failure/verify_full.py.txt": "427968bde006b0ce605547483433ab1f178be9531ffa9136b8e35245a6dd979e", + "evidence/runs/full-network-B1/receipt.json": "5d99810564df133b6dc181eee9eb5c5221f1116df2776e956d87d864858a5d27", + "evidence/runs/full-network-B1/scientific-receipt.json": "d15bbc1abf12e04badc6a43fbc95a09495554e17241f3849118d1a1e04e9dd31", + "evidence/runs/full-network-B1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-B1/stdout.txt": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43", + "evidence/runs/full-network-B1/usage.json": "094d04029c545f0600ad31fabdde4dc28064182c73492203450602cb0dbb0505", + "evidence/runs/full-network-B2/receipt.json": "525d68ac1dbc164c68ae0b2d5064eb1fa44de475f990550b3412d3fa78bc3e3d", + "evidence/runs/full-network-B2/scientific-receipt.json": "78981f93ef8e47517f46e0ce97045846807baf7329f6a488c536c5a64ace9ac7", + "evidence/runs/full-network-B2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-B2/stdout.txt": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d", + "evidence/runs/full-network-B2/usage.json": "ea4d1f8d0d8a09fa3aef146f15481db589c19d43ce5c56ce03e295f6b28cd891", + "evidence/runs/full-network-B3/receipt.json": "6b8eae21187c05dc00a6665b6831bc7ebe3451d2c5f57dc171435c9276c95506", + "evidence/runs/full-network-B3/scientific-receipt.json": "0c7916eb347d9702d19bfe22e192ab3b19d165dfd8221df59e1a40b69eee7495", + "evidence/runs/full-network-B3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-B3/stdout.txt": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe", + "evidence/runs/full-network-B3/usage.json": "e7372d8ce6add9c3bec1f86aa0779af62e278e2ed1e5074377658010f4dcbfc8", + "evidence/runs/full-network-C1/receipt.json": "e49cc524d24b158d3d42e61ace73696b23b063b1cbda0f957b19a7b9d8cce934", + "evidence/runs/full-network-C1/scientific-finite-controls.json": "7571beca3195287602b694654354560ddf0a885840e819217b8392fddb341342", + "evidence/runs/full-network-C1/scientific-receipt.json": "f477afec2b289b560cdd6583ec53428d27a62aa541f3c781671e7ffbcf4c91e8", + "evidence/runs/full-network-C1/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-C1/stdout.txt": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd", + "evidence/runs/full-network-C1/usage.json": "1315deb855cfc8733bc6142062022a456da2f164ce32085773e9d2d9e6552a84", + "evidence/runs/full-network-C2/receipt.json": "f19ca9455e0a5032293917518187be3e90d8cf664be0a0a94cdb8bda70fa7e73", + "evidence/runs/full-network-C2/scientific-finite-controls.json": "32e9152e923672843de3176f6d0e29a3506fe62ed5ffbc5f5a75f2fa71e25969", + "evidence/runs/full-network-C2/scientific-receipt.json": "3e196c680f0fd0169804da7c8215bc4ff03d231e7af08ee35c76005bc4b8822c", + "evidence/runs/full-network-C2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-C2/stdout.txt": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c", + "evidence/runs/full-network-C2/usage.json": "fc7436309d37516f21ba5838e88b1ba6025c060e22b1012ae5b05cfbcd238886", + "evidence/runs/full-network-C3/receipt.json": "e8423e8bd005321fb1e5b806f639814c1ef54e8caa0e3cc98b8ba6d4f3ac32ce", + "evidence/runs/full-network-C3/scientific-finite-controls.json": "307191c8c2c7fc026b0b11b1c204a5d597876fc1e6b4752427f81795c041e237", + "evidence/runs/full-network-C3/scientific-receipt.json": "81ba879f026ee8ed0be4c4be1bbddd4043771fcb2c0617bf392c922253be29eb", + "evidence/runs/full-network-C3/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-C3/stdout.txt": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0", + "evidence/runs/full-network-C3/usage.json": "4a0c22609a9850a10f473e43e8b28bde3ba486f47943c6373636cdf321bac3fb", + "evidence/runs/full-network-profile-v1/receipt.json": "b44f2319460c2f3de5a802fe611b79d6ea914197eaec5232fa85c48e7e30a65c", + "evidence/runs/full-network-profile-v1/stderr.txt": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76", + "evidence/runs/full-network-profile-v1/stdout.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-profile-v1/usage.json": "66b32a9d199a7045d9bb74d68a195b2456510e22e554e9f13786500152212e78", + "evidence/runs/full-network-profile-v2/receipt.json": "6884b826de535b6ddefa0b7304cec41cfd4ff1c3cfef42930cb18c34d69226cf", + "evidence/runs/full-network-profile-v2/scientific-receipt.json": "bc3fda46c74b84d0634f65e1a1e3a4a4fb8295dd7d058520b5e30b39d2d05d8a", + "evidence/runs/full-network-profile-v2/stderr.txt": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "evidence/runs/full-network-profile-v2/stdout.txt": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec", + "evidence/runs/full-network-profile-v2/usage.json": "c1eb62c1868fc3583c60c953d547ec3b29bc30dcc811cc9d132364aef6c0c15b", + "frozen/scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "frozen/scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "frozen/scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "frozen/scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "frozen/scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "frozen/scripts/exclusion_circuit.py": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "frozen/scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "frozen/scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "frozen/scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "frozen/scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "frozen/scripts/shared_point_circuit.py": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "frozen/scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "frozen/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "frozen/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "frozen/upstream/build/figures/multiplication-flow.tex": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "frozen/upstream/build/figures/proof-map.tex": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "frozen/upstream/build/main.tex": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "frozen/upstream/build/references.bib": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "frozen/upstream/build/sections/00-introduction.tex": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "frozen/upstream/build/sections/01-history.tex": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "frozen/upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "frozen/upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "frozen/upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "frozen/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "frozen/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "frozen/upstream/build/sections/07-resampling.tex": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "frozen/upstream/build/sections/08-assembly.tex": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "frozen/upstream/build/sections/09-exact-arithmetic.tex": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "frozen/upstream/build/sections/10-transposition.tex": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "frozen/upstream/build/sections/11-grouped-rectangles.tex": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "frozen/upstream/formalization.yaml": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "frozen/upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "full_B.py": "4ab2f554c1323a26bc2ffd11a4e692e21382a269b5fdb117d226ef76f34578d8", + "full_C.py": "1ba8e7b76077d8d108039ab238d73c59e25929f1abcb5b9fde5944d5f978ebf4", + "full_driver.py": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "reference/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "reference/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "replay.py": "5f8dd1deb7ebc9634b220ed533cad534862892ee59a01803195f34296c740d90", + "verify.py": "04c37b6e3dc50bfb3b954672f4f2e04f354a084ff465f3df09f59736c7eac01b", + "verify_full.py": "c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8" + }, + "files_canonical_json_sha256": "5e1e6b744a89400582c92c23f176fdab2eaa5af539cb562e92d285b77d4d6b24", + "schema_version": 1, + "total_file_bytes": 17870583 +} diff --git a/research/h25-bookkeeping/payload/baseline/README.md b/research/h25-bookkeeping/payload/baseline/README.md new file mode 100644 index 0000000000..e3ce6e1379 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/README.md @@ -0,0 +1,59 @@ +# Complete frozen H25 qualification with native GF(2) + +The fixed six-run comparison reduced median wall time **27.84%**, from **39.686181760 to 28.636256246 seconds**, and median CPU **28.09%**, from **39.58 to 28.46 seconds**. Both reductions pass the predeclared 15% and within-arm-spread gates. This measures the complete frozen historical `complex_network.py` H25 CLI **with retained exact observations**, including cold source copies, custody checks, imports and serialization. Every candidate additionally pays compilation/link/load and all unchanged independent finite controls. + +This is not a bare-CLI performance factor, a current selected-frontier replay, a new mathematical construction or κ, or a gain on the separate unresolved PR5864 objective. Hosted correctness checks do not reproduce the local performance factor. + +## Complete caller and exact retained outputs + +The caller remains byte-identical to canonical main `19fdb086ea96af9a9f87936a2b888e10af4ed810`. It executes its original side-map, label and role checks, network counts, logarithm enclosure, saving comparison, parameters, guard/recurrence/constraint/margin checks, dyadic/ceiling checks, real upstream source verification and gate bound. The actual CLI writes its original certificate and prints both original lines. No source-verifier stub or stored PASS substitutes for execution. + +The 32-file closure includes twelve scientific scripts, the upstream manifest and its nineteen payloads. The pinned manuscript commit is `adc7f1241b42e322a6451854ab7e4b4c146bf78a`. The seven native-engine files are unchanged from the historical PR5929 side verification work. The full driver checks source bytes, import identities, runtime bindings, before/after modes and the exact output-file set. Original full-call assertions remain enabled. + +All six runs matched the entire certificate, stdout, typed full return, ordered side witness, rank transcript and complement receipt. The typed representation retains exact Fraction pairs, primitive/container type distinctions and dictionary order. It contains no replacement approximate arithmetic. Observations cover **59,959 rank calls, 252 distinct matrices and 238,685 ordered complement calls**. The canonical complement-stream digest represents 55,839,507 observed bytes; the stored complement artifact is its complete receipt, not the stream itself. + +## Fixed experiment and failures + +| Sample, in executed order | Wall seconds | CPU seconds | +|---|---:|---:| +| B1 | 42.103671320 | 41.64 | +| C1 | 28.636256246 | 28.46 | +| C2 | 28.595429725 | 28.44 | +| B2 | 39.355439922 | 39.28 | +| B3 | 39.686181760 | 39.58 | +| C3 | 33.129227289 | 31.92 | + +The slower C3 is retained. Median savings of 11.049925514 wall seconds and 11.12 CPU seconds exceed maximum within-arm spreads of 4.533797564 and 3.48 seconds. See [COMPLETE-GATE.json](evidence/COMPLETE-GATE.json) and the complete [run receipts](evidence/runs/). + +Profile v1 failed during import because its entry filename shadowed the standard-library `profile` module. Its error is preserved. A separate entry-name repair left the scientific driver unchanged; profile v2 established the anchor and is excluded from sample selection. There were no benchmark rerolls or automatic retries. Eight original guarded commands, including those two profile attempts, cost about 253.41 seconds under the unchanged serial 180-second/1-GiB policy. Coarse phase measurements are nested diagnostics and must not be added as independent savings. + +The local bad-input checkpoint `bb01abd…` is retained only as failed preparation evidence. The actual publication input ancestor is **`7f9c2985de167e95d159040eee26fc03c1e27fb6`**, containing exactly 42 added inputs. No source pin requires unmerged PR5929 history. + +## Portable checks and replay + +Use Linux CPython 3.12 with existing `cc` and Python headers. The unchanged guard additionally uses `/usr/bin/python3.12` and GNU `/usr/bin/time`. No package installation is requested. + +```sh +python3.12 -B research/gf2-full-network/verify.py +python3.12 -B -O research/gf2-full-network/verify.py +python3.12 -B research/gf2-full-network/verify_full.py +python3.12 -B research/gf2-full-network/check_artifacts.py +``` + +The first two commands execute the unchanged finite dense-oracle, exact-order/type/width/iterator, fallback and runtime-binding controls, using a fresh external build. Failed evidence is retained at its reported path. Optimization is deliberate only for finite controls. `verify_full.py` performs one complete candidate correctness run with original assertions, an inner 150-second guard and a 180-second registered timeout; it never reports a hosted speed factor or adds a benchmark sample. Source/engine inputs remain read-only; only new external runtime directories are writable. `CODE-SOURCES.json` authenticates executable wrappers and frozen inputs before work. Dynamic publication status and evidence metadata are separately declared. + +Canonical transport comprises six payloads with **60,831,231 logical bytes**. The checker streams the large witness and rank files, authenticates their complete decompressed bytes against the immutable anchor, checks typed-return structure, and checks the literal reference certificate/stdout and complement receipt. Compressed transport hashes preserve archive identity; regenerated compression is not mathematical identity. See [canonical manifest](evidence/canonical/MANIFEST.json) and [VALIDATION.json](VALIDATION.json) for current check status. + +The reported six samples measure `full_driver.py` under the frozen parent guard. Publication wrappers additionally authenticate the archived evidence; their correctness replays are separate checks and do not replace those samples or establish a new wrapper performance factor. + +For an explicitly requested new complete replay, use `replay.py B|C NEW_EXTERNAL_DIRECTORY`. It serializes calls for this package, runs the unchanged guard with a 180-second limit and 1-GiB sampled group RSS cap, retains failure evidence and never retries. New timing receipts do not replace the fixed experiment. + +## Open next questions + +The scoped full historical caller evaluation is complete. Broader caller integration or another interpreter/runtime requires its own source-bound full contract and paid checks before any performance transfer. No additional parameter search, mathematical construction or timing reroll is authorized by this package. Structured scope and blockers are in [TASK.json](TASK.json). + +## Credit and limits + +Chris R / Clear1nsight with substantial OpenAI Codex and user-requested Astra xhigh assistance; separate agents performed source design and independent static review, with one parent owning all serial scientific execution. Author self-checks are not independent review or human/kernel acceptance. Preserve [PR5929](https://github.com/CrocSwap/integer-mult-bounds/pull/5929), the original CrocSwap/P104 authors and source-specific notices. Packed GF(2) elimination is a standard technique, not a novelty claim. Original upstream license/README are retained under `frozen/upstream/`. + +The unchanged engine supports its exact 64-bit domain and original fallback behavior with stable source, builtins and dispatch. This is not abi3, free-threaded/subinterpreter support, a general C-memory-safety proof or formal verification of the multiplication theorem. Historical certificate status and inherited assumptions remain intact. diff --git a/research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json b/research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json new file mode 100644 index 0000000000..6c0c5746fb --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/SOURCE-PINS.json @@ -0,0 +1,130 @@ +{ + "scripts/audit_short_guards.py": [ + "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + 436 + ], + "scripts/certify.py": [ + "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + 436 + ], + "scripts/compact_control_layer.py": [ + "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + 436 + ], + "scripts/complex_circuit.py": [ + "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + 436 + ], + "scripts/complex_network.py": [ + "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + 436 + ], + "scripts/exclusion_circuit.py": [ + "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + 436 + ], + "scripts/paired_exclusion_circuit.py": [ + "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + 436 + ], + "scripts/paired_network.py": [ + "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + 436 + ], + "scripts/prepare_layers.py": [ + "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + 436 + ], + "scripts/search_network.py": [ + "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + 436 + ], + "scripts/shared_point_circuit.py": [ + "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + 436 + ], + "scripts/shared_point_network.py": [ + "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + 436 + ], + "upstream/LICENSE": [ + "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + 436 + ], + "upstream/README.md": [ + "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + 436 + ], + "upstream/build/figures/multiplication-flow.tex": [ + "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + 436 + ], + "upstream/build/figures/proof-map.tex": [ + "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + 436 + ], + "upstream/build/main.tex": [ + "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + 436 + ], + "upstream/build/references.bib": [ + "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + 436 + ], + "upstream/build/sections/00-introduction.tex": [ + "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + 436 + ], + "upstream/build/sections/01-history.tex": [ + "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + 436 + ], + "upstream/build/sections/02-streams.tex": [ + "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + 436 + ], + "upstream/build/sections/03-motifs.tex": [ + "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + 436 + ], + "upstream/build/sections/04-swap.tex": [ + "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + 436 + ], + "upstream/build/sections/05-layers.tex": [ + "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + 436 + ], + "upstream/build/sections/06-transforms.tex": [ + "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + 436 + ], + "upstream/build/sections/07-resampling.tex": [ + "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + 436 + ], + "upstream/build/sections/08-assembly.tex": [ + "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + 436 + ], + "upstream/build/sections/09-exact-arithmetic.tex": [ + "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + 436 + ], + "upstream/build/sections/10-transposition.tex": [ + "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + 436 + ], + "upstream/build/sections/11-grouped-rectangles.tex": [ + "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + 436 + ], + "upstream/formalization.yaml": [ + "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + 436 + ], + "upstream/manifest.json": [ + "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + 436 + ] +} diff --git a/research/h25-bookkeeping/payload/baseline/SOURCES.json b/research/h25-bookkeeping/payload/baseline/SOURCES.json new file mode 100644 index 0000000000..46342cb57a --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/SOURCES.json @@ -0,0 +1,514 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "files": [ + { + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "path": "docs/research/agent-task-catalog.json", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81", + "usage": "provenance" + }, + { + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "path": "certificates/selected-result.json", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "usage": "provenance" + }, + { + "git_blob": "6c0c5746fb991ba87221083c6485046960863331", + "path": "research/gf2-full-network/SOURCE-PINS.json", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/SOURCE-PINS.json", + "sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "usage": "input" + }, + { + "git_blob": "d94920c274c0a47db9763dd595230d52df0bd073", + "path": "research/gf2-full-network/engine/compare_side_verifier.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/compare_side_verifier.py", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "usage": "input" + }, + { + "git_blob": "4168f5c7e4cec0f182750c6908315735011ff061", + "path": "research/gf2-full-network/engine/finite_controls.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/finite_controls.py", + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "usage": "input" + }, + { + "git_blob": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "path": "research/gf2-full-network/engine/native_backend.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/native_backend.py", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "usage": "input" + }, + { + "git_blob": "0b6a835981d54ce7d807a3f54947eddb9eda4f9d", + "path": "research/gf2-full-network/engine/native_gf2.c", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/native_gf2.c", + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "usage": "input" + }, + { + "git_blob": "807855eb875673c47da0ed1b5a890a417e28a846", + "path": "research/gf2-full-network/engine/profile_side_verifier.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/profile_side_verifier.py", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "usage": "input" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "research/gf2-full-network/engine/source/complex_circuit.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "input" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "research/gf2-full-network/engine/source/complex_network.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/engine/source/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "input" + }, + { + "git_blob": "e5c52c8afe086a2d0c9418833c550c865ebf8615", + "path": "research/gf2-full-network/frozen/scripts/audit_short_guards.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/audit_short_guards.py", + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "usage": "input" + }, + { + "git_blob": "a773311b726fd1ef98a056f6f76010e872d7908a", + "path": "research/gf2-full-network/frozen/scripts/certify.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/certify.py", + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "usage": "input" + }, + { + "git_blob": "11b2e751bfb2fb141b586042b6f6fec4e498c763", + "path": "research/gf2-full-network/frozen/scripts/compact_control_layer.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/compact_control_layer.py", + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "usage": "input" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "research/gf2-full-network/frozen/scripts/complex_circuit.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "input" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "research/gf2-full-network/frozen/scripts/complex_network.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "input" + }, + { + "git_blob": "b0e2f3e03d7de791ca936dfd92cee2134c7dd4f5", + "path": "research/gf2-full-network/frozen/scripts/exclusion_circuit.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/exclusion_circuit.py", + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "usage": "input" + }, + { + "git_blob": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "path": "research/gf2-full-network/frozen/scripts/paired_exclusion_circuit.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/paired_exclusion_circuit.py", + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "usage": "input" + }, + { + "git_blob": "910449dd510c89ca24aa56904d225b86abfb3be7", + "path": "research/gf2-full-network/frozen/scripts/paired_network.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/paired_network.py", + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "usage": "input" + }, + { + "git_blob": "8e17b52f9573135426d7ba6865c8c9bc8da8639a", + "path": "research/gf2-full-network/frozen/scripts/prepare_layers.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/prepare_layers.py", + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "usage": "input" + }, + { + "git_blob": "f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b", + "path": "research/gf2-full-network/frozen/scripts/search_network.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/search_network.py", + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "usage": "input" + }, + { + "git_blob": "d0864271884398d44ee1fc70f0d99bb982418156", + "path": "research/gf2-full-network/frozen/scripts/shared_point_circuit.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/shared_point_circuit.py", + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "usage": "input" + }, + { + "git_blob": "0ec7e75046fe714968c49178cd7f83e80e9f9d94", + "path": "research/gf2-full-network/frozen/scripts/shared_point_network.py", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/scripts/shared_point_network.py", + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "usage": "input" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "research/gf2-full-network/frozen/upstream/LICENSE", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "input" + }, + { + "git_blob": "c8cb3c3857907bf3465017b9f7ef1add4df5c29b", + "path": "research/gf2-full-network/frozen/upstream/README.md", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "usage": "input" + }, + { + "git_blob": "f0297c9cb841ad74a7cee4b541e302073d913236", + "path": "research/gf2-full-network/frozen/upstream/build/figures/multiplication-flow.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/figures/multiplication-flow.tex", + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "usage": "input" + }, + { + "git_blob": "a2d539e5a794eb8d679c6cad68c6b8d12b0fc880", + "path": "research/gf2-full-network/frozen/upstream/build/figures/proof-map.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/figures/proof-map.tex", + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "usage": "input" + }, + { + "git_blob": "0b11a3feb14714253c1ca06ee561a31dd2fe8662", + "path": "research/gf2-full-network/frozen/upstream/build/main.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/main.tex", + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "usage": "input" + }, + { + "git_blob": "bf01cae12597f2777199c8ee74ee9f6933a1b56e", + "path": "research/gf2-full-network/frozen/upstream/build/references.bib", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/references.bib", + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "usage": "input" + }, + { + "git_blob": "aa9048eef857c3e694989f5bb5020109e6422502", + "path": "research/gf2-full-network/frozen/upstream/build/sections/00-introduction.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/00-introduction.tex", + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "usage": "input" + }, + { + "git_blob": "7c6f033138f97315c80e64afb6cc446a1d590538", + "path": "research/gf2-full-network/frozen/upstream/build/sections/01-history.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/01-history.tex", + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "usage": "input" + }, + { + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "path": "research/gf2-full-network/frozen/upstream/build/sections/02-streams.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/02-streams.tex", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "usage": "input" + }, + { + "git_blob": "cdb0ba527aa8df5d57c151183fd3893c1a7e21ab", + "path": "research/gf2-full-network/frozen/upstream/build/sections/03-motifs.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/03-motifs.tex", + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "usage": "input" + }, + { + "git_blob": "951e792b1768e6509561380b8bbfb1d1ccb64c08", + "path": "research/gf2-full-network/frozen/upstream/build/sections/04-swap.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "usage": "input" + }, + { + "git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "path": "research/gf2-full-network/frozen/upstream/build/sections/05-layers.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "usage": "input" + }, + { + "git_blob": "de073e9292d58573f7065a3cd4f214e0d05f3444", + "path": "research/gf2-full-network/frozen/upstream/build/sections/06-transforms.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "usage": "input" + }, + { + "git_blob": "256243bf9416baefb82bf9203f80215b9ebe28f2", + "path": "research/gf2-full-network/frozen/upstream/build/sections/07-resampling.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/07-resampling.tex", + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "usage": "input" + }, + { + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "path": "research/gf2-full-network/frozen/upstream/build/sections/08-assembly.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "usage": "input" + }, + { + "git_blob": "4c7a1d63c912d081f70f5b166e9cab92d7774ee6", + "path": "research/gf2-full-network/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "usage": "input" + }, + { + "git_blob": "e69cc8276220edb8617a371ae9044a911fbc0767", + "path": "research/gf2-full-network/frozen/upstream/build/sections/10-transposition.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/10-transposition.tex", + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "usage": "input" + }, + { + "git_blob": "44439c716c6290cd6e512ffac91253443b37d3ab", + "path": "research/gf2-full-network/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "usage": "input" + }, + { + "git_blob": "e0584d4993df01ec08233ab344ebc1b1039bf7f7", + "path": "research/gf2-full-network/frozen/upstream/formalization.yaml", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/formalization.yaml", + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "usage": "input" + }, + { + "git_blob": "01c309e34d36cf3669c43d89c5dfb25cdc31b8af", + "path": "research/gf2-full-network/frozen/upstream/manifest.json", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/frozen/upstream/manifest.json", + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "usage": "input" + }, + { + "git_blob": "62a6091887a3894535c1d059e1b0c527d556eb76", + "path": "research/gf2-full-network/reference/certificates/complex-network.json", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/reference/certificates/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "usage": "input" + }, + { + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "path": "research/gf2-full-network/reference/certificates/selected-result.json", + "pin": "head:7f9c2985de167e95d159040eee26fc03c1e27fb6:research/gf2-full-network/reference/certificates/selected-result.json", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5", + "usage": "input" + }, + { + "git_blob": "e5c52c8afe086a2d0c9418833c550c865ebf8615", + "path": "scripts/audit_short_guards.py", + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "usage": "provenance" + }, + { + "git_blob": "a773311b726fd1ef98a056f6f76010e872d7908a", + "path": "scripts/certify.py", + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "usage": "provenance" + }, + { + "git_blob": "11b2e751bfb2fb141b586042b6f6fec4e498c763", + "path": "scripts/compact_control_layer.py", + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "usage": "provenance" + }, + { + "git_blob": "9e83a1065cd5b5f337b39de58d61bac335feb7ce", + "path": "scripts/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "usage": "provenance" + }, + { + "git_blob": "af9bb6d7b31f3006189761d99bdd919da84656a8", + "path": "scripts/complex_network.py", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "usage": "provenance" + }, + { + "git_blob": "b0e2f3e03d7de791ca936dfd92cee2134c7dd4f5", + "path": "scripts/exclusion_circuit.py", + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "usage": "provenance" + }, + { + "git_blob": "36d1fa2c0235b9b307243a8735e38a3fbf957113", + "path": "scripts/paired_exclusion_circuit.py", + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "usage": "provenance" + }, + { + "git_blob": "910449dd510c89ca24aa56904d225b86abfb3be7", + "path": "scripts/paired_network.py", + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "usage": "provenance" + }, + { + "git_blob": "8e17b52f9573135426d7ba6865c8c9bc8da8639a", + "path": "scripts/prepare_layers.py", + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "usage": "provenance" + }, + { + "git_blob": "f03d5c1b2c81afd6c2f1d3ba9e17d4e7bcd31b9b", + "path": "scripts/search_network.py", + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "usage": "provenance" + }, + { + "git_blob": "d0864271884398d44ee1fc70f0d99bb982418156", + "path": "scripts/shared_point_circuit.py", + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "usage": "provenance" + }, + { + "git_blob": "0ec7e75046fe714968c49178cd7f83e80e9f9d94", + "path": "scripts/shared_point_network.py", + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "usage": "provenance" + }, + { + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "path": "upstream/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "usage": "provenance" + }, + { + "git_blob": "c8cb3c3857907bf3465017b9f7ef1add4df5c29b", + "path": "upstream/README.md", + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "usage": "provenance" + }, + { + "git_blob": "f0297c9cb841ad74a7cee4b541e302073d913236", + "path": "upstream/build/figures/multiplication-flow.tex", + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "usage": "provenance" + }, + { + "git_blob": "a2d539e5a794eb8d679c6cad68c6b8d12b0fc880", + "path": "upstream/build/figures/proof-map.tex", + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "usage": "provenance" + }, + { + "git_blob": "0b11a3feb14714253c1ca06ee561a31dd2fe8662", + "path": "upstream/build/main.tex", + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "usage": "provenance" + }, + { + "git_blob": "bf01cae12597f2777199c8ee74ee9f6933a1b56e", + "path": "upstream/build/references.bib", + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "usage": "provenance" + }, + { + "git_blob": "aa9048eef857c3e694989f5bb5020109e6422502", + "path": "upstream/build/sections/00-introduction.tex", + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "usage": "provenance" + }, + { + "git_blob": "7c6f033138f97315c80e64afb6cc446a1d590538", + "path": "upstream/build/sections/01-history.tex", + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "usage": "provenance" + }, + { + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "path": "upstream/build/sections/02-streams.tex", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "usage": "provenance" + }, + { + "git_blob": "cdb0ba527aa8df5d57c151183fd3893c1a7e21ab", + "path": "upstream/build/sections/03-motifs.tex", + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "usage": "provenance" + }, + { + "git_blob": "951e792b1768e6509561380b8bbfb1d1ccb64c08", + "path": "upstream/build/sections/04-swap.tex", + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "usage": "provenance" + }, + { + "git_blob": "5ce8b3c83c455f221bb84858a97230b0285644aa", + "path": "upstream/build/sections/05-layers.tex", + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "usage": "provenance" + }, + { + "git_blob": "de073e9292d58573f7065a3cd4f214e0d05f3444", + "path": "upstream/build/sections/06-transforms.tex", + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "usage": "provenance" + }, + { + "git_blob": "256243bf9416baefb82bf9203f80215b9ebe28f2", + "path": "upstream/build/sections/07-resampling.tex", + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "usage": "provenance" + }, + { + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "path": "upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "usage": "provenance" + }, + { + "git_blob": "4c7a1d63c912d081f70f5b166e9cab92d7774ee6", + "path": "upstream/build/sections/09-exact-arithmetic.tex", + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "usage": "provenance" + }, + { + "git_blob": "e69cc8276220edb8617a371ae9044a911fbc0767", + "path": "upstream/build/sections/10-transposition.tex", + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "usage": "provenance" + }, + { + "git_blob": "44439c716c6290cd6e512ffac91253443b37d3ab", + "path": "upstream/build/sections/11-grouped-rectangles.tex", + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "usage": "provenance" + }, + { + "git_blob": "e0584d4993df01ec08233ab344ebc1b1039bf7f7", + "path": "upstream/formalization.yaml", + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "usage": "provenance" + }, + { + "git_blob": "01c309e34d36cf3669c43d89c5dfb25cdc31b8af", + "path": "upstream/manifest.json", + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "usage": "provenance" + } + ], + "git_blob_derivation": "SHA1 of exact Git blob header plus authenticated bytes; parent publication preflight checks committed objects", + "input_commit": "7f9c2985de167e95d159040eee26fc03c1e27fb6", + "input_file_count": 42, + "predecessor": { + "engine_bytes_retained_in_input_ancestor": true, + "head": "a456c246ec72a23f327d4b1394fbb3bf7087a65c", + "history_required": false, + "pr": 5929 + }, + "schema_version": 1, + "scope": "Full frozen historical H25 CLI with retained observations, not bare CLI/current frontier/PR5864/kappa transfer" +} diff --git a/research/h25-bookkeeping/payload/baseline/TASK.json b/research/h25-bookkeeping/payload/baseline/TASK.json new file mode 100644 index 0000000000..5aa9b96e92 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/TASK.json @@ -0,0 +1,61 @@ +{ + "actual_scope": "complete-frozen-historical-H25-CLI-with-retained-observations", + "ai_assistance": "Substantial OpenAI Codex and user-requested Astra xhigh source design plus separate static review; parent-only serial scientific execution. No human/kernel acceptance.", + "author": "Chris R / Clear1nsight", + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "evidence": "evidence/COMPLETE-GATE.json, all8 original guard receipts, complete exact canonical artifacts, SOURCE-PINS and anchor", + "open_questions": [ + { + "blocked_by": "No broader caller/runtime evaluation or new research run is authorized by this package.", + "first_step": "Define and authenticate the new full source/output/runtime contract and complete paid controls before requesting any bounded evaluation.", + "question": "Can this exact qualified boundary be carried to another complete caller or runtime without changing coverage?", + "why_it_matters": "The measured factor applies only to this frozen historical H25 caller with retained observations." + } + ], + "original_card": { + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Resolve the current selected review, separate complex/ordinary BIT/admitted BIT/outer budgets, and compare the card against live handoffs before starting. Historical ceilings require exact source/model equivalence.", + "scope": "Source-binding orientation only; not a scientific replay or all-size proof. Materialize selected inputs if this checkout is sparse." + }, + "id": "replay-runtime", + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ], + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ] + }, + "outcome": "completed", + "outcome_scope": "Completed scoped historical full-caller experiment; publication correctness checks pending and separate PR5864 objective remains unresolved.", + "schema_version": 1, + "scope_change_reason": "Explicit user Proceed authorized a distinct complete frozen historical H25 CLI evaluation after the earlier side-only work; all outputs and the full cold candidate bill remain included.", + "scope_status": "refined", + "stop_rule": "One profile anchor excluded from selection; fixed BCCBBC only after admitted first pair; retain every failure/sample and stop at source/output/resource/target/noise failure, with no automatic retries.", + "task_id": "replay-runtime", + "time_budget_minutes": 60 +} diff --git a/research/h25-bookkeeping/payload/baseline/VALIDATION.json b/research/h25-bookkeeping/payload/baseline/VALIDATION.json new file mode 100644 index 0000000000..f67bdbd450 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/VALIDATION.json @@ -0,0 +1,123 @@ +{ + "checks": { + "publication-canonical-transport": { + "exit": 0, + "label": "publication-canonical-transport", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "ff0f4e928e2beeddd38b4b67a446c5eb75dbf9f1c78cac386fc0c6528108f205", + "sampled_process_group_rss_bytes": 26345472, + "script": "stages/publication-v1/check_transport.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "ed6d9bcbd7d76f82a5a40df784b8c16ef9709ba7235da5598be540e124077e8e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 392, + "stdout_sha256": "1a4f7854eeab9a589528ccc5d001940e74df4473a35518050b1ab2defa67176d", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 24736, + "system_seconds": 0.05, + "user_seconds": 0.68 + }, + "wall_seconds": 0.7663612379983533 + }, + "publication-finite-normal": { + "exit": 0, + "label": "publication-finite-normal", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "ff0f4e928e2beeddd38b4b67a446c5eb75dbf9f1c78cac386fc0c6528108f205", + "sampled_process_group_rss_bytes": 73506816, + "script": "stages/publication-v1/check_finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "ed6d9bcbd7d76f82a5a40df784b8c16ef9709ba7235da5598be540e124077e8e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 575, + "stdout_sha256": "9522d5f1fb2e4dde550559ef599c08919941047cfbe387c5af7131244515424e", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 41120, + "system_seconds": 0.06, + "user_seconds": 1.97 + }, + "wall_seconds": 2.0647785399924032 + }, + "publication-finite-optimized": { + "exit": 0, + "label": "publication-finite-optimized", + "optimized": true, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "ff0f4e928e2beeddd38b4b67a446c5eb75dbf9f1c78cac386fc0c6528108f205", + "sampled_process_group_rss_bytes": 73236480, + "script": "stages/publication-v1/check_finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "ed6d9bcbd7d76f82a5a40df784b8c16ef9709ba7235da5598be540e124077e8e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 574, + "stdout_sha256": "8b661cc34b2199abdf120c09ad32998a16ebec24ed6ab136b8de03cf1cb83f26", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 41028, + "system_seconds": 0.07, + "user_seconds": 2.04 + }, + "wall_seconds": 2.21852564701112 + }, + "publication-full-readonly-C-v2": { + "exit": 0, + "label": "publication-full-readonly-C-v2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "c71bb6ce1a6800940f337ac415e47de59508cec9cbeed690e5576908f0a0edb2", + "sampled_process_group_rss_bytes": 43126784, + "script": "stages/publication-v2/check_full.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "430c2c0870bdff3afa81929182da5c1185873abfb190fc95158ca5cb6e0f3fb3", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1094, + "stdout_sha256": "398adc722aca188a4c758a29dd3ebd45a1028cab3f0f4464f4e1c8d09a77eaac", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453844, + "system_seconds": 4.58, + "user_seconds": 40.79 + }, + "wall_seconds": 31.122465827997075 + } + }, + "fixed_performance_samples_unchanged": true, + "full_cleanup_v1_failure": "evidence/publication-v1-failure/", + "historical_experiment": "evidence/COMPLETE-GATE.json", + "hosted_checks_are_not_performance_samples": true, + "immutability": "This mutable check-status file is explicitly excluded from CODE-SOURCES; protected123files unchanged from readonly validation stages except wrapper repair sourcev2 already tested.", + "independent_publication_review": { + "sha256": "1ba3d1fe540fc544f3e85c65710a10bde8a55209a78ae9184e17c8ed1c76af46", + "text": "# Publication source review: complete frozen H25 GF(2)\n\n2026-10-28. **STATIC GO for one corrected publication-v2 full C correctness replay.** The first readonly publication attempt exposed a concrete cleanup defect, now repaired without changing the measured scientific driver, native engine or six performance samples. No remaining source blocker was found. This review supplies source clearance; it does not assert that the corrected run or hosted final-head checks have passed.\n\nReviewed package: `publication-repo/research/gf2-full-network/` under this round. Final reviewed `CODE-SOURCES.json` SHA-256 is `0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7`, covering 123 immutable files. Every listed file matched its digest in this static check. The publication-v2 stage has the identical manifest, driver and repaired wrapper. The driver remains `0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36`, retaining the earlier source-review boundary.\n\n## Concrete failure and repair\n\nOriginal `verify_full.py:28` called `shutil.rmtree(temporary)` after successful verification. The full driver copies source directories with `copytree`; readonly export directories therefore retain mode 0555 inside the private runtime tree. Only the runtime root was made writable for the original certificate output. Unprivileged cleanup could not unlink files within the nested readonly engine directories.\n\nThe retained `runtime/runs/publication-full-readonly-C/` receipt confirms outer exit 1 after 33.381816457 seconds, unchanged source bytes/modes, and a `PermissionError` unlinking `finite_controls.py`. The inner scientific guard passed. This was a publication cleanup failure after scientific success, not a discarded timing sample or a changed theorem result. The package preserves the original wrapper as text plus receipt/stdout/stderr/usage and revision explanation in `evidence/publication-v1-failure/`.\n\nRepaired `verify_full.py`, SHA-256 `c65351d258bac75ae661298a351861452c81f990dd82768da819c1910cba8cd8`, changes only nonsymlink directories below its newly created private temporary root to 0755, after the replay's full scientific equality and source authentication checks. It then removes that private tree within the caught block. Immutable package/source directories are never chmodded; copied input file modes remain unchanged when verified. The corrected stage still has 0555 source directories and 0444 source files. This directly addresses the observed failure and justifies one fresh correctness validation, excluded from performance selection.\n\n## Wrappers, freshness and resource boundary\n\n`archive_support.py` authenticates every protected file, rejects symlinks and requires an exact Python/C code census. `CODE-SOURCES.json` itself is bound through committed package identity rather than an impossible self-hash. `VALIDATION.json` and optional publication status are explicitly mutable and never consulted as scientific PASS inputs.\n\n`replay.py` authenticates the guard from source, takes a nonblocking package-specific lock, requires a new output directory outside the repository and runs one B or C subprocess with no retry. It sets the guard's complete protected closure, timeout, aggregate allowance and 1-GiB sampled group RSS cap. The unchanged guard removes ambient Python-path/optimization settings and starts `/usr/bin/python3.12 -B` with external bytecode storage. Full entries reject optimized execution; the full driver additionally rejects already-loaded scientific modules and requires CPython 3.12. All scientific inputs and outputs are fresh private copies; no prior mutable result or PASS receipt replaces live work.\n\n`verify.py` launches the unchanged finite harness with a fresh external build/output directory. It preserves the requested normal or `-O` interpreter mode and checks the resulting mode. The finite controls use explicit checks rather than removable assertions. Both registered modes therefore exercise their controls anew; neither runs the full CLI with assertions disabled.\n\n`verify_full.py` requests one candidate replay with a 150-second inner guard. `VERIFY.json` gives it a 180-second outer timeout, leaving a nominal 30-second wrapper/cleanup margin. This is a bounded correctness check, not a promise of success on every host. The platform dependencies are disclosed. None of these wrappers requires Git or network access at execution time.\n\n## Input and output custody\n\n`SOURCES.json` contains exactly 42 input rows, all pinned to ancestor `7f9c2985de167e95d159040eee26fc03c1e27fb6`. Their paths equal the `VERIFY.json` input set and their hashes equal the retained `INPUT-COMMIT.json` inventory. No executable dependency requires unmerged PR5929 history. Commit ancestry/object verification remains the parent's publication check; I performed no Git operations.\n\n`check_artifacts.py` authenticates the six-payload transport manifest, bounds and streams decompression, and compares complete logical hashes against the immutable anchor. It checks full witness/rank byte counts, the typed-return structure, the literal reference certificate and complement receipt. Its typed validation supplements exact anchored bytes; it does not substitute a new numerical oracle. The README explicitly distinguishes the 55,839,507-byte observed complement stream from its stored digest/count/schema receipt. The large witness and rank artifacts retain their full logical bytes.\n\n## Claim and remaining publication work\n\nThe README/TASK/SOURCES/VERIFY boundary is appropriate: the fixed BCCBBC experiment measures the complete frozen historical H25 CLI **with retained exact observations**, cold copies/imports/custody/serialization, and every candidate's cold compile/link/load plus unchanged independent finite controls. Original full CLI assertions, real upstream verification, certificate and stdout remain executed through the unchanged driver. Publication wrappers add archive authentication overhead and their replays do not replace the measured driver samples.\n\nThe retained complete gate reports 27.843257% median wall and 28.094997% CPU reduction, passing the declared target and noise gates; slower C3 and both profile attempts remain visible. This review does not independently repeat those timings. The claim excludes bare-CLI, selected-frontier, PR5864 and kappa transfers. Predecessor credit and mathematical limitations are retained.\n\nThe parent must finish the already planned corrected readonly replay, commit/export metadata verification and exact-head hosted checks, then update mutable publication status from actual evidence. No new benchmark sequence, control requirement or mathematical work is requested. The earlier PR5864 goal remains separately blocked and paused streams remain paused.\n\nReviewer activity was limited to source/metadata reads, static inventories and hashes, retained receipt inspection, this report, and parent communication. No scientific module import, corpus decoding, compiler/numerical execution, Git/browser operation or delegation was performed.\n" + }, + "pending": [ + "committed-byte/source-history/export checks", + "hosted exact-head CI" + ], + "schema_version": 1, + "status": "PASS_LOCAL_REGISTERED_CHECKS_AND_READONLY_GITFREE" +} diff --git a/research/h25-bookkeeping/payload/baseline/VERIFY.json b/research/h25-bookkeeping/payload/baseline/VERIFY.json new file mode 100644 index 0000000000..f401ee9242 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/VERIFY.json @@ -0,0 +1,89 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "checks": "Fresh unchanged finite dense-oracle, exact-order/type/width/fallback/source/runtime-binding controls; external cold build, no full benchmark.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-B", + "-O", + "{package}/verify.py" + ], + "checks": "Same finite controls in deliberate optimized mode; full scientific assertions are not disabled.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify_full.py" + ], + "checks": "One complete candidate correctness replay through unchanged full driver and150-second/1GiB inner guard; exact original certificate/stdout/types/witness/rank/complement and source checks; no hosted performance factor.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/check_artifacts.py" + ], + "checks": "Bounded complete lossless canonical transport/typed-return/certificate checks; stream58MB witness, no scientific replay or benchmark.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/gf2-full-network/SOURCE-PINS.json", + "research/gf2-full-network/engine/compare_side_verifier.py", + "research/gf2-full-network/engine/finite_controls.py", + "research/gf2-full-network/engine/native_backend.py", + "research/gf2-full-network/engine/native_gf2.c", + "research/gf2-full-network/engine/profile_side_verifier.py", + "research/gf2-full-network/engine/source/complex_circuit.py", + "research/gf2-full-network/engine/source/complex_network.py", + "research/gf2-full-network/frozen/scripts/audit_short_guards.py", + "research/gf2-full-network/frozen/scripts/certify.py", + "research/gf2-full-network/frozen/scripts/compact_control_layer.py", + "research/gf2-full-network/frozen/scripts/complex_circuit.py", + "research/gf2-full-network/frozen/scripts/complex_network.py", + "research/gf2-full-network/frozen/scripts/exclusion_circuit.py", + "research/gf2-full-network/frozen/scripts/paired_exclusion_circuit.py", + "research/gf2-full-network/frozen/scripts/paired_network.py", + "research/gf2-full-network/frozen/scripts/prepare_layers.py", + "research/gf2-full-network/frozen/scripts/search_network.py", + "research/gf2-full-network/frozen/scripts/shared_point_circuit.py", + "research/gf2-full-network/frozen/scripts/shared_point_network.py", + "research/gf2-full-network/frozen/upstream/LICENSE", + "research/gf2-full-network/frozen/upstream/README.md", + "research/gf2-full-network/frozen/upstream/build/figures/multiplication-flow.tex", + "research/gf2-full-network/frozen/upstream/build/figures/proof-map.tex", + "research/gf2-full-network/frozen/upstream/build/main.tex", + "research/gf2-full-network/frozen/upstream/build/references.bib", + "research/gf2-full-network/frozen/upstream/build/sections/00-introduction.tex", + "research/gf2-full-network/frozen/upstream/build/sections/01-history.tex", + "research/gf2-full-network/frozen/upstream/build/sections/02-streams.tex", + "research/gf2-full-network/frozen/upstream/build/sections/03-motifs.tex", + "research/gf2-full-network/frozen/upstream/build/sections/04-swap.tex", + "research/gf2-full-network/frozen/upstream/build/sections/05-layers.tex", + "research/gf2-full-network/frozen/upstream/build/sections/06-transforms.tex", + "research/gf2-full-network/frozen/upstream/build/sections/07-resampling.tex", + "research/gf2-full-network/frozen/upstream/build/sections/08-assembly.tex", + "research/gf2-full-network/frozen/upstream/build/sections/09-exact-arithmetic.tex", + "research/gf2-full-network/frozen/upstream/build/sections/10-transposition.tex", + "research/gf2-full-network/frozen/upstream/build/sections/11-grouped-rectangles.tex", + "research/gf2-full-network/frozen/upstream/formalization.yaml", + "research/gf2-full-network/frozen/upstream/manifest.json", + "research/gf2-full-network/reference/certificates/complex-network.json", + "research/gf2-full-network/reference/certificates/selected-result.json" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/h25-bookkeeping/payload/baseline/anchor.json b/research/h25-bookkeeping/payload/baseline/anchor.json new file mode 100644 index 0000000000..a593a05004 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/anchor.json @@ -0,0 +1 @@ +{"base_commit":"19fdb086ea96af9a9f87936a2b888e10af4ed810","driver_sha256":"0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36","engine_pins":{"compare_side_verifier.py":"6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68","finite_controls.py":"df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a","native_backend.py":"e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5","native_gf2.c":"e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc","profile_side_verifier.py":"9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a","source/complex_circuit.py":"d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1","source/complex_network.py":"0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b"},"schema":"gf2-full-network-anchor-v1","science":{"full_cli_certificate_sha256":"1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f","full_cli_stdout_sha256":"8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015","full_return_lossless_sha256":"542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd","ordered_complements":{"calls":238685,"canonical_stream_bytes":55839507,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"},"side":{"exact_witness_sha256":"4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82","rank_call_count":59959,"rank_distinct_matrix_count":252,"rank_trace_sha256":"85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f","result_sha256":"342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c","serialized_bytes":{"rank_trace":2674272,"result":527,"witness":58143622}},"upstream_commit":"adc7f1241b42e322a6451854ab7e4b4c146bf78a"},"source_pin_sha256":"88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7"} diff --git a/research/h25-bookkeeping/payload/baseline/archive_support.py b/research/h25-bookkeeping/payload/baseline/archive_support.py new file mode 100644 index 0000000000..e11ddca588 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/archive_support.py @@ -0,0 +1,58 @@ +"""Portable wrappers around unchanged measured full-network code; Apache-2.0.""" +from hashlib import sha256 +import json +import os +from pathlib import Path +import runpy +import sys +import types + +ROOT=Path(__file__).resolve().parent + + +def need(ok,why): + if not ok:raise ValueError(why) + + +def digest(path): + h=sha256() + with path.open('rb') as stream: + for block in iter(lambda:stream.read(1024*1024),b''):h.update(block) + return h.hexdigest() + + +def authenticate(): + manifest=json.loads((ROOT/'CODE-SOURCES.json').read_text()) + need(manifest['schema_version']==1,'code/source manifest version') + for name,expected in manifest['files'].items(): + path=ROOT/name + need(not path.is_symlink() and path.is_file() and digest(path)==expected,'exact protected source: '+name) + expected_code={p for p in manifest['files'] if Path(p).suffix in ('.py','.c')} + actual_code={str(p.relative_to(ROOT)) for p in ROOT.rglob('*') if p.is_file() and p.suffix in ('.py','.c')} + need(actual_code==expected_code,'complete protected code census') + need(not any(p.is_symlink() for p in ROOT.rglob('*')),'no package symlinks') + return manifest + + +def source_module(name,path): + authenticate();raw=path.read_bytes() + module=types.ModuleType(name);module.__file__=str(path) + exec(compile(raw,str(path),'exec'),module.__dict__) + return module + + +def external(path): + path=Path(path).resolve() + need(not path.exists() and not path.is_relative_to(ROOT.parent.parent),'fresh external evidence path required') + return path + + +def full_entry(arm): + need(arm in ('B','C') and sys.flags.optimize==0,'full caller requires B/C and original assertions') + authenticate() + output=external(os.environ['CROC_GF2_FULL_OUTPUT']) + driver=ROOT/'full_driver.py' + sys.argv=[str(driver),'--frozen-root',str(ROOT/'frozen'),'--reference',str(ROOT/'reference/certificates/complex-network.json'), + '--mode','baseline' if arm=='B' else 'candidate','--anchor',str(ROOT/'anchor.json'),'--output',str(output)] + runpy.run_path(str(driver),run_name='__main__') + authenticate() diff --git a/research/h25-bookkeeping/payload/baseline/check_artifacts.py b/research/h25-bookkeeping/payload/baseline/check_artifacts.py new file mode 100644 index 0000000000..9ef7653323 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/check_artifacts.py @@ -0,0 +1,69 @@ +"""Bounded complete canonical transport checks; no scientific replay or timing.""" +from hashlib import sha256 +import gzip +import json +from pathlib import Path +import sys +import types +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('check_artifacts.py','archive_support.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('transport wrapper source pin: '+name) +S=types.ModuleType('_gf2_transport_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def typed(node): + S.need(type(node) is list and bool(node) and type(node[0]) is str,'exact typed node') + tag=node[0] + if tag=='None':S.need(len(node)==1,'typed None') + elif tag=='Fraction':S.need(len(node)==3 and type(node[1]) is type(node[2]) is int and node[2]>0,'exact Fraction pair') + elif tag in ('bool','str'):S.need(len(node)==2 and type(node[1]) is (bool if tag=='bool' else str),'exact primitive type') + elif tag=='int':S.need(len(node)==2 and type(node[1]) is str and str(int(node[1]))==node[1],'canonical exact integer string') + elif tag=='float':S.need(len(node)==2 and type(node[1]) is str and float.fromhex(node[1]).hex()==node[1],'lossless float hex') + elif tag in ('list','tuple'): + S.need(len(node)==2 and type(node[1]) is list,'typed sequence') + for item in node[1]:typed(item) + elif tag=='dict': + S.need(len(node)==2 and type(node[1]) is list,'ordered typed dictionary') + for item in node[1]: + S.need(type(item) is list and len(item)==2,'ordered dictionary pair') + typed(item[0]);typed(item[1]) + else:raise ValueError('unknown exact type tag') + + +def main(): + S.need(len(sys.argv)==1,'no alternate transport input') + S.authenticate();science=json.loads((ROOT/'anchor.json').read_text())['science'] + directory=ROOT/'evidence/canonical';manifest=json.loads((directory/'MANIFEST.json').read_text()) + expected={'witness.json.gz':science['side']['exact_witness_sha256'],'rank-trace.json.gz':science['side']['rank_trace_sha256'], + 'full-return.lossless.json.gz':science['full_return_lossless_sha256'],'complex-network.json':science['full_cli_certificate_sha256'], + 'original-stdout.txt':science['full_cli_stdout_sha256']} + complement=(json.dumps(science['ordered_complements'],sort_keys=True,separators=(',',':'))+'\n').encode() + expected['complement-transcript.json']=sha256(complement).hexdigest() + S.need(manifest['schema_version']==1 and set(manifest['artifacts'])==set(expected),'complete six-payload transport census') + totals={};small={} + for name,expected_hash in expected.items(): + row=manifest['artifacts'][name];path=directory/name + S.need(path.is_file() and not path.is_symlink(),'regular canonical artifact') + S.need(type(row['logical_bytes']) is int and 0<=row['logical_bytes']<=128*1024**2 and row['logical_sha256']==expected_hash,'anchor-bound logical payload') + encoding='gzip' if name.endswith('.gz') else 'plain' + S.need(row['encoding']==encoding and type(row['transport_bytes']) is int and path.stat().st_size==row['transport_bytes'] and S.digest(path)==row['transport_sha256'],'committed transport integrity') + h=sha256();count=0;parts=[] + with (gzip.open(path,'rb') if encoding=='gzip' else path.open('rb')) as stream: + for block in iter(lambda:stream.read(1024*1024),b''): + count+=len(block);S.need(count<=row['logical_bytes'],'bounded complete payload') + h.update(block) + if name not in ('witness.json.gz','rank-trace.json.gz'):parts.append(block) + S.need(count==row['logical_bytes'] and h.hexdigest()==expected_hash,'complete decompressed payload equality') + totals[name]=count + if parts:small[name]=b''.join(parts) + S.need(totals['witness.json.gz']==science['side']['serialized_bytes']['witness'] and totals['rank-trace.json.gz']==science['side']['serialized_bytes']['rank_trace'],'complete witness/rank byte counts') + typed(json.loads(small['full-return.lossless.json.gz'])) + S.need(small['complex-network.json']==(ROOT/'reference/certificates/complex-network.json').read_bytes(),'literal original certificate bytes') + S.need(small['complement-transcript.json']==complement,'complete complement receipt') + S.authenticate() + print(json.dumps(dict(status='PASS_FULL_NETWORK_CANONICAL_TRANSPORT',payload_bytes=totals,full_typed_shape=True,no_benchmark_or_theorem_claim=True,regenerated_container_hash_is_not_mathematical_identity=True),sort_keys=True)) + + +if __name__=='__main__':main() diff --git a/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py b/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py new file mode 100644 index 0000000000..d94920c274 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +"""One cold finite or complete side-verification run, under the parent's guard. + +The baseline and candidate serialize identical complete result, structural/ +label/role witness, and rank transcript artifacts. Candidate additionally pays +all C compilation/link/load and independent finite/binding/fallback controls. +No profile or warm-build reuse; no orchestration, retry, search or parallelism. +""" +from __future__ import annotations + +import time +START_WALL = time.perf_counter() +import argparse +import hashlib +import json +from pathlib import Path +import resource +import sys + +sys.dont_write_bytecode = True +from native_backend import (ROOT, SOURCE_SHA256, CALLER_SHA256, ComplementTrace, attach_trace, + bind, build_native, guard_module, load_source, require) +from finite_controls import run_controls +from profile_side_verifier import canonical, source_check + +EXPECTED = { + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, +} + + +def cpu_seconds(): + own = resource.getrusage(resource.RUSAGE_SELF) + children = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + children.ru_utime + children.ru_stime + + +def scientific_run(module, phases): + def phase(name, action): + wall, cpu = time.perf_counter(), cpu_seconds() + answer = action() + phases[name] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + return answer + + c = phase("construction", lambda: module.ComplexSideCircuit(25)) + checks = phase("checks_initialization", lambda: module.Checks(c)) + code = phase("compile_roles", lambda: module.compile_roles(c)) + side_map = phase("verify_map", checks.verify_map) + labels = phase("verify_labels", checks.verify_labels) + roles = phase("verify_role_frames", lambda: module.verify_role_frames(c, checks, code)) + result = {"circuit": c.stats(), "side_map": side_map, "labels": labels, "role_frames": roles} + # This exactly matches profile_side_verifier.py's predeclared witness + # representation. Preserve basis and code dict insertion order as lists. + witness = { + "support": c.support, + "args": c.args, + "kind": c.kind, + "active": sorted(c.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) + for target, node, coefficient in c.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) + for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], + "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + return result, witness + + +def write_scientific(output, result, witness, rank_calls): + encoded_result = canonical(result) + encoded_witness = canonical(witness) + encoded_trace = canonical(rank_calls) + receipt = { + "result_sha256": hashlib.sha256(encoded_result).hexdigest(), + "exact_witness_sha256": hashlib.sha256(encoded_witness).hexdigest(), + "rank_trace_sha256": hashlib.sha256(encoded_trace).hexdigest(), + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len({rows for rows, _ in rank_calls}), + } + require(receipt == EXPECTED, "Complete output, ordered witness, or rank trace changed from the frozen profile") + # Same exact bytes and serialization work in both arms; file hashes omit + # a trailing newline exactly as the existing profile's digest did. + (output / "result.json").write_bytes(encoded_result) + (output / "witness.json").write_bytes(encoded_witness) + (output / "rank-trace.json").write_bytes(encoded_trace) + receipt["serialized_bytes"] = {"result": len(encoded_result), "witness": len(encoded_witness), + "rank_trace": len(encoded_trace)} + return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--mode", choices=("finite", "baseline", "candidate"), required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--expected-complement-sha256", help="Lock to the parent-recorded fresh v2 baseline complement stream") + args = parser.parse_args() + require(args.mode != "candidate" or args.expected_complement_sha256 is not None, "Candidate requires the fresh baseline complement SHA-256 before execution") + require(args.expected_complement_sha256 is None or (args.mode != "finite" and len(args.expected_complement_sha256) == 64 and all(c in "0123456789abcdef" for c in args.expected_complement_sha256)), "Invalid or inapplicable expected complement SHA-256") + require(not args.output.exists(), "Refusing to overwrite earlier run evidence") + args.output.mkdir(parents=True) + require(source_check() == 25, "Frozen H changed") + if args.mode != "finite": + require(sys.flags.optimize == 0, "Complete measurements require all unchanged source assertions") + phases = {} + controls = None + native = None + build = None + if args.mode in ("finite", "candidate"): + wall, cpu = time.perf_counter(), cpu_seconds() + native, build = build_native(args.output / "cold-build") + phases["cold_compile_link_load"] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + wall, cpu = time.perf_counter(), cpu_seconds() + controls = run_controls(native) + phases["all_finite_independent_binding_fallback_controls"] = { + "wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu, + } + (args.output / "finite-controls.json").write_text(json.dumps(controls, indent=2, sort_keys=True) + "\n") + complete = None + binding = None + if args.mode != "finite": + rank_calls = [] + wall, cpu = time.perf_counter(), cpu_seconds() + module = load_source("_matrix_complete_" + args.mode) + complement_trace = ComplementTrace(module.Label) + if args.mode == "candidate": + binding = bind(module, native, rank_calls, complement_trace) + else: + guard_module(module) + attach_trace(module, rank_calls, complement_trace) + phases["cold_source_load_guard_bind"] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + result, witness = scientific_run(module, phases) + wall, cpu = time.perf_counter(), cpu_seconds() + complete = write_scientific(args.output, result, witness, rank_calls) + phases["same_complete_witness_trace_serialization"] = { + "wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu, + } + complete["result"] = result + complete["complement_trace"] = complement_trace.receipt() + require(complete["complement_trace"]["calls"] == 238685, "Complete ordered complement call coverage changed") + if args.expected_complement_sha256 is not None: + require(complete["complement_trace"]["sha256"] == args.expected_complement_sha256, "Complete complement stream differs from the fresh baseline") + (args.output / "complement-transcript.json").write_text(json.dumps(complete["complement_trace"], indent=2, sort_keys=True) + "\n") + if binding is not None: + expected_calls = {"complement_native": 238685, "complement_fallback": 0, + "gram_native": 59959, "gram_fallback": 0} + require(binding["counters"] == expected_calls, "Frozen complete native call coverage changed") + complete["native_calls"] = dict(binding["counters"]) + source_files = ("native_gf2.c", "native_backend.py", "finite_controls.py", + "compare_side_verifier.py", "profile_side_verifier.py") + sources = {name: hashlib.sha256((ROOT / name).read_bytes()).hexdigest() for name in source_files} + receipt = { + "status": "FINITE_PASS" if args.mode == "finite" else "COMPLETE_SIDE_PASS", + "mode": args.mode, + "qualification_revision": 2, + "expected_complement_sha256": args.expected_complement_sha256, + "base_main": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "frozen_sources": {"complex_circuit.py": SOURCE_SHA256, "complex_network.py": CALLER_SHA256}, + "engineering_sources": sources, + "complete": complete, + "controls": controls, + "build": build, + "phases": phases, + "measured_wall_seconds_before_receipt_write": time.perf_counter() - START_WALL, + "process_plus_compiler_cpu_seconds_before_receipt_write": cpu_seconds(), + "environment": {"python": sys.version, "executable": sys.executable, + "platform": sys.platform, "optimization": sys.flags.optimize}, + "measurement_scope": "Cold entire process; parent guard outer wall/CPU is authoritative. Both arms write identical complete witness bytes. Candidate additionally compiles, links, loads and runs every finite/native/binding control.", + "scientific_scope": "Frozen H=25 complex side verification only; no full network certificate, selected frontier, PR5864 gain, new construction, parameter search or kappa admission.", + } + (args.output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(json.dumps({"status": receipt["status"], "mode": args.mode, + "wall_seconds": receipt["measured_wall_seconds_before_receipt_write"], + "cpu_seconds_with_compiler": receipt["process_plus_compiler_cpu_seconds_before_receipt_write"], + "complete_hashes": None if complete is None else {key: complete[key] for key in EXPECTED}, + "complement_trace": None if complete is None else complete["complement_trace"], + "controls": None if controls is None else controls["status"], + "phases": phases}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/payload/baseline/engine/finite_controls.py b/research/h25-bookkeeping/payload/baseline/engine/finite_controls.py new file mode 100644 index 0000000000..4168f5c7e4 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/finite_controls.py @@ -0,0 +1,456 @@ +"""Finite independent qualification for the bounded packed GF(2) backend. + +The source oracle is a fresh unchanged module. The second oracle uses dense +0/1 lists and addition modulo two; it never calls the native extension or the +source's packed rank, dot, echelon, reduce, or complement routines. +""" +from __future__ import annotations + +from collections import UserDict +import builtins +from types import FunctionType +import hashlib +from itertools import permutations, product +import json +import time + +from native_backend import ComplementTrace, attach_trace, bind, guard_module, load_source, require + + +def dense_rank(rows, width): + work = [list(row) for row in rows] + require(all(len(row) == width and all(x in (0, 1) for x in row) for row in work), + "Independent oracle requires dense binary rows") + rank = 0 + for column in range(width - 1, -1, -1): + pivot = next((i for i in range(rank, len(work)) if work[i][column]), None) + if pivot is None: + continue + work[rank], work[pivot] = work[pivot], work[rank] + for i in range(rank + 1, len(work)): + if work[i][column]: + work[i] = [(a + b) % 2 for a, b in zip(work[i], work[rank])] + rank += 1 + return rank + + +def dense_vectors(vectors, width): + return [[(value // (2 ** column)) % 2 for column in range(width)] for value in vectors] + + +def pairing_rows(left, right, width): + left_dense = dense_vectors(left, width) + right_dense = dense_vectors(right, width) + return [[sum(a * b for a, b in zip(x, y)) % 2 for y in right_dense] for x in left_dense] + + +def independent_complement(small, big, out): + width = max((x.bit_length() for x in small + big + out), default=0) + big_dense = dense_vectors(big, width) + out_dense = dense_vectors(out, width) + big_rank = dense_rank(big_dense, width) + pairing = pairing_rows(big, small, width) + pairing_rank = dense_rank(pairing, len(small)) + require(all(value == 0 for row in pairing_rows(out, small, width) for value in row), + "Independent oracle found a nonorthogonal complement vector") + require(dense_rank(big_dense + out_dense, width) == big_rank, + "Independent oracle found a complement vector outside the ambient span") + require(len(out) == len(big) - pairing_rank, + "Independent oracle found a wrong number of coefficient-kernel vectors") + require(dense_rank(out_dense, width) == big_rank - pairing_rank, + "Independent oracle found an incomplete complement span") + + +def raw(label, rows, factory=dict): + obj = object.__new__(label) + obj.basis = factory((i, value) for i, value in enumerate(rows)) + return obj + + +def exact_list(actual, expected): + require(type(actual) is list and type(expected) is list, "Complement output is not an exact list") + require(all(type(value) is int for value in actual), "Complement output contains a non-int") + require(actual == expected, "Ordered complement vectors differ from the unchanged source") + + +def capture(action): + try: + value = action() + except Exception as error: + return ("error", type(error).__name__, str(error)) + return ("value", type(value).__name__, value) + + +class IntSubclass(int): + pass + + +class DictSubclass(dict): + pass + + +class ValuesOnly: + def __init__(self, pairs): + self.rows = tuple(value for _, value in pairs) + + def values(self): + return iter(self.rows) + + +class BrokenValues: + def __init__(self, pairs): + self.rows = tuple(value for _, value in pairs) + + def values(self): + def iterator(): + yield from self.rows[:1] + raise ValueError("frozen broken values iterator") + return iterator() + + +def run_controls(native): + oracle = load_source("_matrix_finite_unchanged_oracle") + candidate = load_source("_matrix_finite_candidate") + guard_module(oracle) + state = bind(candidate, native) + counts = {"ordered_complements": 0, "gram_cases": 0, "fallback_cases": 0, + "boundary_cases": 0, "real_label_permutations": 0, "binding_rejections": 0, + "oracle_negative_controls": 0} + transcript = hashlib.sha256() + + def record(tag, *values): + transcript.update(json.dumps((tag, values), separators=(",", ":"), sort_keys=True).encode("ascii") + b"\n") + + def complement_case(small, big): + reference = oracle.Label.complement_in(raw(oracle.Label, small), raw(oracle.Label, big)) + actual = candidate.Label.complement_in(raw(candidate.Label, small), raw(candidate.Label, big)) + exact_list(actual, reference) + independent_complement(list(small), list(big), actual) + record("complement", small, big, actual) + counts["ordered_complements"] += 1 + + def gram_case(vectors): + reference = oracle.Label.nondegenerate(raw(oracle.Label, vectors)) + actual = candidate.Label.nondegenerate(raw(candidate.Label, vectors)) + width = max((x.bit_length() for x in vectors), default=0) + dense = pairing_rows(vectors, vectors, width) + independent = dense_rank(dense, len(vectors)) == len(vectors) + require(type(actual) is bool and actual is reference and actual is independent, + "Gram nondegeneracy differs from an independent oracle") + answer = native.gram_rank(dict(enumerate(vectors))) + if answer is not NotImplemented: + rows, rank = answer + reference_rows = tuple(sum(value * (2 ** j) for j, value in enumerate(row)) for row in dense) + require(type(rows) is tuple and all(type(row) is int for row in rows), "Native Gram row types changed") + require(type(rank) is int and rows == reference_rows and rank == dense_rank(dense, len(vectors)), + "Native Gram transcript differs from the dense oracle") + record("gram", vectors, actual) + counts["gram_cases"] += 1 + + # Exhaustive ordered row lists (including zero/dependence), widths <= 3. + short = [()] + [tuple(row) for n in (1, 2) for row in product(range(8), repeat=n)] + for small in short: + for big in short: + complement_case(small, big) + for n in range(4): + for rows in product(range(8), repeat=n): + gram_case(rows) + + # Cross native word, augmented-width, independent/dependent and permutation + # boundaries without assuming a machine word bound for the Python fallback. + coordinates64 = tuple(1 << i for i in range(64)) + boundary_pairs = [ + ((), coordinates64), + ((1 << 63,), coordinates64[:63]), + (coordinates64[:63], (1 << 63,)), + (coordinates64, ()), + ((1,), coordinates64), # augmented 65 -> fallback + (coordinates64, (1,)), # augmented 65 -> fallback + ((), coordinates64 + (1 << 64,)), # 65 values -> fallback + ((1 << 64,), (1, 1 << 64)), # vector-width fallback + ((1 << 127,), (1 << 64, 1 << 127)), + ((1 << 63 | 7,), (3, 5, 1 << 63, 1 << 63 | 7)), + ((0,) * 32, (0,) * 32), + ] + for small, big in boundary_pairs: + complement_case(small, big) + gram_case(small) + gram_case(big) + counts["boundary_cases"] += 1 + for rows in ((0,), (2 ** 64 - 1,), (1 << 63,), coordinates64, + coordinates64 + (1 << 64,), (1 << 200, 3 << 199)): + gram_case(rows) + counts["boundary_cases"] += 1 + + # Actual Label construction and dictionary insertion order are retained. + for ordered in permutations((1, 2, 4, 8)): + small_o, big_o = oracle.Label(ordered[:2]), oracle.Label(ordered) + small_c, big_c = candidate.Label(ordered[:2]), candidate.Label(ordered) + require(list(small_c.basis.items()) == list(small_o.basis.items()) and + list(big_c.basis.items()) == list(big_o.basis.items()) and + small_c.key == small_o.key and big_c.key == big_o.key, + "Label constructor or canonical keys changed") + actual = small_c.complement_in(big_c) + exact_list(actual, small_o.complement_in(big_o)) + independent_complement(list(small_o.basis.values()), list(big_o.basis.values()), actual) + record("real_label_order", ordered, actual) + counts["real_label_permutations"] += 1 + + # Unsupported kinds must preserve ordinary return/exception behavior; no + # coercion, narrowing or mask repair is allowed before calling the fallback. + fallback_fixtures = [ + ((-1, 2), dict), ((True, False, 2), dict), ((IntSubclass(3), 5), dict), + ((1 << 100, 3), dict), ((1.5, 2), dict), (("1", 2), dict), + ((1, 2), DictSubclass), ((1, 2), UserDict), ((1, 2), ValuesOnly), + ((1, 2), BrokenValues), + ] + for values, factory in fallback_fixtures: + left_o, left_c = raw(oracle.Label, values, factory), raw(candidate.Label, values, factory) + right_o, right_c = raw(oracle.Label, (1, 2, 4)), raw(candidate.Label, (1, 2, 4)) + expected = capture(lambda: left_o.nondegenerate()) + actual = capture(lambda: left_c.nondegenerate()) + require(actual == expected, "Nondegenerate fallback result/exception changed") + expected_pair = capture(lambda: left_o.complement_in(right_o)) + actual_pair = capture(lambda: left_c.complement_in(right_c)) + require(actual_pair == expected_pair, "Complement fallback result/exception changed") + reverse_expected = capture(lambda: right_o.complement_in(left_o)) + reverse_actual = capture(lambda: right_c.complement_in(left_c)) + require(reverse_actual == reverse_expected, "Other-basis fallback result/exception changed") + record("fallback", factory.__name__, repr(values), actual, actual_pair, reverse_actual) + counts["fallback_cases"] += 3 + for factory in (lambda cls: object.__new__(cls), lambda cls: raw(cls, (), lambda _: None)): + left_o, left_c = factory(oracle.Label), factory(candidate.Label) + require(capture(left_o.nondegenerate) == capture(left_c.nondegenerate), "Missing basis fallback changed") + right_o, right_c = raw(oracle.Label, (1,)), raw(candidate.Label, (1,)) + require(capture(lambda: left_o.complement_in(right_o)) == capture(lambda: left_c.complement_in(right_c)), + "Missing self basis exception changed") + require(capture(lambda: right_o.complement_in(left_o)) == capture(lambda: right_c.complement_in(left_c)), + "Missing other basis exception changed") + counts["fallback_cases"] += 3 + class OracleChild(oracle.Label): + pass + class CandidateChild(candidate.Label): + pass + child_o, child_c = OracleChild((3, 5)), CandidateChild((3, 5)) + require(child_c.nondegenerate() is child_o.nondegenerate(), "Subclass nondegenerate fallback changed") + exact_list(child_c.complement_in(candidate.Label((1, 2, 4))), child_o.complement_in(oracle.Label((1, 2, 4)))) + counts["fallback_cases"] += 2 + + # Reject rebinding modules whose helpers or target methods have changed. + for name in ("dot", "rank", "method"): + changed = load_source("_matrix_binding_rejection_" + name) + if name == "method": + changed.Label.complement_in = lambda self, other: [] + else: + setattr(changed, name, lambda *args: 0) + failure = capture(lambda: bind(changed, native)) + require(failure[0] == "error" and failure[1] == "RuntimeError", "Binding guard admitted changed source code") + counts["binding_rejections"] += 1 + for bad in ((1 << 64,), (-1,), (True,), (IntSubclass(1),)): + require(native.gram_rank(dict(enumerate(bad))) is NotImplemented, "Native bound/type fallback failed") + require(native.complement(dict(enumerate((1,))), dict(enumerate(coordinates64))) is NotImplemented, + "Native augmented-width bound failed") + + # These independent checks must catch a mathematically wrong result and a + # same-subspace reordered witness respectively, including under python -O. + bad_math = capture(lambda: independent_complement([1], [1, 2], [1])) + require(bad_math[0] == "error", "Independent complement control accepted a wrong result") + bad_order = capture(lambda: exact_list([4, 2], [2, 4])) + require(bad_order[0] == "error", "Ordered witness control accepted a reordered result") + counts["oracle_negative_controls"] += 2 + + # A bounded fixed corpus drawn from the frozen h25 label families; repeated + # timings include dict conversion and dispatch, and remain diagnostic only. + full = tuple(1 << i for i in range(25)) + star = tuple(3 | (1 << i) for i in range(2, 25)) + fixtures = [(full[:12], full), (star, full), ((7,), full), ((), full)] + for small, big in fixtures: + complement_case(small, big) + gram_case(small) + gram_case(big) + oracle_pairs = [(raw(oracle.Label, u), raw(oracle.Label, v)) for u, v in fixtures] + candidate_pairs = [(raw(candidate.Label, u), raw(candidate.Label, v)) for u, v in fixtures] + micro = {} + micro_results = {} + for name, pairs in (("unchanged_python", oracle_pairs), ("native_with_conversion", candidate_pairs)): + start_wall, start_cpu = time.perf_counter(), time.process_time() + saved = [] + for _ in range(128): + for small, big in pairs: + saved.append((small.complement_in(big), small.nondegenerate(), big.nondegenerate())) + micro[name] = {"wall_seconds": time.perf_counter() - start_wall, + "cpu_seconds": time.process_time() - start_cpu} + micro_results[name] = saved + require(micro_results["unchanged_python"] == micro_results["native_with_conversion"], + "Fixed conversion-plus-kernel micro corpus changed") + require(all(value > 0 for value in state["counters"].values()), "A native or fallback path was untested") + v2 = v2_binding_and_trace_controls(native) + return {"status": "FINITE_NATIVE_GF2_CONTROLS_PASS", "counts": counts, + "native_and_fallback_calls": dict(state["counters"]), + "fixture_sha256": transcript.hexdigest(), "micro": micro, "v2_controls": v2, + "micro_repetitions": 128, "micro_fixtures": len(fixtures), + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers"} + + +def v2_binding_and_trace_controls(native): + """Fail-closed lookup/dispatch drift and symmetric complete transcript controls.""" + counts = {"prebind_shadow_rejections": 0, "effective_builtins_rejections": 0, + "postbind_drift_rejections": 0, "class_dispatch_rejections": 0, + "real_builtin_drift_rejections": 0, "trace_pairs": 0, + "trace_negative_controls": 0, "native_proxy_rejections": 0} + observed = [] + + def bad_helper(*args, **kwargs): + observed.append("modified helper executed") + return 0 + + def rejected(action, message): + before = list(observed) + outcome = capture(action) + require(outcome[0] == "error" and outcome[1] == "RuntimeError", message) + require(observed == before, "A drift check invoked the modified helper/descriptor") + + class NativeProxy: + def __getattribute__(self, name): + observed.append("native proxy attribute read") + return bad_helper + proxy_source = load_source("_matrix_v2_native_proxy") + rejected(lambda: bind(proxy_source, NativeProxy()), "Native proxy admitted before type check") + counts["native_proxy_rejections"] += 1 + + # Check every relevant effective builtin lookup, not just function bytecode. + for name in ("list", "sum", "enumerate", "len", "range", "next", "max", "all", "tuple", "sorted"): + changed = load_source("_matrix_v2_shadow_" + name) + changed.__dict__[name] = bad_helper + rejected(lambda: bind(changed, native), "Prebind global builtin shadow admitted: " + name) + counts["prebind_shadow_rejections"] += 1 + + # FunctionType captures the active builtins pointer at construction time. + # Restoring module.__builtins__ cannot make this forged function acceptable. + changed = load_source("_matrix_v2_function_builtins") + canonical_builtins = changed.__dict__["__builtins__"] + changed.__dict__["__builtins__"] = dict(canonical_builtins, sum=bad_helper) + forged = FunctionType(changed.Label.nondegenerate.__code__, changed.__dict__) + changed.__dict__["__builtins__"] = canonical_builtins + changed.Label.nondegenerate = forged + rejected(lambda: bind(changed, native), "Forged effective function builtins admitted") + counts["effective_builtins_rejections"] += 1 + changed = load_source("_matrix_v2_module_builtins") + changed.__dict__["__builtins__"] = dict(changed.__dict__["__builtins__"]) + rejected(lambda: bind(changed, native), "Alternate module builtins owner admitted") + counts["effective_builtins_rejections"] += 1 + + for name in ("basis", "__getattribute__"): + changed = load_source("_matrix_v2_pre_descriptor_" + name) + if name == "basis": + changed.Label.basis = property(bad_helper) + else: + changed.Label.__getattribute__ = bad_helper + rejected(lambda: bind(changed, native), "Prebind custom Label dispatch admitted") + counts["class_dispatch_rejections"] += 1 + + mutations = ( + ("dot_identity", lambda module, state: setattr(module, "dot", bad_helper)), + ("rank_identity", lambda module, state: setattr(module, "rank", bad_helper)), + ("sum_shadow", lambda module, state: setattr(module, "sum", bad_helper)), + ("list_shadow", lambda module, state: setattr(module, "list", bad_helper)), + ("module_builtins", lambda module, state: module.__dict__.__setitem__("__builtins__", dict(builtins.__dict__))), + ("dot_code", lambda module, state: setattr(module.dot, "__code__", (lambda x, y: 0).__code__)), + ("dot_defaults", lambda module, state: setattr(module.dot, "__defaults__", (0,))), + ("saved_method_code", lambda module, state: setattr(state["original_nondegenerate"], "__code__", (lambda self: False).__code__)), + ("label_init_code", lambda module, state: setattr(module.Label.__init__, "__code__", (lambda self, vectors: None).__code__)), + ("basis_descriptor", lambda module, state: setattr(module.Label, "basis", property(bad_helper))), + ("getattribute_dispatch", lambda module, state: setattr(module.Label, "__getattribute__", bad_helper)), + ("label_global", lambda module, state: setattr(module, "Label", object)), + ) + for name, mutate in mutations: + module = load_source("_matrix_v2_post_" + name) + state = bind(module, native) + small, big = raw(module.Label, (1,)), raw(module.Label, (1, 2)) + # Capture bound entry points before changing class attribute dispatch. + gram_call = small.nondegenerate + complement_call = small.complement_in + before = dict(state["counters"]) + mutate(module, state) + rejected(gram_call, "Postbind drift admitted by nondegenerate: " + name) + rejected(lambda: complement_call(big), "Postbind drift admitted by complement: " + name) + require(state["counters"] == before, "Drift reached native work or fallback") + counts["postbind_drift_rejections"] += 2 + + # The shared builtins dictionary is restored in finally before any following + # numerical fixture. No altered builtin is called to observe the mutation. + for postbind in (False, True): + module = load_source("_matrix_v2_real_builtin_" + str(postbind)) + if postbind: + state = bind(module, native) + small = raw(module.Label, (1,)) + call = small.nondegenerate + before = dict(state["counters"]) + original_sum = builtins.sum + try: + builtins.sum = bad_helper + rejected(call if postbind else lambda: bind(module, native), "Shared builtin drift admitted") + finally: + builtins.sum = original_sum + if postbind: + require(state["counters"] == before, "Shared builtin drift reached arithmetic") + counts["real_builtin_drift_rejections"] += 1 + + # Native dispatch mutation is rejected even though the wrapper retains the + # original C callable. Restore it before another independently bound module. + module = load_source("_matrix_v2_native_dispatch") + state = bind(module, native) + small = raw(module.Label, (1,)) + before = dict(state["counters"]) + original_native = native.gram_rank + try: + native.gram_rank = bad_helper + rejected(small.nondegenerate, "Changed native dispatch admitted") + finally: + native.gram_rank = original_native + require(state["counters"] == before, "Native dispatch drift reached arithmetic") + counts["postbind_drift_rejections"] += 1 + + # Both complete arms have the same observer and bytes; ordinary unsupported + # integer width still works with tracing, while custom containers are never + # observed by the full-run trace and keep their existing finite fallback tests. + oracle = load_source("_matrix_v2_trace_oracle") + candidate = load_source("_matrix_v2_trace_candidate") + guard_module(oracle) + oracle_rank, candidate_rank = [], [] + oracle_trace = ComplementTrace(oracle.Label) + candidate_trace = ComplementTrace(candidate.Label) + attach_trace(oracle, oracle_rank, oracle_trace) + bind(candidate, native, candidate_rank, candidate_trace) + fixtures = [((), ()), ((), (1, 2, 4)), ((1,), (1, 2, 4)), + ((3, 5), (1, 2, 4)), ((4, 1), (4, 2, 1)), + ((1 << 64,), (1, 1 << 64)), ((1 << 100,), (1, 2, 1 << 100))] + for us, vs in fixtures: + left_o, right_o = raw(oracle.Label, us), raw(oracle.Label, vs) + left_c, right_c = raw(candidate.Label, us), raw(candidate.Label, vs) + exact_list(left_c.complement_in(right_c), left_o.complement_in(right_o)) + require(left_c.nondegenerate() is left_o.nondegenerate(), "Traced Gram result changed") + counts["trace_pairs"] += 1 + require(oracle_trace.receipt() == candidate_trace.receipt() and oracle_rank == candidate_rank, + "Baseline/candidate exact ordered stream differs") + list_trace, none_trace = ComplementTrace(oracle.Label), ComplementTrace(oracle.Label) + list_trace.after(((), ()), []) + none_trace.after(((), ()), None) + require(list_trace.receipt()["sha256"] != none_trace.receipt()["sha256"], "Trace conflates [] with None") + order_a, order_b = ComplementTrace(oracle.Label), ComplementTrace(oracle.Label) + order_a.after(((1,), (1, 2, 4)), [2, 4]) + order_b.after(((1,), (1, 2, 4)), [4, 2]) + require(order_a.receipt()["sha256"] != order_b.receipt()["sha256"], "Trace loses output order") + input_a, input_b = ComplementTrace(oracle.Label), ComplementTrace(oracle.Label) + input_a.after(((1, 2), (1, 2, 4)), [4]) + input_b.after(((2, 1), (1, 2, 4)), [4]) + require(input_a.receipt()["sha256"] != input_b.receipt()["sha256"], "Trace loses input order") + invalid = raw(oracle.Label, (1,), BrokenValues) + rejected(lambda: oracle_trace.before(invalid, raw(oracle.Label, (1,))), "Full trace accepted a side-effecting fallback container") + counts["trace_negative_controls"] += 4 + require(observed == [], "A guarded modified helper was invoked") + return {"status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS", "counts": counts, + "complement_fixture_stream": oracle_trace.receipt(), + "modified_helper_invocations": len(observed), + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift"} diff --git a/research/h25-bookkeeping/payload/baseline/engine/native_backend.py b/research/h25-bookkeeping/payload/baseline/engine/native_backend.py new file mode 100644 index 0000000000..77e55ce9d0 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/native_backend.py @@ -0,0 +1,386 @@ +"""Source-bound packed GF(2), with a fail-closed stable-runtime boundary. + +Supported bindings use the literal frozen source, ordinary built-ins and the +original Label dispatch. Resolved method/helper globals and built-ins, helper +code/defaults/closures and class/native dispatch must remain unchanged after +binding. Calls run serially with no mutation during a call; detected boundary +drift is rejected before arithmetic or fallback. This is not a sandbox +against arbitrary mutation of this backend or native process memory. +""" +from __future__ import annotations + +import builtins +import hashlib +import importlib.util +import json +from pathlib import Path +import shlex +import subprocess +import sys +import sysconfig +from types import BuiltinFunctionType, CodeType, FunctionType, GetSetDescriptorType, ModuleType + +ROOT = Path(__file__).resolve().parent +SOURCE = ROOT / "source" / "complex_circuit.py" +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +CALLER_SHA256 = "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + +# Anchored operations keep drift checks independent of the source's lookup +# environment and avoid executing modified helper functions or descriptors. +_TYPE = type +_LEN = len +_INT = int +_DICT = dict +_LIST = list +_TUPLE = tuple +_OBJECT = object +_RUNTIME_ERROR = RuntimeError +_COMPILE = compile +_DICT_GET = dict.get +_DICT_VALUES = dict.values +_OBJECT_GETATTRIBUTE = object.__getattribute__ +_BUILTINS = builtins.__dict__ +_BUILTIN_NAMES = ("all", "enumerate", "len", "list", "max", "next", "range", + "sorted", "sum", "tuple", "int", "dict", "type", "object") +_CANONICAL_BUILTINS = {name: _BUILTINS[name] for name in _BUILTIN_NAMES} +_HELPER_NAMES = ("echelon", "reduce", "dot", "rank") +_TYPE_BUILTINS = {"list": _LIST, "tuple": _TUPLE, "int": _INT, + "dict": _DICT, "type": _TYPE, "object": _OBJECT} +_BIT_DESCRIPTORS = tuple((_INT, name, getattr(_INT, name)) for name in + ("bit_count", "bit_length", "__and__", "__xor__", "__lshift__", "__rshift__")) + + +def require(condition, message): + if not condition: + raise _RUNTIME_ERROR(message) + + +def _check_builtins(): + for name, expected in _CANONICAL_BUILTINS.items(): + require(_DICT_GET(_BUILTINS, name) is expected, "Runtime drift: builtin " + name) + if name in _TYPE_BUILTINS: + require(expected is _TYPE_BUILTINS[name], "Unexpected builtin type: " + name) + elif name in ("enumerate", "range"): + require(_TYPE(expected) is _TYPE and expected.__name__ == name and + expected.__module__ == "builtins" and not (expected.__flags__ & (1 << 9)), + "Unexpected builtin class: " + name) + else: + require(_TYPE(expected) is BuiltinFunctionType and expected.__name__ == name and + expected.__module__ == "builtins", "Unexpected builtin function: " + name) + for owner, name, descriptor in _BIT_DESCRIPTORS: + require(_TYPE.__getattribute__(owner, name) is descriptor, "Runtime drift: builtin integer semantics") + + +def verify_sources(): + raw = SOURCE.read_bytes() + require(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Frozen complex source changed") + caller = (ROOT / "source" / "complex_network.py").read_bytes() + require(hashlib.sha256(caller).hexdigest() == CALLER_SHA256, "Frozen caller source changed") + return raw + + +def load_source(name): + verify_sources() + spec = importlib.util.spec_from_file_location(name, SOURCE) + require(spec is not None and spec.loader is not None, "Missing frozen module loader") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def _code_shape(code): + """Compare source code using only exact immutable values, never user equality.""" + require(_TYPE(code) is CodeType, "Unexpected function code type") + def constant(value): + kind = _TYPE(value) + if value is None or value is Ellipsis: + return ("singleton", value is Ellipsis) + if kind is _INT or kind is bool or kind is str or kind is bytes: + return (kind.__name__, value) + if kind is _TUPLE: + return ("tuple", _TUPLE(constant(item) for item in value)) + if kind is CodeType: + return ("code", _code_shape(value)) + raise _RUNTIME_ERROR("Unexpected mutable or custom constant in frozen function") + fields = (code.co_argcount, code.co_posonlyargcount, code.co_kwonlyargcount, + code.co_nlocals, code.co_stacksize, code.co_flags, code.co_code, + code.co_names, code.co_varnames, code.co_freevars, code.co_cellvars, + code.co_exceptiontable, code.co_linetable, code.co_firstlineno, + code.co_filename, code.co_name, code.co_qualname, code.co_consts) + return _TUPLE(constant(value) for value in fields) + + +def guard_module(module): + """Validate code AND every resolved builtin/helper/Label dispatch owner.""" + _check_builtins() + raw = verify_sources() + require(_TYPE(module) is ModuleType, "Unexpected source module type") + namespace = module.__dict__ + require(_TYPE(_DICT_GET(namespace, "__file__")) is str and _TYPE(_DICT_GET(namespace, "__name__")) is str, "Unexpected source module metadata types") + require(Path(namespace["__file__"]).resolve() == SOURCE.resolve(), "Unexpected source module path") + require(_DICT_GET(namespace, "__builtins__") is _BUILTINS, "Changed source builtins owner") + for name in _BUILTIN_NAMES: + require(name not in namespace, "Source builtin shadow: " + name) + expected = _COMPILE(raw, str(SOURCE), "exec", dont_inherit=True, optimize=sys.flags.optimize) + codes = {code.co_name: code for code in expected.co_consts if _TYPE(code) is CodeType} + + def check(function, expected_code, name): + require(_TYPE(function) is FunctionType, "Non-function replacement: " + name) + require(function.__globals__ is namespace, "Changed function globals: " + name) + # A function captures its own builtins pointer when created; checking + # only the module's current __builtins__ slot would miss a forged one. + require(function.__builtins__ is _BUILTINS, "Changed effective function builtins: " + name) + require(function.__closure__ is None and function.__defaults__ is None and + function.__kwdefaults__ is None, "Changed function calling contract: " + name) + require(_code_shape(function.__code__) == _code_shape(expected_code), + "Changed frozen function code: " + name) + + for name in _HELPER_NAMES: + check(_DICT_GET(namespace, name), codes[name], name) + label = _DICT_GET(namespace, "Label") + require(_TYPE(label) is _TYPE and label.__mro__ == (label, _OBJECT), "Changed Label class shape") + require(_TYPE(label.__module__) is str and label.__module__ == module.__name__, "Changed Label module ownership") + methods = {code.co_name: code for code in codes["Label"].co_consts if _TYPE(code) is CodeType} + attributes = label.__dict__ + require(_LEN(attributes) == 4 + _LEN(methods), "Changed Label class attributes") + for name in ("__module__", "__doc__", "__dict__", "__weakref__"): + require(name in attributes, "Missing original Label descriptor") + for name in ("__dict__", "__weakref__"): + descriptor = attributes[name] + require(_TYPE(descriptor) is GetSetDescriptorType and descriptor.__objclass__ is label, + "Custom Label descriptor: " + name) + for name, code in methods.items(): + check(attributes.get(name), code, "Label." + name) + require(label.__getattribute__ is _OBJECT.__getattribute__ and label.__new__ is _OBJECT.__new__, + "Custom Label attribute or construction dispatch") + return label + + +class RuntimeGuard: + """Identity-only freshness checks; no modified callable is invoked.""" + def __init__(self, module, label, native, original_functions): + self.module = module + self.namespace = module.__dict__ + self.label = label + self.mro = label.__mro__ + self.class_items = _TUPLE(label.__dict__.items()) + self.global_items = _TUPLE((name, self.namespace[name]) for name in _HELPER_NAMES + ("Label", "__builtins__")) + functions = _LIST(original_functions) + functions.extend(value for _, value in self.class_items if _TYPE(value) is FunctionType) + functions.append(self.namespace["rank"]) + self.functions = _TUPLE((function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, function.__closure__, + () if function.__closure__ is None else + _TUPLE((cell, cell.cell_contents) for cell in function.__closure__)) + for function in functions) + self.native = native + require(_TYPE(native) is ModuleType, "Unexpected native module type") + self.native_items = _TUPLE((name, native.__dict__[name]) for name in ("gram_rank", "complement")) + for name, function in self.native_items: + require(_TYPE(function) is BuiltinFunctionType and function.__self__ is native, + "Changed native entry point: " + name) + self.check() + + def check(self): + # The source globals and Label remain a normal module and exact class; + # lookups below therefore do not invoke user-defined descriptors. + require(_TYPE(self.module) is ModuleType and self.module.__dict__ is self.namespace, + "Runtime drift: source module dispatch") + require(_TYPE(self.label) is _TYPE and self.label.__mro__ is self.mro, + "Runtime drift: Label class dispatch") + for name, value in self.global_items: + require(_DICT_GET(self.namespace, name) is value, "Runtime drift: source helper " + name) + for name, expected in _CANONICAL_BUILTINS.items(): + require(name not in self.namespace and _DICT_GET(_BUILTINS, name) is expected, + "Runtime drift: builtin lookup " + name) + attributes = self.label.__dict__ + require(_LEN(attributes) == _LEN(self.class_items), "Runtime drift: Label descriptors") + for name, value in self.class_items: + require(attributes.get(name) is value, "Runtime drift: Label member " + name) + for function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells in self.functions: + require(function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure, + "Runtime drift: function code or calling environment") + for cell, value in cells: + require(cell.cell_contents is value, "Runtime drift: wrapper closure") + require(_TYPE(self.native) is ModuleType, "Runtime drift: native module dispatch") + for name, function in self.native_items: + require(_DICT_GET(self.native.__dict__, name) is function, "Runtime drift: native entry point " + name) + + +class ComplementTrace: + """Stream every ordered complement input and typed output, without retention. + + Snapshotting is confined to the exact Label/exact dict/int domain of the + complete H25 workload. Finite fallback tests leave this observer disabled. + """ + def __init__(self, label): + self.label = label + self.count = 0 + self.bytes = 0 + self.hasher = hashlib.sha256() + + def before(self, small, big): + require(_TYPE(small) is self.label and _TYPE(big) is self.label, "Trace requires exact frozen Label objects") + big_dict = _OBJECT_GETATTRIBUTE(big, "__dict__") + small_dict = _OBJECT_GETATTRIBUTE(small, "__dict__") + require(_TYPE(big_dict) is _DICT and _TYPE(small_dict) is _DICT, "Trace requires ordinary instance dictionaries") + vs_basis = _DICT_GET(big_dict, "basis") + us_basis = _DICT_GET(small_dict, "basis") + require(_TYPE(vs_basis) is _DICT and _TYPE(us_basis) is _DICT, "Trace requires exact basis dictionaries") + vs = _TUPLE(_DICT_VALUES(vs_basis)) + us = _TUPLE(_DICT_VALUES(us_basis)) + require(all(_TYPE(value) is _INT for value in us + vs), "Trace requires exact integer vectors") + return us, vs + + def after(self, inputs, output): + us, vs = inputs + if output is None: + result = {"type": "None"} + else: + require(_TYPE(output) is _LIST and all(_TYPE(value) is _INT for value in output), + "Trace requires an exact integer list or None result") + result = {"type": "list", "values": output} + record = {"call": self.count, "us": us, "vs": vs, "result": result} + encoded = json.dumps(record, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + b"\n" + self.hasher.update(encoded) + self.bytes += _LEN(encoded) + self.count += 1 + + def receipt(self): + return {"calls": self.count, "canonical_stream_bytes": self.bytes, + "sha256": self.hasher.hexdigest(), + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors"} + + +def build_native(directory): + """Always cold compile/link/load once. The parent supplies the outer guard.""" + require(sys.implementation.name == "cpython" and sys.version_info[:2] == (3, 12), + "This qualification is frozen to CPython 3.12") + require(sys.platform.startswith("linux"), "This qualification is frozen to Linux") + directory = Path(directory) + require(not directory.exists(), "Refusing to reuse a native build directory") + directory.mkdir(parents=True) + source = ROOT / "native_gf2.c" + source_before = source.read_bytes() + source_hash = hashlib.sha256(source_before).hexdigest() + suffix = sysconfig.get_config_var("EXT_SUFFIX") + require(_TYPE(suffix) is str and suffix.endswith(".so"), "Unexpected extension suffix") + target = directory / ("_packed_gf2" + suffix) + compiler = shlex.split(sysconfig.get_config_var("CC") or "cc") + require(compiler, "Missing configured C compiler") + command = compiler + ["-shared", "-fPIC", "-O3", "-std=c11", "-Wall", "-Wextra", "-Werror", + "-I" + sysconfig.get_paths()["include"], str(source), "-o", str(target)] + completed = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, timeout=90, check=False) + manifest = {"command": command, "returncode": completed.returncode, + "stdout": completed.stdout, "stderr": completed.stderr, + "c_source_sha256": source_hash, "python": sys.version, + "no_cached_binary": True} + (directory / "build.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") + require(completed.returncode == 0, "Native compilation failed; see build.json (no retry)") + require(source.read_bytes() == source_before, "Native source changed during compilation") + manifest["extension_sha256"] = hashlib.sha256(target.read_bytes()).hexdigest() + spec = importlib.util.spec_from_file_location("_packed_gf2", target) + require(spec is not None and spec.loader is not None, "Missing extension loader") + native = importlib.util.module_from_spec(spec) + spec.loader.exec_module(native) + (directory / "build.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") + return native, manifest + + +def attach_trace(module, rank_calls, complement_trace=None): + """Baseline observers; original arithmetic and return objects stay intact.""" + original_rank = module.rank + original_complement = module.Label.complement_in + + def traced_rank(rows): + frozen_rows = _TUPLE(rows) + answer = original_rank(frozen_rows) + require(_TYPE(answer) is _INT, "Rank output type changed") + rank_calls.append((frozen_rows, answer)) + return answer + + def traced_complement(self, other): + inputs = complement_trace.before(self, other) + answer = original_complement(self, other) + complement_trace.after(inputs, answer) + return answer + + module.rank = traced_rank + if complement_trace is not None: + module.Label.complement_in = traced_complement + return original_rank + + +def bind(module, native, rank_calls=None, complement_trace=None): + """Replace two methods only; any detected runtime drift is a hard failure.""" + require(_TYPE(native) is ModuleType, "Unexpected native module type") + native_complement = _DICT_GET(native.__dict__, "complement") + native_gram = _DICT_GET(native.__dict__, "gram_rank") + require(_TYPE(native_complement) is BuiltinFunctionType and native_complement.__self__ is native and + _TYPE(native_gram) is BuiltinFunctionType and native_gram.__self__ is native, + "Missing or replaced native entry points") + label = guard_module(module) + original_functions = [module.__dict__[name] for name in _HELPER_NAMES] + original_functions.extend(value for value in label.__dict__.values() if _TYPE(value) is FunctionType) + original_complement = label.complement_in + original_nondegenerate = label.nondegenerate + original_dot = module.dot + original_rank = module.rank + if rank_calls is not None: + attach_trace(module, rank_calls) + counters = {"complement_native": 0, "complement_fallback": 0, + "gram_native": 0, "gram_fallback": 0} + runtime = None + + def complement_in(self, other): + runtime.check() + inputs = None if complement_trace is None else complement_trace.before(self, other) + if _TYPE(self) is label and _TYPE(other) is label: + big_dict = _OBJECT_GETATTRIBUTE(other, "__dict__") + small_dict = _OBJECT_GETATTRIBUTE(self, "__dict__") + if _TYPE(big_dict) is _DICT and _TYPE(small_dict) is _DICT: + big = _DICT_GET(big_dict, "basis") + small = _DICT_GET(small_dict, "basis") + if _TYPE(big) is _DICT and _TYPE(small) is _DICT: + result = native_complement(small, big) + if result is not NotImplemented: + counters["complement_native"] += 1 + if complement_trace is not None: + complement_trace.after(inputs, result) + return result + counters["complement_fallback"] += 1 + result = original_complement(self, other) + if complement_trace is not None: + complement_trace.after(inputs, result) + return result + + def nondegenerate(self): + runtime.check() + if _TYPE(self) is label: + instance = _OBJECT_GETATTRIBUTE(self, "__dict__") + if _TYPE(instance) is _DICT: + basis = _DICT_GET(instance, "basis") + if _TYPE(basis) is _DICT: + answer = native_gram(basis) + if answer is not NotImplemented: + rows, rank = answer + if rank_calls is not None: + require(_TYPE(rank) is _INT, "Native rank output type changed") + rank_calls.append((rows, rank)) + counters["gram_native"] += 1 + return rank == _LEN(rows) + counters["gram_fallback"] += 1 + return original_nondegenerate(self) + + label.complement_in = complement_in + label.nondegenerate = nondegenerate + # Set the closure before capturing it, then initialize the guard in place. + # Thus every captured cell identity is its final stable value. + runtime = _OBJECT.__new__(RuntimeGuard) + RuntimeGuard.__init__(runtime, module, label, native, original_functions) + return {"counters": counters, "original_complement": original_complement, + "original_nondegenerate": original_nondegenerate, "original_dot": original_dot, + "original_rank": original_rank, "label": label, "runtime_guard": runtime} diff --git a/research/h25-bookkeeping/payload/baseline/engine/native_gf2.c b/research/h25-bookkeeping/payload/baseline/engine/native_gf2.c new file mode 100644 index 0000000000..0b6a835981 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/native_gf2.c @@ -0,0 +1,209 @@ +#define PY_SSIZE_T_CLEAN +#include +#include +#include + +/* This module is deliberately bounded. Unsupported inputs return the sentinel + * NotImplemented; the Python binder calls the unchanged source implementation. + * No Python integer is truncated, and the GIL remains held for each bounded call. + */ +_Static_assert(sizeof(unsigned long long) * CHAR_BIT == 64, + "This finite backend requires 64-bit unsigned long long"); + +/* Read exact dict values in their insertion order. Keys are not observed by the + * original two methods either. Return 1 for supported inputs, 0 for fallback, + * and -1 for a genuine Python error. No caller object is changed. + */ +static int read_vectors(PyObject *basis, uint64_t vectors[64], Py_ssize_t *count) { + Py_ssize_t position = 0; + Py_ssize_t length; + Py_ssize_t at = 0; + PyObject *key; + PyObject *value; + if (!PyDict_CheckExact(basis)) return 0; + length = PyDict_Size(basis); + if (length < 0) return -1; + if (length > 64) return 0; + while (PyDict_Next(basis, &position, &key, &value)) { + unsigned long long converted; + (void)key; + if (!PyLong_CheckExact(value)) return 0; + converted = PyLong_AsUnsignedLongLong(value); + if (PyErr_Occurred()) { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + if (at >= length) { + PyErr_SetString(PyExc_RuntimeError, "basis size changed during conversion"); + return -1; + } + vectors[at++] = (uint64_t)converted; + } + if (at != length) { + PyErr_SetString(PyExc_RuntimeError, "basis size changed during conversion"); + return -1; + } + *count = length; + return 1; +} + +/* XOR folding preserves parity; 0x6996 encodes parity of the low four bits. */ +static unsigned parity64(uint64_t x) { + x ^= x >> 32; + x ^= x >> 16; + x ^= x >> 8; + x ^= x >> 4; + return (unsigned)((UINT64_C(0x6996) >> (x & UINT64_C(15))) & UINT64_C(1)); +} + +/* Only the scalar rank is observed. Forward elimination is sufficient. */ +static Py_ssize_t binary_rank(uint64_t rows[64], Py_ssize_t n) { + Py_ssize_t rank = 0; + unsigned column; + for (column = 0; column < 64 && rank < n; ++column) { + uint64_t bit = UINT64_C(1) << column; + Py_ssize_t pivot = rank; + Py_ssize_t i; + uint64_t temp; + while (pivot < n && !(rows[pivot] & bit)) ++pivot; + if (pivot == n) continue; + temp = rows[rank]; rows[rank] = rows[pivot]; rows[pivot] = temp; + for (i = rank + 1; i < n; ++i) { + if (rows[i] & bit) rows[i] ^= rows[rank]; + } + ++rank; + } + return rank; +} + +/* Return (the original ordered Gram rows, its exact rank), so the same full + * rank transcript can be recorded by both benchmark arms. The public Label + * method still returns exactly bool, including True for the empty basis. + */ +static PyObject *gram_rank(PyObject *self, PyObject *args) { + PyObject *basis; + uint64_t vectors[64]; + uint64_t rows[64]; + uint64_t work[64]; + Py_ssize_t n = 0; + Py_ssize_t i; + Py_ssize_t j; + Py_ssize_t rank; + int accepted; + PyObject *gram; + PyObject *rank_value; + PyObject *answer; + (void)self; + if (!PyArg_ParseTuple(args, "O:gram_rank", &basis)) return NULL; + accepted = read_vectors(basis, vectors, &n); + if (accepted < 0) return NULL; + if (!accepted) Py_RETURN_NOTIMPLEMENTED; + for (i = 0; i < n; ++i) { + uint64_t row = 0; + for (j = 0; j < n; ++j) { + row |= (uint64_t)parity64(vectors[i] & vectors[j]) << (unsigned)j; + } + rows[i] = row; + work[i] = row; + } + rank = binary_rank(work, n); + gram = PyTuple_New(n); + if (gram == NULL) return NULL; + for (i = 0; i < n; ++i) { + PyObject *value = PyLong_FromUnsignedLongLong((unsigned long long)rows[i]); + if (value == NULL) { Py_DECREF(gram); return NULL; } + PyTuple_SET_ITEM(gram, i, value); + } + rank_value = PyLong_FromSsize_t(rank); + if (rank_value == NULL) { Py_DECREF(gram); return NULL; } + answer = PyTuple_New(2); + if (answer == NULL) { Py_DECREF(gram); Py_DECREF(rank_value); return NULL; } + PyTuple_SET_ITEM(answer, 0, gram); + PyTuple_SET_ITEM(answer, 1, rank_value); + return answer; +} + +/* Literal ordered augmented-row algorithm from Label.complement_in. + * low k bits: pairings against self, in self.basis insertion order. + * high n bits: coefficient identity for other.basis, in its insertion order. + * The first available pivot and ALL-row clearing match the source exactly; + * output rows stay in the identical order and are not re-canonicalized. + */ +static PyObject *complement(PyObject *self, PyObject *args) { + PyObject *small; + PyObject *big; + uint64_t us[64]; + uint64_t vs[64]; + uint64_t rows[64]; + Py_ssize_t k = 0; + Py_ssize_t n = 0; + Py_ssize_t i; + Py_ssize_t j; + Py_ssize_t column; + Py_ssize_t rank = 0; + int accepted; + uint64_t low_mask; + PyObject *out; + (void)self; + if (!PyArg_ParseTuple(args, "OO:complement", &small, &big)) return NULL; + accepted = read_vectors(big, vs, &n); + if (accepted < 0) return NULL; + if (!accepted) Py_RETURN_NOTIMPLEMENTED; + accepted = read_vectors(small, us, &k); + if (accepted < 0) return NULL; + if (!accepted || k + n > 64) Py_RETURN_NOTIMPLEMENTED; + for (i = 0; i < n; ++i) { + uint64_t row = UINT64_C(1) << (unsigned)(k + i); + for (j = 0; j < k; ++j) { + row |= (uint64_t)parity64(vs[i] & us[j]) << (unsigned)j; + } + rows[i] = row; + } + for (column = 0; column < k; ++column) { + uint64_t bit = UINT64_C(1) << (unsigned)column; + Py_ssize_t pivot = rank; + uint64_t temp; + while (pivot < n && !(rows[pivot] & bit)) ++pivot; + if (pivot == n) continue; + temp = rows[rank]; rows[rank] = rows[pivot]; rows[pivot] = temp; + for (i = 0; i < n; ++i) { + if (i != rank && (rows[i] & bit)) rows[i] ^= rows[rank]; + } + ++rank; + } + low_mask = k == 64 ? UINT64_MAX : ((UINT64_C(1) << (unsigned)k) - UINT64_C(1)); + out = PyList_New(n - rank); + if (out == NULL) return NULL; + for (i = rank; i < n; ++i) { + uint64_t x = 0; + PyObject *value; + if (rows[i] & low_mask) { + Py_DECREF(out); + PyErr_SetString(PyExc_AssertionError, ""); + return NULL; + } + for (j = 0; j < n; ++j) { + if ((rows[i] >> (unsigned)(k + j)) & UINT64_C(1)) x ^= vs[j]; + } + value = PyLong_FromUnsignedLongLong((unsigned long long)x); + if (value == NULL) { Py_DECREF(out); return NULL; } + PyList_SET_ITEM(out, i - rank, value); + } + return out; +} + +static PyMethodDef methods[] = { + {"gram_rank", gram_rank, METH_VARARGS, "Ordered GF(2) Gram rows and exact rank, or NotImplemented."}, + {"complement", complement, METH_VARARGS, "Exact ordered GF(2) complement vectors, or NotImplemented."}, + {NULL, NULL, 0, NULL} +}; +static struct PyModuleDef module_definition = { + PyModuleDef_HEAD_INIT, "_packed_gf2", "Bounded exact GF(2) verification kernels.", + -1, methods, NULL, NULL, NULL, NULL +}; +PyMODINIT_FUNC PyInit__packed_gf2(void) { + return PyModule_Create(&module_definition); +} diff --git a/research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py b/research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py new file mode 100644 index 0000000000..807855eb87 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py @@ -0,0 +1,193 @@ +#!/usr/bin/env python3 +"""Diagnostic profile of an unchanged, frozen h=25 side verification scope. + +This is not complex_network.certificate(), a selected-frontier replay, a +construction search, or a performance qualification. Run only under the +parent's serial process-group guard. No compiler or third-party dependency. +""" +from __future__ import annotations + +import argparse +import ast +from collections import Counter +import cProfile +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import pstats +import sys +import time + +BASE_MAIN = "de5ec2e7a6074068452f45b1a191b5c72832df4a" +PINS = { + "complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", +} +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise RuntimeError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def source_check(): + for name, expected in PINS.items(): + actual = hashlib.sha256((ROOT / "source" / name).read_bytes()).hexdigest() + require(actual == expected, "Source digest changed: " + name) + tree = ast.parse((ROOT / "source" / "complex_network.py").read_text()) + hs = [ast.literal_eval(node.value) for node in tree.body + if isinstance(node, ast.Assign) and + any(isinstance(target, ast.Name) and target.id == "H" for target in node.targets)] + require(hs == [25], "The unchanged caller no longer freezes H=25") + return hs[0] + + +def run_side(h, rank_calls, phases): + def phase(name, action): + start_wall = time.perf_counter() + start_cpu = time.process_time() + value = action() + phases[name] = {"wall_seconds": time.perf_counter() - start_wall, + "cpu_seconds": time.process_time() - start_cpu} + return value + + def load(): + spec = importlib.util.spec_from_file_location("_frozen_matrix_complex_circuit", ROOT / "source" / "complex_circuit.py") + require(spec is not None and spec.loader is not None, "Cannot load frozen module") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + module = phase("load", load) + original_rank = module.rank + + def traced_rank(rows): + frozen_rows = tuple(rows) + result = original_rank(frozen_rows) + require(type(result) is int, "Rank result changed its exact type") + rank_calls.append((frozen_rows, result)) + return result + + module.rank = traced_rank + circuit = phase("construction", lambda: module.ComplexSideCircuit(h)) + checks = phase("checks_initialization", lambda: module.Checks(circuit)) + code = phase("compile_roles", lambda: module.compile_roles(circuit)) + side_map = phase("verify_map", checks.verify_map) + labels = phase("verify_labels", checks.verify_labels) + roles = phase("verify_role_frames", lambda: module.verify_role_frames(circuit, checks, code)) + # These are exactly the complete finite side checks called, in this order, + # by complex_network.certificate(). No mathematical parameters are varied. + result = {"circuit": circuit.stats(), "side_map": side_map, + "labels": labels, "role_frames": roles} + return circuit, checks, code, result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + require(sys.flags.optimize == 0, "This source uses assert; profile must run without -O") + sys.dont_write_bytecode = True + require(not args.output.exists(), "Refusing to overwrite diagnostic evidence") + args.output.mkdir(parents=True) + h = source_check() + profile = cProfile.Profile() + rank_calls = [] + phases = {} + start_wall = time.perf_counter() + start_cpu = time.process_time() + circuit, checks, code, result = profile.runcall(run_side, h, rank_calls, phases) + profile_cpu = time.process_time() - start_cpu + profile_wall = time.perf_counter() - start_wall + profile.dump_stats(str(args.output / "profile.pstats")) + stats = pstats.Stats(profile) + targeted = [] + all_source = [] + for (filename, line, name), (primitive, total, self_time, cumulative, callers) in stats.stats.items(): + if filename.endswith("complex_circuit.py"): + row = {"name": name, "line": line, "primitive_calls": primitive, + "total_calls": total, "self_seconds": self_time, + "cumulative_seconds": cumulative} + all_source.append(row) + if name in {"rank", "echelon", "reduce", "dot", "complement_in", "nondegenerate"}: + targeted.append(row) + shape_counts = Counter((len(rows), max((x.bit_length() for x in rows), default=0)) + for rows, _ in rank_calls) + unique = {} + for rows, rank in rank_calls: + previous = unique.setdefault(rows, rank) + require(previous == rank, "Identical rank matrices produced different outputs") + # Preserve the ordered trace, exact rows and expected outputs. This frozen + # corpus enables a later conversion-plus-native check without a new search. + with (args.output / "rank-trace.jsonl").open("x", encoding="ascii") as output: + for rows, rank in rank_calls: + output.write(canonical({"rows": rows, "rank": rank}).decode("ascii") + "\n") + rank_corpus = [{"rows": rows, "rank": rank} for rows, rank in sorted(unique.items())] + (args.output / "rank-corpus.json").write_bytes(canonical(rank_corpus) + b"\n") + # Basis dictionary insertion order, labels, pivots, role order and coefficient + # numerators/denominators are all hashed without normalization of witnesses. + witnesses = { + "support": circuit.support, + "args": circuit.args, + "kind": circuit.kind, + "active": sorted(circuit.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) + for target, node, coefficient in circuit.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) + for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], + "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + receipt = { + "status": "DIAGNOSTIC_COMPLETE_SIDE_SCOPE_ONLY", + "base_main": BASE_MAIN, + "sources": PINS, + "unchanged_caller": "scripts/complex_network.py:certificate (side verification segment)", + "h": h, + "result": result, + "result_sha256": digest(result), + "exact_witness_sha256": digest(witnesses), + "rank_trace_sha256": digest(rank_calls), + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len(unique), + "rank_shape_counts": [{"rows": r, "columns": c, "calls": n} + for (r, c), n in sorted(shape_counts.items())], + "profiled_complete_side_wall_seconds": profile_wall, + "profiled_complete_side_cpu_seconds": profile_cpu, + "profiled_phases": phases, + "targeted_functions": sorted(targeted, key=lambda item: item["cumulative_seconds"], reverse=True), + "all_source_functions": sorted(all_source, key=lambda item: item["self_seconds"], reverse=True), + "environment": {"python": sys.version, "executable": sys.executable, + "platform": sys.platform, "pid": os.getpid()}, + "limitations": [ + "Profiled timings include cProfile and exact rank-trace instrumentation.", + "Cumulative times are nested and must not be summed.", + "No native code or candidate execution; no speedup established.", + "The complete side verification segment is not the full complex-network certificate.", + "No PR5864 workload is executed and no matrix time counts toward its improvement target.", + "No new construction, parameter search, kappa admission or formal theorem verification.", + ], + } + (args.output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(json.dumps({"status": receipt["status"], "h": h, + "wall_seconds": profile_wall, "cpu_seconds": profile_cpu, + "rank_calls": len(rank_calls), "rank_distinct_matrices": len(unique), + "result_sha256": receipt["result_sha256"], + "exact_witness_sha256": receipt["exact_witness_sha256"], + "targeted_functions": receipt["targeted_functions"]}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py b/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py new file mode 100644 index 0000000000..9e83a1065c --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py @@ -0,0 +1,454 @@ +#!/usr/bin/env python3 +"""Compressed side correction for the complex network, with binary frames. + +Target S must receive (1/2) * sum{x_T : T disjoint from S} +minus (1/2) * sum{x_T : |S cap T| = 2}. Both sums are computed by +cancellation-free addition graphs and injected as pieces with those weights. + +Labels are subspaces of F2^h with the dot product. A disjoint-sum node carries +the coordinate space of its covered points; a pair-star node carries the span +of its triple indicators, which is orthonormal. An injected piece must leave a +point outside S uncovered: the residual up to t_S^perp then contains an odd +coordinate vector. A disjoint piece covering every point outside S would have +the alternating residual , so the disjoint sum is split. +""" +from fractions import Fraction as Q +from itertools import combinations + +EMPTY = frozenset() + + +def subsets(points, k): + return [frozenset(c) for j in range(min(k, len(points))+1) + for c in combinations(points, j)] + + +class ComplexSideCircuit: + def __init__(self, h): + assert h >= 8, 'Need at least four points outside every target' + self.h = h + self.triples = list(combinations(range(h), 3)) + self.index = {t: i for i, t in enumerate(self.triples)} + self.support = [0]; self.args = [None]; self.kind = [None] + self.lookup = {}; self.input = {} + for i, t in enumerate(self.triples): + self.input[t] = len(self.support) + self.support.append(1 << i); self.args.append(None); self.kind.append('in') + self.points = {} # covered point masks, filled lazily + self.pieces = [] # (target, node, coefficient) + self.build_disjoint() + self.build_pair_stars() + self.prune() + + # -- node store ------------------------------------------------------- + def x(self, *pts): + return self.input[tuple(sorted(pts))] + + def add(self, a, b, kind): + if not a: return b + if not b: return a + sa, sb = self.support[a], self.support[b] + assert not sa & sb, 'Cancellation is forbidden' + key = (kind, sa | sb) + node = self.lookup.get(key) + if node is None: + node = len(self.support) + self.lookup[key] = node + self.support.append(sa | sb); self.args.append((a, b)); self.kind.append(kind) + return node + + def total(self, nodes, kind): + nodes = [x for x in nodes if x] + while len(nodes) > 1: + nodes = [self.add(nodes[i], nodes[i+1], kind) if i+1 < len(nodes) else nodes[i] + for i in range(0, len(nodes), 2)] + return nodes[0] if nodes else 0 + + # -- disjoint sums ---------------------------------------------------- + def vec(self, items, k): + """{E: sum of item nodes whose points avoid E}, |E| <= k.""" + if not items: return {EMPTY: 0} + if len(items) == 1: + p, node = items[0] + return {EMPTY: node, frozenset([p]): 0} if k else {EMPTY: node} + half = len(items)//2 + A = self.vec(items[:half], k); B = self.vec(items[half:], k) + return {ea | eb: self.add(xa, xb, 'd0') for ea, xa in A.items() + for eb, xb in B.items() if len(ea)+len(eb) <= k} + + def pairs(self, pts, weight, k): + """{E: sum of weight(u,v) over pairs avoiding E}, |E| <= k.""" + if len(pts) < 2: return {E: 0 for E in subsets(pts, k)} + half = len(pts)//2; L, R = pts[:half], pts[half:] + PL = self.pairs(L, weight, k); PR = self.pairs(R, weight, k) + rows = {u: self.vec([(r, weight(u, r)) for r in R], k) for u in L} + cross = {} + for ER in subsets(R, k): + for EL, node in self.vec([(u, rows[u][ER]) for u in L], k-len(ER)).items(): + cross[EL, ER] = node + return {EL | ER: self.total([xl, xr, cross[EL, ER]], 'd0') + for EL, xl in PL.items() for ER, xr in PR.items() if len(EL)+len(ER) <= k} + + def tri_parts(self, pts, k): + """Recursive halves and the two mixed families, before combination.""" + half = len(pts)//2; L, R = pts[:half], pts[half:] + TL = self.tri(L, k); TR = self.tri(R, k) + PR = {r: self.pairs(L, lambda u, v, r=r: self.x(u, v, r), k) for r in R} + PL = {u: self.pairs(R, lambda a, b, u=u: self.x(u, a, b), k) for u in L} + return L, R, TL, TR, PR, PL + + def tri(self, pts, k): + """{E: sum of triples inside pts avoiding E}, |E| <= k.""" + if len(pts) < 3: return {E: 0 for E in subsets(pts, k)} + L, R, TL, TR, PR, PL = self.tri_parts(pts, k) + c21 = {}; c12 = {} + for EL in subsets(L, k): + for ER, node in self.vec([(r, PR[r][EL]) for r in R], k-len(EL)).items(): + c21[EL, ER] = node + for ER in subsets(R, k): + for EL, node in self.vec([(u, PL[u][ER]) for u in L], k-len(ER)).items(): + c12[EL, ER] = node + return {EL | ER: self.total([xl, xr, c21[EL, ER], c12[EL, ER]], 'd0') + for EL, xl in TL.items() for ER, xr in TR.items() if len(EL)+len(ER) <= k} + + def build_disjoint(self): + """Six pieces per target, each leaving an outside point uncovered.""" + pts = list(range(self.h)) + L, R, TL, TR, PR, PL = self.tri_parts(pts, 3) + R1, R2 = R[:len(R)//2], R[len(R)//2:] + L1, L2 = L[:len(L)//2], L[len(L)//2:] + for S in self.triples: + E = frozenset(S); EL = E & frozenset(L); ER = E & frozenset(R) + pieces = [TL[EL], TR[ER]] + for half in (R1, R2): + pieces.append(self.vec([(r, PR[r][EL]) for r in half], 3-len(EL))[ER & frozenset(half)]) + for half in (L1, L2): + pieces.append(self.vec([(u, PL[u][ER]) for u in half], 3-len(ER))[EL & frozenset(half)]) + for node in pieces: self.emit(S, node, Q(1, 2)) + + # -- pair stars ------------------------------------------------------- + def build_pair_stars(self): + """Prefix and suffix pair-star sums around each excluded third point.""" + h = self.h + for a, b in combinations(range(h), 2): + others = [u for u in range(h) if u not in (a, b)] + n = len(others) + pre = [0] + for u in others: pre.append(self.add(pre[-1], self.x(a, b, u), 'd2')) + suf = [0]*(n+1) + for i in range(n-1, -1, -1): suf[i] = self.add(self.x(a, b, others[i]), suf[i+1], 'd2') + for i, c in enumerate(others): + S = tuple(sorted((a, b, c))) + self.emit(S, pre[i], Q(-1, 2)); self.emit(S, suf[i+1], Q(-1, 2)) + + def emit(self, S, node, coef): + """Inject a piece, splitting it until it leaves a point outside S uncovered.""" + if not node: return + if self.cover(node) | sum(1 << p for p in S) == (1 << self.h)-1: + a, b = self.args[node] + self.emit(S, a, coef); self.emit(S, b, coef) + else: + self.pieces.append((S, node, coef)) + + # -- bookkeeping ------------------------------------------------------ + def prune(self): + self.active = set(); stack = [node for _, node, _ in self.pieces] + while stack: + node = stack.pop() + if node in self.active: continue + self.active.add(node) + if self.args[node]: stack.extend(self.args[node]) + self.additions = sum(self.args[n] is not None for n in self.active) + self.roles = self.additions + len(self.pieces) + + def cover(self, node): + """Mask of ground points covered by the node's source triples.""" + if node not in self.points: + s = self.support[node]; mask = 0 + while s: + low = s & -s; mask |= sum(1 << p for p in self.triples[low.bit_length()-1]); s ^= low + self.points[node] = mask + return self.points[node] + + def stats(self): + v = len(self.triples) + return dict(h=self.h, v=v, additions=self.additions, injections=len(self.pieces), + roles=self.roles, roles_per_target=round(self.roles/v, 3), + disjoint_additions=sum(self.kind[n] == 'd0' for n in self.active), + pair_star_additions=sum(self.kind[n] == 'd2' for n in self.active)) + + +# -- binary linear algebra on F2^h, vectors as integer masks --------------- +def echelon(vectors): + """Reduced basis {pivot bit: vector}; raises on dependence.""" + basis = {} + for x in vectors: + for bit, b in basis.items(): + if x & bit: x ^= b + assert x, 'Dependent label vectors' + bit = x & -x + for other in basis: + if basis[other] & bit: basis[other] ^= x + basis[bit] = x + return basis + + +def reduce(basis, x): + for bit, b in basis.items(): + if x & bit: x ^= b + return x + + +def dot(x, y): + return (x & y).bit_count() & 1 + + +def rank(rows): + rows = list(rows); r = 0 + for col in range(max((x.bit_length() for x in rows), default=0)): + bit = 1 << col + pivot = next((i for i in range(r, len(rows)) if rows[i] & bit), None) + if pivot is None: continue + rows[r], rows[pivot] = rows[pivot], rows[r] + for i in range(len(rows)): + if i != r and rows[i] & bit: rows[i] ^= rows[r] + r += 1 + return r + + +class Label: + """A binary subspace with a canonical basis.""" + def __init__(self, vectors): + self.basis = echelon(vectors); self.dim = len(self.basis) + self.key = tuple(sorted(self.basis.values())) + + def contains(self, other): + return all(not reduce(self.basis, x) for x in other.basis.values()) + + def nondegenerate(self): + vs = list(self.basis.values()) + return rank([sum(dot(a, b) << j for j, b in enumerate(vs)) for a in vs]) == len(vs) + + def complement_in(self, other): + """Basis of other ∩ self^perp, assuming self ⊆ other.""" + vs = list(other.basis.values()); us = list(self.basis.values()); k = len(us) + rows = [sum(dot(v, u) << j for j, u in enumerate(us)) | 1 << (k+i) + for i, v in enumerate(vs)] + r = 0 + for col in range(k): + bit = 1 << col + piv = next((i for i in range(r, len(rows)) if rows[i] & bit), None) + if piv is None: continue + rows[r], rows[piv] = rows[piv], rows[r] + for i in range(len(rows)): + if i != r and rows[i] & bit: rows[i] ^= rows[r] + r += 1 + out = [] + for row in rows[r:]: + assert not row & ((1 << k)-1) + x = 0 + for i, v in enumerate(vs): + if row >> (k+i) & 1: x ^= v + out.append(x) + return out + + +def odd(vectors): + return any(x.bit_count() & 1 for x in vectors) + + +# -- exact checks ----------------------------------------------------------- +def tmask(t): + return sum(1 << p for p in t) + + +class Checks: + """Exact verification of the side map, labels and compiled roles.""" + def __init__(self, c): + self.c = c; self.h = c.h; self.cache = {}; self.verdicts = {} + self.everything = Label([1 << p for p in range(c.h)]) + + def label(self, node): + if node in self.cache: return self.cache[node] + c = self.c; kind = c.kind[node] + if kind == 'in': + vectors = [tmask(c.triples[node-1])] + elif kind == 'd0': + m = c.cover(node); vectors = [1 << p for p in range(self.h) if m >> p & 1] + else: + s = c.support[node]; ts = [] + while s: + low = s & -s; ts.append(c.triples[low.bit_length()-1]); s ^= low + common = set(ts[0]).intersection(*ts) + assert len(common) >= 2, 'Pair-star node without a common pair' + vectors = [tmask(t) for t in ts] + lab = Label(vectors); self.cache[node] = lab + return lab + + def target_frame(self, S): + t = tmask(S) + key = ('perp', S) + if key not in self.cache: + self.cache[key] = Label([x for x in (1 << p for p in range(self.h)) + if not dot(x, t)] + [tmask((S[0], S[1])), tmask((S[1], S[2]))]) + return self.cache[key] + + def residual_ok(self, small, big): + """small ⊆ big and big ⊖ small is zero or has an odd vector.""" + key = (small.key, big.key) + if key not in self.verdicts: + res = small.complement_in(big) if big.contains(small) else None + self.verdicts[key] = res is not None and (not res or odd(res)) + return self.verdicts[key] + + def label_ok(self, lab): + """Nondegenerate, contains an odd vector, and its complement is zero or does.""" + key = ('label', lab.key) + if key not in self.verdicts: + perp = lab.complement_in(self.everything) + self.verdicts[key] = (lab.nondegenerate() and odd(lab.basis.values()) + and (not perp or odd(perp))) + return self.verdicts[key] + + def verify_map(self): + c = self.c + for node in c.active: + if c.args[node]: + a, b = c.args[node] + assert a < node and b < node and not c.support[a] & c.support[b] + assert c.support[node] == c.support[a] | c.support[b] + got = {} + for S, node, coef in c.pieces: + assert coef in (Q(1, 2), Q(-1, 2)) + key = (S, coef) + assert not got.get(key, 0) & c.support[node], 'Overlapping pieces' + got[key] = got.get(key, 0) | c.support[node] + nonzero = 0 + for S in c.triples: + zero = sum(1 << i for i, T in enumerate(c.triples) if not set(S) & set(T)) + two = sum(1 << i for i, T in enumerate(c.triples) if len(set(S) & set(T)) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + + def verify_labels(self): + c = self.c; checked = 0 + for node in sorted(c.active): + lab = self.label(node) + assert self.label_ok(lab), node # includes the exit to the full space + if c.args[node]: + for child in c.args[node]: + assert self.residual_ok(self.label(child), lab), (node, child) + checked += 1 + for S, node, coef in c.pieces: + assert self.residual_ok(self.label(node), self.target_frame(S)), (S, node) + checked += 1 + return dict(active_nodes=len(c.active), checked_inclusions=checked, + all_labels_nondegenerate=True, all_residuals_have_odd_vectors=True) + + +def compile_roles(c): + """Reversible roles: one per addition plus one per injected piece.""" + users = {x: [] for x in c.active} + for node in sorted(c.active): + if c.args[node]: + for pos, x in enumerate(c.args[node]): users[x].append(('gate', node, pos)) + for i, (_, node, _) in enumerate(c.pieces): users[node].append(('output', i)) + edge = {}; sources = {}; outputs = {}; gates = []; size = 0 + for node in sorted(c.active): + if c.args[node]: + ins = (edge[node, 0], edge[node, 1]); pivot = ins[0] + else: + pivot = size; size += 1; ins = (pivot,); sources[c.triples[node-1]] = pivot + assert users[node] + outs = (pivot,)+tuple(range(size, size+len(users[node])-1)) + size += len(users[node])-1 + assert len(set(ins)) == len(ins) and set(ins) & set(outs) == {pivot} + gates.append((node, ins, outs)) + for user, slot in zip(users[node], outs): + if user[0] == 'gate': edge[user[1], user[2]] = slot + else: outputs[user[1]] = slot + assert size == c.roles + return dict(roles=size, gates=gates, sources=sources, outputs=outputs) + + +def verify_role_frames(c, checks, code=None): + """Follow every physical role in both directions through its frames.""" + code = code or compile_roles(c) + def step(small, big): assert checks.residual_ok(small, big) + frames = [None]*code['roles'] + for T, slot in code['sources'].items(): frames[slot] = checks.label(c.input[T]) + for node, ins, outs in code['gates']: + lab = checks.label(node) + for slot in set(ins+outs): + if frames[slot] is None: assert checks.label_ok(lab) # entry from D0 + else: step(frames[slot], lab) + frames[slot] = lab + for i, slot in code['outputs'].items(): + S = c.pieces[i][0]; J = checks.target_frame(S) + step(frames[slot], J); frames[slot] = J + for lab in frames: + assert checks.label_ok(lab) # includes the exit residual to D1 + # Reverse stage: complements, traversed backward. U^perp grows iff U shrinks. + # Its entries and exits have the forward residuals U^perp and U, checked above. + back = [None]*code['roles'] + for i, slot in code['outputs'].items(): back[slot] = ('line', c.pieces[i][0]) + for node, ins, outs in reversed(code['gates']): + lab = checks.label(node) + for slot in set(ins+outs): + prev = back[slot] + if prev is None: + assert checks.label_ok(lab) # reverse entry residual is lab^perp + elif prev[0] == 'line': # ⊆ U^perp iff U ⊆ t_S^perp + step(lab, checks.target_frame(prev[1])) + else: + step(lab, prev[1]) # prev^perp ⊆ lab^perp iff lab ⊆ prev + back[slot] = ('node', lab) + for T, slot in code['sources'].items(): + assert back[slot][1].key == checks.label(c.input[T]).key # ends at t_T^perp + return dict(roles=code['roles'], forward_frames_nested=True, + reverse_complement_frames_nested=True) + + +def simulate_invocation(c, code, x, y, side, center, inverse=False): + """Scalar invocation over Q with arbitrary scratch; returns the new state. + + Forward: L,-J,L^-1,-R,V,G,R,L,J,L^-1,G^-1,V^-1 gives y <- y + x. + inverse=True runs the inverted schedule, giving x <- x - y. + """ + h = c.h; T = c.triples + side = list(side); center = dict(center); x = dict(x); y = dict(y) + def L(sign=1): + order = code['gates'] if sign > 0 else list(reversed(code['gates'])) + for node, ins, outs in order: + if sign > 0: + if len(ins) == 2: side[ins[0]] += side[ins[1]] + for o in outs[1:]: side[o] += side[outs[0]] + else: + for o in outs[1:]: side[o] -= side[outs[0]] + if len(ins) == 2: side[ins[0]] -= side[ins[1]] + def J(target, sign): + for i, slot in code['outputs'].items(): + S, _, coef = c.pieces[i]; target[S] += sign*coef*side[slot] + def V(source, sign): + for t, slot in code['sources'].items(): side[slot] += sign*source[t] + def G(source, sign): + for i in range(h): center[i] += sign*sum(source[t] for t in T if i in t) + center['*'] += sign*sum(source.values()) + def R(target, sign): + for t in T: target[t] += sign*(sum(center[i] for i in t)-center['*'])/2 + if not inverse: + L(); J(y, -1); L(-1); R(y, -1); V(x, 1); G(x, 1); R(y, 1) + L(); J(y, 1); L(-1); G(x, -1); V(x, -1) + else: # inverse schedule with logical source y and target x + V(y, 1); G(y, 1); L(); J(x, -1); L(-1); R(x, -1); G(y, -1); V(y, -1) + R(x, 1); L(); J(x, 1); L(-1) + return x, y, side, center + + +if __name__ == '__main__': + import sys, time + for h in map(int, sys.argv[1:] or ['10', '12', '16']): + t = time.time(); c = ComplexSideCircuit(h) + print(c.stats(), f'{time.time()-t:.1f}s', flush=True) diff --git a/research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py b/research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py new file mode 100644 index 0000000000..af9bb6d7b3 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +"""Conditional 59/10^11 witness: a compressed complex side circuit. + +The compact-control witness was limited by the original complex motif, whose +v*z_c side wires per invocation dilute its rank deficit. The new side circuit +computes the same correction with shared sums, binary coordinate and pair-star +labels, and the bit network's transparent twelve-operation schedule. The bit +network, compact-control movement and assembly recipe are unchanged. +""" +from fractions import Fraction as Q +from math import comb +from pathlib import Path +import json + +from certify import Parameters, constraints, margins, require, verify_sources +from compact_control_layer import layer_exponents +from complex_circuit import ComplexSideCircuit, Checks, compile_roles, verify_role_frames +from paired_network import BIT_SAVING +from prepare_layers import serializable +from search_network import log_integer_bounds + +ROOT = Path(__file__).resolve().parents[1] +H = 25 +COMPLEX_SAVING = Q(14, 10**9) +LOG_BOUND = Q(966, 100) +KAPPA = Q(59, 10**11) + + +def counts(c): + h = c.h; v = comb(h, 3); m = h**3; N = v**3; I = 3*v*v + R = c.roles; W = 2*N+I*(R+h+1); L = I*(h+1)*h + s = W*m-2*N+2*L + require(L < N, 'Complex deficit is not positive') + return dict(h=h, v=v, m=m, N=N, I=I, side_roles_per_invocation=R, + central_roles=h+1, W=W, L=L, s=s, deficit=W*m-s, eta=Q(W*m-s, W*m), + original_side_wires_per_invocation=v*(comb(h-3, 3)+3*(h-3))) + + +def gate_count(c, n): + """Per invocation: four mixer passes, two copies, two injections, four central gates.""" + per = 4*len(c.active)+4*n['v']+4 + require(n['I']*per <= 12*n['W'], 'The 12W gate bound behind E=64(W+m+1)^3 failed') + return dict(gates_per_invocation=per, total_gates=n['I']*per, twelve_W=12*n['W']) + + +def guard(n, beta, zeta): + """Generalized stopped-depth guard with the new complex constants.""" + m, s, W = n['m'], n['s'], n['W'] + E = 64*(W+m+1)**3; B = s+E + require(m >= 3 and 2 <= s < m**5, 'Unverified coefficient-depth hypothesis') + require(s*(8+E) <= 9*B*B, 'One-piece constant failed') + C1 = 5-4*beta+zeta + raw = max(Q(128*m*B*B), 18*m*B*B*(1+1/zeta)) + C0 = -(-raw.numerator//raw.denominator) + require(9*m*B*B*(1+1/zeta)+18 <= C0, 'Whole-layer constant failed') + return dict(m=m, s=s, E=E, B=B, beta=beta, zeta=zeta, C0=C0, C1=C1) + + +def parameters(): + return Parameters(tau=1-BIT_SAVING, sigma=1-COMPLEX_SAVING, + epsilon=Q(19999, 100000), c=Q(999, 1000), + lam=1-Q(2958, 10**12), lamp=1-Q(2956, 10**12), + kappa=KAPPA, beta=Q(1, 1000), delta=Q(1, 10**6), + C1=Q(49961, 10000)) + + +def witness(p, n): + g = guard(n, p.beta, Q(1, 10000)) + require(p.C1 == g['C1'], 'Guard mismatch') + e = layer_exponents(p.tau, p.sigma, p.beta, p.c) + slacks = constraints(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + slacks['packed_overhead'] = p.lam-e['internal'] # compact control: internal = max exponent + slacks['reserved_axes'] = p.lamp-e['preprocessing'] + for name, slack in slacks.items(): require(slack > 0, 'Constraint failed: '+name) + gs = margins(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + require(min(gs.values()) > p.kappa, 'No final absorption gap') + return dict(parameters=vars(p), guard=g, recurrence=e, constraint_slacks=slacks, + margins=gs, minimum_margin=min(gs.values()), + limiting_margins=[k for k, v in gs.items() if v == min(gs.values())], + absorption_gap=min(gs.values())-p.kappa) + + +def witness_only(): + """Counts and parameter witness without the full finite checks (for the patch).""" + n = counts(ComplexSideCircuit(H)) + require(n['eta'] > COMPLEX_SAVING*LOG_BOUND, 'Complex saving failed') + return witness(parameters(), n) + + +def certificate(): + c = ComplexSideCircuit(H); checks = Checks(c); code = compile_roles(c) + side = checks.verify_map(); labels = checks.verify_labels() + roles = verify_role_frames(c, checks, code) + n = counts(c) + lo, hi = log_integer_bounds(n['m']) + require(hi < LOG_BOUND, 'Logarithm enclosure failed') + require(n['eta'] > COMPLEX_SAVING*LOG_BOUND, 'Complex saving failed') + p = parameters(); w = witness(p, n) + require(Q(1, 2**31) < KAPPA < Q(1, 2**30), 'Unexpected dyadic scale') + # With the bit exponent fixed, g3 <= epsilon*(1-lambda) < epsilon*a_b < a_b/5. + ceiling = BIT_SAVING/5 + require(ceiling < Q(1, 2**30), 'This bit network could cross 2^-30') + return dict(status='CONDITIONAL 59/10^11 WITNESS; COMPRESSED COMPLEX SIDE CIRCUIT; NOT FORMAL VERIFICATION', + upstream_commit=verify_sources(), circuit=c.stats(), side_map=side, + labels=labels, role_frames=roles, gates=gate_count(c, n), + complex_counts=n, complex_saving=COMPLEX_SAVING, log_m_upper=LOG_BOUND, + log_enclosure=(lo, hi), complex_deficit_slack=n['eta']-COMPLEX_SAVING*LOG_BOUND, + bit_saving=BIT_SAVING, witness=w, + improvement_over_compact_control=KAPPA/Q(83, 10**12), + scoped_ceiling=dict(upper=ceiling, below_2_to_minus_30=True, + scope='Published h=50 paired bit network and retained Gaussian margin; not a bound on other networks or algorithms.'), + scope='Conditional on the pinned upstream interfaces, the compact-control movement and guard proofs, the paired bit network, and the written binary-frame transfer for this complex side circuit. Exact arithmetic and finite checks are not formal verification.') + + +if __name__ == '__main__': + result = serializable(certificate()) + (ROOT/'certificates/complex-network.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print('PASS conditional', KAPPA, '> 2^-31; minimum margin', result['witness']['minimum_margin']) + print('Side roles per invocation', result['complex_counts']['side_roles_per_invocation'], + 'vs original', result['complex_counts']['original_side_wires_per_invocation']) diff --git a/research/h25-bookkeeping/payload/baseline/evidence/COMPLETE-GATE.json b/research/h25-bookkeeping/payload/baseline/evidence/COMPLETE-GATE.json new file mode 100644 index 0000000000..7d7eb5624e --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/COMPLETE-GATE.json @@ -0,0 +1,119 @@ +{ + "all_failures_and_samples_retained": true, + "all_six_scientific_observations_exact_equal": true, + "cold_build_and_all_native_controls_in_every_candidate": true, + "diagnostic_excluded": true, + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "metrics": { + "cpu_seconds": { + "absolute_saving": 11.119999999999997, + "baseline_median": 39.58, + "baseline_samples": [ + 41.64, + 39.28, + 39.58 + ], + "candidate_median": 28.46, + "candidate_samples": [ + 28.46, + 28.439999999999998, + 31.919999999999998 + ], + "maximum_within_arm_range": 3.4800000000000004, + "noise_pass": true, + "reduction_fraction": 0.2809499747347145, + "target_pass": true + }, + "wall_seconds": { + "absolute_saving": 11.049925514002098, + "baseline_median": 39.68618175998563, + "baseline_samples": [ + 42.103671320015565, + 39.355439921986545, + 39.68618175998563 + ], + "candidate_median": 28.63625624598353, + "candidate_samples": [ + 28.63625624598353, + 28.595429725013673, + 33.12922728899866 + ], + "maximum_within_arm_range": 4.53379756398499, + "noise_pass": true, + "reduction_fraction": 0.27843256831382557, + "target_pass": true + } + }, + "samples": [ + { + "cpu_seconds": 41.64, + "label": "B1", + "sampled_rss_bytes": 407670784, + "wall_seconds": 42.103671320015565 + }, + { + "cpu_seconds": 28.46, + "label": "C1", + "sampled_rss_bytes": 408207360, + "wall_seconds": 28.63625624598353 + }, + { + "cpu_seconds": 28.439999999999998, + "label": "C2", + "sampled_rss_bytes": 416595968, + "wall_seconds": 28.595429725013673 + }, + { + "cpu_seconds": 39.28, + "label": "B2", + "sampled_rss_bytes": 427556864, + "wall_seconds": 39.355439921986545 + }, + { + "cpu_seconds": 39.58, + "label": "B3", + "sampled_rss_bytes": 407625728, + "wall_seconds": 39.68618175998563 + }, + { + "cpu_seconds": 31.919999999999998, + "label": "C3", + "sampled_rss_bytes": 436506624, + "wall_seconds": 33.12922728899866 + } + ], + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scope": "Complete frozen historical complex_network.py CLI WITH retained full output/type/ordered witness and transcript observations; no bareCLI/selectedfrontier/PR5864/kappa transfer", + "sequence": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "status": "PASS_COMPLETE_FROZEN_H25_CALLER_15_PERCENT_WALL_CPU_AND_NOISE" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/ENVIRONMENT.json b/research/h25-bookkeeping/payload/baseline/evidence/ENVIRONMENT.json new file mode 100644 index 0000000000..c3267ba932 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/ENVIRONMENT.json @@ -0,0 +1,10 @@ +{ + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "executable": "/usr/bin/python3", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "machine": "x86_64", + "cpu_model": "Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz", + "logical_cpu_count": 8, + "measurement_environment": "PYTHONHASHSEED=0 LC_ALL=C.UTF-8 TZ=UTC; cold per process; compiler child CPU included; parentguard serial; originalassertions on", + "guard_stdout_stderr_cap_bytes": 2097152 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/FIRST-PAIR-GATE.json b/research/h25-bookkeeping/payload/baseline/evidence/FIRST-PAIR-GATE.json new file mode 100644 index 0000000000..d6e2de98ae --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/FIRST-PAIR-GATE.json @@ -0,0 +1,70 @@ +{ + "status": "PAIR_TARGET_PASS_ADMIT_REMAINDER_FIXED_SEQUENCE", + "wall_reduction": 0.31986320080429165, + "cpu_reduction": 0.31652257444764653, + "science_exact_equal": true, + "samples": { + "B1": { + "exit": 0, + "label": "full-network-B1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 407670784, + "script": "stages/qualification-v1/full_B1.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3665, + "stdout_sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453356, + "system_seconds": 0.32, + "user_seconds": 41.32 + }, + "wall_seconds": 42.103671320015565, + "cpu_seconds": 41.64 + }, + "C1": { + "exit": 0, + "label": "full-network-C1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 408207360, + "script": "stages/qualification-v1/full_C1.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3947, + "stdout_sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453852, + "system_seconds": 0.35, + "user_seconds": 28.11 + }, + "wall_seconds": 28.63625624598353, + "cpu_seconds": 28.46 + } + }, + "remaining_sequence": [ + "C2", + "B2", + "B3", + "C3" + ], + "no_final_performance_claim_yet": true, + "final_gate": "threeperarmmedians>=15%wallCPUandmediansavings>maxwithinarmrangeforboth" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/FULL-PAIR-ADMISSION.json b/research/h25-bookkeeping/payload/baseline/evidence/FULL-PAIR-ADMISSION.json new file mode 100644 index 0000000000..ca82514297 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/FULL-PAIR-ADMISSION.json @@ -0,0 +1,13 @@ +{ + "decision": "ADMIT_ONE_FROZEN_COMPLETE_B1_C1_PAIR", + "basis": "Fresh full caller/inputs/output/witness/type/coverage anchor passes; verify_labels dominates real complete CLI. Unchanged source-bound C kernel has prior separate segment qualification; none of that historical percentage is transferred to this workload. Fullcaller exact extra stages execute. The next paired test can directly decide complete target with all cold costs.", + "prior_profile": "diagnostic only, excluded from performance samples", + "profile_outer_wall_seconds": 40.92687450101948, + "profile_verify_labels_wall_seconds": 28.431476872006897, + "stage": "outputs/gf2-full-network-20261028/stages/qualification-v1", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "anchor_sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "static_review": "INDEPENDENT-REVIEW.md", + "pair_gate": "wall AND CPU >=15% after all source/copy/observation/compile/finite bills; if passes finish already-declared C2 B2 B3 C3; no rerolls", + "separate_PR5864_goal": "blocked and unchanged" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/INDEPENDENT-REVIEW.md b/research/h25-bookkeeping/payload/baseline/evidence/INDEPENDENT-REVIEW.md new file mode 100644 index 0000000000..5987d7d522 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/INDEPENDENT-REVIEW.md @@ -0,0 +1,53 @@ +# Independent static review: full historical complex-network GF(2) + +Date: 2026-10-28. **STATIC CLEARANCE FOR ONE GUARDED PROFILE/ANCHOR ATTEMPT.** No open source blocker remains in the final driver. This is not a runtime PASS, a cost admission or permission to skip PLAN's subsequent gates. The parent remains the sole scientific runner. + +Reviewed driver: `source-design/full_driver.py`, 356 lines, SHA-256 `0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36`. Design SHA-256: `609a4c6aee119ddaed9f10dc2726ece18436179ad9caaced70cebaa58066f8eb`. Source inventory SHA-256: `88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7`. + +## Scope and complete caller + +[PLAN.json](PLAN.json), lines 2–12 and 24–41, defines the full H25 historical conditional CLI at main `19fdb086ea96af9a9f87936a2b888e10af4ed810`, with PR5929's native predecessor. This is separate from the blocked further-15% PR5864 task and current selected-frontier replay. + +The untouched [complex_network.py](frozen/scripts/complex_network.py), lines 90–112, performs side-map, label and role checks, counts, logarithm enclosure, strict saving comparison, parameters, guard/recurrence/constraint/margin checks, dyadic/ceiling checks, source verification and gate bound. Lines 115–120 perform the actual JSON file write and two stdout lines. The driver executes this complete file through `runpy.run_path(..., run_name='__main__')`, not `witness_only()` or the former side-only harness ([driver](source-design/full_driver.py), lines 257–274). + +Every full mode requires normal assertion execution (driver lines 144–146). The original assertions in [complex_circuit.py](frozen/scripts/complex_circuit.py), including map checks at 313–333, labels at 335–348 and forward/reverse role checks at 376–411, remain in the executed functions. No other imported module's `__main__` search/certificate is invoked. + +## Sources, imports and the real verifier + +The frozen inventory contains twelve scripts, the upstream manifest and all **19** payloads. The driver authenticates the pinned inventory, exact file sets and contents; then cross-checks the manifest's commit, payload set and each digest against that inventory (lines 152–180). The original [certify.verify_sources](frozen/scripts/certify.py), lines 226–232, still reads and hashes every actual payload. Its observational wrapper delegates the original function, and the complete run requires exactly one original-verifier call. No stubbed verifier or cached PASS replaces it. + +The seven engine/input files match published PR5929 bytes. In particular, native backend, finite controls and C kernel hashes are respectively `e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5`, `df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a`, and `e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc`. + +Both duplicated engine source files must equal the corresponding frozen scripts (driver lines 192–194). The engine's exact loaded circuit module is registered as `complex_circuit`; afterward, the driver checks the CLI's imported class/function identities and all scientific module paths (lines 209–218 and 270–289). The circuit's alternative filesystem location is explicit and byte-bound, not an unverified replacement module. + +## Observers and exact outputs + +The role observer calls the original function once and returns its original result object. The depth-aware serializer delegates the original recursive serializer once per value and captures only the outer full certificate (driver lines 225–255). Original [prepare_layers.serializable](frozen/scripts/prepare_layers.py), lines 148–155, retains its recursion and conversions. + +The logarithm wrapper's import order is sound: `prepare_layers` first captures its ordinary alias; `search_network.log_integer_bounds` is then wrapped; the full caller subsequently imports that wrapper for its one direct call. No other called full-certificate path adds a hidden second logarithm call. Required coarse-phase counts are checked at driver lines 280–283. These observer changes do not alter Label members or helper globals tracked by the native runtime guard. + +The original certificate must match pinned reference bytes, including formatting/newline, and captured CLI stdout must match both literal lines (driver lines 267–269). Reference SHA-256 is `1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f`. The exact CLI stdout is separately retained and re-emitted; the outer driver also prints clearly separate receipt metadata. + +The added typed full-return representation preserves Fraction pairs, float hex values, exact primitive/container types and dictionary order (driver lines 91–110). Both arms retain the complete side structural/label/role witness and ordered rank transcript through the unchanged PR5929 writer, with its fixed hashes and 59,959 calls. The complete complement receipt requires all 238,685 ordered calls and 55,839,507 canonical bytes, with the retained digest. No sampling or replacement by rank/odd-vector predicates occurs (driver lines 295–321). + +## Native and independent finite boundary + +The unchanged [native backend](source-design/engine/native_backend.py), lines 113–209 and 317–386, binds source/code, effective builtins, Label/helper dispatch and native callables; detects subsequent drift before native work or fallback; and preserves unsupported types/widths through the original methods. The C kernel requires exact dictionaries and nonnegative exact integers fitting 64 bits; augmented complements require total width at most 64. It preserves first-pivot/all-row elimination and ordered complement outputs ([native_gf2.c](source-design/engine/native_gf2.c), lines 17–50 and 129–195). + +Each candidate cold-builds, links and loads once, then executes the entire unchanged finite suite before the full CLI (driver lines 204–207). [finite_controls.py](source-design/engine/finite_controls.py), lines 20–61, provides a separate dense-list/modulo-two oracle; lines 124–260 check ordered results, exact types, short exhaustive cases, boundary widths, permutations, fallback/error behavior and deliberately wrong/reordered controls. Lines 296–456 retain runtime-binding and complete-stream controls. The live independent finite oracle is not replaced by the profile anchor. + +## Repair, cost and remaining gates + +One concrete pre-execution repair was identified: `copytree` preserves readonly directory modes, so a readonly cloned root could not create `certificates/`. The final driver makes only its fresh private runtime root `0755` before that creation (lines 182–191). Copied scientific file modes remain unchanged. Compiler temporary files stay under the new output directory (lines 168–170). Source/engine/reference/anchor bytes and before/after file modes are checked; only the expected certificate may be added to the runtime tree (lines 324–331). + +Both benchmark arms pay fresh copies, imports, custody checks, the complete CLI and identical retained observations; the candidate additionally pays cold build/load and all finite controls. The parent outer wall and process-group CPU receipts are authoritative. Coarse phases are nested diagnostics and must not be summed as independent savings. + +The first profile creates the source-bound full-result anchor and is excluded from performance selection. Both benchmark modes reject an absent or mismatched driver/engine/input/scientific anchor (lines 145–166 and 318–323). A successful profile must precede a separate parent headroom decision. Only then may PLAN's fixed B1,C1 gate and conditional remaining BCCBBC samples proceed, retaining every stop/failure. The 180-second, 1-GiB and aggregate caps remain unchanged. No completion, memory fit, 15% gain, formal verification, new κ or PR5864 improvement is asserted by this static clearance. + +Reviewer actions were source reads, file inventories and hashes only. No scientific import, execution, compilation, timing, Git/browser operation or delegation was performed. + +## Parent runtime follow-up: entry-name correction + +The first parent-created entry, `stages/profile-v1/profile.py`, shadowed the standard-library `profile` module imported by the unchanged helper's `cProfile` dependency. The retained [v1 receipt](runtime/runs/full-network-profile-v1/receipt.json), lines 2–22, records STOP after 0.976437556 seconds, unchanged source bytes/modes and empty stdout; [stderr](runtime/runs/full-network-profile-v1/stderr.txt), lines 21–38, identifies the recursive import and overwrite refusal. This stopped during helper import, before circuit construction or any candidate compilation. It is a retained failed attempt, not a performance sample or evidence against the mathematics. + +The parent made a separate manual entry correction in immutable `profile-v2/full_profile_entry.py`; the v2 stage contains no `profile.py`. I read that entry and verified the driver/backend/finite/C hashes above are unchanged. The driver source clearance therefore carries to the corrected entry. The corrected diagnostic was reported running; no successful profile, anchor or candidate measurement is claimed in this review. [PROFILE-v1-FAILURE.json](PROFILE-v1-FAILURE.json) retains the correction boundary. diff --git a/research/h25-bookkeeping/payload/baseline/evidence/INPUT-COMMIT.json b/research/h25-bookkeeping/payload/baseline/evidence/INPUT-COMMIT.json new file mode 100644 index 0000000000..1e4f3084de --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/INPUT-COMMIT.json @@ -0,0 +1,56 @@ +{ + "base": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "commit": "7f9c2985de167e95d159040eee26fc03c1e27fb6", + "diff": { + "added": 42, + "deleted": 0, + "modified": 0 + }, + "files": { + "SOURCE-PINS.json": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "engine/finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "engine/native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "engine/native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "engine/profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "engine/source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "frozen/scripts/audit_short_guards.py": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1", + "frozen/scripts/certify.py": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e", + "frozen/scripts/compact_control_layer.py": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f", + "frozen/scripts/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "frozen/scripts/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "frozen/scripts/exclusion_circuit.py": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3", + "frozen/scripts/paired_exclusion_circuit.py": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2", + "frozen/scripts/paired_network.py": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7", + "frozen/scripts/prepare_layers.py": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947", + "frozen/scripts/search_network.py": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a", + "frozen/scripts/shared_point_circuit.py": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95", + "frozen/scripts/shared_point_network.py": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697", + "frozen/upstream/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "frozen/upstream/README.md": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "frozen/upstream/build/figures/multiplication-flow.tex": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "frozen/upstream/build/figures/proof-map.tex": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "frozen/upstream/build/main.tex": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "frozen/upstream/build/references.bib": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "frozen/upstream/build/sections/00-introduction.tex": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "frozen/upstream/build/sections/01-history.tex": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "frozen/upstream/build/sections/02-streams.tex": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "frozen/upstream/build/sections/03-motifs.tex": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "frozen/upstream/build/sections/04-swap.tex": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "frozen/upstream/build/sections/05-layers.tex": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "frozen/upstream/build/sections/06-transforms.tex": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "frozen/upstream/build/sections/07-resampling.tex": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "frozen/upstream/build/sections/08-assembly.tex": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "frozen/upstream/build/sections/09-exact-arithmetic.tex": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "frozen/upstream/build/sections/10-transposition.tex": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "frozen/upstream/build/sections/11-grouped-rectangles.tex": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "frozen/upstream/formalization.yaml": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "frozen/upstream/manifest.json": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392", + "reference/certificates/complex-network.json": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "reference/certificates/selected-result.json": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "path": "research/gf2-full-network", + "preserved_failed_local_commit": "bb01abd4ce01a722ef883a42bc6a34e7ce617762", + "publication": "not pushed" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/LOCAL-INPUT-INDEX-STOP.json b/research/h25-bookkeeping/payload/baseline/evidence/LOCAL-INPUT-INDEX-STOP.json new file mode 100644 index 0000000000..c71b7f25f6 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/LOCAL-INPUT-INDEX-STOP.json @@ -0,0 +1,12 @@ +{ + "status": "LOCAL_INPUT_INDEX_ERROR_PRESERVED_NOT_PUBLISHED", + "head": "bb01abd4ce01a722ef883a42bc6a34e7ce617762", + "change_counts": { + "A": 42, + "D": 126453, + "M": 0, + "T": 0 + }, + "cause": "New --no-checkout worktree index was not populated from base before adding inputs; preserve local mistaken commit and reconstruct correct tree from exact base", + "scientific_source_change": false +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/PLAN.json b/research/h25-bookkeeping/payload/baseline/evidence/PLAN.json new file mode 100644 index 0000000000..ec9df5043f --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/PLAN.json @@ -0,0 +1,56 @@ +{ + "authorized_by": "User Proceed after concrete full-network GF2 evaluation proposal, 2026-10-28 local", + "scope": "Complete unchanged scripts/complex_network.py CLI H25 historical conditional certificate at source-pinned canonical main; no current selected-frontier/theorem/kappa improvement claim", + "separate_goal": "Further15% complete PR5864 app objective remains blocked and incomplete; this authorized full-network evaluation is a distinct workload and decision", + "baseline_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "native_predecessor": { + "pr": 5929, + "head": "a456c246ec72a23f327d4b1394fbb3bf7087a65c" + }, + "target": { + "wall_reduction_minimum": 0.15, + "cpu_reduction_minimum": 0.15 + }, + "resource_policy": { + "parent_serial_runner_only": true, + "per_command_wall_seconds": 180, + "sampled_process_group_rss_bytes": 1073741824, + "first_feasibility_seconds": 600, + "round_total_seconds": 1500, + "previous_round_spent_seconds": 790.6046611171041, + "new_scope_not_reset_of_prior_ledger": true, + "automatic_retries": false + }, + "sequence": [ + "static source/closure and live overlap check", + "one complete unchanged baseline profile/anchor diagnostic, excluded from performance selection", + "review full costs/headroom and exact outputs", + "one complete baseline/candidate pair B1,C1 only if admitted", + "if both >=15% wall and CPU at pair with exact outputs, finish fixed C2,B2,B3,C3 BCCBBC sequence", + "finite normal/O and Git-free readonly/source/export checks", + "focused publication via Chrome if useful supported result" + ], + "noise_rule": "For six fixed cold BCCBBC runs, baseline median minus candidate median must exceed max(within-baseline range,within-candidate range) separately for wall and CPU, in addition to15% both; all samples and stops retained; first diagnostic not selected", + "preserve": [ + "unchanged full caller bytes and arithmetic/source checks", + "every original finite check and exact output", + "full original CLI certificate bytes/stdout", + "ordered side witnesses/rank trace/complement stream", + "native finite independent dense oracle, source/type/binding/fallback controls", + "cold compiler/link/load and all new controls in candidate bill", + "all failure evidence and source bytes/modes" + ], + "paused": [ + "kappa research", + "Work1/2 mathematical streams", + "unrelated feeds", + "automations" + ], + "stop": [ + "source/output/coverage/oracle mismatch", + "wall/RSS/aggregate cap", + "first complete pair fails target", + "final medians fail target/noise", + "full caller has unpriced side effects or dependencies" + ] +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/PROFILE-v1-FAILURE.json b/research/h25-bookkeeping/payload/baseline/evidence/PROFILE-v1-FAILURE.json new file mode 100644 index 0000000000..09d6c1cdc0 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/PROFILE-v1-FAILURE.json @@ -0,0 +1,8 @@ +{ + "status": "PRE_SCIENCE_IMPORT_STOP_RETAINED", + "cause": "Parent entry profile.py shadowed stdlib profile imported by unchanged cProfile dependency", + "correction": "New immutable profile-v2 stage with full_profile_entry.py; driver/engine/caller unchanged; no same-stage retry", + "scientific_work_executed": false, + "timing_sample": false, + "receipt": "runtime/runs/full-network-profile-v1/receipt.json" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/RESULTS.md b/research/h25-bookkeeping/payload/baseline/evidence/RESULTS.md new file mode 100644 index 0000000000..2787a89633 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/RESULTS.md @@ -0,0 +1,18 @@ +# Complete frozen H25 verification qualification + +All six declared cold BCCBBC processes pass exact full-caller correctness, the minimum 15% wall AND CPU gate, and the declared repeat-spread noise gate. This is the complete frozen historical `scripts/complex_network.py` CLI with retained full typed return, ordered side witnesses, rank records and complement observation. It is not an uninstrumented bare-CLI factor or a selected-frontier/PR5864/kappa result. + +| Metric | Baseline median | Native median | Reduction | Saving | Largest within-arm range | +|---|---:|---:|---:|---:|---:| +| Wall seconds | 39.686181760 | 28.636256246 | 27.843257% | 11.049925514 | 4.533797564 | +| CPU seconds, compiler included | 39.58 | 28.46 | 28.094997% | 11.12 | 3.48 | + +No sample was dropped or rerun. C3 was slower and remains in the calculation. The profile anchor is excluded. The initial 0.976-second parent entry import failure is retained separately; it preceded scientific work, and the corrected entry has a distinct frozen stage and basename. + +The full original caller executes side construction, role compilation, every finite side/map/label/role check, exact counts/gates, logarithm enclosure, guard/recurrence/constraint/margin checks, the historical ceiling check, the original 19-payload upstream verifier, original JSON serialization/write and both original stdout lines. Both arms retain the same observations and exact output work. Every candidate additionally pays cold compilation/link/load and the unchanged PR5929 independent dense/finite, type, width, fallback and source/live-binding controls. Full runs retain original assertions; optimized full verification is rejected. + +The full certificate matches committed SHA-256 `1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f`. Lossless ordered full-return SHA-256 `542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd` matches the independently generated baseline anchor in every arm. All original side identities match PR5929: 59,959Gram-rank records, 238,685ordered complements and 55,839,507canonical complement-stream bytes. The complete 58,143,622-byte ordered witness, 2,674,272-byte rank transcript, typed return, certificate, stdout and complement receipt are retained in canonical lossless artifacts with independent logical and transport hashes. + +Parent ran every scientific/compiler process serially, under 180 seconds per command and 1 GiB sampled process-group RSS. Source bytes/modes are unchanged in every successful receipt. Environment: Linux x86-64, CPython 3.12.3, GCC 13.3. Metadata, read-only export and hosted checks are publication obligations, recorded separately from these six local performance samples. + +Existing PR5929 source design/native kernel is reused unchanged and credited. Its earlier 29.27% side-segment result is separate. Original CrocSwap authors/notices and upstream license remain preserved. Chris R/Clear1nsight with substantial OpenAI Codex implementation and user-requested Astra xhigh source design/independent review. This is finite engineering evidence, not a formal proof or new mathematical admission. The original further 15% PR5864 app goal remains blocked and incomplete; paused mathematical streams, feeds and automations remain paused. diff --git a/research/h25-bookkeeping/payload/baseline/evidence/SOURCE-DESIGN.md b/research/h25-bookkeeping/payload/baseline/evidence/SOURCE-DESIGN.md new file mode 100644 index 0000000000..f5d1915940 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/SOURCE-DESIGN.md @@ -0,0 +1,54 @@ +# Full historical complex-network GF(2) evaluation + +## Source and scope + +The fixed caller is `scripts/complex_network.py` at canonical main `19fdb086ea96af9a9f87936a2b888e10af4ed810`, with `H=25`. Its bytes match PR5929's frozen caller (`0da395e…`). The circuit bytes likewise match (`d623617f…`). PR5929's seven engine/input files are copied unchanged into `engine/` and individually pinned. No old source or evidence is edited. + +The evaluation target is the **complete historical CLI with retained exact observations**. It is distinct from the prior side-only scope, the blocked further-15% PR5864 objective and current selected-frontier replay. No gain, new construction, parameter search, mathematical admission or bare-CLI performance factor is inferred here. + +## What the complete caller adds + +The original `certificate()` first constructs the side circuit, initializes checks, compiles roles and calls all three side-verification functions. It then performs: + +1. Exact network counts and positive-deficit check. +2. Rational logarithm enclosure and strict saving comparison. +3. Fixed rational parameters, stopped-depth guard constants, compact-control recurrence, every strict constraint slack, every margin and absorption gap. +4. Dyadic-scale and retained-bit ceiling checks. +5. The real `certify.verify_sources()` and gate-count bound. + +The return includes all those observations and the unchanged historical conditional status/scope. The literal CLI applies the original recursive `serializable`, writes `certificates/complex-network.json` with its existing sorted/indented JSON and newline, then prints its two original lines. The reference file hash is `1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f`. Fractions become strings in that file, so an additional typed full-return representation preserves exact Fraction numerator/denominator, int/bool/float/string distinctions, tuple/list distinctions and dictionary insertion order. + +## Closed inputs + +`SOURCE-PINS.json` is a byte-identical copy of the parent's authenticated 32-file inventory, pinned by its own hash. Twelve Python modules form the complete import closure: + +- `complex_network`, `complex_circuit`, `certify`; +- `compact_control_layer`, `prepare_layers`, `search_network`; +- `paired_network`, `shared_point_network`, `shared_point_circuit`; +- `paired_exclusion_circuit`, `exclusion_circuit`, `audit_short_guards`. + +Their external imports are standard-library modules. Importing the related modules does not call their `__main__` certificate/search routines; no h50 graph or unrelated search should be executed. The complete caller still imports those modules normally and pays their cold cost. + +The remaining files are `upstream/manifest.json` and all 19 payloads it names: license, README, formalization YAML, main/bibliography, twelve sections and two figures. The manuscript commit is `adc7f1241b42e322a6451854ab7e4b4c146bf78a`. The original verifier reads the manifest and hashes every payload; the wrapper additionally pins the manifest itself and independently checks its complete file inventory. No network fetch, source-verifier stub or substituted PASS is permitted. The previously missing `upstream/` tree was a cheap blocker, now resolved by the parent's complete frozen copy. + +## Untouched CLI invocation + +`full_driver.py` accepts explicit `--frozen-root`, `--reference` (the JSON file), `--mode profile|baseline|candidate`, and a new external `--output`. Both benchmark arms additionally require `--anchor`. All inputs and the unchanged engine are copied into that output directory inside the measured process. The wrapper never writes or chmods the immutable stage. It retains actual input file modes in both copies; only the fresh private runtime root is made writable so the original CLI can create its certificate. Readonly and Git-export storage modes need not equal the historical inventory's local 0664 mode. + +The engine loads its pinned circuit with canonical module name `complex_circuit`; that exact object is registered in `sys.modules`. Its two source copies must equal the corresponding frozen scripts byte-for-byte. Other scientific modules resolve only from the private full scripts tree. The original caller executes once through `runpy.run_path(..., run_name='__main__')`, with original argv semantics, normal assertion mode and original ROOT-derived output location. Its actual import identities and output file set are checked afterward. + +An observational wrapper around the original `verify_role_frames` delegates exactly once, preserves its returned object, and retains `c`, `checks` and `code`. A depth-aware `serializable` observer delegates the original routine once per value and captures only the outer full certificate. Lightweight phase wrappers expose construction/map/label/role, logarithm, source-hashing and outer serialization costs. They do not replace checks, sum nested durations or justify projected speedups. The original source stdout is captured, compared byte-for-byte and re-emitted; wrapper metadata is separately identified. + +## Exact evidence and binding + +Both arms reconstruct the same complete side structural/basis/role witness and ordered Gram-rank transcript using the unchanged PR5929 writer. They require its three exact hashes, 59,959 rank calls and 252 distinct matrices. Every ordered complement input/output is streamed with the original canonical schema, requiring 238,685 calls, 55,839,507 canonical bytes and digest `7dec2bf…`. No witness is sampled or reduced to only an odd-vector predicate. + +The candidate binds only the published `Label.complement_in` and `Label.nondegenerate` implementation. Its exact-domain/fallback, resolved-builtins, function-code/closure, class and native-dispatch guards remain unchanged. Observation wrappers do not alter Label dispatch. A fresh process, serial calls and no in-call environment mutation remain mandatory. Every candidate pays cold compilation/link/load and the entire unchanged finite independent dense-oracle, ordering, width/type/iterator/fallback and binding suite before the full CLI. + +Profile mode runs the literal baseline path once and emits a new anchor of full file/stdout bytes, typed full return and all retained side observations. It is excluded from performance selection. Baseline/candidate samples reject an anchor from different driver, engine, input pins or scientific observations. The existing side-only hashes do not predeclare a full-caller timing or typed-return result. + +## Resource boundary and immediate checks + +The additional source closure is modest and its arithmetic uses exact scalars; static inspection exposes no newly invoked large graph or third-party dependency. Nevertheless, retained side objects, full witness serialization, compiler and all controls determine actual peak RSS and cost. No numerical headroom or gain is projected. The parent's unchanged serial 180-second/1-GiB guard and aggregate caps govern the first diagnostic and any admitted fixed comparison. + +Before execution, the independent reviewer should check canonical module identity, one original role call, intact recursive serialization, real source verification, exact CLI bytes, complete source custody and anchor gating. Runtime correctness and cost remain untested by this source-owning agent. All work here was static reading, copying, authoring and source hashing; no scientific imports, compilation, corpus decoding or timing was performed. diff --git a/research/h25-bookkeeping/payload/baseline/evidence/UPSTREAM-REFRESH.json b/research/h25-bookkeeping/payload/baseline/evidence/UPSTREAM-REFRESH.json new file mode 100644 index 0000000000..c547891428 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/UPSTREAM-REFRESH.json @@ -0,0 +1,47 @@ +{ + "canonical_main": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "paths": { + "AGENTS.md": { + "sha256": "fbee67ab9e0ae4629a35fd9dba69c8f7e29e4a15392eb2d0f75d8768ffb65f40" + }, + "CONTRIBUTING.md": { + "sha256": "fcd1a8d0e52342a23b8ffa9e905e85ccc539fb084145ef016dfc93cedfb3d924" + }, + "autoresearch.md": { + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + "docs/research/agent-procedure.md": { + "sha256": "8367063f9f2d48543415451e026f83224ea962b28801bea6904e6e425ed023e4" + }, + "docs/research/research-family-status.md": { + "sha256": "92c8010dfd9fc33e921f70526231f8689e06ea784f1b1387d895344b227f36d7" + }, + "docs/research/research-package-guide.md": { + "sha256": "5e3aa8b2ce657f943ef5fd187473a01a92a7073ef7e05b30affa08979daa2c6e" + }, + "docs/research/research-priorities.json": { + "available": false + }, + "certificates/selected-result.json": { + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + "docs/research/agent-task-catalog.json": { + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + } + }, + "priority_revision": 8, + "freshly_fetched": true, + "claim": "https://github.com/CrocSwap/integer-mult-bounds/pull/5929#issuecomment-6451967873", + "chrome_overlap": { + "H25_open_prs": [ + 5929, + 5972 + ], + "GF2_discussions": [ + 1587, + 1166 + ], + "recent_handoff_page_read": true, + "coverage": "bounded title/body searches and newest handoff page, not exhaustive" + } +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json b/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json new file mode 100644 index 0000000000..95917d3e64 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json @@ -0,0 +1,47 @@ +{ + "artifacts": { + "complement-transcript.json": { + "encoding": "plain", + "logical_bytes": 227, + "logical_sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8", + "transport_bytes": 227, + "transport_sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "complex-network.json": { + "encoding": "plain", + "logical_bytes": 5662, + "logical_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "transport_bytes": 5662, + "transport_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "full-return.lossless.json.gz": { + "encoding": "gzip", + "logical_bytes": 7311, + "logical_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "transport_bytes": 2360, + "transport_sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "original-stdout.txt": { + "encoding": "plain", + "logical_bytes": 137, + "logical_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "transport_bytes": 137, + "transport_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "rank-trace.json.gz": { + "encoding": "gzip", + "logical_bytes": 2674272, + "logical_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "transport_bytes": 22029, + "transport_sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "witness.json.gz": { + "encoding": "gzip", + "logical_bytes": 58143622, + "logical_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "transport_bytes": 16995263, + "transport_sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + } + }, + "schema_version": 1 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/complement-transcript.json b/research/h25-bookkeeping/payload/baseline/evidence/canonical/complement-transcript.json new file mode 100644 index 0000000000..00290f932b --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/canonical/complement-transcript.json @@ -0,0 +1 @@ +{"calls":238685,"canonical_stream_bytes":55839507,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json b/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json new file mode 100644 index 0000000000..62a6091887 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json @@ -0,0 +1,143 @@ +{ + "bit_saving": "37/12500000000", + "circuit": { + "additions": 80595, + "disjoint_additions": 68595, + "h": 25, + "injections": 27600, + "pair_star_additions": 12000, + "roles": 108195, + "roles_per_target": 47.041, + "v": 2300 + }, + "complex_counts": { + "I": 15870000, + "L": 10315500000, + "N": 12167000000, + "W": 1741801270000, + "central_roles": 26, + "deficit": 3703000000, + "eta": "28/205789375", + "h": 25, + "m": 15625, + "original_side_wires_per_invocation": 3693800, + "s": 27215641140750000, + "side_roles_per_invocation": 108195, + "v": 2300 + }, + "complex_deficit_slack": "6761797/8231575000000000", + "complex_saving": "7/500000000", + "gates": { + "gates_per_invocation": 340784, + "total_gates": 5408242080000, + "twelve_W": 20901615240000 + }, + "improvement_over_compact_control": "590/83", + "labels": { + "active_nodes": 82895, + "all_labels_nondegenerate": true, + "all_residuals_have_odd_vectors": true, + "checked_inclusions": 188790 + }, + "log_enclosure": [ + "1003674733095412338935264801206694829502804118660273821722358572561777951813562324984581151664909098376456139346987946438356114944865114544057566309229396051200891281693308045036569381219925884240815457348697380244265196736/103936362434495646010619550865033734742948881177937982419226476521510946436948314218071351858470876811875561920539687733866419026027866373569756270393100104240876895441796280524990301784985328254889750901950661699188332905", + "119905674780465260758132999318298249674205865631153226854493684575647168973933813765866273005815485563618924127097549911779010579460799218169313950759672923946122257420539013677630274686709038285230521425787947340179037163618384721/12416930765507746510068682343342696843957626338057657633016923061769841067667425271918924168691987416458733797440474694605908192976129102762466882436295692453310093108779928980052174719912913882184162241086372384329699504384000000" + ], + "log_m_upper": "483/50", + "role_frames": { + "forward_frames_nested": true, + "reverse_complement_frames_nested": true, + "roles": 108195 + }, + "scope": "Conditional on the pinned upstream interfaces, the compact-control movement and guard proofs, the paired bit network, and the written binary-frame transfer for this complex side circuit. Exact arithmetic and finite checks are not formal verification.", + "scoped_ceiling": { + "below_2_to_minus_30": true, + "scope": "Published h=50 paired bit network and retained Gaussian margin; not a bound on other networks or algorithms.", + "upper": "37/62500000000" + }, + "side_map": { + "coefficients": "+1/2 disjoint, -1/2 intersection two", + "nonzero_coefficients": 3693800, + "side_map_exact": true, + "targets": 2300 + }, + "status": "CONDITIONAL 59/10^11 WITNESS; COMPRESSED COMPLEX SIDE CIRCUIT; NOT FORMAL VERIFICATION", + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a", + "witness": { + "absorption_gap": "29261/25000000000000000", + "constraint_slacks": { + "K_dominates_log_p": "19979001/100000000", + "K_smaller_than_ell": "60021999/100000000", + "alpha_below_sqrt_p": "80001/400000", + "beta_below_one": "999/1000", + "beta_positive": "1/1000", + "c_positive": "999/1000", + "crt_layout": "2960037/1250000000000000", + "delta_below_one_eighth": "124999/1000000", + "delta_positive": "1/1000000", + "dimension_upper_bound": "40003/300000", + "epsilon_positive": "19999/100000", + "gamma_sublinear": "40003/200000", + "gaussian_cost": "23/2000000", + "guard_width": "829961/1000000000", + "kappa_positive": "59/100000000000", + "lambda_above_sigma": "5521/500000000000", + "lambda_above_tau": "1/500000000000", + "lambda_below_one": "1479/500000000000", + "lambda_prime_above_lambda": "1/500000000000", + "lambda_prime_below_one": "739/250000000000", + "leaf_cost": "1103/100000000000", + "packed_overhead": "1/500000000000", + "prefix_cost": "60021999/100000000", + "prime_interval_growth": "30001/50000", + "r_superpolynomial": "80001/100000", + "reserved_axes": "249749999261/250000000000", + "scalar_cost": "800009/1000000", + "sigma_below_one": "7/500000000", + "sigma_positive": "499999993/500000000", + "tau_below_one": "37/12500000000", + "tau_positive": "12499999963/12500000000" + }, + "guard": { + "B": 338201706233372774319109678801287590064, + "C0": 321727027889740762489223803495350305328695729120143793284991524019954162292886152000000, + "C1": "49961/10000", + "E": 338201706233372774319082463160146840064, + "beta": "1/1000", + "m": 15625, + "s": 27215641140750000, + "zeta": "1/10000" + }, + "limiting_margins": [ + "g3" + ], + "margins": { + "g1": "60021999/100000000", + "g2": "739223037/1250000000000000000", + "g3": "14779261/25000000000000000", + "g4": "2960037/1250000000000000", + "g5": "23/2000000", + "g6": "800009/1000000", + "g7": "19999/100000" + }, + "minimum_margin": "14779261/25000000000000000", + "parameters": { + "C1": "49961/10000", + "beta": "1/1000", + "c": "999/1000", + "delta": "1/1000000", + "epsilon": "19999/100000", + "kappa": "59/100000000000", + "lam": "499999998521/500000000000", + "lamp": "249999999261/250000000000", + "sigma": "499999993/500000000", + "tau": "12499999963/12500000000" + }, + "recurrence": { + "internal": "12499999963/12500000000", + "layer": "12499999963/12500000000", + "leaf": "499999993007/500000000000", + "preprocessing": "1/1000" + } + } +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/full-return.lossless.json.gz b/research/h25-bookkeeping/payload/baseline/evidence/canonical/full-return.lossless.json.gz new file mode 100644 index 0000000000..e751ba95d9 Binary files /dev/null and b/research/h25-bookkeeping/payload/baseline/evidence/canonical/full-return.lossless.json.gz differ diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/original-stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/canonical/original-stdout.txt new file mode 100644 index 0000000000..ea0a81bb3a --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/canonical/original-stdout.txt @@ -0,0 +1,2 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz b/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz new file mode 100644 index 0000000000..8b071cc725 Binary files /dev/null and b/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz differ diff --git a/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz b/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz new file mode 100644 index 0000000000..4d7d6a59c7 Binary files /dev/null and b/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz differ diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/REVISION.json b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/REVISION.json new file mode 100644 index 0000000000..08bc595fe1 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/REVISION.json @@ -0,0 +1,8 @@ +{ + "status": "SCIENTIFIC_PASS_PUBLICATION_CLEANUP_STOP_RETAINED", + "inner_scientific_guard_status": "PASS", + "failure": "shutil.rmtree cannot unlink inside0555 private cloned engine dirs", + "repair": "Only private external temporary clone directories become0755 after all source/scientific checks; remove temporary root inside caughttry so any cleanup failure reports evidence path", + "changed_scientific_code_or_benchmark_samples": false, + "next": "One source-reviewed corrected full readonly publication replay, excluded from performance selection" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/receipt.json new file mode 100644 index 0000000000..cea5919b9c --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/receipt.json @@ -0,0 +1,23 @@ +{ + "exit": 1, + "label": "publication-full-readonly-C", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "ff0f4e928e2beeddd38b4b67a446c5eb75dbf9f1c78cac386fc0c6528108f205", + "sampled_process_group_rss_bytes": 53157888, + "script": "stages/publication-v1/check_full.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "ed6d9bcbd7d76f82a5a40df784b8c16ef9709ba7235da5598be540e124077e8e", + "status": "STOP", + "stderr_bytes": 1638, + "stderr_sha256": "9cc43b411c844bdc69171311f26efbba2d063c20cc5f1ece45f465f92ece9515", + "stdout_bytes": 947, + "stdout_sha256": "3a5034b4208e91f156d7658387ea85eb1d0ad98fa283c0e3185e41bf0e4c7342", + "termination": null, + "usage": { + "raw": "Command exited with non-zero status 1\n{\"user_seconds\":43.34,\"system_seconds\":4.77,\"kernel_max_rss_kib\":453552,\"exit\":1}\n" + }, + "wall_seconds": 33.3818164569966 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stderr.txt new file mode 100644 index 0000000000..e8114ba283 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stderr.txt @@ -0,0 +1,25 @@ +Traceback (most recent call last): + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/publication-v1/check_full.py", line 5, in + runpy.run_path(str(script),run_name='__main__') + File "", line 286, in run_path + File "", line 98, in _run_module_code + File "", line 88, in _run_code + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/publication-v1/package/verify_full.py", line 32, in + if __name__=='__main__':main() + ^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/publication-v1/package/verify_full.py", line 28, in main + else:shutil.rmtree(temporary) + ^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/shutil.py", line 785, in rmtree + _rmtree_safe_fd(fd, path, onexc) + File "/usr/lib/python3.12/shutil.py", line 686, in _rmtree_safe_fd + _rmtree_safe_fd(dirfd, fullname, onexc) + File "/usr/lib/python3.12/shutil.py", line 686, in _rmtree_safe_fd + _rmtree_safe_fd(dirfd, fullname, onexc) + File "/usr/lib/python3.12/shutil.py", line 686, in _rmtree_safe_fd + _rmtree_safe_fd(dirfd, fullname, onexc) + File "/usr/lib/python3.12/shutil.py", line 717, in _rmtree_safe_fd + onexc(os.unlink, fullname, err) + File "/usr/lib/python3.12/shutil.py", line 715, in _rmtree_safe_fd + os.unlink(entry.name, dir_fd=topfd) +PermissionError: [Errno 13] Permission denied: 'finite_controls.py' diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stdout.txt new file mode 100644 index 0000000000..1e8f19b699 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/stdout.txt @@ -0,0 +1 @@ +{"exit": 0, "label": "complete-C", "optimized": false, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", "runtime_policy_sha256": "9f44d808d289c073d749f0a9b77a748784895ad25d0f74a0aad32d55ed65d463", "sampled_process_group_rss_bytes": 407900160, "script": "full_C.py", "source_bytes_and_modes_unchanged": true, "source_inventory_sha256": "53340091e61a64b3c3b3045df6eea2e36a81dfa242fb2d68c99f69c21244b43f", "status": "PASS", "stderr_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 3969, "stdout_sha256": "3bd0a544756b8e748bcfc265338c1986504a28327bbf2bb85058e45d813d196f", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 453552, "system_seconds": 0.44, "user_seconds": 30.91}, "wall_seconds": 31.691533826990053} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/usage.json new file mode 100644 index 0000000000..188ace82e8 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/usage.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"user_seconds":43.34,"system_seconds":4.77,"kernel_max_rss_kib":453552,"exit":1} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/verify_full.py.txt b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/verify_full.py.txt new file mode 100644 index 0000000000..aaa120d23b --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/publication-v1-failure/verify_full.py.txt @@ -0,0 +1,32 @@ +"""One complete C correctness replay; never a hosted performance-factor claim.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('verify_full.py','archive_support.py','replay.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('full correctness wrapper pin: '+name) +S=types.ModuleType('_gf2_verify_full_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def main(): + import shutil + import tempfile + S.need(len(sys.argv)==1 and sys.flags.optimize==0,'one full correctness run with original assertions') + S.authenticate();temporary=Path(tempfile.mkdtemp(prefix='gf2-full-correctness-')) + replay=S.source_module('_gf2_verify_full_replay',ROOT/'replay.py') + try: + result=replay.run('C',temporary/'run',timeout=150) + S.need(result['scientific']['science']==json.loads((ROOT/'anchor.json').read_text())['science'],'full exact anchor equality') + S.authenticate() + except BaseException as error: + error.add_note('Full correctness evidence retained at '+str(temporary)) + raise + else:shutil.rmtree(temporary) + print(json.dumps(dict(status='PASS_GF2_FULL_C_CORRECTNESS',hosted_performance_factor_claim=False,fixed_benchmark_sample=False,inner_timeout_seconds=150))) + + +if __name__=='__main__':main() diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/receipt.json new file mode 100644 index 0000000000..8ae82daeda --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-B1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 407670784, + "script": "stages/qualification-v1/full_B1.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3665, + "stdout_sha256": "0f6e7069212f9ee752d4123475fde0ca526fc9c41d68bf952022e7cd41612f43", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453356, + "system_seconds": 0.32, + "user_seconds": 41.32 + }, + "wall_seconds": 42.103671320015565 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/scientific-receipt.json new file mode 100644 index 0000000000..4335a746b3 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/scientific-receipt.json @@ -0,0 +1,355 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": null, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": null, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "baseline", + "native_calls": null, + "native_predecessor_pr": 5929, + "phases": { + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 0.0001079999999995529, + "wall_seconds": 0.00010796598508022726 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.008097999999999939, + "wall_seconds": 0.008197507006116211 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.01277499999999998, + "wall_seconds": 0.013128021004376933 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.041035000000000044, + "wall_seconds": 0.043566201988141984 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0072790000000000354, + "wall_seconds": 0.016366670024581254 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.6908230000000004, + "wall_seconds": 0.8413900150044356 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 38.959421, + "wall_seconds": 39.27583644501283 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0026479999999999837, + "wall_seconds": 0.002697159012313932 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.001931000000000016, + "wall_seconds": 0.0022246230219025165 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.007979999999999987, + "wall_seconds": 0.06242200400447473 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0005049999999968691, + "wall_seconds": 0.0005052119959145784 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1996499999999983, + "wall_seconds": 1.1996787980024237 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.01242500000000002, + "wall_seconds": 0.013132498977938667 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00018099999999776628, + "wall_seconds": 0.00018295799964107573 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002079000000009046, + "wall_seconds": 0.0020764229993801564 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.170162, + "wall_seconds": 2.2056040469906293 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 27.23334, + "wall_seconds": 27.24539458801155 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 7.048207, + "wall_seconds": 7.165842581016477 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.774670999999998, + "wall_seconds": 1.774711590987863 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 41.249183, + "process_wall_seconds_before_receipt": 41.39030711899977, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B1/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/stdout.txt new file mode 100644 index 0000000000..a820e10947 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 41.249183, "mode": "baseline", "phases": {"checks_initialization": {"calls": 1, "cpu_seconds_with_children": 0.0001079999999995529, "wall_seconds": 0.00010796598508022726}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.008097999999999939, "wall_seconds": 0.008197507006116211}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.01277499999999998, "wall_seconds": 0.013128021004376933}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.041035000000000044, "wall_seconds": 0.043566201988141984}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0072790000000000354, "wall_seconds": 0.016366670024581254}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.6908230000000004, "wall_seconds": 0.8413900150044356}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 38.959421, "wall_seconds": 39.27583644501283}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0026479999999999837, "wall_seconds": 0.002697159012313932}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.001931000000000016, "wall_seconds": 0.0022246230219025165}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.007979999999999987, "wall_seconds": 0.06242200400447473}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0005049999999968691, "wall_seconds": 0.0005052119959145784}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1996499999999983, "wall_seconds": 1.1996787980024237}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.01242500000000002, "wall_seconds": 0.013132498977938667}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00018099999999776628, "wall_seconds": 0.00018295799964107573}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002079000000009046, "wall_seconds": 0.0020764229993801564}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.170162, "wall_seconds": 2.2056040469906293}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 27.23334, "wall_seconds": 27.24539458801155}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 7.048207, "wall_seconds": 7.165842581016477}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.774670999999998, "wall_seconds": 1.774711590987863}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 41.39030711899977} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/usage.json new file mode 100644 index 0000000000..fed1a6a860 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B1/usage.json @@ -0,0 +1 @@ +{"user_seconds":41.32,"system_seconds":0.32,"kernel_max_rss_kib":453356,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/receipt.json new file mode 100644 index 0000000000..c00da88b73 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-B2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 427556864, + "script": "stages/qualification-v1/full_B2.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3667, + "stdout_sha256": "8f7a10dda0295c3d396017a48eeadd0319a160fe1e4d6993df82426b197c5a2d", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453332, + "system_seconds": 0.31, + "user_seconds": 38.97 + }, + "wall_seconds": 39.355439921986545 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/scientific-receipt.json new file mode 100644 index 0000000000..cb91b93386 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/scientific-receipt.json @@ -0,0 +1,355 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": null, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": null, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "baseline", + "native_calls": null, + "native_predecessor_pr": 5929, + "phases": { + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 0.00011899999999975819, + "wall_seconds": 0.00011770101264119148 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004872000000000043, + "wall_seconds": 0.004872203018749133 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.006765999999999994, + "wall_seconds": 0.006765390979126096 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.030687999999999993, + "wall_seconds": 0.030686862010043114 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003684999999999994, + "wall_seconds": 0.0036916589888278395 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.423743, + "wall_seconds": 0.4238316960108932 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 36.82342, + "wall_seconds": 36.84268290398177 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0015740000000000753, + "wall_seconds": 0.0015721209929324687 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0022179999999999978, + "wall_seconds": 0.002216478023910895 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.007475999999999983, + "wall_seconds": 0.02265488400007598 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.00043399999999849115, + "wall_seconds": 0.00043424699106253684 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2114559999999983, + "wall_seconds": 1.2146476329944562 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.008126999999999968, + "wall_seconds": 0.008125677006319165 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.0001469999999983429, + "wall_seconds": 0.0001483919913880527 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002313999999998373, + "wall_seconds": 0.002313801000127569 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.003161, + "wall_seconds": 2.0039629240054637 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 26.857797000000005, + "wall_seconds": 26.87378448600066 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.665053, + "wall_seconds": 5.666641563992016 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.845056999999997, + "wall_seconds": 1.8458280370105058 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 38.912362, + "process_wall_seconds_before_receipt": 38.7821343439864, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B2/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/stdout.txt new file mode 100644 index 0000000000..2260e8f633 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 38.912362, "mode": "baseline", "phases": {"checks_initialization": {"calls": 1, "cpu_seconds_with_children": 0.00011899999999975819, "wall_seconds": 0.00011770101264119148}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004872000000000043, "wall_seconds": 0.004872203018749133}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.006765999999999994, "wall_seconds": 0.006765390979126096}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.030687999999999993, "wall_seconds": 0.030686862010043114}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003684999999999994, "wall_seconds": 0.0036916589888278395}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.423743, "wall_seconds": 0.4238316960108932}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 36.82342, "wall_seconds": 36.84268290398177}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0015740000000000753, "wall_seconds": 0.0015721209929324687}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0022179999999999978, "wall_seconds": 0.002216478023910895}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.007475999999999983, "wall_seconds": 0.02265488400007598}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.00043399999999849115, "wall_seconds": 0.00043424699106253684}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2114559999999983, "wall_seconds": 1.2146476329944562}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.008126999999999968, "wall_seconds": 0.008125677006319165}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.0001469999999983429, "wall_seconds": 0.0001483919913880527}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002313999999998373, "wall_seconds": 0.002313801000127569}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.003161, "wall_seconds": 2.0039629240054637}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 26.857797000000005, "wall_seconds": 26.87378448600066}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.665053, "wall_seconds": 5.666641563992016}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.845056999999997, "wall_seconds": 1.8458280370105058}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 38.7821343439864} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/usage.json new file mode 100644 index 0000000000..8cce3323f3 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B2/usage.json @@ -0,0 +1 @@ +{"user_seconds":38.97,"system_seconds":0.31,"kernel_max_rss_kib":453332,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/receipt.json new file mode 100644 index 0000000000..1b4009653e --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-B3", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 407625728, + "script": "stages/qualification-v1/full_B3.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3686, + "stdout_sha256": "61a94286b63bbfb14e6dca09aed4b5c0d1ecb3deb146ce3bf15b6a7ff44a74fe", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453276, + "system_seconds": 0.29, + "user_seconds": 39.29 + }, + "wall_seconds": 39.68618175998563 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/scientific-receipt.json new file mode 100644 index 0000000000..deff002b38 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/scientific-receipt.json @@ -0,0 +1,355 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": null, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": null, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "baseline", + "native_calls": null, + "native_predecessor_pr": 5929, + "phases": { + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.799999999980045e-05, + "wall_seconds": 7.766199996694922e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0050080000000000124, + "wall_seconds": 0.005007674015359953 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.007201000000000013, + "wall_seconds": 0.007199090003268793 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.03180000000000005, + "wall_seconds": 0.03179865100537427 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0034190000000000054, + "wall_seconds": 0.0034164249955210835 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4601970000000004, + "wall_seconds": 0.4602043409831822 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 36.946802999999996, + "wall_seconds": 36.9577529229864 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0015680000000000138, + "wall_seconds": 0.0015666490071453154 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.001377000000000017, + "wall_seconds": 0.0013764659815933555 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0069049999999999945, + "wall_seconds": 0.02324625800247304 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004049999999935494, + "wall_seconds": 0.00040486399666406214 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.3208640000000003, + "wall_seconds": 1.3208754350198433 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007475000000000009, + "wall_seconds": 0.007473533012671396 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.0001409999999992806, + "wall_seconds": 0.00014300498878583312 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0021630000000030236, + "wall_seconds": 0.0021598360035568476 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.91855, + "wall_seconds": 1.918588976986939 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 27.036111000000005, + "wall_seconds": 27.04202196697588 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.651154, + "wall_seconds": 5.655990925995866 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.850075000000004, + "wall_seconds": 1.8502157629991416 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 39.166801, + "process_wall_seconds_before_receipt": 39.02328489799402, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-B3/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/stdout.txt new file mode 100644 index 0000000000..4134ecd379 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 39.166801, "mode": "baseline", "phases": {"checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.799999999980045e-05, "wall_seconds": 7.766199996694922e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.0050080000000000124, "wall_seconds": 0.005007674015359953}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.007201000000000013, "wall_seconds": 0.007199090003268793}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.03180000000000005, "wall_seconds": 0.03179865100537427}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.0034190000000000054, "wall_seconds": 0.0034164249955210835}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4601970000000004, "wall_seconds": 0.4602043409831822}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 36.946802999999996, "wall_seconds": 36.9577529229864}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0015680000000000138, "wall_seconds": 0.0015666490071453154}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.001377000000000017, "wall_seconds": 0.0013764659815933555}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.0069049999999999945, "wall_seconds": 0.02324625800247304}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004049999999935494, "wall_seconds": 0.00040486399666406214}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.3208640000000003, "wall_seconds": 1.3208754350198433}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007475000000000009, "wall_seconds": 0.007473533012671396}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.0001409999999992806, "wall_seconds": 0.00014300498878583312}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0021630000000030236, "wall_seconds": 0.0021598360035568476}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.91855, "wall_seconds": 1.918588976986939}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 27.036111000000005, "wall_seconds": 27.04202196697588}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.651154, "wall_seconds": 5.655990925995866}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.850075000000004, "wall_seconds": 1.8502157629991416}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 39.02328489799402} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/usage.json new file mode 100644 index 0000000000..f5db1c701f --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-B3/usage.json @@ -0,0 +1 @@ +{"user_seconds":39.29,"system_seconds":0.29,"kernel_max_rss_kib":453276,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/receipt.json new file mode 100644 index 0000000000..e3fe3cc697 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-C1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 408207360, + "script": "stages/qualification-v1/full_C1.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3947, + "stdout_sha256": "6707c1cb48a8836730dac7da627201e50ce69ae0e6d77be9dddc6e531a3c22dd", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453852, + "system_seconds": 0.35, + "user_seconds": 28.11 + }, + "wall_seconds": 28.63625624598353 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-finite-controls.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-finite-controls.json new file mode 100644 index 0000000000..27cc01afcf --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-finite-controls.json @@ -0,0 +1 @@ +{"counts":{"binding_rejections":3,"boundary_cases":17,"fallback_cases":38,"gram_cases":621,"oracle_negative_controls":2,"ordered_complements":5344,"real_label_permutations":24},"fixture_sha256":"fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84","independent_oracle":"Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers","micro":{"native_with_conversion":{"cpu_seconds":0.02329199599999998,"wall_seconds":0.02328904700698331},"unchanged_python":{"cpu_seconds":0.16048985399999993,"wall_seconds":0.1604897780052852}},"micro_fixtures":4,"micro_repetitions":128,"micro_scope":"Fixed h25 label families with conversion; diagnostic only, not complete side speed","native_and_fallback_calls":{"complement_fallback":30,"complement_native":5875,"gram_fallback":20,"gram_native":1638},"status":"FINITE_NATIVE_GF2_CONTROLS_PASS","v2_controls":{"complement_fixture_stream":{"calls":7,"canonical_stream_bytes":597,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"},"counts":{"class_dispatch_rejections":2,"effective_builtins_rejections":2,"native_proxy_rejections":1,"postbind_drift_rejections":25,"prebind_shadow_rejections":10,"real_builtin_drift_rejections":2,"trace_negative_controls":4,"trace_pairs":7},"modified_helper_invocations":0,"runtime_policy":"Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift","status":"V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-receipt.json new file mode 100644 index 0000000000..202f2919e4 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/scientific-receipt.json @@ -0,0 +1,445 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.02329199599999998, + "wall_seconds": 0.02328904700698331 + }, + "unchanged_python": { + "cpu_seconds": 0.16048985399999993, + "wall_seconds": 0.1604897780052852 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5929, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.2747220000000001, + "wall_seconds": 1.2777388819959015 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.300000000043383e-05, + "wall_seconds": 7.220098632387817e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0074430000000000884, + "wall_seconds": 0.007443159003742039 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.20845299999999994, + "wall_seconds": 0.21121469399076886 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.011801999999999868, + "wall_seconds": 0.011808373004896566 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.029615999999999976, + "wall_seconds": 0.029615854989970103 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005469000000000168, + "wall_seconds": 0.00546643600682728 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4116039999999992, + "wall_seconds": 0.4118194069887977 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 24.504319, + "wall_seconds": 24.552782502985792 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0013299999999999979, + "wall_seconds": 0.0013290279894135892 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0012810000000000044, + "wall_seconds": 0.0012795469956472516 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005525000000000002, + "wall_seconds": 0.018503998988308012 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0005619999999986192, + "wall_seconds": 0.0005611329979728907 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2029150000000008, + "wall_seconds": 1.2042208680068143 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006855, + "wall_seconds": 0.006855287007056177 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00015999999999749548, + "wall_seconds": 0.000160297000547871 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.002006999999998982, + "wall_seconds": 0.0020142020075581968 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.9836409999999995, + "wall_seconds": 1.9847552279825322 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 15.191200000000002, + "wall_seconds": 15.236444887996186 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.506254, + "wall_seconds": 5.507646362006199 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.3741439999999976, + "wall_seconds": 1.3746171279926784 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 28.06481, + "process_wall_seconds_before_receipt": 27.970882914989488, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C1/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/stdout.txt new file mode 100644 index 0000000000..d7643d5a8a --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 28.06481, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.2747220000000001, "wall_seconds": 1.2777388819959015}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.300000000043383e-05, "wall_seconds": 7.220098632387817e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.0074430000000000884, "wall_seconds": 0.007443159003742039}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.20845299999999994, "wall_seconds": 0.21121469399076886}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.011801999999999868, "wall_seconds": 0.011808373004896566}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.029615999999999976, "wall_seconds": 0.029615854989970103}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.005469000000000168, "wall_seconds": 0.00546643600682728}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4116039999999992, "wall_seconds": 0.4118194069887977}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 24.504319, "wall_seconds": 24.552782502985792}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0013299999999999979, "wall_seconds": 0.0013290279894135892}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0012810000000000044, "wall_seconds": 0.0012795469956472516}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005525000000000002, "wall_seconds": 0.018503998988308012}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0005619999999986192, "wall_seconds": 0.0005611329979728907}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2029150000000008, "wall_seconds": 1.2042208680068143}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006855, "wall_seconds": 0.006855287007056177}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00015999999999749548, "wall_seconds": 0.000160297000547871}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.002006999999998982, "wall_seconds": 0.0020142020075581968}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.9836409999999995, "wall_seconds": 1.9847552279825322}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 15.191200000000002, "wall_seconds": 15.236444887996186}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.506254, "wall_seconds": 5.507646362006199}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.3741439999999976, "wall_seconds": 1.3746171279926784}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 27.970882914989488} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/usage.json new file mode 100644 index 0000000000..f3a74caa48 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C1/usage.json @@ -0,0 +1 @@ +{"user_seconds":28.11,"system_seconds":0.35,"kernel_max_rss_kib":453852,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/receipt.json new file mode 100644 index 0000000000..7ec22cefde --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-C2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 416595968, + "script": "stages/qualification-v1/full_C2.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3963, + "stdout_sha256": "1bef720cc7a18ef23b9c9336ebcea0fc327ce72b8ab8ad1fd94b5dfde51bcc7c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453764, + "system_seconds": 0.29, + "user_seconds": 28.15 + }, + "wall_seconds": 28.595429725013673 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-finite-controls.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-finite-controls.json new file mode 100644 index 0000000000..24b362d361 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-finite-controls.json @@ -0,0 +1 @@ +{"counts":{"binding_rejections":3,"boundary_cases":17,"fallback_cases":38,"gram_cases":621,"oracle_negative_controls":2,"ordered_complements":5344,"real_label_permutations":24},"fixture_sha256":"fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84","independent_oracle":"Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers","micro":{"native_with_conversion":{"cpu_seconds":0.020282467999999998,"wall_seconds":0.020279434975236654},"unchanged_python":{"cpu_seconds":0.14628275699999982,"wall_seconds":0.14630153399775736}},"micro_fixtures":4,"micro_repetitions":128,"micro_scope":"Fixed h25 label families with conversion; diagnostic only, not complete side speed","native_and_fallback_calls":{"complement_fallback":30,"complement_native":5875,"gram_fallback":20,"gram_native":1638},"status":"FINITE_NATIVE_GF2_CONTROLS_PASS","v2_controls":{"complement_fixture_stream":{"calls":7,"canonical_stream_bytes":597,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"},"counts":{"class_dispatch_rejections":2,"effective_builtins_rejections":2,"native_proxy_rejections":1,"postbind_drift_rejections":25,"prebind_shadow_rejections":10,"real_builtin_drift_rejections":2,"trace_negative_controls":4,"trace_pairs":7},"modified_helper_invocations":0,"runtime_policy":"Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift","status":"V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-receipt.json new file mode 100644 index 0000000000..4dc44cf782 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/scientific-receipt.json @@ -0,0 +1,445 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.020282467999999998, + "wall_seconds": 0.020279434975236654 + }, + "unchanged_python": { + "cpu_seconds": 0.14628275699999982, + "wall_seconds": 0.14630153399775736 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5929, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.244774, + "wall_seconds": 1.2449181789997965 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.000000000045858e-05, + "wall_seconds": 6.948600639589131e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.004972999999999894, + "wall_seconds": 0.0049734850181266665 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.2347300000000001, + "wall_seconds": 0.23694395500933751 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.006947999999999954, + "wall_seconds": 0.006946792011149228 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.03512799999999999, + "wall_seconds": 0.0351287960074842 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003538000000000041, + "wall_seconds": 0.0035365690127946436 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4012159999999989, + "wall_seconds": 0.4012432179879397 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 24.523470999999997, + "wall_seconds": 24.538060710998252 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0013470000000000149, + "wall_seconds": 0.0013467240205500275 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0014789999999999526, + "wall_seconds": 0.013941254001110792 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.005178999999999989, + "wall_seconds": 0.020863882993580773 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004810000000006198, + "wall_seconds": 0.0004880210035480559 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2299279999999975, + "wall_seconds": 1.2300507120089605 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006196000000000007, + "wall_seconds": 0.006195071997353807 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00014399999999881175, + "wall_seconds": 0.0001449490082450211 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0026159999999997297, + "wall_seconds": 0.0026130040059797466 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.029509, + "wall_seconds": 2.032118825998623 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 15.081998999999996, + "wall_seconds": 15.091367307992186 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.787010000000001, + "wall_seconds": 5.78891231000307 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.1937980000000046, + "wall_seconds": 1.194428655988304 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 28.072429999999997, + "process_wall_seconds_before_receipt": 27.943907899025362, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C2/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/stdout.txt new file mode 100644 index 0000000000..a6580d9a04 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 28.072429999999997, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.244774, "wall_seconds": 1.2449181789997965}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.000000000045858e-05, "wall_seconds": 6.948600639589131e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.004972999999999894, "wall_seconds": 0.0049734850181266665}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.2347300000000001, "wall_seconds": 0.23694395500933751}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.006947999999999954, "wall_seconds": 0.006946792011149228}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.03512799999999999, "wall_seconds": 0.0351287960074842}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003538000000000041, "wall_seconds": 0.0035365690127946436}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4012159999999989, "wall_seconds": 0.4012432179879397}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 24.523470999999997, "wall_seconds": 24.538060710998252}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0013470000000000149, "wall_seconds": 0.0013467240205500275}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0014789999999999526, "wall_seconds": 0.013941254001110792}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.005178999999999989, "wall_seconds": 0.020863882993580773}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004810000000006198, "wall_seconds": 0.0004880210035480559}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2299279999999975, "wall_seconds": 1.2300507120089605}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006196000000000007, "wall_seconds": 0.006195071997353807}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00014399999999881175, "wall_seconds": 0.0001449490082450211}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0026159999999997297, "wall_seconds": 0.0026130040059797466}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.029509, "wall_seconds": 2.032118825998623}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 15.081998999999996, "wall_seconds": 15.091367307992186}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.787010000000001, "wall_seconds": 5.78891231000307}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.1937980000000046, "wall_seconds": 1.194428655988304}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 27.943907899025362} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/usage.json new file mode 100644 index 0000000000..aeaba09189 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C2/usage.json @@ -0,0 +1 @@ +{"user_seconds":28.15,"system_seconds":0.29,"kernel_max_rss_kib":453764,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/receipt.json new file mode 100644 index 0000000000..2d3d534673 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-C3", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "8d87423d90a0a85e0115c85b74f500847e409c30b7e98850d47b6e36f560c772", + "sampled_process_group_rss_bytes": 436506624, + "script": "stages/qualification-v1/full_C3.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "cd8215aef55d75ba5c7bf9377a9572eb3509b0cd1c699db221435c7b519e25a9", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3954, + "stdout_sha256": "847d85da1c1e4660bb9b76c4a266c828c51f5d61820ff93f81a27d3496a842b0", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453752, + "system_seconds": 0.34, + "user_seconds": 31.58 + }, + "wall_seconds": 33.12922728899866 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-finite-controls.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-finite-controls.json new file mode 100644 index 0000000000..8be952bc4d --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-finite-controls.json @@ -0,0 +1 @@ +{"counts":{"binding_rejections":3,"boundary_cases":17,"fallback_cases":38,"gram_cases":621,"oracle_negative_controls":2,"ordered_complements":5344,"real_label_permutations":24},"fixture_sha256":"fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84","independent_oracle":"Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers","micro":{"native_with_conversion":{"cpu_seconds":0.024255946000000028,"wall_seconds":0.02425268100341782},"unchanged_python":{"cpu_seconds":0.140536805,"wall_seconds":0.14053679100470617}},"micro_fixtures":4,"micro_repetitions":128,"micro_scope":"Fixed h25 label families with conversion; diagnostic only, not complete side speed","native_and_fallback_calls":{"complement_fallback":30,"complement_native":5875,"gram_fallback":20,"gram_native":1638},"status":"FINITE_NATIVE_GF2_CONTROLS_PASS","v2_controls":{"complement_fixture_stream":{"calls":7,"canonical_stream_bytes":597,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d"},"counts":{"class_dispatch_rejections":2,"effective_builtins_rejections":2,"native_proxy_rejections":1,"postbind_drift_rejections":25,"prebind_shadow_rejections":10,"real_builtin_drift_rejections":2,"trace_negative_controls":4,"trace_pairs":7},"modified_helper_invocations":0,"runtime_policy":"Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift","status":"V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS"}} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-receipt.json new file mode 100644 index 0000000000..fb86eaaf10 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/scientific-receipt.json @@ -0,0 +1,445 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": { + "c_source_sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "command": [ + "x86_64-linux-gnu-gcc", + "-shared", + "-fPIC", + "-O3", + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + "-I/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/engine/native_gf2.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/cold-build/_packed_gf2.cpython-312-x86_64-linux-gnu.so" + ], + "extension_sha256": "d990705af645971612df802a427642bdb4cd79de0bb028a2f8ed3667bcf44c04", + "no_cached_binary": true, + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "stderr": "", + "stdout": "" + }, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": { + "counts": { + "binding_rejections": 3, + "boundary_cases": 17, + "fallback_cases": 38, + "gram_cases": 621, + "oracle_negative_controls": 2, + "ordered_complements": 5344, + "real_label_permutations": 24 + }, + "fixture_sha256": "fbf7cb44bb99c96ee7d393eb91f2ebfbfb94375917c78a902d547320afd75d84", + "independent_oracle": "Dense binary lists, descending pivots, addition modulo 2; no packed/source/native helpers", + "micro": { + "native_with_conversion": { + "cpu_seconds": 0.024255946000000028, + "wall_seconds": 0.02425268100341782 + }, + "unchanged_python": { + "cpu_seconds": 0.140536805, + "wall_seconds": 0.14053679100470617 + } + }, + "micro_fixtures": 4, + "micro_repetitions": 128, + "micro_scope": "Fixed h25 label families with conversion; diagnostic only, not complete side speed", + "native_and_fallback_calls": { + "complement_fallback": 30, + "complement_native": 5875, + "gram_fallback": 20, + "gram_native": 1638 + }, + "status": "FINITE_NATIVE_GF2_CONTROLS_PASS", + "v2_controls": { + "complement_fixture_stream": { + "calls": 7, + "canonical_stream_bytes": 597, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "ed44b2291db9f1bafc9bdb02e6d3b53e1926b01e549ef8bdccc1991922a6345d" + }, + "counts": { + "class_dispatch_rejections": 2, + "effective_builtins_rejections": 2, + "native_proxy_rejections": 1, + "postbind_drift_rejections": 25, + "prebind_shadow_rejections": 10, + "real_builtin_drift_rejections": 2, + "trace_negative_controls": 4, + "trace_pairs": 7 + }, + "modified_helper_invocations": 0, + "runtime_policy": "Reject before native/fallback on source helper, effective builtins, class, function, closure or native dispatch drift", + "status": "V2_RUNTIME_AND_COMPLEMENT_STREAM_PASS" + } + }, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "candidate", + "native_calls": { + "complement_fallback": 0, + "complement_native": 238685, + "gram_fallback": 0, + "gram_native": 59959 + }, + "native_predecessor_pr": 5929, + "phases": { + "all_native_finite_independent_controls": { + "calls": 1, + "cpu_seconds_with_children": 1.227425, + "wall_seconds": 1.2275855469924863 + }, + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.700000000010476e-05, + "wall_seconds": 7.611099863424897e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.005416000000000087, + "wall_seconds": 0.005415920983068645 + }, + "cold_compile_link_load": { + "calls": 1, + "cpu_seconds_with_children": 0.21777799999999997, + "wall_seconds": 0.21753678898676299 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.006381000000000192, + "wall_seconds": 0.006378763006068766 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.03850099999999995, + "wall_seconds": 0.03850089298794046 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.003942999999999808, + "wall_seconds": 0.003940455993870273 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.4549339999999993, + "wall_seconds": 0.4549829850147944 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 27.925429, + "wall_seconds": 29.078367923997575 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0017240000000000033, + "wall_seconds": 0.0017239000007975847 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0015730000000000466, + "wall_seconds": 0.0015719660150352865 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.006025000000000058, + "wall_seconds": 0.006023566995281726 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0006140000000023349, + "wall_seconds": 0.0006134730065241456 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.2417860000000047, + "wall_seconds": 1.2523431289882865 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.007376999999999967, + "wall_seconds": 0.007374856009846553 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.00021699999999924557, + "wall_seconds": 0.00021787398145534098 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.003420000000001977, + "wall_seconds": 0.0034182759991381317 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 2.0518059999999996, + "wall_seconds": 2.051926429994637 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 16.505060999999998, + "wall_seconds": 17.133974119002232 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 7.600691000000002, + "wall_seconds": 8.117029485991225 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.2754340000000006, + "wall_seconds": 1.2829192350036465 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 31.547, + "process_wall_seconds_before_receipt": 32.53604939501383, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/full-C3/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_COMPLETE_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/stdout.txt new file mode 100644 index 0000000000..c3183c9551 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 31.547, "mode": "candidate", "phases": {"all_native_finite_independent_controls": {"calls": 1, "cpu_seconds_with_children": 1.227425, "wall_seconds": 1.2275855469924863}, "checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.700000000010476e-05, "wall_seconds": 7.611099863424897e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.005416000000000087, "wall_seconds": 0.005415920983068645}, "cold_compile_link_load": {"calls": 1, "cpu_seconds_with_children": 0.21777799999999997, "wall_seconds": 0.21753678898676299}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.006381000000000192, "wall_seconds": 0.006378763006068766}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.03850099999999995, "wall_seconds": 0.03850089298794046}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.003942999999999808, "wall_seconds": 0.003940455993870273}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.4549339999999993, "wall_seconds": 0.4549829850147944}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 27.925429, "wall_seconds": 29.078367923997575}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0017240000000000033, "wall_seconds": 0.0017239000007975847}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0015730000000000466, "wall_seconds": 0.0015719660150352865}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.006025000000000058, "wall_seconds": 0.006023566995281726}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0006140000000023349, "wall_seconds": 0.0006134730065241456}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.2417860000000047, "wall_seconds": 1.2523431289882865}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.007376999999999967, "wall_seconds": 0.007374856009846553}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.00021699999999924557, "wall_seconds": 0.00021787398145534098}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.003420000000001977, "wall_seconds": 0.0034182759991381317}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 2.0518059999999996, "wall_seconds": 2.051926429994637}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 16.505060999999998, "wall_seconds": 17.133974119002232}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 7.600691000000002, "wall_seconds": 8.117029485991225}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.2754340000000006, "wall_seconds": 1.2829192350036465}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_COMPLETE_PASS", "wall_seconds": 32.53604939501383} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/usage.json new file mode 100644 index 0000000000..86c76faa83 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-C3/usage.json @@ -0,0 +1 @@ +{"user_seconds":31.58,"system_seconds":0.34,"kernel_max_rss_kib":453752,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/receipt.json new file mode 100644 index 0000000000..28c09234c4 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/receipt.json @@ -0,0 +1,23 @@ +{ + "exit": 1, + "label": "full-network-profile-v1", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "499fa281b148ac532a30c3045952553e415b82c7149c3a9be09048ceb4a510a5", + "sampled_process_group_rss_bytes": 40812544, + "script": "stages/profile-v1/profile.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "6aea2934cd09fa090b820ab4c6a7ce8a214422714c76eeaad36248236047c1cb", + "status": "STOP", + "stderr_bytes": 3199, + "stderr_sha256": "d4a8ee4b536eefd9269d82bf2d3821971a2f9e3bac20c6a720249eaf11746b76", + "stdout_bytes": 0, + "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "termination": null, + "usage": { + "raw": "Command exited with non-zero status 1\n{\"user_seconds\":0.80,\"system_seconds\":0.03,\"kernel_max_rss_kib\":38804,\"exit\":1}\n" + }, + "wall_seconds": 0.9764375559752807 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/stderr.txt new file mode 100644 index 0000000000..c5f9a90710 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/stderr.txt @@ -0,0 +1,38 @@ +Traceback (most recent call last): + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/profile.py", line 6, in + runpy.run_path(str(root/'full_driver.py'),run_name='__main__') + File "", line 286, in run_path + File "", line 98, in _run_module_code + File "", line 88, in _run_code + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/full_driver.py", line 356, in + main() + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/full_driver.py", line 200, in main + comparison = importlib.import_module("compare_side_verifier") + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/usr/lib/python3.12/importlib/__init__.py", line 90, in import_module + return _bootstrap._gcd_import(name[level:], package, level) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "", line 1387, in _gcd_import + File "", line 1360, in _find_and_load + File "", line 1331, in _find_and_load_unlocked + File "", line 935, in _load_unlocked + File "", line 995, in exec_module + File "", line 488, in _call_with_frames_removed + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v1/engine/compare_side_verifier.py", line 24, in + from profile_side_verifier import canonical, source_check + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v1/engine/profile_side_verifier.py", line 13, in + import cProfile + File "/usr/lib/python3.12/cProfile.py", line 12, in + import profile as _pyprofile + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/profile.py", line 6, in + runpy.run_path(str(root/'full_driver.py'),run_name='__main__') + File "", line 286, in run_path + File "", line 98, in _run_module_code + File "", line 88, in _run_code + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/full_driver.py", line 356, in + main() + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/full_driver.py", line 149, in main + need(not output.exists(), "Refusing to overwrite run evidence") + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/stages/profile-v1/full_driver.py", line 56, in need + raise RuntimeError(message) +RuntimeError: Refusing to overwrite run evidence diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/usage.json new file mode 100644 index 0000000000..c1fe890de9 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v1/usage.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"user_seconds":0.80,"system_seconds":0.03,"kernel_max_rss_kib":38804,"exit":1} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/receipt.json new file mode 100644 index 0000000000..ff4e727436 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-network-profile-v2", + "optimized": false, + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "runner_sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "runtime_policy_sha256": "039539e0dc0f27c28ed81bf7c5310d56ea14dca255f931031a9ac4477ab8f809", + "sampled_process_group_rss_bytes": 407506944, + "script": "stages/profile-v2/full_profile_entry.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "c12b49924e90133624033133044a091e3cc582b2e67df13795df3672883ffbd5", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 3705, + "stdout_sha256": "33c1a3007fd8c27abbfe2f7cbbda2afc0d9c81a5b1285c899d67b1c2fe2b0dec", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 453284, + "system_seconds": 0.32, + "user_seconds": 40.51 + }, + "wall_seconds": 40.92687450101948 +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json new file mode 100644 index 0000000000..2ba8e0c9b8 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/scientific-receipt.json @@ -0,0 +1,355 @@ +{ + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "build": null, + "compiler_tmpdir": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/compiler-tmp", + "driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "engine_custody": { + "compare_side_verifier.py": { + "bytes": 10571, + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "finite_controls.py": { + "bytes": 23815, + "mode": 292, + "sha256": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a" + }, + "native_backend.py": { + "bytes": 20334, + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "native_gf2.c": { + "bytes": 7425, + "mode": 292, + "sha256": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc" + }, + "profile_side_verifier.py": { + "bytes": 8959, + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "source/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "source/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + } + }, + "environment": { + "executable": "/usr/bin/python3.12", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]" + }, + "finite_controls": null, + "frozen_custody": { + "scripts/audit_short_guards.py": { + "bytes": 7956, + "mode": 292, + "sha256": "c2c929c956e617bee739963b517b9069e0d067cfebc6820f401a4e90a1769eb1" + }, + "scripts/certify.py": { + "bytes": 11276, + "mode": 292, + "sha256": "2348d95008276c5d5764f7e028c3918e484582cd589bd4d9b82919161745e53e" + }, + "scripts/compact_control_layer.py": { + "bytes": 7892, + "mode": 292, + "sha256": "e814c9f8d84f2e5d3aa2e06c36697f27f110218addc40ff8df2801fde861ff9f" + }, + "scripts/complex_circuit.py": { + "bytes": 19732, + "mode": 292, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "scripts/complex_network.py": { + "bytes": 6105, + "mode": 292, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "scripts/exclusion_circuit.py": { + "bytes": 9450, + "mode": 292, + "sha256": "f9fbcd6e85e442cbd0926ac0887414e20735b2dc923d2d5822c803ceb46726d3" + }, + "scripts/paired_exclusion_circuit.py": { + "bytes": 2289, + "mode": 292, + "sha256": "8f05f04cf06217befd6d0ee0f2d7d0c5c5eb32cfab8c9a8ca7917fd6d620b7d2" + }, + "scripts/paired_network.py": { + "bytes": 4933, + "mode": 292, + "sha256": "991223dc3c1374284c361ed017e42bf732dd971fa0bea2be2282cfb18257b3f7" + }, + "scripts/prepare_layers.py": { + "bytes": 8196, + "mode": 292, + "sha256": "a6e2adc612f264b1c0e51d18ce6315de9ae5e2ae2420aa22e99a22d8bf304947" + }, + "scripts/search_network.py": { + "bytes": 4314, + "mode": 292, + "sha256": "3a4faa5037d9b8e7ca5828afac193a96b6966a8b114f14937921795b24ec4f6a" + }, + "scripts/shared_point_circuit.py": { + "bytes": 13167, + "mode": 292, + "sha256": "360d9bffc0f55315fe294789b72c71c79e0991524555b3a5f42a2ca504d7da95" + }, + "scripts/shared_point_network.py": { + "bytes": 3119, + "mode": 292, + "sha256": "a85e7f0d8c42d6a27e3846308571ca324a1824ac5c2d59e4daa5c7673c33c697" + }, + "upstream/LICENSE": { + "bytes": 11357, + "mode": 292, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "upstream/README.md": { + "bytes": 541, + "mode": 292, + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e" + }, + "upstream/build/figures/multiplication-flow.tex": { + "bytes": 847, + "mode": 292, + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320" + }, + "upstream/build/figures/proof-map.tex": { + "bytes": 524, + "mode": 292, + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848" + }, + "upstream/build/main.tex": { + "bytes": 1882, + "mode": 292, + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa" + }, + "upstream/build/references.bib": { + "bytes": 9790, + "mode": 292, + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476" + }, + "upstream/build/sections/00-introduction.tex": { + "bytes": 11515, + "mode": 292, + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0" + }, + "upstream/build/sections/01-history.tex": { + "bytes": 9689, + "mode": 292, + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead" + }, + "upstream/build/sections/02-streams.tex": { + "bytes": 11311, + "mode": 292, + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + "upstream/build/sections/03-motifs.tex": { + "bytes": 31874, + "mode": 292, + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb" + }, + "upstream/build/sections/04-swap.tex": { + "bytes": 19884, + "mode": 292, + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906" + }, + "upstream/build/sections/05-layers.tex": { + "bytes": 46811, + "mode": 292, + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594" + }, + "upstream/build/sections/06-transforms.tex": { + "bytes": 33854, + "mode": 292, + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c" + }, + "upstream/build/sections/07-resampling.tex": { + "bytes": 22053, + "mode": 292, + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c" + }, + "upstream/build/sections/08-assembly.tex": { + "bytes": 46444, + "mode": 292, + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + }, + "upstream/build/sections/09-exact-arithmetic.tex": { + "bytes": 6950, + "mode": 292, + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3" + }, + "upstream/build/sections/10-transposition.tex": { + "bytes": 2398, + "mode": 292, + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb" + }, + "upstream/build/sections/11-grouped-rectangles.tex": { + "bytes": 7405, + "mode": 292, + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174" + }, + "upstream/formalization.yaml": { + "bytes": 73925, + "mode": 292, + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9" + }, + "upstream/manifest.json": { + "bytes": 6217, + "mode": 292, + "sha256": "16ab13971694cabab09440c47ebf2fc0496a9d35fc3af33950fda3498f8e2392" + } + }, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "mode": "profile", + "native_calls": null, + "native_predecessor_pr": 5929, + "phases": { + "checks_initialization": { + "calls": 1, + "cpu_seconds_with_children": 7.700000000010476e-05, + "wall_seconds": 7.630701293237507e-05 + }, + "cold_certify_import": { + "calls": 1, + "cpu_seconds_with_children": 0.0048819999999999975, + "wall_seconds": 0.004881600005319342 + }, + "cold_complex_module_load": { + "calls": 1, + "cpu_seconds_with_children": 0.007469999999999977, + "wall_seconds": 0.007469646981917322 + }, + "cold_engine_import": { + "calls": 1, + "cpu_seconds_with_children": 0.031227000000000005, + "wall_seconds": 0.031225840997649357 + }, + "cold_prepare_import": { + "calls": 1, + "cpu_seconds_with_children": 0.00351900000000005, + "wall_seconds": 0.003515991003951058 + }, + "compile_roles": { + "calls": 1, + "cpu_seconds_with_children": 0.46021199999999984, + "wall_seconds": 0.46021310400101356 + }, + "complete_original_cli": { + "calls": 1, + "cpu_seconds_with_children": 38.413862, + "wall_seconds": 38.45578884801944 + }, + "engine_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.0013130000000000086, + "wall_seconds": 0.0013116140034981072 + }, + "fresh_engine_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.0010519999999999974, + "wall_seconds": 0.0010504020028747618 + }, + "fresh_root_copy": { + "calls": 1, + "cpu_seconds_with_children": 0.00469799999999998, + "wall_seconds": 0.004696172982221469 + }, + "full_log_integer_bounds": { + "calls": 1, + "cpu_seconds_with_children": 0.0004249999999998977, + "wall_seconds": 0.0004239009867887944 + }, + "identical_lossless_side_serialization": { + "calls": 1, + "cpu_seconds_with_children": 1.1930289999999957, + "wall_seconds": 1.1958469099772628 + }, + "input_custody": { + "calls": 1, + "cpu_seconds_with_children": 0.006013999999999964, + "wall_seconds": 0.006014826009050012 + }, + "original_serializable": { + "calls": 1, + "cpu_seconds_with_children": 0.0001580000000060977, + "wall_seconds": 0.00016135399346239865 + }, + "original_upstream_verify_sources": { + "calls": 1, + "cpu_seconds_with_children": 0.0022060000000010405, + "wall_seconds": 0.0022053630091249943 + }, + "side_construction": { + "calls": 1, + "cpu_seconds_with_children": 1.9314599999999997, + "wall_seconds": 1.9318207079777494 + }, + "verify_labels": { + "calls": 1, + "cpu_seconds_with_children": 28.392512000000004, + "wall_seconds": 28.431476872006897 + }, + "verify_map": { + "calls": 1, + "cpu_seconds_with_children": 5.667751999999998, + "wall_seconds": 5.669881440990139 + }, + "verify_role_frames": { + "calls": 1, + "cpu_seconds_with_children": 1.9336330000000004, + "wall_seconds": 1.9340399659995455 + } + }, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "process_and_compiler_cpu_seconds_before_receipt": 40.46915, + "process_wall_seconds_before_receipt": 40.33484589200816, + "science": { + "full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "ordered_complements": { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838" + }, + "side": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "serialized_bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + } + }, + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a" + }, + "scientific_imports": { + "audit_short_guards": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/audit_short_guards.py", + "certify": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/certify.py", + "compact_control_layer": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/compact_control_layer.py", + "complex_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/engine/source/complex_circuit.py", + "exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/exclusion_circuit.py", + "paired_exclusion_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/paired_exclusion_circuit.py", + "paired_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/paired_network.py", + "prepare_layers": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/prepare_layers.py", + "search_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/search_network.py", + "shared_point_circuit": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/shared_point_circuit.py", + "shared_point_network": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/runtime/artifacts/profile-v2/runtime-root/scripts/shared_point_network.py" + }, + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + "source_pin_sha256": "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7", + "status": "FULL_NETWORK_PROFILE_ANCHOR_PASS" +} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/stderr.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/stdout.txt b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/stdout.txt new file mode 100644 index 0000000000..0f2be38159 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/stdout.txt @@ -0,0 +1,3 @@ +PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000 +Side roles per invocation 108195 vs original 3693800 +{"cpu_seconds_with_compiler": 40.46915, "mode": "profile", "phases": {"checks_initialization": {"calls": 1, "cpu_seconds_with_children": 7.700000000010476e-05, "wall_seconds": 7.630701293237507e-05}, "cold_certify_import": {"calls": 1, "cpu_seconds_with_children": 0.0048819999999999975, "wall_seconds": 0.004881600005319342}, "cold_complex_module_load": {"calls": 1, "cpu_seconds_with_children": 0.007469999999999977, "wall_seconds": 0.007469646981917322}, "cold_engine_import": {"calls": 1, "cpu_seconds_with_children": 0.031227000000000005, "wall_seconds": 0.031225840997649357}, "cold_prepare_import": {"calls": 1, "cpu_seconds_with_children": 0.00351900000000005, "wall_seconds": 0.003515991003951058}, "compile_roles": {"calls": 1, "cpu_seconds_with_children": 0.46021199999999984, "wall_seconds": 0.46021310400101356}, "complete_original_cli": {"calls": 1, "cpu_seconds_with_children": 38.413862, "wall_seconds": 38.45578884801944}, "engine_custody": {"calls": 1, "cpu_seconds_with_children": 0.0013130000000000086, "wall_seconds": 0.0013116140034981072}, "fresh_engine_copy": {"calls": 1, "cpu_seconds_with_children": 0.0010519999999999974, "wall_seconds": 0.0010504020028747618}, "fresh_root_copy": {"calls": 1, "cpu_seconds_with_children": 0.00469799999999998, "wall_seconds": 0.004696172982221469}, "full_log_integer_bounds": {"calls": 1, "cpu_seconds_with_children": 0.0004249999999998977, "wall_seconds": 0.0004239009867887944}, "identical_lossless_side_serialization": {"calls": 1, "cpu_seconds_with_children": 1.1930289999999957, "wall_seconds": 1.1958469099772628}, "input_custody": {"calls": 1, "cpu_seconds_with_children": 0.006013999999999964, "wall_seconds": 0.006014826009050012}, "original_serializable": {"calls": 1, "cpu_seconds_with_children": 0.0001580000000060977, "wall_seconds": 0.00016135399346239865}, "original_upstream_verify_sources": {"calls": 1, "cpu_seconds_with_children": 0.0022060000000010405, "wall_seconds": 0.0022053630091249943}, "side_construction": {"calls": 1, "cpu_seconds_with_children": 1.9314599999999997, "wall_seconds": 1.9318207079777494}, "verify_labels": {"calls": 1, "cpu_seconds_with_children": 28.392512000000004, "wall_seconds": 28.431476872006897}, "verify_map": {"calls": 1, "cpu_seconds_with_children": 5.667751999999998, "wall_seconds": 5.669881440990139}, "verify_role_frames": {"calls": 1, "cpu_seconds_with_children": 1.9336330000000004, "wall_seconds": 1.9340399659995455}}, "science": {"full_cli_certificate_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", "full_cli_stdout_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", "full_return_lossless_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", "ordered_complements": {"calls": 238685, "canonical_stream_bytes": 55839507, "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"}, "side": {"exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", "rank_call_count": 59959, "rank_distinct_matrix_count": 252, "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", "serialized_bytes": {"rank_trace": 2674272, "result": 527, "witness": 58143622}}, "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a"}, "status": "FULL_NETWORK_PROFILE_ANCHOR_PASS", "wall_seconds": 40.33484589200816} diff --git a/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/usage.json b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/usage.json new file mode 100644 index 0000000000..07f437a5d5 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/evidence/runs/full-network-profile-v2/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.51,"system_seconds":0.32,"kernel_max_rss_kib":453284,"exit":0} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py new file mode 100644 index 0000000000..e5c52c8afe --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/audit_short_guards.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""Short working guards and an explicit, still-unproved gathering target. + +The packed gadget and address permutation are checked exactly. No fast tape +implementation of gathering is claimed; independent window moves are linear +in the number of windows and do not achieve the required saving. +""" +from fractions import Fraction as Q +from pathlib import Path +import json + +from certify import require, verify_sources +from prepare_layers import serializable, scenarios + +ROOT=Path(__file__).resolve().parents[1] +ROTATIONS=(('y',-1,0),('z',-1,0),('y',1,0),('z',1,0), + ('z',1,1),('y',1,1),('z',-1,1),('y',-1,1)) + + +def guard_width(p): + require(isinstance(p,int) and p>=2,'Integer p>=2 required') + return 4*(p-1).bit_length()+6 + + +def gather_order(f,K,rho,g): + """Input bit indices in output low-to-high order for one slot. + + Gather the first f-1 windows into the most significant contiguous field. + Keep the remaining coordinates in relative order in a spectator field. + The highest selected bit is omitted and handled separately after undo. + """ + require(f>=1 and K>=1 and 0<=rho>source)&1)<>target)&1)<>(j*g))&1)<<(j*g) for j in range(n)) + + +def rotate_gadget(x,y,z,n,g,*,inverse=False): + """Eight modular rotations on compact n*g-bit slots, omitting the top bit.""" + require(n>=1 and g>=1,'Nonempty compact slots required') + modulus=1<<(n*g) + state={'y':y,'z':z} + operations=reversed(ROTATIONS) if inverse else ROTATIONS + for target,sign,test in operations: + other=state['z' if target=='y' else 'y'] + offset=sum(1<<(j*g) for j in range(n-1) + if x>>(j*g)&1 and (other>>(j*g)&1)==test) + state[target]=(state[target]+(-sign if inverse else sign)*offset)%modulus + return x,state['y'],state['z'] + + +def exceptional(y,z,n,g): + mask=(1<>(j*g))&mask)//2<=maximum + for slot in (y,z) for j in range(n-1)) + + +def compact_add(x,y,z,n,g): + """Exact address map, including the existing exceptional-set correction. + + This simulates addresses, not a tape implementation or its running time. + For g<6 every guard may be exceptional; those cases are finite controls. + """ + out=rotate_gadget(x,y,z,n,g) + if exceptional(out[1],out[2],n,g): + original=rotate_gadget(*out,n,g,inverse=True) + out=(original[0],original[1]^active_mask(original[0],n-1,g),original[2]) + # Supply the most significant selected bit omitted by the rotations. + top=(n-1)*g + return out[0],out[1]^(((out[0]>>top)&1)<>rho)&1)<>spectator_width for v in packed] + updated=compact_add(*data,n,g) + result=[ungather((new<>top)&1)<= 64*p**4,'Short guard inequality failed') + # Before inserting A<=C*p and R superpolynomial, the bad fraction is + # bounded by 80*f*2^-g <= (5/4)*p^-3. This deliberately overcounts. + fraction=Q(80*f,1<0 and + 0=0,'Invalid exponent hypothesis') + gathering=r+theta*c+(1-beta)*max(sigma-r,Q(0)) + compact=tau+(1-beta)*max(sigma-tau,Q(0)) + leaf=sigma+beta*(1-sigma) + return dict(gathering=gathering,compact_gadget=compact,leaf=leaf, + layer=max(gathering,compact,leaf), + status='IMPLICATION OF AN UNPROVED GATHERING BOUND') + + +def monotone_lengths(permutation): + """Small exact LIS/LDS control; no inference about unrestricted tape time.""" + inc=[1]*len(permutation);dec=[1]*len(permutation) + for i,x in enumerate(permutation): + for j in range(i): + if permutation[j]x:dec[i]=max(dec[i],dec[j]+1) + return max(inc,default=0),max(dec,default=0) + + +def monotone_stream_obstruction(guard_bits,active_bits): + """A restricted transpose inside an extreme-field gathering permutation. + + For A guard values and B active values, any global monotone output stream + contains at most A+B-1 of the AB selected records. This only rules out a + bounded number of one-shot global monotone streams; nested local reversals + and coded tape algorithms are outside this model. + """ + require(guard_bits>=1 and active_bits>=1,'Need two nonempty variable fields') + A,B=1<= 20, "C1 must cover the upstream guard bound") + else: + # Caller must also certify m>=3 and 2<=s_c= 2 and p.beta >= Q(9, 10), + "Stopping guard requires C1>=2 and beta>=9/10") + slacks = constraints(p, layout_model=layout_model, assembly_model=assembly_model) + for name, slack in slacks.items(): + require(slack > 0, f"Failed strict constraint: {name} ({slack})") + gs = margins(p, layout_model=layout_model, assembly_model=assembly_model) + if strict_margin: + require(min(gs.values()) > p.kappa, "Need a positive absorption gap") + else: + require(min(gs.values()) >= 2*p.kappa, + "The proposed patch requires every g_i >= 2*kappa") + result = {"parameters": {k: str(v) for k, v in vars(p).items()}, + "constraint_slacks": {k: str(v) for k, v in slacks.items()}, + "margins": {k: str(v) for k, v in gs.items()}, + "minimum_margin": str(min(gs.values())), + "limiting_margins": [k for k, v in gs.items() if v == min(gs.values())], + "all_margins_at_least_twice_kappa": min(gs.values()) >= 2*p.kappa, + "absorption_gap": str(min(gs.values())-p.kappa), + "slack_rule": "strict" if strict_margin else "half", + "generalized_beta": generalized_beta} + if assembly_model != "original" or guard_model != "original": + result.update(assembly_model=assembly_model, guard_model=guard_model) + return result + + +def network(h): + """Generalized counts only; these do not prove the network interface.""" + require(h > 6 and h != 9, "Need spare coordinates and nondegenerate rational form") + v, m = comb(h, 3), h**3 + N, I = v**3, 3*v**2 + zb, zc = 3*comb(h-3, 2), comb(h-3, 3)+3*(h-3) + Wb, Wc = 2*N+I*(v*zb+h), 2*N+I*(v*zc+h+1) + Lb, Lc = I*h*h, I*(h+1)*h + sb, sc = Wb*m-N+2*Lb, Wc*m-2*N+2*Lc + eb, ec = Q(Wb*m-sb, Wb*m), Q(Wc*m-sc, Wc*m) + E = 64*(Wc+m+1)**3 + B = sc+E + nu = 1 + while m**nu < B: + nu += 1 + return dict(h=h, v=v, m=m, N=N, I=I, zb=zb, zc=zc, + Wb=Wb, Wc=Wc, Lb=Lb, Lc=Lc, sb=sb, sc=sc, + eta_b=eb, eta_c=ec, B=B, nu=nu, C1=max(20, nu+3)) + + +def certify_network(h, k, log_bound): + n = network(h) + # A positive Taylor partial sum below exp(log_bound) proves m n["m"], "Could not certify the logarithm bound") + for key in ("eta_b", "eta_c"): + require(n[key] > log_bound*dyadic(k), f"Insufficient deficit: {key}") + require(2*n["Lb"] < n["N"] and 2*n["Lc"] < n["N"], + "The generalized residual lemma requires L A*LOG_BOUND for key in ("eta_b", "eta_c")), + "Rank deficit does not support the requested rational saving") + certify_network(46, 36, 12) # Residual and guard conditions. + return {"h": 46, "saving": str(A), "log_bound": str(LOG_BOUND), + "log_lower": str(lo), "log_upper": str(hi), + "deficit_slacks": {k: str(n[k]-A*LOG_BOUND) for k in ("eta_b", "eta_c")}} + + +def certificates(): + return { + "upstream_commit": verify_sources(), + "scope": "Exact numerical certificates, conditional on the upstream proof interfaces", + "cases": {name: certify_parameters(p) for name, p in { + "baseline_182": BASELINE, "frozen_154": proposed(50), + "same_network_130": proposed(42), "h46_112": proposed(36), + "balanced_frozen_153": balanced(50), + "balanced_same_network_129": balanced(42), + "balanced_h46_111": balanced(36), + "near_supremum_frozen": near_supremum(50), + "near_supremum_same_network": near_supremum(42), + "near_supremum_h46": near_supremum(36), + }.items()} | { + f"pushed_{v}": certify_parameters(pushed(v), generalized_beta=v != "109", + strict_margin=True) + for v in ("109", "108", "rational") + }, + "networks": { + "baseline_h100": certify_network(100, 50, 20), + "improved_h100": certify_network(100, 42, 14), + "improved_h46": certify_network(46, 36, 12), + "rational_h46": certify_rational_network(), + }, + } + + +if __name__ == "__main__": + result = certificates() + out = ROOT / "certificates/parameters.json" + out.parent.mkdir(exist_ok=True) + out.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + for name, case in result["cases"].items(): + print(f"PASS {name}: minimum {case['minimum_margin']} ({', '.join(case['limiting_margins'])})") + print(f"Wrote {out.relative_to(ROOT)}") diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py new file mode 100644 index 0000000000..11b2e751bf --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/compact_control_layer.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +"""Exact accounting for the written compact-control layer extension. + +Arithmetic checks accompany, and do not replace, the fixed-tape construction +and proof. Historical witnesses and pinned upstream files are unchanged. +""" +from fractions import Fraction as Q +from pathlib import Path +import hashlib +import json + +from certify import Parameters,constraints,margins,network,require,verify_sources +from paired_network import BIT_SAVING +from prepare_layers import guard,packed_exponents,complex_saving_bounds,serializable +from search_network import log_integer_bounds +from audit_short_guards import guard_width + +ROOT=Path(__file__).resolve().parents[1] +COMPLEX_H=25 +COMPLEX_SAVING=Q(418,10**12) +KAPPA=Q(83,10**12) + + +def ceil_log(n,base): + require(n>=1 and base>=2,'Invalid logarithm') + j=0;power=1 + while power=1 and min(m,W)>=2,'Invalid dimensions') + q0=ceil_log(W,2)*ceil_log(2*d,m) + k0=ceil_log(d,m) + H=d*G + front=(2*H+K-1)//K;back=(H+K-1)//K + reserved=q0+front+back + require(q0*K>=k0*ceil_log(W,2),'Insufficient row divisor capacity') + require(front*K>=2*H and back*K>=H,'Insufficient compact fields') + return dict(d=d,D=D,K=K,G=G,compact_capacity=H,row_chunks=q0, + front_chunks=front,back_chunks=back,reserved_chunks=reserved, + recursion_depth_cap=k0,row_bits=q0*K, + mode='individual' if D<=reserved else 'recursive', + active_chunks=max(0,D-reserved), + preprocessed_chunks=min(D,reserved), + front_slack_bits=front*K-2*H,back_slack_bits=back*K-H) + + +def repair_bound(p,n,K): + require(p>=2 and 0<=n<=p,'Invalid repair family') + G=guard_width(p);ell=(p-1).bit_length() + require(K>=G+4*ell+10,'Use the common eventual cutoff') + delta=Q(2*n,1<0,'Positive spacing growth required') + e=packed_exponents(tau,sigma,beta,c,theta=Q(0)) + return dict(internal=e['internal'],leaf=e['leaf'], + preprocessing=max(Q(0),1-c), + layer=max(e['internal'],e['leaf'],1-c,Q(0))) + + +def parameters(): + return Parameters(tau=1-BIT_SAVING,sigma=1-COMPLEX_SAVING, + epsilon=Q(1999,10000),c=Q(1,5), + lam=1-Q(1671,4*10**12),lamp=1-Q(167,4*10**11), + kappa=KAPPA,beta=Q(1,1000),delta=Q(1,10**6),C1=Q(49961,10000)) + + +def check(p,h=COMPLEX_H,zeta=Q(1,10000)): + require(0<1-p.tau<=BIT_SAVING,'Bit exponent exceeds retained witness') + n=network(h);lo,hi=complex_saving_bounds(h) + require(0<1-p.sigma0,'Compact-control constraint: '+name) + gs=margins(p,layout_model='nonadjacent',assembly_model='tight-gaussian') + require(min(gs.values())>p.kappa,'No final absorption gap') + require(Q(1,2**34)0 for v in cs.values()),'Milestone constraint failed') + gs=margins(p,layout_model='nonadjacent',assembly_model='tight-gaussian') + require(min(gs.values())>p.kappa,'Milestone has no absorption gap') + return dict(parameters=vars(p),guard=g,recurrence=e,constraint_slacks=cs, + minimum_margin=min(gs.values()),absorption_gap=min(gs.values())-p.kappa) + + +def certificate(): + from prepare_layers import scenarios + p=parameters();main=check(p);n=network(COMPLEX_H) + _,log_hi=log_integer_bounds(n['m']) + require(n['eta_c']>COMPLEX_SAVING*log_hi,'Simple exponential comparison failed') + targets={} + for key,h in (('hypothetical_39',50),('hypothetical_34',25)): + old=scenarios()[key] + targets[key.replace('hypothetical_','target_')]=milestone(Parameters(**old['parameters']),h) + hi=complex_saving_bounds(COMPLEX_H)[1] + # The Gaussian margin enforces epsilon<1/5; the leaf margin limits + # 1-lambda' to (1-beta)*a_c 2^-34; proof review required.') diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py new file mode 100644 index 0000000000..9e83a1065c --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_circuit.py @@ -0,0 +1,454 @@ +#!/usr/bin/env python3 +"""Compressed side correction for the complex network, with binary frames. + +Target S must receive (1/2) * sum{x_T : T disjoint from S} +minus (1/2) * sum{x_T : |S cap T| = 2}. Both sums are computed by +cancellation-free addition graphs and injected as pieces with those weights. + +Labels are subspaces of F2^h with the dot product. A disjoint-sum node carries +the coordinate space of its covered points; a pair-star node carries the span +of its triple indicators, which is orthonormal. An injected piece must leave a +point outside S uncovered: the residual up to t_S^perp then contains an odd +coordinate vector. A disjoint piece covering every point outside S would have +the alternating residual , so the disjoint sum is split. +""" +from fractions import Fraction as Q +from itertools import combinations + +EMPTY = frozenset() + + +def subsets(points, k): + return [frozenset(c) for j in range(min(k, len(points))+1) + for c in combinations(points, j)] + + +class ComplexSideCircuit: + def __init__(self, h): + assert h >= 8, 'Need at least four points outside every target' + self.h = h + self.triples = list(combinations(range(h), 3)) + self.index = {t: i for i, t in enumerate(self.triples)} + self.support = [0]; self.args = [None]; self.kind = [None] + self.lookup = {}; self.input = {} + for i, t in enumerate(self.triples): + self.input[t] = len(self.support) + self.support.append(1 << i); self.args.append(None); self.kind.append('in') + self.points = {} # covered point masks, filled lazily + self.pieces = [] # (target, node, coefficient) + self.build_disjoint() + self.build_pair_stars() + self.prune() + + # -- node store ------------------------------------------------------- + def x(self, *pts): + return self.input[tuple(sorted(pts))] + + def add(self, a, b, kind): + if not a: return b + if not b: return a + sa, sb = self.support[a], self.support[b] + assert not sa & sb, 'Cancellation is forbidden' + key = (kind, sa | sb) + node = self.lookup.get(key) + if node is None: + node = len(self.support) + self.lookup[key] = node + self.support.append(sa | sb); self.args.append((a, b)); self.kind.append(kind) + return node + + def total(self, nodes, kind): + nodes = [x for x in nodes if x] + while len(nodes) > 1: + nodes = [self.add(nodes[i], nodes[i+1], kind) if i+1 < len(nodes) else nodes[i] + for i in range(0, len(nodes), 2)] + return nodes[0] if nodes else 0 + + # -- disjoint sums ---------------------------------------------------- + def vec(self, items, k): + """{E: sum of item nodes whose points avoid E}, |E| <= k.""" + if not items: return {EMPTY: 0} + if len(items) == 1: + p, node = items[0] + return {EMPTY: node, frozenset([p]): 0} if k else {EMPTY: node} + half = len(items)//2 + A = self.vec(items[:half], k); B = self.vec(items[half:], k) + return {ea | eb: self.add(xa, xb, 'd0') for ea, xa in A.items() + for eb, xb in B.items() if len(ea)+len(eb) <= k} + + def pairs(self, pts, weight, k): + """{E: sum of weight(u,v) over pairs avoiding E}, |E| <= k.""" + if len(pts) < 2: return {E: 0 for E in subsets(pts, k)} + half = len(pts)//2; L, R = pts[:half], pts[half:] + PL = self.pairs(L, weight, k); PR = self.pairs(R, weight, k) + rows = {u: self.vec([(r, weight(u, r)) for r in R], k) for u in L} + cross = {} + for ER in subsets(R, k): + for EL, node in self.vec([(u, rows[u][ER]) for u in L], k-len(ER)).items(): + cross[EL, ER] = node + return {EL | ER: self.total([xl, xr, cross[EL, ER]], 'd0') + for EL, xl in PL.items() for ER, xr in PR.items() if len(EL)+len(ER) <= k} + + def tri_parts(self, pts, k): + """Recursive halves and the two mixed families, before combination.""" + half = len(pts)//2; L, R = pts[:half], pts[half:] + TL = self.tri(L, k); TR = self.tri(R, k) + PR = {r: self.pairs(L, lambda u, v, r=r: self.x(u, v, r), k) for r in R} + PL = {u: self.pairs(R, lambda a, b, u=u: self.x(u, a, b), k) for u in L} + return L, R, TL, TR, PR, PL + + def tri(self, pts, k): + """{E: sum of triples inside pts avoiding E}, |E| <= k.""" + if len(pts) < 3: return {E: 0 for E in subsets(pts, k)} + L, R, TL, TR, PR, PL = self.tri_parts(pts, k) + c21 = {}; c12 = {} + for EL in subsets(L, k): + for ER, node in self.vec([(r, PR[r][EL]) for r in R], k-len(EL)).items(): + c21[EL, ER] = node + for ER in subsets(R, k): + for EL, node in self.vec([(u, PL[u][ER]) for u in L], k-len(ER)).items(): + c12[EL, ER] = node + return {EL | ER: self.total([xl, xr, c21[EL, ER], c12[EL, ER]], 'd0') + for EL, xl in TL.items() for ER, xr in TR.items() if len(EL)+len(ER) <= k} + + def build_disjoint(self): + """Six pieces per target, each leaving an outside point uncovered.""" + pts = list(range(self.h)) + L, R, TL, TR, PR, PL = self.tri_parts(pts, 3) + R1, R2 = R[:len(R)//2], R[len(R)//2:] + L1, L2 = L[:len(L)//2], L[len(L)//2:] + for S in self.triples: + E = frozenset(S); EL = E & frozenset(L); ER = E & frozenset(R) + pieces = [TL[EL], TR[ER]] + for half in (R1, R2): + pieces.append(self.vec([(r, PR[r][EL]) for r in half], 3-len(EL))[ER & frozenset(half)]) + for half in (L1, L2): + pieces.append(self.vec([(u, PL[u][ER]) for u in half], 3-len(ER))[EL & frozenset(half)]) + for node in pieces: self.emit(S, node, Q(1, 2)) + + # -- pair stars ------------------------------------------------------- + def build_pair_stars(self): + """Prefix and suffix pair-star sums around each excluded third point.""" + h = self.h + for a, b in combinations(range(h), 2): + others = [u for u in range(h) if u not in (a, b)] + n = len(others) + pre = [0] + for u in others: pre.append(self.add(pre[-1], self.x(a, b, u), 'd2')) + suf = [0]*(n+1) + for i in range(n-1, -1, -1): suf[i] = self.add(self.x(a, b, others[i]), suf[i+1], 'd2') + for i, c in enumerate(others): + S = tuple(sorted((a, b, c))) + self.emit(S, pre[i], Q(-1, 2)); self.emit(S, suf[i+1], Q(-1, 2)) + + def emit(self, S, node, coef): + """Inject a piece, splitting it until it leaves a point outside S uncovered.""" + if not node: return + if self.cover(node) | sum(1 << p for p in S) == (1 << self.h)-1: + a, b = self.args[node] + self.emit(S, a, coef); self.emit(S, b, coef) + else: + self.pieces.append((S, node, coef)) + + # -- bookkeeping ------------------------------------------------------ + def prune(self): + self.active = set(); stack = [node for _, node, _ in self.pieces] + while stack: + node = stack.pop() + if node in self.active: continue + self.active.add(node) + if self.args[node]: stack.extend(self.args[node]) + self.additions = sum(self.args[n] is not None for n in self.active) + self.roles = self.additions + len(self.pieces) + + def cover(self, node): + """Mask of ground points covered by the node's source triples.""" + if node not in self.points: + s = self.support[node]; mask = 0 + while s: + low = s & -s; mask |= sum(1 << p for p in self.triples[low.bit_length()-1]); s ^= low + self.points[node] = mask + return self.points[node] + + def stats(self): + v = len(self.triples) + return dict(h=self.h, v=v, additions=self.additions, injections=len(self.pieces), + roles=self.roles, roles_per_target=round(self.roles/v, 3), + disjoint_additions=sum(self.kind[n] == 'd0' for n in self.active), + pair_star_additions=sum(self.kind[n] == 'd2' for n in self.active)) + + +# -- binary linear algebra on F2^h, vectors as integer masks --------------- +def echelon(vectors): + """Reduced basis {pivot bit: vector}; raises on dependence.""" + basis = {} + for x in vectors: + for bit, b in basis.items(): + if x & bit: x ^= b + assert x, 'Dependent label vectors' + bit = x & -x + for other in basis: + if basis[other] & bit: basis[other] ^= x + basis[bit] = x + return basis + + +def reduce(basis, x): + for bit, b in basis.items(): + if x & bit: x ^= b + return x + + +def dot(x, y): + return (x & y).bit_count() & 1 + + +def rank(rows): + rows = list(rows); r = 0 + for col in range(max((x.bit_length() for x in rows), default=0)): + bit = 1 << col + pivot = next((i for i in range(r, len(rows)) if rows[i] & bit), None) + if pivot is None: continue + rows[r], rows[pivot] = rows[pivot], rows[r] + for i in range(len(rows)): + if i != r and rows[i] & bit: rows[i] ^= rows[r] + r += 1 + return r + + +class Label: + """A binary subspace with a canonical basis.""" + def __init__(self, vectors): + self.basis = echelon(vectors); self.dim = len(self.basis) + self.key = tuple(sorted(self.basis.values())) + + def contains(self, other): + return all(not reduce(self.basis, x) for x in other.basis.values()) + + def nondegenerate(self): + vs = list(self.basis.values()) + return rank([sum(dot(a, b) << j for j, b in enumerate(vs)) for a in vs]) == len(vs) + + def complement_in(self, other): + """Basis of other ∩ self^perp, assuming self ⊆ other.""" + vs = list(other.basis.values()); us = list(self.basis.values()); k = len(us) + rows = [sum(dot(v, u) << j for j, u in enumerate(us)) | 1 << (k+i) + for i, v in enumerate(vs)] + r = 0 + for col in range(k): + bit = 1 << col + piv = next((i for i in range(r, len(rows)) if rows[i] & bit), None) + if piv is None: continue + rows[r], rows[piv] = rows[piv], rows[r] + for i in range(len(rows)): + if i != r and rows[i] & bit: rows[i] ^= rows[r] + r += 1 + out = [] + for row in rows[r:]: + assert not row & ((1 << k)-1) + x = 0 + for i, v in enumerate(vs): + if row >> (k+i) & 1: x ^= v + out.append(x) + return out + + +def odd(vectors): + return any(x.bit_count() & 1 for x in vectors) + + +# -- exact checks ----------------------------------------------------------- +def tmask(t): + return sum(1 << p for p in t) + + +class Checks: + """Exact verification of the side map, labels and compiled roles.""" + def __init__(self, c): + self.c = c; self.h = c.h; self.cache = {}; self.verdicts = {} + self.everything = Label([1 << p for p in range(c.h)]) + + def label(self, node): + if node in self.cache: return self.cache[node] + c = self.c; kind = c.kind[node] + if kind == 'in': + vectors = [tmask(c.triples[node-1])] + elif kind == 'd0': + m = c.cover(node); vectors = [1 << p for p in range(self.h) if m >> p & 1] + else: + s = c.support[node]; ts = [] + while s: + low = s & -s; ts.append(c.triples[low.bit_length()-1]); s ^= low + common = set(ts[0]).intersection(*ts) + assert len(common) >= 2, 'Pair-star node without a common pair' + vectors = [tmask(t) for t in ts] + lab = Label(vectors); self.cache[node] = lab + return lab + + def target_frame(self, S): + t = tmask(S) + key = ('perp', S) + if key not in self.cache: + self.cache[key] = Label([x for x in (1 << p for p in range(self.h)) + if not dot(x, t)] + [tmask((S[0], S[1])), tmask((S[1], S[2]))]) + return self.cache[key] + + def residual_ok(self, small, big): + """small ⊆ big and big ⊖ small is zero or has an odd vector.""" + key = (small.key, big.key) + if key not in self.verdicts: + res = small.complement_in(big) if big.contains(small) else None + self.verdicts[key] = res is not None and (not res or odd(res)) + return self.verdicts[key] + + def label_ok(self, lab): + """Nondegenerate, contains an odd vector, and its complement is zero or does.""" + key = ('label', lab.key) + if key not in self.verdicts: + perp = lab.complement_in(self.everything) + self.verdicts[key] = (lab.nondegenerate() and odd(lab.basis.values()) + and (not perp or odd(perp))) + return self.verdicts[key] + + def verify_map(self): + c = self.c + for node in c.active: + if c.args[node]: + a, b = c.args[node] + assert a < node and b < node and not c.support[a] & c.support[b] + assert c.support[node] == c.support[a] | c.support[b] + got = {} + for S, node, coef in c.pieces: + assert coef in (Q(1, 2), Q(-1, 2)) + key = (S, coef) + assert not got.get(key, 0) & c.support[node], 'Overlapping pieces' + got[key] = got.get(key, 0) | c.support[node] + nonzero = 0 + for S in c.triples: + zero = sum(1 << i for i, T in enumerate(c.triples) if not set(S) & set(T)) + two = sum(1 << i for i, T in enumerate(c.triples) if len(set(S) & set(T)) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + + def verify_labels(self): + c = self.c; checked = 0 + for node in sorted(c.active): + lab = self.label(node) + assert self.label_ok(lab), node # includes the exit to the full space + if c.args[node]: + for child in c.args[node]: + assert self.residual_ok(self.label(child), lab), (node, child) + checked += 1 + for S, node, coef in c.pieces: + assert self.residual_ok(self.label(node), self.target_frame(S)), (S, node) + checked += 1 + return dict(active_nodes=len(c.active), checked_inclusions=checked, + all_labels_nondegenerate=True, all_residuals_have_odd_vectors=True) + + +def compile_roles(c): + """Reversible roles: one per addition plus one per injected piece.""" + users = {x: [] for x in c.active} + for node in sorted(c.active): + if c.args[node]: + for pos, x in enumerate(c.args[node]): users[x].append(('gate', node, pos)) + for i, (_, node, _) in enumerate(c.pieces): users[node].append(('output', i)) + edge = {}; sources = {}; outputs = {}; gates = []; size = 0 + for node in sorted(c.active): + if c.args[node]: + ins = (edge[node, 0], edge[node, 1]); pivot = ins[0] + else: + pivot = size; size += 1; ins = (pivot,); sources[c.triples[node-1]] = pivot + assert users[node] + outs = (pivot,)+tuple(range(size, size+len(users[node])-1)) + size += len(users[node])-1 + assert len(set(ins)) == len(ins) and set(ins) & set(outs) == {pivot} + gates.append((node, ins, outs)) + for user, slot in zip(users[node], outs): + if user[0] == 'gate': edge[user[1], user[2]] = slot + else: outputs[user[1]] = slot + assert size == c.roles + return dict(roles=size, gates=gates, sources=sources, outputs=outputs) + + +def verify_role_frames(c, checks, code=None): + """Follow every physical role in both directions through its frames.""" + code = code or compile_roles(c) + def step(small, big): assert checks.residual_ok(small, big) + frames = [None]*code['roles'] + for T, slot in code['sources'].items(): frames[slot] = checks.label(c.input[T]) + for node, ins, outs in code['gates']: + lab = checks.label(node) + for slot in set(ins+outs): + if frames[slot] is None: assert checks.label_ok(lab) # entry from D0 + else: step(frames[slot], lab) + frames[slot] = lab + for i, slot in code['outputs'].items(): + S = c.pieces[i][0]; J = checks.target_frame(S) + step(frames[slot], J); frames[slot] = J + for lab in frames: + assert checks.label_ok(lab) # includes the exit residual to D1 + # Reverse stage: complements, traversed backward. U^perp grows iff U shrinks. + # Its entries and exits have the forward residuals U^perp and U, checked above. + back = [None]*code['roles'] + for i, slot in code['outputs'].items(): back[slot] = ('line', c.pieces[i][0]) + for node, ins, outs in reversed(code['gates']): + lab = checks.label(node) + for slot in set(ins+outs): + prev = back[slot] + if prev is None: + assert checks.label_ok(lab) # reverse entry residual is lab^perp + elif prev[0] == 'line': # ⊆ U^perp iff U ⊆ t_S^perp + step(lab, checks.target_frame(prev[1])) + else: + step(lab, prev[1]) # prev^perp ⊆ lab^perp iff lab ⊆ prev + back[slot] = ('node', lab) + for T, slot in code['sources'].items(): + assert back[slot][1].key == checks.label(c.input[T]).key # ends at t_T^perp + return dict(roles=code['roles'], forward_frames_nested=True, + reverse_complement_frames_nested=True) + + +def simulate_invocation(c, code, x, y, side, center, inverse=False): + """Scalar invocation over Q with arbitrary scratch; returns the new state. + + Forward: L,-J,L^-1,-R,V,G,R,L,J,L^-1,G^-1,V^-1 gives y <- y + x. + inverse=True runs the inverted schedule, giving x <- x - y. + """ + h = c.h; T = c.triples + side = list(side); center = dict(center); x = dict(x); y = dict(y) + def L(sign=1): + order = code['gates'] if sign > 0 else list(reversed(code['gates'])) + for node, ins, outs in order: + if sign > 0: + if len(ins) == 2: side[ins[0]] += side[ins[1]] + for o in outs[1:]: side[o] += side[outs[0]] + else: + for o in outs[1:]: side[o] -= side[outs[0]] + if len(ins) == 2: side[ins[0]] -= side[ins[1]] + def J(target, sign): + for i, slot in code['outputs'].items(): + S, _, coef = c.pieces[i]; target[S] += sign*coef*side[slot] + def V(source, sign): + for t, slot in code['sources'].items(): side[slot] += sign*source[t] + def G(source, sign): + for i in range(h): center[i] += sign*sum(source[t] for t in T if i in t) + center['*'] += sign*sum(source.values()) + def R(target, sign): + for t in T: target[t] += sign*(sum(center[i] for i in t)-center['*'])/2 + if not inverse: + L(); J(y, -1); L(-1); R(y, -1); V(x, 1); G(x, 1); R(y, 1) + L(); J(y, 1); L(-1); G(x, -1); V(x, -1) + else: # inverse schedule with logical source y and target x + V(y, 1); G(y, 1); L(); J(x, -1); L(-1); R(x, -1); G(y, -1); V(y, -1) + R(x, 1); L(); J(x, 1); L(-1) + return x, y, side, center + + +if __name__ == '__main__': + import sys, time + for h in map(int, sys.argv[1:] or ['10', '12', '16']): + t = time.time(); c = ComplexSideCircuit(h) + print(c.stats(), f'{time.time()-t:.1f}s', flush=True) diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py new file mode 100644 index 0000000000..af9bb6d7b3 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/complex_network.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 +"""Conditional 59/10^11 witness: a compressed complex side circuit. + +The compact-control witness was limited by the original complex motif, whose +v*z_c side wires per invocation dilute its rank deficit. The new side circuit +computes the same correction with shared sums, binary coordinate and pair-star +labels, and the bit network's transparent twelve-operation schedule. The bit +network, compact-control movement and assembly recipe are unchanged. +""" +from fractions import Fraction as Q +from math import comb +from pathlib import Path +import json + +from certify import Parameters, constraints, margins, require, verify_sources +from compact_control_layer import layer_exponents +from complex_circuit import ComplexSideCircuit, Checks, compile_roles, verify_role_frames +from paired_network import BIT_SAVING +from prepare_layers import serializable +from search_network import log_integer_bounds + +ROOT = Path(__file__).resolve().parents[1] +H = 25 +COMPLEX_SAVING = Q(14, 10**9) +LOG_BOUND = Q(966, 100) +KAPPA = Q(59, 10**11) + + +def counts(c): + h = c.h; v = comb(h, 3); m = h**3; N = v**3; I = 3*v*v + R = c.roles; W = 2*N+I*(R+h+1); L = I*(h+1)*h + s = W*m-2*N+2*L + require(L < N, 'Complex deficit is not positive') + return dict(h=h, v=v, m=m, N=N, I=I, side_roles_per_invocation=R, + central_roles=h+1, W=W, L=L, s=s, deficit=W*m-s, eta=Q(W*m-s, W*m), + original_side_wires_per_invocation=v*(comb(h-3, 3)+3*(h-3))) + + +def gate_count(c, n): + """Per invocation: four mixer passes, two copies, two injections, four central gates.""" + per = 4*len(c.active)+4*n['v']+4 + require(n['I']*per <= 12*n['W'], 'The 12W gate bound behind E=64(W+m+1)^3 failed') + return dict(gates_per_invocation=per, total_gates=n['I']*per, twelve_W=12*n['W']) + + +def guard(n, beta, zeta): + """Generalized stopped-depth guard with the new complex constants.""" + m, s, W = n['m'], n['s'], n['W'] + E = 64*(W+m+1)**3; B = s+E + require(m >= 3 and 2 <= s < m**5, 'Unverified coefficient-depth hypothesis') + require(s*(8+E) <= 9*B*B, 'One-piece constant failed') + C1 = 5-4*beta+zeta + raw = max(Q(128*m*B*B), 18*m*B*B*(1+1/zeta)) + C0 = -(-raw.numerator//raw.denominator) + require(9*m*B*B*(1+1/zeta)+18 <= C0, 'Whole-layer constant failed') + return dict(m=m, s=s, E=E, B=B, beta=beta, zeta=zeta, C0=C0, C1=C1) + + +def parameters(): + return Parameters(tau=1-BIT_SAVING, sigma=1-COMPLEX_SAVING, + epsilon=Q(19999, 100000), c=Q(999, 1000), + lam=1-Q(2958, 10**12), lamp=1-Q(2956, 10**12), + kappa=KAPPA, beta=Q(1, 1000), delta=Q(1, 10**6), + C1=Q(49961, 10000)) + + +def witness(p, n): + g = guard(n, p.beta, Q(1, 10000)) + require(p.C1 == g['C1'], 'Guard mismatch') + e = layer_exponents(p.tau, p.sigma, p.beta, p.c) + slacks = constraints(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + slacks['packed_overhead'] = p.lam-e['internal'] # compact control: internal = max exponent + slacks['reserved_axes'] = p.lamp-e['preprocessing'] + for name, slack in slacks.items(): require(slack > 0, 'Constraint failed: '+name) + gs = margins(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + require(min(gs.values()) > p.kappa, 'No final absorption gap') + return dict(parameters=vars(p), guard=g, recurrence=e, constraint_slacks=slacks, + margins=gs, minimum_margin=min(gs.values()), + limiting_margins=[k for k, v in gs.items() if v == min(gs.values())], + absorption_gap=min(gs.values())-p.kappa) + + +def witness_only(): + """Counts and parameter witness without the full finite checks (for the patch).""" + n = counts(ComplexSideCircuit(H)) + require(n['eta'] > COMPLEX_SAVING*LOG_BOUND, 'Complex saving failed') + return witness(parameters(), n) + + +def certificate(): + c = ComplexSideCircuit(H); checks = Checks(c); code = compile_roles(c) + side = checks.verify_map(); labels = checks.verify_labels() + roles = verify_role_frames(c, checks, code) + n = counts(c) + lo, hi = log_integer_bounds(n['m']) + require(hi < LOG_BOUND, 'Logarithm enclosure failed') + require(n['eta'] > COMPLEX_SAVING*LOG_BOUND, 'Complex saving failed') + p = parameters(); w = witness(p, n) + require(Q(1, 2**31) < KAPPA < Q(1, 2**30), 'Unexpected dyadic scale') + # With the bit exponent fixed, g3 <= epsilon*(1-lambda) < epsilon*a_b < a_b/5. + ceiling = BIT_SAVING/5 + require(ceiling < Q(1, 2**30), 'This bit network could cross 2^-30') + return dict(status='CONDITIONAL 59/10^11 WITNESS; COMPRESSED COMPLEX SIDE CIRCUIT; NOT FORMAL VERIFICATION', + upstream_commit=verify_sources(), circuit=c.stats(), side_map=side, + labels=labels, role_frames=roles, gates=gate_count(c, n), + complex_counts=n, complex_saving=COMPLEX_SAVING, log_m_upper=LOG_BOUND, + log_enclosure=(lo, hi), complex_deficit_slack=n['eta']-COMPLEX_SAVING*LOG_BOUND, + bit_saving=BIT_SAVING, witness=w, + improvement_over_compact_control=KAPPA/Q(83, 10**12), + scoped_ceiling=dict(upper=ceiling, below_2_to_minus_30=True, + scope='Published h=50 paired bit network and retained Gaussian margin; not a bound on other networks or algorithms.'), + scope='Conditional on the pinned upstream interfaces, the compact-control movement and guard proofs, the paired bit network, and the written binary-frame transfer for this complex side circuit. Exact arithmetic and finite checks are not formal verification.') + + +if __name__ == '__main__': + result = serializable(certificate()) + (ROOT/'certificates/complex-network.json').write_text(json.dumps(result, indent=2, sort_keys=True)+'\n') + print('PASS conditional', KAPPA, '> 2^-31; minimum margin', result['witness']['minimum_margin']) + print('Side roles per invocation', result['complex_counts']['side_roles_per_invocation'], + 'vs original', result['complex_counts']['original_side_wires_per_invocation']) diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py new file mode 100644 index 0000000000..b0e2f3e03d --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/exclusion_circuit.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 +"""Cancellation-free circuit for all pair sums avoiding two specified points. + +Every addition has disjoint input supports. Node interning shares equal sums; +support tracking verifies the full linear map, not sampled input values. +""" +from itertools import combinations +from hashlib import sha256 +import json + + +class ExclusionCircuit: + def __init__(self,n): + assert n>=4 + self.n=n + self.inputs=list(combinations(range(n),2)) + self.support=[0]+[1<=3 and 2<=sBIT_SAVING*LOG_BOUND,'Bit saving failed') + require(old['eta_c']>COMPLEX_SAVING*LOG_BOUND,'Complex saving failed') + require(2*old['Lc']=2^40 cutoff failed') + witness=certify_parameters(p,generalized_beta=True,strict_margin=True, + layout_model='nonadjacent',guard_model='stopping',assembly_model='tight-gaussian') + require(Q(witness['minimum_margin'])==p.epsilon*p.beta*BIT_SAVING**2,'Wrong limiting margin') + a_upper=n['eta']/((1-n['eta'])*lo) + ceiling=a_upper*a_upper/(5*(1-a_upper)) + require(ceiling 0, 'Need 00') + n = network(h) + m, s, B = n['m'], n['sc'], n['B'] + E = B-s + require(m >= 3 and 2 <= s < m**5, 'Unverified coefficient-depth hypothesis') + require(s*(8+E) <= 9*B*B, 'One-piece constant failed') + C1 = 5-4*beta+zeta + raw_C0 = max(Q(128*m*B*B), 18*m*B*B*(1+1/zeta)) + C0 = -(-raw_C0.numerator//raw_C0.denominator) + require(9*m*B*B*(1+1/zeta)+18 <= C0, 'Whole-layer constant failed') + return dict(h=h, m=m, s=s, E=E, B=B, beta=beta, zeta=zeta, + C0=C0, C1=C1, one_piece_exponent=5-4*beta) + + +def packed_exponents(tau, sigma, beta, c, *, theta=None): + """Sum the recurrence for either exponent ordering. + + theta=tau is the EXISTING packed bound. Any other theta is only a + hypothetical O(V e^tau K^theta) primitive with the same remaining contract. + """ + require(0 < tau < 1 and 0 <= sigma < 1 and 0 < beta < 1 and c > 0, + 'Invalid recurrence parameters') + theta = tau if theta is None else theta + require(theta >= 0, 'Negative spacing exponent is not supported') + internal = tau+(1-beta)*max(sigma-tau, Q(0))+theta*c + leaf = sigma+beta*(1-sigma) + return dict(internal=internal, leaf=leaf, layer=max(internal, leaf), + theta=theta, hypothetical=theta != tau) + + +def check_parameters(p, g, *, hypothetical_theta=None): + """Check the stated extensions, without relaxing the published checker.""" + require(g == guard(g['beta'],g['zeta'],g['h']), 'Guard certificate was altered') + require(p.beta == g['beta'] and p.C1 == g['C1'], 'Guard/parameter mismatch') + require(1-p.tau <= BIT_SAVING, 'Preparation retains the published bit saving') + require(1-p.sigma < complex_saving_bounds(g['h'])[0], + 'Complex exponent is not supported by the chosen motif') + exp = packed_exponents(p.tau, p.sigma, p.beta, p.c, theta=hypothetical_theta) + slacks = constraints(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + slacks['packed_overhead'] = p.lam-exp['internal'] + for name, slack in slacks.items(): + require(slack > 0, 'Failed preparation constraint: '+name) + gs = margins(p, layout_model='nonadjacent', assembly_model='tight-gaussian') + require(min(gs.values()) > p.kappa, 'No strict final margin') + return dict(status=('HYPOTHETICAL SPARSE PRIMITIVE; NOT A MULTIPLICATION RESULT' + if exp['hypothetical'] else + 'Existing packed routine; conditional preparation estimates'), + parameters=vars(p), guard=g, recurrence=exp, + constraint_slacks=slacks, margins=gs, minimum_margin=min(gs.values())) + + +def complex_saving_bounds(h): + n = network(h) + eta = n['eta_c'] + require(0 < eta < Q(1, 2), 'Complex deficit must be positive') + lo, hi = log_ratio_bounds(1/(1-eta), terms=3) + dlo, dhi = log_integer_bounds(n['m']) + return lo/dhi, hi/dlo + + +def complex_search(): + # L_c3h(h+1) iff h^2-21h-16>0, hence integer h>=22. + bounds = {h: complex_saving_bounds(h) for h in range(22, 200)} + winner = max(bounds, key=lambda h: bounds[h][0]) + lo, hi = bounds[winner] + require(all(lo > b[1] for h, b in bounds.items() if h != winner), + 'Finite winner not separated') + n200 = network(200) + # eta_c<2/(3*z_c*m), log(m)>1; every factor increases for h>=200. + tail = Q(2, 3*n200['zc']*n200['m']-2) + require(log_integer_bounds(n200['m'])[0] > 1, 'Tail log denominator failed') + require(lo > tail, 'Tail could improve the result') + n = network(winner) + certified = Q(418, 10**12) + _, log_hi = log_integer_bounds(n['m']) + require(n['eta_c'] > certified*log_hi, 'Chosen simple complex saving failed') + require(n['Lc'] < n['N'] and 2*n['Lc'] >= n['N'], + 'Expected the complex-only admissibility range') + require(n['sc'] < n['m']**5, 'Guard requires a different depth bound') + fixed50 = Q(169, 10**13) + require(network(50)['eta_c'] > fixed50*log_integer_bounds(50**3)[1], + 'Fixed-h=50 saving failed') + return dict(status='Conditional complex interface; separate-arity integration not patched', + winner_h=winner, admissible_integer_h_minimum=22, + saving_lower=lo, saving_upper=hi, certified_saving=certified, + counts={k:n[k] for k in ('h','m','v','N','Wc','sc','Lc','eta_c')}, + fixed_h50_saving=fixed50, tail_start=200, tail_upper=tail, + finite_enclosures={str(h):dict(lower=b[0],upper=b[1]) for h,b in bounds.items()}, + scope='Original complex motif only, all integer h>=22; no shared bit positivity requirement. Written interface audit required, not a formal proof.') + + +def scenarios(): + a = BIT_SAVING + epsilon = Q(199,1000) + # The published numerical choice remains valid under the generalized proof. + beta = Q(999,1000) + g = guard(beta) + existing = Parameters(1-a, 1-Q(1,10**11), epsilon, beta*a, + 1-(1+beta)*a*a/2, 1-beta*a*a, Q(1,2**59), + beta=beta, delta=Q(1,10000), C1=g['C1']) + result = {'existing_59_control':check_parameters(existing,g)} + # These two rows assume theta=a instead of theta=tau. No such primitive + # is supplied here. They expose exact research targets and guard budgets. + for name,h,ac,beta,c,q,k in ( + ('hypothetical_39',50,Q(1,10**11),Q(1,100),Q(1,200),Q(95,10**13),39), + ('hypothetical_34',25,Q(418,10**12),Q(1,5),Q(1,10),Q(3,10**10),34)): + g = guard(beta,h=h) + exp = packed_exponents(1-a,1-ac,beta,c,theta=a) + lamp = 1-q + lam = (max(1-a,1-ac,exp['internal'])+lamp)/2 + p = Parameters(1-a,1-ac,epsilon,c,lam,lamp,Q(1,2**k), + beta=beta,delta=Q(1,10000),C1=g['C1']) + result[name] = check_parameters(p,g,hypothetical_theta=a) + actual = packed_exponents(p.tau,p.sigma,p.beta,p.c) + require(actual['internal'] > 1, 'Hypothetical target accidentally uses an existing bound') + result[name]['existing_primitive_internal_exponent'] = actual['internal'] + result[name]['missing_hypothesis'] = 'Uniform fixed-tape O(V f^(1-a) K^a) selected-bit primitive, up to fixed powers of log(p) only, including descriptors, exceptional repair, and dirty-scratch restoration.' + return result + + +def certificate(): + return dict(status='PREPARATION PASS; published headline remains conditional 2^-59', + upstream_commit=verify_sources(), complex_family=complex_search(), + scenarios=scenarios(), + verification_boundary='Exact arithmetic and finite recurrence checks accompany written proofs. Sparse scenarios are unproved design targets, not certificates of new algorithms.') + + +def serializable(value): + if isinstance(value,Q): + return str(value) + if isinstance(value,dict): + return {k:serializable(v) for k,v in value.items()} + if isinstance(value,(list,tuple)): + return [serializable(v) for v in value] + return value + + +if __name__ == '__main__': + result = certificate() + (ROOT/'certificates/layer-preparation.json').write_text( + json.dumps(serializable(result),indent=2,sort_keys=True)+'\n') + print('PASS preparation estimates; complex-family optimum h='+str(result['complex_family']['winner_h'])) + print('Published result remains 2^-59. Sparse targets 2^-39 and 2^-34 remain hypothetical.') diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py new file mode 100644 index 0000000000..f03d5c1b2c --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/search_network.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +"""Certify the best shared recurrence exponent within the generalized h family. + +Uses rational enclosures of logarithms, plus a tail bound for all h>=200. +The result concerns the counting formulas, conditional on the network proof. +""" +from fractions import Fraction as Q +import json +from pathlib import Path +from certify import network, require + +ROOT = Path(__file__).resolve().parents[1] + + +def log_ratio_bounds(x, terms=24): + """Bounds for log(x), 1 <= x <= 2, by the atanh series.""" + require(1 <= x <= 2, "Log series expects 1<=x<=2") + z = (x-1)/(x+1) + lower = 2*sum((z**(2*j+1)/Q(2*j+1) for j in range(terms)), Q(0)) + tail = 2*z**(2*terms+1)/((2*terms+1)*(1-z*z)) + return lower, lower+tail + + +def log_integer_bounds(m): + k = m.bit_length()-1 + lo2, hi2 = log_ratio_bounds(Q(2)) + lo, hi = log_ratio_bounds(Q(m, 2**k)) + return k*lo2+lo, k*hi2+hi + + +def saving_bounds(n, bit_only=False): + eta = n["eta_b"] if bit_only else min(n["eta_b"], n["eta_c"]) + require(0 < eta < Q(1, 2), "Need a positive small rank deficit") + # Shared exponent saving is min(-log(1-eta_b),-log(1-eta_c))/log(m). + lo_num, hi_num = log_ratio_bounds(1/(1-eta), terms=3) + lo_den, hi_den = log_integer_bounds(n["m"]) + return lo_num/hi_den, hi_num/lo_den + + +def search(bit_only=False): + bounds = {} + rejected = [] + for h in range(7, 200): + if h == 9: + rejected.append(h) + continue + n = network(h) + if 2*n["Lb"] >= n["N"] or 2*n["Lc"] >= n["N"]: + rejected.append(h) + continue + bounds[h] = saving_bounds(n, bit_only=bit_only) + winner = max(bounds, key=lambda h: bounds[h][0]) + lo, hi = bounds[winner] + require(all(lo > b[1] for h, b in bounds.items() if h != winner), + "Enclosures do not separate a unique winner") + # eta_b < 1/(3*z_b*m), and -log(1-eta_b) < eta_b/(1-eta_b). + # For h>=200, z_b and m increase and log(m)>1. This bounds ALL the tail. + n200 = network(200) + tail_upper = Q(1, 3*n200["zb"]*n200["m"]-1) + require(lo > tail_upper, "Tail could contain a better network") + dyadic_power = 1 + while Q(1, 2**dyadic_power) >= lo: + dyadic_power += 1 + require(hi < Q(1, 2**(dyadic_power-1)), "Cannot certify optimal dyadic saving") + return { + "scope": ("Bit-network saving alone" if bit_only else "Common tau=sigma saving") + + "; generalized counting formulas, construction conditional", + "winner_h": winner, + "saving_lower": str(lo), "saving_upper": str(hi), + "largest_certified_dyadic_saving": f"2^-{dyadic_power}", + "tail_start": 200, "tail_saving_upper": str(tail_upper), + "excluded_h": rejected, + "finite_enclosures": {str(h): {"lower": str(b[0]), "upper": str(b[1])} + for h, b in bounds.items()}, + } + + +def parameter_ceiling(): + """Upper bound for kappa even with variable beta and separate sigma. + + Put a=1-tau. The final g4>0 gives epsilon Q(99, 100)*upper, "Witness below 99% of ceiling") + return {"bit_network_search": result, "kappa_upper": str(upper), + "simple_kappa_upper": str(Q(5838, 10**36)), + "witness": str(witness), "witness_fraction_of_upper": str(witness/upper), + "next_dyadic_excluded": "2^-107", + "scope": "Seven-margin accounting and stated network rank bounds; not all algorithms"} + + +if __name__ == "__main__": + result = search() + result["parameter_ceiling"] = parameter_ceiling() + path = ROOT / "certificates/network-search.json" + path.parent.mkdir(exist_ok=True) + path.write_text(json.dumps(result, indent=2, sort_keys=True)+"\n") + print(f"Certified h={result['winner_h']} best within the stated counting family,") + print(f"including all h>=200 by a tail bound; dyadic saving {result['largest_certified_dyadic_saving']}") diff --git a/research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py b/research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py new file mode 100644 index 0000000000..d086427188 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/scripts/shared_point_circuit.py @@ -0,0 +1,296 @@ +#!/usr/bin/env python3 +"""Merge equal sums across the common-point circuits, with exact certificates. + +Supports are represented by their provenance in the small pair circuit, not +by half a million dense global bit vectors. A sum that occurs in two distinct +common-point groups must be a pair-star; its fixed pair and union of vertices +identify its support exactly. +""" +from hashlib import sha256 +from itertools import combinations + +from exclusion_circuit import ExclusionCircuit + + +class SharedPointCircuit: + def __init__(self,h,circuit=None): + """Merge equal pair-star sums across common-point groups. + + Tooling note (shared-point / bit-compression replay): the merge/lookup + loop keeps the historical node-allocation order and output keys, but + pre-sorts the local active set and output items once, unpacks child + mappings without a per-node generator, and binds hot attributes locally. + ``merged_additions``, topology and ``circuit_sha256`` are unchanged. + See ``research/shared-point-init/``. + """ + assert h>=6 and h!=9, 'The ambient form I-J/9 must be nondegenerate' + self.h=h + self.local=circuit or ExclusionCircuit(h-1) + assert self.local.n==h-1, 'Pair circuit has the wrong ground size' + self.inputs=list(combinations(range(h),3)) + self.variables={t:i+1 for i,t in enumerate(self.inputs)} + nin=len(self.inputs) + self.args=[None]*(nin+1) + self.core=[0]+[sum(1<=2: + key=(cval,uval) + hit=lookup.get(key) + if hit is not None: + mapping[node]=hit;self.merged+=1 + continue + new=len(args);mapping[node]=new + append_args((a,b));append_core(cval);append_union(uval) + append_prov((common,node));lookup[key]=new + else: + new=len(args);mapping[node]=new + append_args((a,b));append_core(cval);append_union(uval) + append_prov((common,node)) + outs=self.outputs + for pair,node in outputs_items: + outs[common,tuple(sorted((common,*(pts[x] for x in pair))))]=mapping[node] + self.active=set();stack=list(self.outputs.values());active=self.active + while stack: + n=stack.pop() + if n in active:continue + active.add(n) + edge=args[n] + if edge:stack.extend(edge) + self.additions=sum(args[n] is not None for n in active) + + def support_in(self,node,common): + """Exact pair-input support in coordinates with this common point. + + Tooling note (shared-point / bit-compression frame replay): results are + memoized in a per-instance dense table indexed by ``node * h + common`` + instead of a process-wide ``lru_cache(maxsize=16384)``. The historical + full-size checker (``h=46``) asks for far more than 16384 distinct + ``(node, common)`` pairs during ``verify_frames``, so the small LRU + thrashed. Leaf triples and two-point stars unpack pairs without a + generator or ``sorted`` call. Returned bitmasks are unchanged. See + ``research/shared-point-frame-contains/``. + """ + try: + cache=self._support_in_cache + except AttributeError: + cache=[None]*(len(self.args)*self.h) + self._support_in_cache=cache + h=self.h + idx=node*h+common + hit=cache[idx] + if hit is not None: + return hit + core_row=self.core + core=core_row[node] + assert core&(1<=6 and h%2==0,'Even ground size required') + c=circuit or SharedPointCircuit(h) + require(c.h==h,'Mismatched circuit') + v=comb(h,3);N=v**3;m=h**3;R=c.additions+len(c.outputs) + W=2*N+2*v*v*(R+h);L=3*v*v*h*h;D=N-2*L + return dict(h=h,v=v,N=N,m=m,side_roles_per_invocation=R, + W=W,L=L,D=D,s=W*m-D,eta=Q(D,W*m)) + + +def parameters(): + a=BIT_SAVING + return Parameters(1-a,1-A,Q(1,21),9*a/10,1-19*a*a/20, + 1-9*a*a/10,KAPPA,beta=Q(9,10)) + + +def certificate(): + c=SharedPointCircuit(46);n=counts(circuit=c) + symbolic=c.verify();frames=c.verify_frames() + _,log_hi=log_integer_bounds(n['m']) + require(log_hiBIT_SAVING*LOG_BOUND,'Insufficient saving') + witness=certify_parameters(parameters(),generalized_beta=True,strict_margin=True, + layout_model='nonadjacent') + require(Q(witness['minimum_margin'])==3*BIT_SAVING**2/70,'Wrong minimum') + # Necessary bound for this particular circuit and downstream constraints. + log_lo,_=log_integer_bounds(n['m']) + a_upper=n['eta']/((1-n['eta'])*log_lo) + ceiling=a_upper*a_upper/(20*(1-a_upper)) + require(ceilingQ(1,2**59),'Invalid target saving') + budget=n['D']/(2*n['v']**2*n['m']*target_a*LOG_BOUND)-n['v']-n['h'] + return dict(status='CONDITIONAL 13*2^-66 WITNESS; frame-transfer proof supplied separately', + upstream_commit=verify_sources(),bit_counts={k:str(v) for k,v in n.items()}, + circuit=symbolic,frames=frames,bit_saving=str(BIT_SAVING), + complex_saving_unchanged=str(A),log_m_upper=str(LOG_BOUND), + deficit_slack=str(n['eta']-BIT_SAVING*LOG_BOUND),witness=witness, + exact_circuit_kappa_upper=str(ceiling), + target_59=dict(bit_saving=str(target_a), + sufficient_maximum_integer_side_roles=(budget.numerator-1)//budget.denominator), + scope='Conditional on the written source-span/complement-frame transfer and unchanged upstream interfaces; no general optimality claim.') + + +if __name__=='__main__': + result=certificate() + (ROOT/'certificates/shared-point-network.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n') + print('PASS conditional shared-point witness 13*2^-66; minimum',result['witness']['minimum_margin']) + print(result['bit_counts']) + print('Target 59:',result['target_59']) diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE b/research/h25-bookkeeping/payload/baseline/frozen/upstream/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/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/h25-bookkeeping/payload/baseline/frozen/upstream/README.md b/research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md new file mode 100644 index 0000000000..c8cb3c3857 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/README.md @@ -0,0 +1,17 @@ +# [Integer multiplication below n log n](paper.pdf) + +**Author:** OpenAI + +**Date:** September 23, 2026 + +## Citation + +```bibtex +@misc{OAI:Integer-multiplication-below-n-log-n-September-23-2026, + author = {{OpenAI}}, + title = {{Integer multiplication below $n\log n$}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/Integer-multiplication-below-n-log-n-September-23-2026/paper.pdf}{OAI:Integer-multiplication-below-n-log-n-September-23-2026}}, + year = {2026} +} +``` diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex new file mode 100644 index 0000000000..f0297c9cb8 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/multiplication-flow.tex @@ -0,0 +1,17 @@ +\begin{tikzpicture}[ + node distance=10mm, + every node/.style={font=\small}, + box/.style={draw,rounded corners=2pt,align=center,text width=9.6cm,inner sep=5pt}, + >=Stealth] +\node[box] (digits) {Integer product\\radix-digit convolution}; +\node[box,below=of digits] (prime) {Cyclic convolution on distinct prime axes}; +\node[box,below=of prime] (power) {Normalized convolution on power-of-two axes}; +\node[box,below=of power] (ring) {Convolution over $\mathbb C[y]/(y^r+1)$\\ +synthetic transforms and packed polynomial products}; +\draw[->] (digits)--node[right,font=\scriptsize,align=left] + {Chinese-remainder\\address map}(prime); +\draw[->] (prime)--node[right,font=\scriptsize,align=left] + {Gaussian resampling\\and chirps}(power); +\draw[->] (power)--node[right,font=\scriptsize,align=left] + {last-coordinate\\phase twist}(ring); +\end{tikzpicture} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex new file mode 100644 index 0000000000..a2d539e5a7 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/figures/proof-map.tex @@ -0,0 +1,8 @@ +\begin{tikzpicture}[node distance=5mm, every node/.style={font=\small}, box/.style={draw,rounded corners=2pt,align=center,text width=11cm,inner sep=5pt}, >=Stealth] +\node[box] (c) {One edge on the array assigned to a wire role\\ +$D_u g_w\ \xrightarrow{\quad D_vD_u^{-1}\quad}\ D_v g_w$\\ +the frame changes while the logical array stays fixed}; +\node[box,below=of c] (d) {One pointwise gate $G$ on $t$ aligned roles, all in frame $D_v$\\ +$G(D_vg_1,\ldots,D_vg_t)=D_vG(g_1,\ldots,g_t)$}; +\draw[->] (c)--(d); +\end{tikzpicture} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex new file mode 100644 index 0000000000..0b11a3feb1 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/main.tex @@ -0,0 +1,51 @@ +\documentclass[11pt]{article} +\usepackage[T1]{fontenc} +\usepackage{lmodern,microtype} +\usepackage{amsmath,amssymb,amsthm,mathrsfs,mathtools,booktabs,array,longtable} +\usepackage[margin=1in]{geometry} +\usepackage{tikz} +\usetikzlibrary{positioning,arrows.meta} +\usepackage[hyphens]{url} +\usepackage{hyperref} +\hypersetup{colorlinks=true,linkcolor=blue!45!black,citecolor=blue!45!black,urlcolor=blue!45!black,pdftitle={Integer multiplication below n log n},pdfauthor={OpenAI}} +\pdfinfoomitdate=1 +\pdftrailerid{} +\pdfsuppressptexinfo=15 +\newtheorem{theorem}{Theorem} +\newtheorem{lemma}[theorem]{Lemma} +\newtheorem{proposition}[theorem]{Proposition} +\newtheorem{corollary}[theorem]{Corollary} +\theoremstyle{definition} +\newtheorem{definition}[theorem]{Definition} +\newtheorem{remark}[theorem]{Remark} +\newcommand{\norm}[1]{\lVert#1\rVert_\infty} +\title{Integer multiplication below \texorpdfstring{$n\log n$}{n log n}} +\author{OpenAI} +\date{September 23, 2026} +\begin{document} +\maketitle +\begin{abstract} +We give a deterministic algorithm that multiplies two $n$-bit integers +in $O(n(\lg n)^{1-\kappa})$ worst-case time, with +$\kappa=2^{-182}$, on one fixed finite-alphabet Turing machine with a +fixed finite number of one-dimensional tapes. The algorithm is exact +for every input length and disproves the $n\log n$ optimality conjecture +of Sch\"onhage and Strassen in this model. +\end{abstract} +\tableofcontents +\clearpage +\input{sections/00-introduction.tex} +\input{sections/02-streams.tex} +\input{sections/03-motifs.tex} +\input{sections/04-swap.tex} +\input{sections/05-layers.tex} +\input{sections/06-transforms.tex} +\input{sections/07-resampling.tex} +\input{sections/08-assembly.tex} +\input{sections/09-exact-arithmetic.tex} +\input{sections/10-transposition.tex} +\appendix +\input{sections/11-grouped-rectangles.tex} +\bibliographystyle{plain} +\bibliography{references} +\end{document} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib new file mode 100644 index 0000000000..bf01cae125 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/references.bib @@ -0,0 +1,301 @@ +@article{KaratsubaOfman1962, + author = {Karatsuba, A. and Ofman, Yu.}, + title = {Multiplication of Many-Digital Numbers by Automatic Computers}, + journal = {Doklady Akademii Nauk SSSR}, + volume = {145}, + number = {2}, + pages = {293--294}, + year = {1962}, + note = {In Russian}, + url = {https://www.mathnet.ru/eng/dan26729} +} +@article{Toom1963, + author = {Toom, A. L.}, + title = {The Complexity of a Scheme of Functional Elements Simulating the Multiplication of Integers}, + journal = {Doklady Akademii Nauk SSSR}, + volume = {150}, + number = {3}, + pages = {496--498}, + year = {1963}, + note = {In Russian}, + url = {https://www.mathnet.ru/eng/dan27978} +} +@article{SchonhageStrassen1971, + author = {Sch{\"o}nhage, Arnold and Strassen, Volker}, + title = {Schnelle {Multiplikation} gro{\ss}er {Zahlen}}, + journal = {Computing}, + volume = {7}, + pages = {281--292}, + year = {1971}, + doi = {10.1007/BF02242355} +} +@inproceedings{Furer2007, + author = {F{\"u}rer, Martin}, + title = {Faster Integer Multiplication}, + booktitle = {Proceedings of the 39th Annual ACM Symposium on Theory of Computing}, + pages = {57--66}, + year = {2007}, + publisher = {ACM}, + doi = {10.1145/1250790.1250800} +} +@article{Furer2009, + author = {F{\"u}rer, Martin}, + title = {Faster Integer Multiplication}, + journal = {SIAM Journal on Computing}, + volume = {39}, + number = {3}, + pages = {979--1005}, + year = {2009}, + doi = {10.1137/070711761} +} +@article{Nussbaumer1980, + author = {Nussbaumer, H. J.}, + title = {Fast Polynomial Transform Algorithms for Digital Convolution}, + journal = {IEEE Transactions on Acoustics, Speech, and Signal Processing}, + volume = {28}, + number = {2}, + pages = {205--215}, + year = {1980}, + doi = {10.1109/TASSP.1980.1163372} +} +@article{NussbaumerQuandalle1978, + author = {Nussbaumer, H. J. and Quandalle, P.}, + title = {Computation of Convolutions and Discrete {Fourier} Transforms by Polynomial Transforms}, + journal = {IBM Journal of Research and Development}, + volume = {22}, + number = {2}, + pages = {134--144}, + year = {1978}, + doi = {10.1147/rd.222.0134}, + url = {https://bitsavers.org/pdf/ibm/IBM_Journal_of_Research_and_Development/222/ibmrd2202D.pdf} +} +@article{DuttRokhlin1993, + author = {Dutt, A. and Rokhlin, V.}, + title = {Fast {Fourier} Transforms for Nonequispaced Data}, + journal = {SIAM Journal on Scientific Computing}, + volume = {14}, + number = {6}, + pages = {1368--1393}, + year = {1993}, + doi = {10.1137/0914081} +} +@article{RosserSchoenfeld1962, + author = {Rosser, J. Barkley and Schoenfeld, Lowell}, + title = {Approximate Formulas for Some Functions of Prime Numbers}, + journal = {Illinois Journal of Mathematics}, + volume = {6}, + pages = {64--94}, + year = {1962}, + doi = {10.1215/ijm/1255631807} +} +@article{DeKururSahaSaptharishi2013, + author = {De, Anindya and Kurur, P. P. and Saha, Chandan and Saptharishi, Ramprasad}, + title = {Fast Integer Multiplication Using Modular Arithmetic}, + journal = {SIAM Journal on Computing}, + volume = {42}, + number = {2}, + pages = {685--699}, + year = {2013}, + doi = {10.1137/100811167} +} +@article{Schonhage1980, + author = {Sch{\"o}nhage, Arnold}, + title = {Storage Modification Machines}, + journal = {SIAM Journal on Computing}, + volume = {9}, + number = {3}, + pages = {490--508}, + year = {1980}, + doi = {10.1137/0209036} +} +@article{Bluestein1970, + author = {Bluestein, L. I.}, + title = {A Linear Filtering Approach to the Computation of Discrete {Fourier} Transform}, + journal = {IEEE Transactions on Audio and Electroacoustics}, + volume = {18}, + number = {4}, + pages = {451--455}, + year = {1970}, + doi = {10.1109/TAU.1970.1162132} +} + +@article{HarveyHoeven2021, + author = {Harvey, David and van der Hoeven, Joris}, + title = {Integer Multiplication in Time {$O(n\log n)$}}, + journal = {Annals of Mathematics}, + series = {2}, + volume = {193}, + number = {2}, + pages = {563--617}, + year = {2021}, + doi = {10.4007/annals.2021.193.2.4}, + url = {https://www.texmacs.org/joris/nlogn/nlogn.pdf}, + note = {Result numbering refers to the 45-page author-hosted manuscript, + \url{https://www.texmacs.org/joris/nlogn/nlogn.pdf}, + accessed 4 October 2026} +} + +@inproceedings{HarveyHoeven2025, + author = {Harvey, David and van der Hoeven, Joris}, + title = {Integer Multiplication Is at Least as Hard as Matrix Transposition}, + booktitle = {Proceedings of the 66th Annual Symposium on Foundations of Computer Science (FOCS)}, + pages = {1366--1381}, + publisher = {IEEE Computer Society}, + year = {2025}, + doi = {10.1109/FOCS63196.2025.00072}, + eprint = {2503.22848v1}, + archivePrefix = {arXiv}, + primaryClass = {cs.CC}, + url = {https://arxiv.org/abs/2503.22848v1}, + note = {Cited theorem numbering follows arXiv version 1, 28 March 2025, + \url{https://arxiv.org/abs/2503.22848v1}} +} + +@article{HarveyHoevenLecerf2016, + author = {Harvey, David and van der Hoeven, Joris and Lecerf, Gr{\'e}goire}, + title = {Even Faster Integer Multiplication}, + journal = {Journal of Complexity}, + volume = {36}, + pages = {1--30}, + year = {2016}, + doi = {10.1016/j.jco.2016.03.001}, + url = {https://arxiv.org/abs/1407.3360v1} +} + +@inproceedings{HarveyHoeven2019Lattice, + author = {Harvey, David and van der Hoeven, Joris}, + title = {Faster Integer Multiplication Using Short Lattice Vectors}, + booktitle = {Proceedings of the Thirteenth Algorithmic Number Theory Symposium}, + editor = {Scheidler, Renate and Sorenson, Jonathan}, + series = {The Open Book Series}, + volume = {2}, + pages = {293--310}, + publisher = {Mathematical Sciences Publishers}, + year = {2019}, + doi = {10.2140/obs.2019.2.293}, + url = {https://arxiv.org/abs/1802.07932v1}, + note = {Preprint posted 22 February 2018} +} + +@misc{Groff2019, + author = {Groff, Matt}, + title = {Faster Integer Multiplication Using Preprocessing}, + year = {2019}, + eprint = {1911.07124v2}, + archivePrefix = {arXiv}, + primaryClass = {cs.DS}, + url = {https://arxiv.org/abs/1911.07124v2}, + note = {Version 2, 11 December 2019} +} + +@misc{Harvey2023Truncated, + author = {Harvey, David}, + title = {Faster Truncated Integer Multiplication}, + year = {2023}, + eprint = {1703.00640v2}, + archivePrefix = {arXiv}, + primaryClass = {cs.SC}, + url = {https://arxiv.org/abs/1703.00640v2}, + note = {Version 2, 2 August 2023; first posted 2 March 2017} +} + +@article{Brent1976, + author = {Brent, Richard P.}, + title = {Fast Multiple-Precision Evaluation of Elementary Functions}, + journal = {Journal of the ACM}, + volume = {23}, + number = {2}, + pages = {242--251}, + year = {1976}, + url = {https://maths-people.anu.edu.au/~brent/pd/rpb034.pdf}, + note = {Author-hosted copy: + \url{https://maths-people.anu.edu.au/~brent/pd/rpb034.pdf}} +} + +@article{AgarwalCooley1977, + author = {Agarwal, R. C. and Cooley, J. W.}, + title = {New Algorithms for Digital Convolution}, + journal = {IEEE Transactions on Acoustics, Speech, and Signal Processing}, + volume = {25}, + number = {5}, + pages = {392--410}, + year = {1977}, + doi = {10.1109/TASSP.1977.1162981} +} + +@article{FranklWilson1981, + author = {Frankl, Peter and Wilson, Richard M.}, + title = {Intersection Theorems with Geometric Consequences}, + journal = {Combinatorica}, + volume = {1}, + number = {4}, + pages = {357--368}, + year = {1981}, + doi = {10.1007/BF02579457} +} + +@article{Alon1998, + author = {Alon, Noga}, + title = {The {Shannon} Capacity of a Union}, + journal = {Combinatorica}, + volume = {18}, + number = {3}, + pages = {301--310}, + year = {1998}, + doi = {10.1007/PL00009824}, + url = {https://www.tau.ac.il/~nogaa/PDFS/shann3.pdf} +} + +@inproceedings{BarYossefBirkJayramKol2006, + author = {Bar-Yossef, Ziv and Birk, Yitzhak and Jayram, T. S. and Kol, Tomer}, + title = {Index Coding with Side Information}, + booktitle = {Proceedings of the 47th Annual IEEE Symposium on Foundations of Computer Science}, + pages = {197--206}, + publisher = {IEEE Computer Society}, + year = {2006}, + url = {https://webee.technion.ac.il/people/zivby/papers/indexing/indexing.focs.pdf} +} + +@article{LubetzkyStav2009, + author = {Lubetzky, Eyal and Stav, Uri}, + title = {Nonlinear Index Coding Outperforming the Linear Optimum}, + journal = {IEEE Transactions on Information Theory}, + volume = {55}, + number = {8}, + pages = {3544--3551}, + year = {2009}, + doi = {10.1109/TIT.2009.2023702}, + url = {https://arxiv.org/abs/0806.1919}, + note = {Result numbering refers to the 16-page author preprint, + \url{https://arxiv.org/pdf/0806.1919}, accessed 4 October 2026} +} + +@inproceedings{BuhrmanCleveKouckyLoffSpeelman2014, + author = {Buhrman, Harry and Cleve, Richard and Kouck{\'y}, Michal and Loff, Bruno and Speelman, Florian}, + title = {Computing with a Full Memory: Catalytic Space}, + booktitle = {Proceedings of the 46th Annual ACM Symposium on Theory of Computing}, + pages = {857--866}, + publisher = {ACM}, + year = {2014}, + doi = {10.1145/2591796.2591874}, + url = {https://ir.cwi.nl/pub/22659/22659B.pdf} +} + +@article{Grigoriev1982, + author = {Grigor'ev, D. Yu.}, + title = {Additive Complexity in Directed Computations}, + journal = {Theoretical Computer Science}, + volume = {19}, + pages = {39--67}, + year = {1982}, + doi = {10.1016/0304-3975(82)90014-7}, + url = {https://logic.pdmi.ras.ru/~grigorev/pub/additive82.pdf} +} + +@misc{OpenAIExactDFT2026, + author = {{OpenAI}}, + title = {{An explicit power saving for the exact discrete Fourier transform}}, + howpublished = {OpenAI Math Release preprint + \href{https://github.com/openai/math/blob/main/preprints/An-explicit-power-saving-for-the-exact-discrete-Fourier-transform-September-25-2026/main.pdf}{OAI:An-explicit-power-saving-for-the-exact-discrete-Fourier-transform-September-25-2026}}, + year = {2026} +} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex new file mode 100644 index 0000000000..aa9048eef8 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/00-introduction.tex @@ -0,0 +1,216 @@ +\section{Introduction} + +Sch\"onhage and Strassen proved in 1971 that two $n$-bit integers can +be multiplied in $O(n\log n\log\log n)$ time on a multitape Turing +machine, and proposed $n\log n$ as the optimal order of growth +\cite[Section~1]{SchonhageStrassen1971}. After a sequence of improvements, +Harvey and van der Hoeven reached the unconditional $O(n\log n)$ upper +bound~\cite{HarveyHoeven2021}. We obtain a strict power saving in the +logarithmic factor, in the same fixed finite-tape model. The algorithm +uses linear combinations of intermediate data to reduce the cost of +both address rearrangement and Fourier-transform layers. + +For a binary string $x$ of length $n$, let $\operatorname{val}(x)$ be +its nonnegative integer value, with the leftmost bit most significant. +For $0\le z<2^k$, let $\operatorname{bin}_k(z)$ denote its binary +representation padded on the left to length $k$. We consider exact +multiplication: on input $x\#y$, with $x,y\in\{0,1\}^n$, the output +must be $\operatorname{bin}_{2n}(\operatorname{val}(x)\operatorname{val}(y))$. +Write $\lg n=\max\{\lceil\log_2 n\rceil,1\}$. + +\begin{theorem}\label{thm:main} +There is one deterministic Turing machine $A$, with a fixed finite +alphabet and a fixed finite number of one-dimensional tapes, that +computes this exact product for every $n\ge1$ and every pair of $n$-bit +inputs. Its worst-case running time satisfies +\[ + T_A(n)=O\!\left(n(\lg n)^{1-\kappa}\right), + \qquad \kappa=2^{-182}. +\] +\end{theorem} + +The bound is asymptotic through all input lengths. The constants and +thresholds in the construction are extremely large; the algorithm is +intended to establish a bit-complexity bound. The theorem refutes an +eventual $\Omega(n\log n)$ lower bound for every fixed multiplication +machine in this model. + +\subsection{The two tape operations} + +Splitting the inputs into radix digits reduces multiplication to +convolution of short integer coefficients. Our starting point is the +Gaussian-resampling reduction of Harvey and van der Hoeven +\cite{HarveyHoeven2021}: it replaces the Fourier transforms needed for +this convolution by multidimensional transforms whose axis lengths are +powers of two. After a further conversion to convolution, one coordinate +is stored as the coefficient list of a polynomial modulo $y^r+1$, with $r$ a power of two. Powers of $y$ then +serve as roots of unity in the remaining axes, and multiplication by +such a root is a signed shift of the coefficient list. These are the +synthetic polynomial transforms of Nussbaumer and Quandalle and +Nussbaumer~\cite{NussbaumerQuandalle1978,Nussbaumer1980}. + +In this representation, the transform calculation consists of address +rearrangements, signed shifts, and two-point butterfly operations. +Scanning an array of $\Theta(n)$ stored bits at each of +$\Theta(\log n)$ transform levels already costs $\Theta(n\log n)$. +We therefore need savings in both movement and arithmetic. Two tape +procedures supply them; in both bounds, $V$ denotes the stored bit volume. + +The first procedure interchanges two disjoint contiguous address fields +of $u$ bits in an array whose addresses form a complete Cartesian +product. Its cost is $O(Vu^\tau)$ for a fixed $\tau<1$. +Although its final effect is an exact permutation, its intermediate +steps form pointwise XOR combinations of data. The final permutation is +exact for arbitrary initial auxiliary values. + +The second procedure applies +\[ + H_0(u,v)=\bigl((u+v)/2,(u-v)/2\bigr) +\] +simultaneously on selected coordinate bits of the numerical arrays. +Each record is a polynomial with complex fixed-point coefficients, and +$H_0$ acts coefficientwise. On the layouts used in the multiplication +algorithm, one selects the same bit position in each of at most $d$ +equal-width address chunks, and the cost is $O(Vd^{\lambda'})$ for a +fixed $\lambda'<1$. Intermediate values are exact Gaussian dyadics, +whose real and imaginary parts have power-of-two denominators. A single +truncation follows the completed contractive layer. +Section~\ref{sec:tape-interchange} proves the address bound, and +Section~\ref{sec:fast-butterfly-layers} gives the numerical layout, +precision hypotheses, and layer bound. + +\subsection{Linear networks and the recursive saving} + +Each procedure arises from its own fixed linear network that exchanges two +banks of values, with prescribed signs, and restores every auxiliary +value. A wire's fixed place in the network is called its role. To use +the network on an array, regard a row as the complete ordered suffix, +including all active address fields, at a fixed prefix and row index. +Distribute rows cyclically among the $W$ roles, padding the row count +for each prefix to a multiple of $W$. Let $V$ now denote the node volume +after padding. All role streams have the same local address set and each +contains $V/W$ bits. A scalar gate is then applied +pointwise to matching addresses on the roles that it touches. + +The representation of a role's array may change along the network. +At a source, gate, or sink $v$, choose an invertible linear operator +$D_v$ on the space of arrays indexed by the common address set. We call $D_v$ its frame: the stored +array is $D_vg$ when the logical array is $g$. All incidences of one +gate have the same frame. Along an edge from $u$ to $v$, the operator +$D_vD_u^{-1}$ changes the stored array from $D_ug$ to $D_vg$. +At a pointwise linear gate $G$, the common frame commutes with the gate: +\[ + G(D_vg_1,\ldots,D_vg_t)=D_vG(g_1,\ldots,g_t). +\] +The supplied input needs no preliminary change of frame: its logical +interpretation is defined by applying the inverse input frame. Thus the +intermediate frames cancel, and a route from input role $w$ to output +role $\rho(w)$ applies +$D_{\mathrm{sink}(\rho(w))}D_{\mathrm{source}(w)}^{-1}$, together with +its prescribed scalar sign. Undoing the role exchange and those signs +leaves the endpoint operator on every role array, including the roles +that carried auxiliary scalar values. + +For the bit procedure, that endpoint operator is an address shear: +two fields, written as vectors $H,D$ over a common residue ring, are +updated by $(H,D)\mapsto(H+D,D)$. Two further linear-cost address +updates complete their interchange. For the numerical procedure, the +endpoint operator becomes the simultaneous $H_0$ layer after diagonal +phase operations and a dyadic scale. The intermediate frames are chosen +so that every edge can be implemented by smaller calls to the same +procedure. + +The finite construction in Section~\ref{sec:finite-networks} attaches +subspaces of a fixed $m$-dimensional space to its gates and terminals. +The subspaces at adjacent vertices are nested. Their dimension changes +count the smaller operations needed on an edge, with an additional +source contribution in the bit construction. The construction uses +three-element subsets: gather and scatter create coefficients depending +on intersection size, and auxiliary wires cancel the unwanted +coefficients. Orthogonality of the corresponding indicator vectors permits +the subspace assignments. The decisive property is that the total +number $s$ of smaller calls satisfies $s0$, the division machine takes $x\#y$ +and returns $\operatorname{bin}_n(q)\#\operatorname{bin}_n(r)$, where +$q=\lfloor a/b\rfloor$ and $r=a-bq$. The square-root machine takes $x$ +and returns $\operatorname{bin}_n(\lfloor\sqrt a\rfloor)$. +Leading zeroes are allowed, and $\kappa$ is as in +Theorem~\ref{thm:main}. +\end{corollary} + +The classical Newton reductions described by +Brent~\cite[Lemmas 2.1--2.4]{Brent1976} compute reciprocal and +square-root approximations at geometrically increasing precisions. +Their multiplication costs are bounded by a geometric sum controlled by +the last precision, and exact remainder and square tests recover the +required integer answers. Section~\ref{sec:exact-arithmetic-proof} +gives the complete fixed-tape implementation. + +\input{sections/01-history.tex} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex new file mode 100644 index 0000000000..7c6f033138 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/01-history.tex @@ -0,0 +1,164 @@ + +\subsection{Historical context and inherited methods} + +Karatsuba's recursive construction, published jointly +with Ofman in 1962, gave a binary multiplication circuit of size +$O(n^{\log_2 3})$~\cite{KaratsubaOfman1962}. Toom's subsequent use of polynomial +evaluation and interpolation gave circuit size +$n\exp(O(\sqrt{\log n}))$, and hence $O(n^{1+\eta})$ for every fixed +$\eta>0$~\cite{Toom1963}. These early results were formulated in terms of +automata and logical networks. Cook adapted Toom's method to the +Turing-machine setting; the contemporary account of Sch\"onhage and +Strassen credits this adaptation explicitly +\cite[Section~1, p.~282]{SchonhageStrassen1971}. + +In the multitape Turing model, +Sch\"onhage and Strassen proved the bound +$O(n\log n\log\log n)$ in 1971~\cite{SchonhageStrassen1971}. +F\"urer improved it to $n\log n\,2^{O(\log^* n)}$ in 2007, with a full +journal account in 2009~\cite{Furer2007,Furer2009}; here $\log^* n$ counts +iterated logarithms until a constant threshold is reached. +De, Kurur, Saha and Saptharishi developed a modular-arithmetic route to +the same scale~\cite{DeKururSahaSaptharishi2013}. +Later improvements made the exponential factor $8^{\log^* n}$ and then +$4^{\log^* n}$~\cite{HarveyHoevenLecerf2016,HarveyHoeven2019Lattice}. +Harvey and van der Hoeven proved the unconditional +$O(n\log n)$ bound~\cite{HarveyHoeven2021}. + +The multitape bounds just cited concern that fixed model. Sch\"onhage obtained +linear-time multiplication on storage-modification machines~\cite{Schonhage1980}. +Groff later gave a smaller-than-$\log n$ factor in a unit-cost RAM model +with constant-time arbitrary memory access, after polynomial preprocessing +whose cost is excluded from that bound~\cite[Sections~2 and~4]{Groff2019}. +Neither result establishes the bound in the fixed finite-tape model of +Theorem~\ref{thm:main}. + +The transform methods behind these bounds also underlie the present +construction. Sch\"onhage--Strassen multiplication uses roots of unity in +Fermat-type residue rings, where certain multiplications become shifts. +F\"urer combines cheap polynomial roots of unity with more general roots, +reducing the frequency of expensive multiplications. Harvey and van der +Hoeven use Gaussian resampling to pass to multidimensional transforms with +power-of-two dimensions, then evaluate them using polynomial transforms +developed by Nussbaumer and Quandalle and subsequently by +Nussbaumer~\cite{NussbaumerQuandalle1978,Nussbaumer1980,HarveyHoeven2021}. +The Gaussian-gridding work of Dutt and Rokhlin is an earlier conceptual +precursor~\cite{DuttRokhlin1993}; Harvey and van der Hoeven discuss the +connection in~\cite[Section~4.4.3]{HarveyHoeven2021}. The quantitative +resampling and bit-cost estimates used here are those of the latter paper. + +More specifically, the proof adapts Harvey and van der Hoeven's +Gaussian-resampling identity, contraction bounds, and short-convolution +procedures~\cite[Theorem~4.2, Proposition~4.7 and Lemmas~4.8--4.12]{HarveyHoeven2021}. +Their framework already permits arbitrary dimension. Here the source and +target permutations remain in the transform identity, while the faster tape +procedures perform the required axis movements. Bluestein's conversion to +convolution~\cite{Bluestein1970} and the synthetic-root convolution algorithm +are retained; the latter follows the polynomial-transform construction +in~\cite[Section~2.4 and Section~3]{HarveyHoeven2021}. Signed coefficient +packing is a form of Kronecker substitution, with the fixed-tape version +of~\cite[Lemma~2.5]{HarveyHoeven2021} as a direct antecedent. +Calls to the established $O(n\log n)$ multiplier are ordinary subroutine +calls; they do not invoke the improved theorem recursively. + +\subsection{The finite-network ingredients} + +The subset-intersection construction in Section~\ref{sec:finite-networks} +has an earlier source outside multiplication. Alon's presentation of the +Frankl--Wilson construction~\cite{FranklWilson1981} gives low-degree +representations of complementary intersection graphs over different fields +\cite[Section~3, remark after the proof of Theorem~1.1]{Alon1998}. +At the prime $p=2$, its subsets have size three and the two polynomial evaluations +are the intersection count modulo two and the intersection count minus one. +These are the two pairing formulas used here. We change the ground-set +size and express the second pairing through a rational bilinear form. + +The gather and scatter operations, together with the side wires, have the +form of linear index-code decoding: a low-rank linear summary gives the +wanted coordinate plus contributions from known neighboring coordinates, +and those contributions are subtracted. Bar-Yossef, Birk, Jayram and Kol +establish the fitting-matrix formulation and this decoder +\cite[Section~3, proof of Theorem~5]{BarYossefBirkJayramKol2006}. +Lubetzky and Stav treat decoding over other fields and use related +intersection representations to separate their possible ranks +\cite[Proposition~2.1 and Section~2.3]{LubetzkyStav2009}. +These comparisons explain the algebraic role of the two fields here; +they do not supply the subspace labels on the subsequent network. + +Restoring scratch registers with arbitrary initial contents also has a +precise precedent. The transparent-computation construction of Buhrman, +Cleve, Kouck\'y, Loff and Speelman subtracts an initial register value, +performs a computation, adds the resulting value, and reverses the +computation~\cite[Section~3]{BuhrmanCleveKouckyLoffSpeelman2014}. +Our scratch schedule is the linear-readout version of that construction. +The rank reduction used for address shears is a singular-matrix Bruhat +factorization: after reversing the coordinate order, Grigor'ev's +upper-triangular factors become the two lower-triangular factors needed +here~\cite[Appendix~A.2, Proposition~14(c)]{Grigoriev1982}. + +The finite networks and their labels are proved directly in +Section~\ref{sec:finite-networks}. The additional requirements are the +three-stage bank exchange, nested subspaces with a strict total rank or +dimension deficit, and endpoint frames acting on every role. The tape +implementations then turn that deficit into the volume-normalized +recurrences of Sections~\ref{sec:tape-interchange} +and~\ref{sec:fast-butterfly-layers}, including the costs of addressing, +padding, coefficient growth, and finite precision. The cited decoding, +restoration, and factorization results provide ingredients; these further +properties are established in the present proof. + +\subsection{Lower-bound scope and matrix transposition} + +Sch\"onhage and Strassen conjectured $n\log n$ as the optimal order of +multiplication cost~\cite[Section~1]{SchonhageStrassen1971}. In the present +fixed-tape model, an eventual lower bound for every multiplication machine means that, for +each fixed machine $A$, there are constants $c_A>0$ and $N_A$ such that +$T_A(n)\ge c_A n\lg n$ whenever $n\ge N_A$. +Its negation requires one machine satisfying +$\liminf_{n\to\infty}T_A(n)/(n\lg n)=0$. +The power saving proved here gives a limit of zero through all input lengths, +which is a stronger conclusion. + +Harvey and van der Hoeven consider a binary transposition machine +supplied an integer $m\ge1$ and a $k\times k$ binary matrix, where +$k=\lfloor\sqrt m\rfloor$. They proved that if every fixed such machine +has worst-case cost $\Omega(m\lg m)$ through all sufficiently large +supplied values of $m$, then every fixed multiplication machine has the +corresponding eventual lower bound~\cite[Theorem~1.2]{HarveyHoeven2025}. +Combining their quantitative reduction~\cite[Corollary~6.2]{HarveyHoeven2025} +with Theorem~\ref{thm:main} gives a deterministic fixed-tape algorithm +that transposes a row-major $k\times k$ binary matrix in +$O(k^2(\lg k)^{1-\kappa})$ time, with $\kappa$ as in +Theorem~\ref{thm:main}. Section~\ref{sec:transposition} proves the more +general rectangular-matrix bound. + +This comparison concerns unrestricted computation on a fixed number of +one-dimensional tapes. Our address procedure forms XOR combinations of +intermediate data, even though its final effect is a permutation. +It therefore lies outside models restricted to moving data without such +computations; see~\cite[Section~1.4]{HarveyHoeven2025} for the distinction. + +\subsection{Companion application to exact Fourier transforms} + +The complex phase network of Proposition~\ref{prop:complex-motif-interface} +is also used in the companion manuscript~\cite[Section~1.1, Theorem~1.1 +and Corollary~1.2]{OpenAIExactDFT2026}. That manuscript gives a single +algorithm for the exact discrete Fourier transform at every positive +transform length $n$. As $n\to\infty$, its cost is +$O(n(\log n)^{1-10^{-13}})=o(n\log n)$. + +The cost is measured in an exact complex-register model that assigns unit +cost to exact complex field operations. The algorithm accepts every +$x\in\mathbb C^n$, with no bound on its entries or on intermediate complex +magnitudes. Its computation on the input uses only addition, subtraction, +and multiplication by prepared input-independent scalars. The magnitudes +of those scalar coefficients are unrestricted as well. + +Integer operations and random access on $O(\log(n+2))$-bit words have unit +cost, with a fixed number of words for each address or integer. The model +supplies one specified Fourier root $\zeta_{D_*}$ of explicitly computable +order $D_*<1024n^3$. Scalar preparation, schedule construction, and index +work are charged. This is a separate application of the finite network, +with its own uniform array implementation. It is neither a bit-complexity +consequence nor a stable floating-point FFT consequence of the fixed-tape +multiplication theorem, Theorem~\ref{thm:main}. diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex new file mode 100644 index 0000000000..088fceea18 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/02-streams.tex @@ -0,0 +1,208 @@ +\section{The machine model and elementary streams} +\label{sec:streams} + +A machine has one fixed finite alphabet and one fixed finite number of +one-dimensional tapes. A step reads and writes at most one cell on each +tape and moves each head by at most one cell. Fixed tracks and finitely +many work tapes change time by a fixed factor. We distinguish moving one +digit in a fixed radix, which needs a bounded number of scans, from +interchanging fields whose numbers of digits grow. The latter permutation +will be realized in Section~\ref{sec:tape-interchange} by computing XOR +combinations of intermediate data streams. The present section supplies +the elementary scans it uses. Every scan includes its counters and the +return of its tape heads. + +\subsection{Array order and elementary scans} + +For a positive integer $a$ write $[a]=\{0,\ldots,a-1\}$. +An array with address set $[a_1]\times\cdots\times[a_t]$ is stored in +lexicographic order, with the first coordinate most significant. Its +entries are bits unless a record width is specified. A trailing record +of $B$ bits can equivalently be regarded as a final address field $[B]$. +An address is implicit in an entry's position in this ordered stream; it +is not stored beside every data bit. +The \emph{logical volume} $V$ is the number of stored data bits. Work +tapes and duplicate streams are charged in time but do not increase $V$ +in recurrences. All the fields discussed below are nonempty. A call +with an empty array is handled directly. + +An address permutation $f$ moves the entry at $x$ to $f(x)$. Thus its +action on an array $A$ is $(fA)(f(x))=A(x)$. Adjacent fields which are +irrelevant to an operation may be replaced by a single field whose length +is their product. In particular, the elementary procedures below have a +fixed number of formal address fields even when a surrounding algorithm +has a growing list of coordinates. Lengths and positions are supplied in +canonical binary on descriptor tapes; no additional tape head is attached to an +address coordinate. Each elementary call receives a fixed number of +collapsed canonical lengths. Constructing them from a longer surrounding +list is work of the caller; recursive calls below construct their own +collapsed descriptors within their stated bounds. + +When one address field is designated as a row field, collapse the fields +before it to a prefix $[P]$ and those after it to a suffix $[B]$. If the +row field has range $[R]$, a \emph{row} at prefix $p$ and row index $r$ +is the complete consecutive block $\{p\}\times\{r\}\times[B]$. +Every row therefore contains $B$ bits in the same suffix order. + +For headers that concatenate a list of positive integer parameters, we use +the self-delimiting code +\begin{equation} + b_v=\lfloor\log_2v\rfloor+1,\qquad + \Gamma(v)=0^{b_v-1}\operatorname{bin}_{b_v}(v),\qquad + |\Gamma(v)|=2b_v-1\quad(v\ge1). + \label{eq:integer-descriptor-code} +\end{equation} +The initial zeroes specify how many further bits follow the first one, +so concatenated codes can be read in order. We use this code when an +interface specifies a header; elementary calls still receive the fixed +number of canonical binary lengths described above. + +\begin{lemma}[Elementary stream operations] +\label{lem:elementary-streams} +Fix a radix $q\ge2$. Each of the following operations on an array of +volume $V$ takes $O(V)$ steps on a fixed number of one-dimensional tapes: +\begin{enumerate} +\item any fixed permutation of the pair of digit values at two specified +radix-$q$ positions, whether or not the positions are adjacent; +\item moving one specified radix-$q$ digit to another position, preserving +the order of the intervening positions; +\item splitting on a specified radix-$q$ digit, applying a fixed +pointwise map to aligned streams, and merging them back; +\item for positive integers $P,R,B$, within each prefix of an array on +$[P]\times[R]\times[B]$, splitting +whole rows cyclically into a fixed number $W$ of streams, and, when $W$ +divides $R$, merging those streams in any fixed order of the row classes. +\end{enumerate} +The bounds include shape preparation, counter initialization and resets, +and returning or clearing the visited portions of work tapes. Their +constants may depend on the fixed radix, the fixed pointwise map, and the +fixed number of row classes. +\end{lemma} + +\begin{proof} +For the first operation split into $q^2$ streams according to the two +specified digits. With these digits fixed, the order of all remaining +digits is unchanged by the permutation. Enumerate output addresses in +their required order and read the stream prescribed by the two preimage +digits. For a digit move use $q$ streams instead. The same observation +shows that splitting on one digit gives streams with the same remaining +address set in the same order. Scan their aligned entries, apply the +fixed pointwise map, and merge according to the output digit; this proves +the third operation. For the fourth, write $r=Wg+w$, where +$0\le w1$. +The same argument gives a unit vector in $Q^\perp$ when it is nonzero. +A triple complement, and the complement of two neighboring triple +lines, contain coordinate units outside supports of sizes at most +three and six, respectively. Full tensor spaces contain coordinate +units as well. In each nonzero tensor summand, tensoring these chosen +norm-one vectors gives a norm-one vector; placing it in that orthogonal +summand gives one in the whole residual. Each residual is nondegenerate +by the decompositions above. Thus every nonzero residual is nonalternating. + +For completeness, every nondegenerate nonalternating binary symmetric +space has an orthonormal basis. Split off unit lines until the +remaining space is alternating. A nonzero nondegenerate alternating +space splits into planes with bases $a,b$ satisfying +$a\cdot a=b\cdot b=0$, $a\cdot b=1$; this follows by choosing a +nonzero $a$, choosing $b$ with $a\cdot b=1$, and taking the orthogonal +complement of their nondegenerate plane. Retain one unit vector $w$ +from the lines already split off. A plane orthogonal to $w$ can be +absorbed into that line: the three vectors +\[ + w+a,\qquad w+b,\qquad w+a+b +\] +are independent, pairwise orthogonal, and have norm one. +Use one of these new unit vectors in place of $w$ for the next plane; +the remaining planes are still orthogonal to it. Repeating this +operation absorbs every alternating plane. +\end{proof} + +The loss ratios have the exact values +\[ + \frac{L_{\rm b}}{N}=\frac{100}{539},\qquad + \frac{L_{\rm c}}{N}=\frac{101}{539}. +\] +In particular, both are smaller than $1/2$. We now turn the dimension +count into the two interfaces needed later. + +\subsection{The rational matrix interface} + +For a nondegenerate rational subspace $U\subset\mathcal F$, write +$P_U$ for the projection onto $U$ along $U^\perp$. Assign $P_U$ to +each gate or sink with label $U$. Assign the source matrix $-P_{U_a}$ +to $X_a$ and zero to every other source. +These are fixed rational $m\times m$ matrices; write $M_v$ for the matrix +at vertex $v$. Define +$\rho(X_a)=Y_a$, $\rho(Y_a)=X_a$, and let $\rho$ fix every auxiliary +wire. + +In the tape application, two address chunks are written as vectors $H,D$ +of $m$ fields. For a matrix $M$, the frame $\Phi_M$ moves the array entry +at $(H,D)$ to $(H+MD,D)$, leaving the other address fields unchanged. +The fields use a radix coprime to the fixed denominators, and addition is +modulo their common range. Hence $\Phi_M$ is an invertible +$\mathbb F_2$-linear permutation of array entries, and +$\Phi_{M'}\Phi_M=\Phi_{M'+M}$. Using $D_v=\Phi_{M_v}$ +in \eqref{eq:common-frame-identity}, the endpoint matrix difference on each +routed role is exactly the shear applied to that role. The following identity +makes it the same shear $H\gets H+D$ on every role; +Section~\ref{sec:tape-interchange} turns that shear into a field interchange +and implements an edge change with one smaller interchange per unit of its +rational rank. + +\begin{proposition}\label{prop:bit-motif-interface} +The bit network has $W_{\rm b}$ wires, uses only pointwise XOR gates, +and sends its input vector to the permutation $\rho$ of that vector. +Its rational matrices are common to all incidences of a gate and obey +\[ + M_{\mathrm{sink}(\rho(w))}-M_{\mathrm{source}(w)}=I_m + \quad\text{for every input role }w. +\] +The sum of the rational ranks of all edge differences is +\begin{align} + s_{\rm b} + &=\sum_{e}\operatorname{rank}_{\mathbb Q} + (M_{\mathrm{head}(e)}-M_{\mathrm{tail}(e)})\\ + &=W_{\rm b}m-N+2L_{\rm b} + =1771765690887858612870000000$. + +For an input $X_a$ the endpoint difference is +$P_{U_a^\perp}-(-P_{U_a})=I_m$. Every other role has zero source +matrix and identity sink matrix. This proves the interface. +\end{proof} + +\subsection{The binary phase interface} + +Use the complex scalar network and binary labels. For a binary vector +$x$, let $\operatorname{wt}(x)$ denote its integer Hamming weight, and +write $[b]\in\{0,1\}$ for the integer representative of $b\in\mathbb F_2$. +For a label $U$, let +\[ + q_U(x)=\operatorname{wt}(P_Ux)\pmod4. +\] +The projection here is over $\mathbb F_2$. +Let +\[ + H=\frac1{\sqrt2}\begin{pmatrix}1&1\\1&-1\end{pmatrix},\quad + C=H\begin{pmatrix}1&0\\0&i\end{pmatrix}H + =aI+bX,\qquad a=\frac{1+i}{2},\quad b=\frac{1-i}{2}, +\] +where $X$ interchanges the two coordinates. On functions of +$x\in\mathbb F_2^m$ define +\[ + \mathcal C_U=H^{\otimes m}\operatorname{diag}_x(i^{q_U(x)})H^{\otimes m}. +\] +The use of $H$ in this definition is an identity of matrices. Each entry +of $\mathcal C_U$ and its inverse is a Gaussian integer divided by $2^m$, +so both preserve arrays over $\mathbb Z[i,1/2]$. The kernels implemented +below have Gaussian dyadic coefficients. + +To apply the scalar network to these functions, replace the scalar on +each wire $w$ by an array +$f_w:\mathbb F_2^m\to\mathbb Z[i,1/2]$. At each address, a gate +applies its scalar linear map to the values on the wires it touches. +The frame in \eqref{eq:common-frame-identity} is $D_v=\mathcal C_U$ at a +vertex with label $U$. On an edge from label $U$ to label $V$, apply +$\mathcal C_V\mathcal C_U^{-1}$ to that wire's array. +All frames are diagonalized by the same matrix $H^{\otimes m}$. +For an integer $k\ge1$, an address for $k$ columns is +$(x^{(1)},\ldots,x^{(k)})\in(\mathbb F_2^m)^k$; every frame and edge +operator is then the tensor product of its one-column version over +these $k$ coordinates. Each scalar gate is still applied once at each +joint address, to the vector of values on the roles it touches. + +\begin{proposition}\label{prop:complex-motif-interface} +For each edge of the complex network, write $U,V$ for its tail and +head labels. Its phase-frame difference +$\mathcal C_V\mathcal C_U^{-1}$ is a product of one translation +kernel $aI+bX_v$, or its inverse, per vector in an orthonormal basis +of the edge residual. Here $(X_vf)(x)=f(x+v)$. +The sum of these basis lengths is +\[ + s_{\rm c}=W_{\rm c}m-2N+2L_{\rm c} + =18738072446366712673080000000$. + +For an edge $e$, write $\mathcal B_e$ for its residual basis and +$K_{e,v}$ for the forward or inverse translation kernel associated +with $v\in\mathcal B_e$. Taking tensor products preserves their +product, so on $k$ columns +\[ + \bigl(\mathcal C_V\mathcal C_U^{-1}\bigr)^{\otimes k} + =\prod_{v\in\mathcal B_e}K_{e,v}^{\otimes k}. +\] +Thus each residual vector contributes one factor acting on all $k$ +columns, and there are $s_{\rm c}$ such factors over the network. + +Let $\rho$ denote the underlying permutation of the complex roles: it +exchanges $X_a,Y_a$ and fixes each scratch role. +By Lemma~\ref{lem:scalar-motifs}, the pointwise scalar network sends an input array at +$X_a$ to $Y_a$ with sign $+1$, an input at $Y_a$ to $X_a$ with sign +$-1$, and each scratch input to its own output with sign $+1$. +Applying \eqref{eq:common-frame-identity} with $D_v=\mathcal C_{U_v}$, +where $U_v$ is the label at vertex $v$, shows that an input role $w$ reaches +output role $\rho(w)$ with that sign and with operator +$\mathcal C_{U_{\mathrm{sink}(\rho(w))}} + \mathcal C_{U_{\mathrm{source}(w)}}^{-1}$. +For $k$ columns, use $D_v=\mathcal C_{U_v}^{\otimes k}$ on the joint +address set in the same identity. The route operator is then the $k$th +tensor power of the displayed address operator, multiplied by its scalar +route sign once. +The zero label has frame $I$, while the full label has frame +$C^{\otimes m}$ because $q_{\mathcal F}(x)=\operatorname{wt}(x)$. +Every pair except $X_a\to Y_a$ has these zero and full labels. +For the remaining pair, write $u=u_a$. Its binary norm is one and +its weight is $3^3=27$. Orthogonal weight additivity yields +\begin{align*} + q_{U_a^\perp}(x)-q_{U_a}(x) + &=\operatorname{wt}(x)-2\operatorname{wt}(u)[u\cdot x]\\ + &=\operatorname{wt}(x)+2[u\cdot x]\pmod4. +\end{align*} +Since $2[u\cdot x]\equiv2\sum_{j\in\operatorname{supp}(u)}x_j +\pmod4$, the operator on $X_a\to Y_a$ is the tensor of $C^{-1}$ on the +27 coordinates of $\operatorname{supp}(u)$ and $C$ elsewhere. +Put $Z=\operatorname{diag}(1,-1)$. Direct multiplication gives +\[ + C=iZC^{-1}Z,\qquad C^{-1}=-iZCZ. +\] +For $k$ columns, let $Z_{a,k}$ be the tensor product of $Z$ on +those 27 coordinates in every column and the identity elsewhere. +Apply $Z_{a,k}$ before the network at $X_a$, and apply +$i^{27k}Z_{a,k}$ after the network at $Y_a$; the latter scalar is +applied once to the whole role. There are $27k$ inverse factors, so +the identity $C=iZC^{-1}Z$ turns each of them into $C$. The operator +on this pair is therefore $C^{\otimes mk}$ as well. +Only the physical $X$ outputs still carry the minus sign of the +scalar exchange. Negate those outputs and send output role $\rho(w)$ +back to role $w$. Every role, including every scratch role, now has +the required forward tensor product. +\end{proof} + +\subsection{Explicit rational bounds for the two recurrences} + +The relative rank deficits are +\[ + \eta_{\rm b}=\frac{W_{\rm b}m-s_{\rm b}}{W_{\rm b}m} + =\frac{339}{22587335000000},\qquad + \eta_{\rm c}=\frac{W_{\rm c}m-s_{\rm c}}{W_{\rm c}m} + =\frac{73}{19906842167500}. +\] +For both recurrences we may use the fixed rational exponent +\begin{equation} + \tau=\sigma=1-2^{-50}. + \label{eq:explicit-motif-exponents} +\end{equation} +Both exact deficits displayed above are greater than $20\cdot2^{-50}$. +Since $m<2^{20}$ and $\log 2<1$, we have $\log m<20$, whence +\[ + m^{1-2^{-50}} + =m\exp(-2^{-50}\log m) + >m(1-20\cdot2^{-50})>m(1-\eta) +\] +for either $\eta=\eta_{\rm b}$ or $\eta=\eta_{\rm c}$. +Consequently +\[ + \frac{s_{\rm b}}{W_{\rm b}}0$, write each chunk as $m$ +consecutive $b=e/m$ digit fields, giving vectors $H,D$ over +$\mathbb Z/q^b\mathbb Z$. We first construct the shear $H\leftarrow H+D$. + +Split whole rows cyclically into $W$ role streams within each prefix +preceding the row field. Write the original row number as +$r=Wg+(w-1)$ with $1\le w\le W$; stream $w$ has row number $g$. +These streams have exactly the same remaining shape, including the +full ranges of $H$ and $D$. Each has +logical volume $V/W$, and its row count is divisible by $W^{k-1}$. + +For a rational matrix $M$, let $\Phi_M$ act on an array by moving its +entry at address $(H,D)$ to $(H+MD,D)$, with every spectator unchanged. +Thus $\Phi_M$ is the array permutation induced by that address map. +Its inverse is $\Phi_{-M}$ and +$\Phi_{M'}\Phi_M=\Phi_{M'+M}$. On every circuit edge apply +$\Phi_{A_e}$ to that role stream; implement it by +Lemma~\ref{lem:matrix-shear}, recursively interchanging each pivot pair +of $b$-digit fields. Execute each circuit gate pointwise at matching +addresses of its role streams. + +The row split supplies the common address set used in the +frame identity~\eqref{eq:common-frame-identity}. Here the frame at a +vertex with matrix $M$ is the address permutation $\Phi_M$, and every +edge changes it by $\Phi_{M'-M}$. The same invariant proof applies +because a common address permutation commutes with every pointwise +bit gate. For the physical input arrays $f_w$, the logical arrays are +$g_w=\Phi_{-M_{\mathrm{in}(w)}}f_w$; this only specifies their +interpretation, with no initial tape operation. The logical circuit +routes $g_w$ to role $\rho(w)$. Thus its physical output satisfies +\[ + f'_{\rho(w)} + =\Phi_{M_{\mathrm{out}(\rho(w))}} + \Phi_{-M_{\mathrm{in}(w)}}f_w + =\Phi_{I_m}f_w, +\] +by~\eqref{eq:finite-shear-contract}. Merge by returning row $g$ of +output role $\rho(w)$ to the original row $Wg+(w-1)$ within the same +preceding prefix. This undoes $\rho$ and restores row order. The result +is $H\leftarrow H+D$ on every original row, including rows assigned +to scratch roles, whose initial values were arbitrary. + +To interchange the two full chunks, perform +\[ + D\leftarrow D-H,\qquad H\leftarrow H+D,\qquad D\leftarrow H-D, +\] +componentwise. Only the middle shear uses the circuit. The other two +updates target the later group and have linear cost. The transformation +sends $(H,D)$ to $(D,H)$. + +The number of recursive calls is the sum of the edge ranks, exactly $s$. +Each acts on one role stream of volume $V/W$, retaining all other +fields as spectators. Splitting, +merging, gates, and triangular operations have total cost $O(V)$ because +their number is fixed. Below we verify that scheduling the recursive +calls on fixed tapes also costs $O(V)$ at this node. Thus if $F_k$ is a +uniform upper bound for time divided by logical volume, then +\begin{equation} +\label{eq:swap-recurrence} + F_0=O(1),\qquad F_k\le(s/W)F_{k-1}+O(1). +\end{equation} +For $a=s/W1$, it is $O(a^k)$. +Hence $F_k=O(e^\tau)$. + +\paragraph{A fixed-tape depth-first schedule.} +Here we complete the implementation assertion used in +\eqref{eq:swap-recurrence}. Reserve $W$ role tapes, a fixed set of +I/O and elementary-operation work tapes, one parking stack tape, and a +separate descriptor stack. Although $W$ is large, it is fixed. +At a call boundary all reusable work tapes, other than the current I/O +and local descriptor, are empty and their heads are at their origins. +The parking and descriptor heads are at the tops of their stacks. + +Before a recursive call, append the $W-1$ inactive role streams to the +parking stack in a fixed order, with separators. Copy the active stream +to the child I/O area, and erase the parent role tapes while traversing +their current contents. Push the parent descriptor and its finite +program counter to the descriptor stack. The role and work tapes are +now available to the child, using the same tapes at every depth. +On return, copy the child output into the designated active role. +Pop the inactive streams in reverse order. To recover a stream in its +original direction, prepare its destination to the known length and +write the popped symbols from the destination's right end toward its +left end. Erase the popped stack cells as they are left. This uses +linear time and ends with the parking head at the previously saved top. +No scan passes through a parked ancestor. Cleanup is always limited to +the region visited by the current call; a reused tape is not swept to +the largest position ever visited by an ancestor. + +Each push, pop, copy, positioning operation, or erasure moves $O(V)$ +symbols at a parent node. There are only the fixed number $s$ of child +calls. This gives precisely the additional $O(V)$ term claimed above, +even though each child itself has volume $V/W$. Temporary storage is +therefore not substituted for logical volume in the factor $s/W$. + +For completeness, descriptor processing also fits this term when the +payload is one bit. Let $V_0$ be the volume at the root of one +power-width call with width $e_0=m^{k_0}$, and $V_j=V_0/W^j$ the volume +of any depth-$j$ child. Here $j\le k_0=\log_m e_0$. The root row +count is at least $W^{k_0}$, so at depth $j$ it is still at least one. +Both original chunk ranges remain present: digits outside the current +subchunks become spectators rather than being removed. Hence +\[ + V_j\ge q^{2e_0},\qquad + j\log W\le(\log_m e_0)\log W=O(e_0)=O(\log V_j). +\] +It follows that +$\log V_0=\log V_j+j\log W=O(\log(2V_j))$. +A local descriptor lists the row field, at most the current $m+m$ +fields, and a fixed number of intervals formed from intervening +spectator fields. Computing products of their lengths, subdividing +target fields, copying lengths, and storing the current instruction take +$(\log(2V_0))^{O(1)}=O(V_j)$ time at that child, since every fixed +power of $\log(2V_j)$ is $O(V_j)$. Before descending, +construct the child's descriptor by retaining its two target fields and +combining each consecutive group of spectator fields into one interval. +The ancestor's subdivision need not remain active in the child. Stack entries contain +finite instructions and binary integers, not new alphabet symbols. +These observations establish one finite machine for every recursion +depth and every choice of spectator lengths. + +\end{proof} + + +We use the rational value $\tau=1-2^{-50}$ established in +\eqref{eq:explicit-motif-exponents}. Its verification uses fixed integer +comparisons and the displayed exponential inequality; it needs no +real-arithmetic oracle. + + +\subsection{Removing width and row restrictions} + +We have proved the fast operation for power widths with enough rows. +Rows for a general array can be supplied by a few of its own high digits. +Their movement will cost less than the final bound. + +\begin{lemma}[Arbitrary-width interchange] +\label{lem:chunk-swap} +There exist fixed $0<\tau<1$ and one fixed finite-alphabet multitape +procedure with the following property. For positive integers $P,G,B$ +and $u\ge1$, it transforms an arbitrary bit array on +\[ + [P]\times[2^u]\times[G]\times[2^u]\times[B] +\] +by the address permutation +\[ + (p,h,g,d,z)\longmapsto(p,d,g,h,z) +\] +in $O(Vu^\tau)$ steps, where $V=PG B\,2^{2u}$. +The integers specifying the shape are part of the input. The time +includes their processing, all padding and unpadding, and fixed-tape +workspace cleanup. In particular, $B=1$ is allowed. +\end{lemma} + +\begin{proof} +First suppose the two ranges are $[q^e]$, where $q$ is the fixed prime +already chosen. Set +\[ + k=\lceil\log_m e\rceil,\qquad + \rho=\left\lceil\frac{k\log W}{2\log q}\right\rceil. +\] +For all sufficiently large $e$, $1\le\rho0,\quad 0<\epsilon<1. +\] +The exponents and comparison constants are fixed, and we impose their +further restrictions in Proposition~\ref{prop:simultaneous-layer}. +Two consequences explain the layout. The polynomial length $r$ grows +faster than every fixed power of $p$, so a scan of a record pays for +polynomial work on its address. Also $K/\log p\to\infty$, which will +make the exceptional set in a packed change of address bits small enough +to repair by sorting. We will obtain cost $O(Vd^{\lambda'})$, with +$\lambda'<1$ and $V$ the logical bit volume, whereas separate butterfly +factors would require $D$ whole-array passes. + +We first construct tensor products of the auxiliary two-point kernel +$C$ from Proposition~\ref{prop:complex-motif-interface}. Its phase +frames express a $C$ tensor product using smaller groups of +selected bits, separated by binary changes of basis. We implement those +changes by moving whole address chunks. Splitting complete rows among +the network's wire roles then reduces the volume of each recursive +call. Finally, we bound the intermediate dyadic values and convert the +completed $C$ layer to the normalized $H_0$ layer. The entire layer is +evaluated exactly before one final truncation. + +\subsection{Phase frames for a simultaneous butterfly layer} +\label{subsec:phase-frames} + +Hold the unselected address bits fixed and regard the stored complex +values on one wire role as a function of the selected bits. The phase +identities below express an edge's residual operator as a product of +two-point kernels on selected directions. + +Put +\[ + H_0=\frac12\begin{pmatrix}1&1\\1&-1\end{pmatrix},\qquad + H=\sqrt2 H_0,\qquad \mathsf S=\operatorname{diag}(1,i),\qquad + Z=\operatorname{diag}(1,-1). +\] +For the bit-flip matrix $X=\bigl(\begin{smallmatrix}0&1\\1&0\end{smallmatrix}\bigr)$, +define +\begin{equation}\label{eq:phase-C} + C=H\mathsf SH=aI+bX,\qquad a=\frac{1+i}{2},\quad b=\frac{1-i}{2}. +\end{equation} +Direct multiplication gives +\begin{equation}\label{eq:phase-basic-identities} + H_0=b\mathsf SC\mathsf S,\qquad C^2=X,\qquad C^4=I,\qquad + C^{-1}=bI+aX=-iZCZ. +\end{equation} +In particular, $C=iZC^{-1}Z$. These identities use only Gaussian dyadic +coefficients. The Hadamard matrices in the definition of +$\mathcal C_U$ are used to prove identities; they need not be executed +by the machine. + +Consider an edge from label $U_-$ to label $U_+$, and choose an +orthonormal basis $v_1,\ldots,v_{\rho_{\rm edge}}$ of its residual. +Proposition~\ref{prop:complex-motif-interface} gives the frame change +\[ + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\prod_{j=1}^{\rho_{\rm edge}}(aI+bX_{v_j})^{\epsilon_j}, + \qquad \epsilon_j\in\{1,-1\}. +\] +Here $(X_vf)(x)=f(x+v)$, and we write $C_v=aI+bX_v$. +The number of directional kernels is precisely +$\rho_{\rm edge}$, including on decreasing edges. The next step puts those directions +into coordinate positions without performing a general transpose. + +\paragraph{Implementing an arbitrary residual basis.} +For $M\in\operatorname{GL}(m,\mathbb F_2)$, let $\mathcal P_M$ be the +address permutation that moves the value at $x$ to $Mx$. Thus +$(\mathcal P_Mf)(x)=f(M^{-1}x)$, and +\begin{equation}\label{eq:phase-conjugation} + \mathcal P_MX_v\mathcal P_M^{-1}=X_{Mv}. +\end{equation} +Extend $v_1,\ldots,v_{\rho_{\rm edge}}$ to a basis of $\mathbb F_2^m$ and take these vectors as +the first $\rho_{\rm edge}$ columns of $M$. The displayed edge identity +then becomes +\begin{equation}\label{eq:phase-edge-coordinate} + \mathcal C_{U_+}\mathcal C_{U_-}^{-1} + =\mathcal P_M\left(\prod_{j=1}^{\rho_{\rm edge}}C_{e_j}^{\epsilon_j}\right) + \mathcal P_M^{-1}, +\end{equation} +where $e_j$ is the $j$th standard basis vector. The matrix $M$ need not +preserve the dot product: equation~\eqref{eq:phase-conjugation} only +uses its invertibility. + +For the array layout used below, take a group of $e=mf$ consecutive +axis chunks and divide it into $m$ consecutive slots of $f$ chunks, +numbered in physical order. +Number the chunks within each slot by $j=0,\ldots,f-1$, starting at +its least significant end. Write $x_{h,j}$ for the selected bit in +chunk $j$ of slot $h$, where $1\le h\le m$. Column $j$ is the vector +$(x_{1,j},\ldots,x_{m,j})$. A frame on this group is the tensor +product of the same phase frame +$\mathcal C_U$ of Proposition~\ref{prop:complex-motif-interface} +on these $f$ columns. + +To implement \eqref{eq:phase-edge-coordinate} on the group, first apply +$\mathcal P_M^{-1}$ separately to each column. For each +$1\le h\le\rho_{\rm edge}$, apply $(C^{\epsilon_h})^{\otimes f}$ to the +$f$ bits $x_{h,0},\ldots,x_{h,f-1}$. This is one child operation +on the $f$ axes in slot $h$. Finally apply $\mathcal P_M$ to every +column. A negative directional kernel still requires only one +forward child, because +\begin{equation}\label{eq:phase-inverse-child} + (C^{-1})^{\otimes f} + =(-i)^f Z^{\otimes f}C^{\otimes f}Z^{\otimes f}. +\end{equation} +The rightmost phase is applied first. All inverse wrappers are address +signs and constant fourth-root phases, so they add no recursive calls. + +Gaussian elimination expresses any $M\in\operatorname{GL}(m,\mathbb F_2)$ +as a product of at most $m(m-1)+3m$ elementary row additions: one clears +at most $m-1$ other entries per pivot, and each row swap is three row +additions. Reversing the elimination gives the required product since +each row addition is an involution. The number is a constant because +$m$ is fixed. Adding row $h'$ to row $h$ in every column applies +$x_{h,j}\leftarrow x_{h,j}\mathbin\oplus x_{h',j}$ for every +$0\le j1$, these segments +are disjoint, and the highest one ends immediately below $j_{f-1}$. +Write their initial values in $y$ and $z$ as +\[ + u_i=2g_i+a_i,\qquad w_i=2h_i+b_i, + \qquad a_i,b_i\in\{0,1\}. +\] +The values $g_i,h_i\in\{0,\ldots,2^{K-1}-1\}$ are the guard values. The +control for this pair of segments is the selected bit $c_i=x_{j_i}$. + +Apply each line of \eqref{eq:eight-packed-additions} simultaneously to all +these segment pairs. Physically, a line updating $y$ by sign $\varepsilon$ +and testing parity $b$ of $z$ is the single cyclic shift +\begin{equation} +\label{eq:packed-cyclic-shift} + y\longleftarrow y+ + \varepsilon\sum_{i=0}^{f-2}2^{j_i} + [\,x_{j_i}=1\,][\,z_{j_i}=b\,] + \pmod{2^L}. +\end{equation} +For a line updating $z$, interchange $y$ and $z$ in this formula. +The shift offset never depends on its target chunk, so each line is a +bijection of the rectangle. Let $S_0$ be their composition. It fixes +the spectator coordinates. + +Let $\mathcal B$ consist of the addresses for which +at least one used guard value, in either $y$ or $z$, fails +\begin{equation} +\label{eq:packed-guard-interval} + 10\le g\le 2^{K-1}-11. +\end{equation} +At an address outside $\mathcal B$, each segment initially lies in +$[20,2^K-21]$. Even displacement eight keeps it inside +$[0,2^K-1]$. Inductively, each packed addition therefore agrees with all +the independent segment additions: no segment carries into or borrows +from the next segment. When $f>1$, the bits below $j_0$ and above the +highest used segment are untouched as well. By +\eqref{eq:eight-packed-result}, $S_0$ +then agrees with the ideal permutation $T_0$ that performs the required +XORs at $j_0,\ldots,j_{f-2}$ and fixes all other address coordinates. + +There are exactly twenty excluded values for each guard in +\eqref{eq:packed-guard-interval}. Since its complete range has +$2^{K-1}$ values, the union bound over the $2(f-1)$ guards gives +\begin{equation} +\label{eq:packed-bad-fraction} + |\mathcal B|\le\delta_{\rm bad}M. +\end{equation} +Indeed, the complete $y,z$ ranges give the same guard distribution at +each choice of spectator coordinates. No record value enters this count. + +The ideal map $T_0$ preserves all guard values and therefore preserves +$\mathcal B$. Both $T_0$ and $S_0$ are bijections, and they agree off +$\mathcal B$. Taking complements in the finite rectangle gives +\[ + S_0(\mathcal B^c)=T_0(\mathcal B^c)=\mathcal B^c, + \qquad S_0(\mathcal B)=\mathcal B. +\] +Thus $T_0S_0^{-1}$ fixes $\mathcal B^c$ and permutes $\mathcal B$. +It remains to implement the rotations and this correction on tapes. + +For one rotation, move its target to the rightmost of the three chunk +positions if necessary. Let $P^{\rm sw}$ be the product of the record +field lengths before the earlier exchanged chunk, let $G^{\rm sw}$ +be the product between the exchanged chunks, and let $B^{\rm sw}$ be +$R$ times the product after the later one. Empty products are one. +The bit array has exactly the shape +\[ + [P^{\rm sw}]\times[2^L]\times[G^{\rm sw}] + \times[2^L]\times[B^{\rm sw}]. +\] +The third chunk lies inside one collapsed spectator interval. +Pass only $L$ and these three positive canonical lengths to +Lemma~\ref{lem:chunk-swap}. Each length is at most $V$, so the local +descriptor has $O(A_{\rm rect})$ bits. The swap costs $O(VL^\tau)$, including +its own padding and cleanup. + +The equal chunk lengths leave the field-length list unchanged by a +completed swap. Keep the permutation of the logical names $x,y,z$ in +finite local state. With the target now after its two controls, collapse +the remaining intervals to obtain +\[ + [\Lambda_0]\times[2^L]_{\rm control\,1}\times[\Lambda_1] + \times[2^L]_{\rm control\,2}\times[\Lambda_2] + \times[2^L]_{\rm target}\times[B_{\rm rot}], +\] +where $B_{\rm rot}$ includes the payload and every displayed spectator +length is positive. Their product with the chunk lengths is $V$. +Together with $K,f,\rho$ and the finite name permutation, these fixed +canonical lengths form an $O(A_{\rm rect})$-bit local descriptor. The offset +routine receives the two current $L$-bit logical control values. A scan +of at most $f\le L$ selected positions evaluates +\eqref{eq:packed-cyclic-shift} in $L^{O(1)}$ time, without reading the +target or spectator values. Lemma~\ref{lem:ordered-affine-streams} +therefore gives an $O(V)$ rotation: its offset work is absorbed by the +$2^L$ nonempty target blocks in each fiber. Undo the swap after the +rotation. The local descriptors and name permutation are updated at +completed swap boundaries; the primitives use their own descriptors +inside padded layouts. +There are at most sixteen swaps and eight rotations in $S_0$. + +To implement the correction, scan the stream with a record-rank counter. +All chunk names are back in their original positions. Dividing the +current rank through the fixed seven field lengths recovers the three +chunk values and their mixed-radix record strides. The strides exclude +the $R$ payload bits. All involved integers have $O(A_{\rm rect})$ bits, so +schoolbook arithmetic, descriptor copying, and resets take at most +$O(A_{\rm rect}^3)$ per record. Test membership in $\mathcal B$ and extract just +those records. For a current exceptional address $q$, compute +$q'=T_0(S_0^{-1}(q))$ by reversing the eight modular additions with +negated offsets, then applying the selected XORs directly. Each reversed +mask uses the current controls of that reversed line. There are at most +$f\le L\le A_{\rm rect}$ selected positions, so this calculation also fits +$O(A_{\rm rect}^3)$ time. + +If $q_h,q'_h$ are the current and destination values of chunk +$h\in\{x,y,z\}$ and $\sigma_h$ is its record stride, the fixed +spectator coordinates give +\[ + \operatorname{rank}(q')=\operatorname{rank}(q)+ + \sum_{h\in\{x,y,z\}}(q'_h-q_h)\sigma_h. +\] +The differences are signed. Attach this destination rank, padded to +$\lceil\log_2M\rceil\le A_{\rm rect}$ bits, to the extracted record, and mark its +hole on a fixed track of the full stream. Hold the full stream untouched +while stable binary radix sorting scans only the extracted records and +keys, least significant key bit first. Since $T_0S_0^{-1}$ permutes +$\mathcal B$, these keys are distinct and are exactly the ranks of the +marked holes. One forward full-stream scan reinserts the sorted records. +This implements $T_0$ everywhere. + +Finally apply the two-bit XOR to $x_{j_{f-1}},y_{j_{f-1}}$ by +Lemma~\ref{lem:elementary-streams}, splitting those chunks at the +selected positions and collapsing the other intervals. Its descriptor +again has a fixed number of positive lengths, each at most $V$. +This costs $O(V)$ and supplies the omitted selected position. When +$f=1$, $S_0,T_0$ are identities, $\mathcal B$ is empty, and this last +step is the entire algorithm. + +The movement costs $O(V(L^\tau+1))$. A fixed number of full record scans +costs $O(MA_{\rm rect}^3+V)$, and the at most $A_{\rm rect}$ radix passes cost +$O(|\mathcal B|A_{\rm rect}(R+A_{\rm rect}))$; skip them when the extracted bank is empty. +The initial descriptor has a fixed number of canonical integers of +$O(A_{\rm rect})$ bits, so its preparation is covered by $O(MA_{\rm rect}^3)$. +All counters, positioning, rewinds, and cleanup are included. +Equation~\eqref{eq:packed-bad-fraction} proves +\eqref{eq:packed-rectangle-time} on a fixed number of tapes. +After division by $V=MR$, its additional terms are bounded by +$A_{\rm rect}^3/R$ and +$80(f-1)2^{-K}A_{\rm rect}(1+A_{\rm rect}/R)$. Under the stated family bounds +the first tends to zero, and the second is +$O(p^2 2^{-K}(1+A_{\rm rect}/R))=o(1)$. This proves the final assertion. +\end{proof} + +\paragraph{Application to a fixed binary change of basis.} +An invertible matrix over $\mathbb F_2$ of fixed order $m\ge3$ is a +product of a fixed number of elementary row additions; a row exchange +is three such additions. In one invocation of the finite network on +$e=mf$ axes, slot $h$ consists of $f$ consecutive $K$-bit axis chunks. +It therefore has address-bit width $L=fK$, and its selected bits +$x_{h,j}$ occupy positions $\rho+jK$ for $0\le j1$. +For these fixed choices +there are a cutoff $p_0$, one fixed finite-alphabet multitape procedure, +and an implicit time constant with the following guarantee. The cutoff +and time constant may depend on the fixed rational parameters +and these constants. For every choice of positive integers $p,d,r$ +with $p\ge p_0$ and +\[ + a_dp^\epsilon\le d\le b_dp^\epsilon,\qquad + 2^{a_rp/d}\le r\le 2^{b_rp/d}, +\] +put $K=\lfloor d^c\rfloor$, and let $1\le D\le d$, $P,S\ge1$, and +$0\le\rho0$ +and $C_w>1$, and choose the layer constants once as +\[ + C_M=C_\ell+1,\qquad + C_{\rm desc}=32(C_\ell+C_w+1). +\] +Use these constants and $C_w$ in +Proposition~\ref{prop:simultaneous-layer}. These fixed choices determine +a cutoff $p_1$, one fixed-tape procedure, and an implicit time constant +with the following guarantee. For every choice of positive integers +$p,d,r$ with $p\geq p_1$ and +\[ + a_dp^\epsilon\leq d\leq b_dp^\epsilon,\qquad + 2^{a_rp/d}\leq r\leq2^{b_rp/d}, +\] +suppose $d\geq2$ and $r=2^\ell$ with an integer $2\leq\ell0$. Thus all participating axes in a +common round have current length $u_i=2^{h+1}$. +The branch bit written at position $h$ is frequency bit $a_i-1-h$; +its frequency significance can differ between long and short axes. +The descriptor locates that named slot after $L$, so the physical +move has not changed which pair the current butterfly uses. The +opposite procedure executes this schedule in reverse order and, +when present, ends with the extra leading round on the long axes. + +For a position $h$ in the remaining chunks, the selected bit has +offset $(h-b)\bmod K$, counted from the least significant bit, in +each of the $D$ consecutive chunks with the same chunk index $j$. +Let $n_P$ and $n_S$ be the numbers of record-address bits before and +after that group. Every combination of those bits occurs, so the +layer sees the complete address set +\[ + [P]\times[2^K]^D\times[S],\qquad + P=2^{n_P},\quad S=2^{n_S},\quad + n_P+DK+n_S=\sum_i a_i\leq D\ell=O(p). +\] +Thus its record count is $PS2^{DK}=M$ and +$\log_2(2M)\leq(C_\ell+1)p=C_Mp$. +The current transform parameters supply $p,d,r,K,w$, and the round +determines $D,P,S$ and the selected offset $\rho$. Encode these values +as the header $\mathcal E$ of Proposition~\ref{prop:simultaneous-layer}. +The same fixed descriptor bound covers every axis choice and round. +Indeed $|\Gamma(v)|\leq2\log_2v+1$, and +$\ell+n_P+n_S\leq d\ell\leq C_\ell p$. Also +$d,D\leq\max\{C_\ell,1\}p$, $K,\rho+1\leq p$, and $w\leq C_wp$. +Adding the nine code lengths therefore gives +\[ + |\mathcal E| + \leq 2C_\ell p+12\log_2p+ + 4\log_2\max\{C_\ell,1\}+2\log_2C_w+9 + \leq C_{\rm desc}p. +\] +The last inequality uses $p\geq1$, $\log_2p\leq p$, and +$\log_2x\leq x$ for $x\geq1$. +This is the descriptor passed to the layer; the longer +table locating named slots remains separate for the transform's address +calculations. +The simultaneous-layer procedure therefore applies at cost +$O(Tpd^{\lambda'})$ per round and $O(Tp\ell d^{\lambda'})$ in total. + +In a round on prefix slots, process the participating bits individually. +Temporarily move one such bit immediately before the polynomial +suffix. In each now adjacent pair, buffer the first record and scan +it with the second, writing the half-sums and half-differences to two +work tapes. Append the half-sum record and then the half-difference +record, and reverse the bit move after +all pairs are processed. Including head returns, the work is +$O(rp)$ per pair and $O(Tp)$ for the moves and scans at coefficient +width $O(p)$. +That width suffices without truncating between axes: after $s\leq D$ +individual $H_0$ factors, the coefficients are exact dyadics on the +$2^{-(p+s)}$ grid and still lie in the disk. A temporary sum has +modulus at most two and needs only a constant number of extra integer +bits. Hence +$p+D+O(1)=O(p)$ bits per component suffice, since $D\leq d$ and +$d\ell=O(p)$. Complete the combined monomial exactly and apply +$Q_p$ once at the end of the round. Write the resulting disk-grid +numerators in the supplied $w$-bit component format. Their magnitudes +are at most $2^p$, so this takes one linear scan within the same bound. +In an opposite round on prefix slots the +inverse monomial comes first and preserves the grid and disk, so the +same width bound holds for its individual factors. There are at +most $b+1\leq K$ rounds on prefix slots, giving cost $O(TpdK)$. + +For each output record of a forward butterfly round, the descriptor +locates the new branch bit $b_i$ and the lower named slots that encode +$k_i$. Read their current values to compute +\eqref{eq:combined-twiddle}. Before an opposite round at position +$h$, all lower positions have already been processed in reverse. +Those slots again index the lower inputs of that level, while slot +$h$ still gives $b_i$. They therefore encode the same $k_i$ needed +by the inverse monomial before its +butterfly. The binary descriptions of the addresses, exponent, and +layout have polynomial length in $p$. Ordinary +fixed-tape arithmetic therefore computes the exponent in +$\operatorname{poly}(p)$ time per polynomial record. Each record +contains $\Theta(rp)$ bits, and $r$ dominates every fixed power of +$p$, so this work fits within its scan cost. The same bound covers +scans of the polynomially many round and layout descriptors. +Growing lists reside on tapes; a fixed number of counter and work +tapes suffices for every number of axes. + +To implement the monomial, write $E=er+s$ with $0\leq s1$. +Let $w$ be an integer with $p+2\leq w\leq C_wp$. +The input supplies $\Gamma(p)\Gamma(r)\Gamma(w)$ and two disk grid +polynomials $f,g\in\mathcal R_r$ in the component format of +Proposition~\ref{prop:simultaneous-layer} with width $w$. +One can compute the exact Gaussian integer +numerators of $fg$, and then return $Q_p(fg/r)$ in that same format, in time +$O(rp\log(rp))$ on a fixed number of tapes. The output is a disk +grid polynomial with error less than $\sqrt2\,2^{-p}$ from $fg/r$. +\end{lemma} +\begin{proof} +The supplied power of two $r$ determines $\ell=\log_2r$. +Write +\[ + f=2^{-p}(a+ib),\qquad g=2^{-p}(c+ie), +\] +where $a,b,c,e\in\mathbb Z[y]$ have degree less than $r$ and +coefficients of absolute value at most $2^p$. Set $B_0=2^{4p}$ +and, for $u\in\{a,b,c,e\}$, define the signed evaluation integer +\[ + A_u=u(B_0)=\sum_{j=0}^{r-1}u_jB_0^j. +\] +The bound +\[ + |A_u|\leq2^p\frac{B_0^r-1}{B_0-1}100$ and integers $k>1$, $0\leq j100$, $2\leq sp/\alpha^4. +\] +Define coordinate permutations by +\[ + (P_su)_j=u_{tj},\qquad (P_tv)_k=v_{-sk}. +\] +There are linear contractions $A:\mathbb C^s\to\mathbb C^t$ and +$B_0:\mathbb C^t\to\mathbb C^s$ satisfying +\begin{equation} + P_sF_s=2^{2\alpha^2}B_0P_tF_tA. + \label{eq:no-sort-one-dimensional} +\end{equation} +There are fixed multitape algorithms for approximations +$\widetilde A:\mathbb D_p^s\to\mathbb D_p^t$ and +$\widetilde B_0:\mathbb D_p^t\to\mathbb D_p^s$, each with error less +than $p^2$ and time +\[ + O(tp^{3/2+\delta}\alpha). +\] +The constant is uniform in $p,s,t,\alpha$. Inputs and outputs use the +scalar component format above and occur in increasing coordinate order. +\end{lemma} + +\begin{proof} +The Gaussian resampling argument uses two maps +$\mathsf S,\mathsf T:\mathbb C^s\to\mathbb C^t$. For $0\leq kp/\alpha^4$, we have +$\alpha^2\theta>p/\alpha^2>1$. Thus $\|N-I\|<1/2$, so $N$ is invertible +by the Neumann series. Put +\[ + \mathsf S'=\mathsf S/2,\qquad + \mathsf J'=N^{-1}/2,\qquad + \mathsf D'=2^{-(2\alpha^2-2)}\mathsf D. +\] +The proof of Proposition~4.7(i) in the cited paper gives +\[ + \|\mathsf S'\|<\frac34,\qquad + \|\mathsf J'\|<\frac78,\qquad + \|\mathsf D'\|<1. +\] +Now set $A=\mathsf S'$ and $B_0=\mathsf D'\mathsf J'C$. +Because $\|C\|=1$, both are contractions. The diagonal map $\mathsf D$ +is invertible, and $C\mathsf T=N\mathsf D^{-1}$, so +\[ + (\mathsf D N^{-1}C)\mathsf T + =\mathsf D N^{-1}(N\mathsf D^{-1})=I. +\] +Applying this left inverse to the first identity in +\eqref{eq:gaussian-public-facts} gives +$\mathsf D N^{-1}CP_tF_t\mathsf S=P_sF_s$. The normalizations in +$\mathsf D'$, $\mathsf J'$, and $\mathsf S'$ have product +$2^{-(2\alpha^2-2)}2^{-1}2^{-1}=2^{-2\alpha^2}$. Hence +\[ + B_0P_tF_tA + =2^{-2\alpha^2}\mathsf D N^{-1}CP_tF_t\mathsf S + =2^{-2\alpha^2}P_sF_s, +\] +which is \eqref{eq:no-sort-one-dimensional}. + +\paragraph{Ordered numerical maps.} +Lemmas~4.8, 4.9 and 4.12 of +\cite{HarveyHoeven2021} supply the following algorithms. Their inputs +and outputs are in increasing coordinate order, and every output is in +the disk grid. The record conversions and tape movement needed to use +these routines in our format are accounted for below. Their numerical +guarantees are +\[ +\begin{array}{c|c|c} + \text{map}&\text{error bound}&\text{time bound}\\ \hline + \widetilde{\mathsf S}'&16p&O(tp^{3/2+\delta}\alpha)\\ + \widetilde{\mathsf J}'&3p^2/4&O(tp^{3/2+\delta}\alpha)\\ + \widetilde{\mathsf D}'&4&O(tp^{1+\delta}). +\end{array} +\] +For $C$, observe that $q_0=0$, $q_{s-1}q_j$, +because $t/s>1$. Thus $C$ selects an ordered subsequence. A forward scan, +with the current input coordinate stored on a work tape, copies a record +exactly when that coordinate equals the next $q_j$. + +The selected indices can themselves be generated in order using only +$O(p)$ work per index. Precompute $t=hs+\rho$ with $0\leq\rhoe^{2/\eta}$, the interval +\[ + (1-2\eta)x8d=2/\eta$. +For either choice, the stated lower bound for the number of primes is +$x/(8d\log x)$ and exceeds $d$: +indeed, $\log x=\Theta(p^{1-\epsilon})$, whereas +$\log(8d^2\log x)=O(\log p)=o(\log x)$, so $x>8d^2\log x$ eventually. +The two intervals are disjoint because +$(1-\eta)r/2<(1-2\eta)r$ for $\eta<1/4$, and both intervals lie above +$2$. We may therefore choose distinct odd primes satisfying +\[ + (1-2\eta)t_i + \left(1-\frac1{2d}\right)^d>\frac12 + \qquad(d\geq2). +\] +Together with $s_i\eta$. Therefore +\[ + \alpha^4\theta_i>\frac{12d^2b}{4d}=3db\geq6b=p. +\] +The choice of $\alpha$ gives +$\alpha=\Theta(p^{1/4+\epsilon/2})$, and \eqref{eq:gamma} already +ensures $2\leq\alpha<\sqrt p$ for large $n$. We also have +$t_i\leq r\leq T<8n/b<2^{6b}=2^p$. +Thus every hypothesis of Lemma~\ref{lem:no-sort-resampling} holds for +all sufficiently large input lengths. The superpolynomial growth of $r$ +established above also supplies the setup condition in +Lemma~\ref{lem:tensor-resampling}. + +The machine finds these primes by scanning the two intervals +deterministically and testing each candidate by trial division through +its square root. Testing every candidate would visit $O(r)$ candidates +and at most $O(\sqrt r)$ trial divisors per candidate. Elementary +division on $O(\log r)$-bit integers and management of a list of at most +$d$ selected primes give the conservative bound +$O(dr^{3/2}\operatorname{poly}(p))$. Its logarithm is +\[ + O(\log p+\log r)=O(\log p+p/d)=o(p). +\] +Since $p=6\lceil\log_2 n\rceil=\Theta(\log n)$, the search takes +$n^{o(1)}=o(n)$ time. +All remaining scalar setup, including comparisons for fixed rational +powers, modular inverses, +prime products and shape descriptors, has cost polynomial in $p$. +For example, $d=\lfloor b^{2^{-75}}\rfloor$ is found by binary search +using exact comparisons $d^{2^{75}}\le b$; the exponent is fixed. +The same procedure computes $K$ and all other fixed rational powers. +All primes and length parameters are therefore generated by the machine; +they are not advice. + +\subsubsection{The radix-digit polynomials} + +Write the two inputs as polynomials in $2^b$, each with +$q=\lceil n/b\rceil$ nonnegative digits. Their product has degree at most +\[ + 2q-2<2n/b\le T/2i$ are divisible by $s_i$, and $\mu_iP_i=1$ modulo +$s_i$. Numerical order of $k$ is lexicographic order of +$(a_d,\ldots,a_1)$. Insert the padding in one nested scan of the full +box $\prod_i[0,t_i)$ in this lexicographic order, with $a_d$ the +outermost counter and $a_1$ the innermost. At an address satisfying +$a_i{\raggedright\arraybackslash}p{.40\linewidth}ll@{}} +\toprule +Operation & Normalized cost & Power of $p$\\ +\midrule +Prefix-slot moves and individual butterfly rounds & $dK$ & $\epsilon(1+c)$\\ +Chunk exchanges for transform layout & $pK^{\tau-1}$ & $1-\epsilon c(1-\tau)$\\ +Simultaneous butterfly rounds & $\ell d^{\lambda'}$ & $1-\epsilon(1-\lambda')$\\ +CRT and axis layouts & $d^2(1+\ell^\tau)$ & $\tau+\epsilon(2-\tau)$\\ +Gaussian line maps & $dp^{1/2+\delta}\alpha$ & $3/4+\delta+3\epsilon/2$\\ +Chirps, twists and scalar products & $dp^\delta$ & $\epsilon+\delta$\\ +Packed polynomial products & $\log(rp)$ & $1-\epsilon$\\ +Final scaling and rounding & $p^\delta$ & absorbed above\\ +Input, padding, carries and output & $1$ & absorbed above\\ +\bottomrule +\end{tabular} +\caption{Costs divided by $Tp$; each coefficient +representation has $O(p)$ bits.}\label{tab:costs} +\end{table} + +The seven dominant powers in Table~\ref{tab:costs} have the following +margins below one: +\begin{equation}\label{eq:margin-list} +\begin{split} + g_1&=1-\epsilon(1+c),\qquad + g_2=\epsilon c(1-\tau),\qquad + g_3=\epsilon(1-\lambda'),\\ + g_4&=1-\tau-\epsilon(2-\tau),\qquad + g_5=1/4-\delta-3\epsilon/2,\\ + g_6&=1-\delta-\epsilon,\qquad g_7=\epsilon. +\end{split} +\end{equation} +Direct substitution gives +\[ + g_1>\frac12,\quad g_2=2^{-181},\quad g_3=2^{-129},\quad + g_4>2^{-51},\quad g_5>\frac18,\quad g_6>\frac12,\quad g_7=2^{-75}. +\] +Thus $\min_i g_i=2^{-181}=2\kappa$. This explicit slack will cover +any remaining fixed power of $\log p$. + +Here $d^2$ is absorbed by $d^2\ell^\tau$, and +$\log(rp)=O(p^{1-\epsilon}+\log p)=O(p^{1-\epsilon})$. +The first three rows are the terms in +\eqref{eq:synthetic-transform-cost}. The prefix-slot moves and +individual butterfly rounds in Lemma~\ref{lem:synthetic-transform-cost} +use $O(dK)$ linear scans. Its positional layout uses $O(p/K)$ exchanges +of width-$K$ chunks, because $d\ell=O(p)$. Each exchange costs +$O(VK^\tau)$ by Lemma~\ref{lem:chunk-swap}, so the normalized total is +\[ + O(p/K)\,K^\tau=O(pK^{\tau-1}). +\] +For the at most $\ell$ simultaneous rounds, +Proposition~\ref{prop:simultaneous-layer} supplies $O(Vd^{\lambda'})$ +per round. Its bound already includes the binary basis changes, +deterministic repair, row padding and removal, all base-$m$ groups, +and fixed-tape cleanup. + +Axis exposure and restoration require $O(d^2)$ adjacent axis moves. +Each costs $O(V(1+\ell^\tau))$: peel a single excess bit when widths +differ by one, exchange their equal-width parts, and restore the bit. +The $d$ CRT rotations copy valid and invalid intervals in $O(dV)$ time. +Their offset setup was bounded above by $O(dTp^C/r)=o(Tp)$, +using at most $T/t_i$ control prefixes for target $i$. + +For Gaussian resampling, axis $i$ has at most $T/t_i$ processed lines. +The line-machine costs therefore sum to +\[ + \sum_{i=1}^d\frac{T}{t_i} + O(t_i p^{3/2+\delta}\alpha) + =O(dTp^{3/2+\delta}\alpha). +\] +Dividing by $V=Tp$ gives the fifth row. The factor +$\alpha=\Theta(p^{1/4+\epsilon/2})$ explains its displayed power of $p$. + +Chirp numerators have $O(p)$ bits and can be computed modulo $2r$ as +sums of $d$ terms $s_i j_i^2(r/t_i)$. Computing their squares and +products with the previously established $O(N\log(2N))$ multiplier +on $N$-bit inputs, +then generating the exponentials, costs $O(dp^{1+\delta})$ per entry. +The smaller twist and scalar pointwise-product costs fit the same row: +they use a fixed number of exact products on $O(p)$-bit component +numerators, followed by linear truncation scans. The two final products +by $S$ also cost $O(p\log p)$ per entry, so their normalized cost is +$O(\log p)=O(p^\delta)$ as listed separately. There are $T/r$ +polynomial records in each pointwise ring product. Four integer +products on $O(rp)$ bits per record therefore cost +$O(Tp\log(rp))$ in total. Signed packing, centered extraction, +negacyclic wrapping, and copying are linear stream passes. These calls +use the previously established multiplier on records of length +$O(rp)=o(n)$; they do not call the improved algorithm being constructed. +The exact source scaling by $2^\gamma$ is a shift of $O(p)$-bit +numerators by $\gamma=O(p)$ places, so it is a linear scan per entry +and fits the final-scaling row. The scalar-format adapters and the exact +removal of sign-extension bits after the ring and source scales also use +linear scans of their $O(p)$-bit components, within the listed scan costs. + +\paragraph{Setup and exceptional streams across all calls.} +We next separate setup at recursion nodes from work repeated for every +polynomial record or every Gaussian line. Here a visit means a node +of the layer or address-layout recursions, or one of their round and +group invocations. The internal recursion of the established integer +multiplier and the iterations of the quoted Gaussian algorithms are +already included in their separately charged running times. +The layer and address-layout recursions have constant branching and +depth $O(\log p)$, and the number of their rounds and base-$m$ groups +is polynomial in $p$. Choose a fixed exponent $A$ so that their +total number of visits is at most $p^A$, and a fixed $C$ bounding +descriptor setup performed once per visit by $p^C$ steps. This setup then +costs at most $p^{A+C}=o(Tp)$. + +At a layer or synthetic-transform visit that processes polynomial +records, there are at most $O(T/r)$ such records, including the +bounded row padding. Every relevant child keeps the whole +length-$r$ polynomial suffix. Consequently $O(p^C)$ descriptor or +address work per record, over these visits, costs at most +$O(Tp^{A+C}/r)=o(Tp)$. Setup before each Gaussian line call has a +different count: +there are at most $2dT/r$ lines per tensor map and only a fixed number +of such maps, so $O(p^C)$ setup per line costs +$O(dTp^C/r)=o(Tp)$. These estimates all use that $r$ exceeds every +fixed power of $p$. + +The general address-swap subroutine also covers one-bit payloads, +where no polynomial suffix is available. For root volume $V_0$ and +current child volume $V_j$, the descriptor estimate in the proof of +Proposition~\ref{prop:power-interchange} gives +$(\log(2V_0))^{O(1)}=O(V_j)$. It uses the invariant that both original +chunk ranges remain present in every child, and therefore includes +polynomial descriptor work even for a one-bit payload. +Elementary counter updates use local length copies, so they do not +rescan a growing descriptor for each data bit. The chirp computation +does scan the axis descriptors at every coefficient; its +$O(Tdp^{1+\delta})$ cost was included in the chirp row. + +For one packed change of basis, let $V_{\rm call}$ be its current +logical volume. The bad-address fraction is +$O(d2^{-K})$, independently of the payload. Each polynomial record +has $\Theta(rp)$ payload bits, and an exceptional record adds an +$O(p)$-bit destination key. Thus the compact exceptional stream has +length +\[ + O\!\left(\frac{V_{\rm call}}{rp}\,d2^{-K}(rp+p)\right) + =O(V_{\rm call}d2^{-K}). +\] +Stable bit sorting makes $O(p)$ scans of this stream, for one-call +cost $O(V_{\rm call}dp2^{-K})$. Extraction and reinsertion use a +constant number of scans of the full current volume; those scans are +already in the node overhead. Since there are at most $p^A$ visits, +each of volume $O(V)$, the compact sorting costs sum to at most +\[ + O\!\left(dp2^{-K}\sum_{\rm calls}V_{\rm call}\right) + =O(Vp^{A'}2^{-K})=o(V) +\] +for another fixed exponent $A'$. Here $d=O(p^\epsilon)$ and +$K=\Theta(p^{\epsilon c})$ with $\epsilon c>0$. Predicate and key +arithmetic is the polynomial work per record counted above. This is +a deterministic worst-case bound. + +Finally, all role, arithmetic, and stack tapes form fixed finite +families. A child parks and restores only its parent's streams, with +the stack head at the active top; copying and cleanup are charged to +that logical volume. No operation repeatedly scans parked ancestors. +Growing axis lists and call states are stored data, not extra tapes or +alphabet symbols. Global setup and prime search cost $o(V)$, as +proved earlier. + +Each of the seven displayed powers is at most $1-2\kappa$ by +\eqref{eq:margin-list}. Any fixed power of $\log p$ is at most $p^\kappa$ +eventually. The complete large-input bound is consequently +\[ + O(Tp\,p^{1-\kappa})=O(n(\log n)^{1-\kappa}). +\] +Fix one cutoff beyond all the size, precision, margin and layout +conditions, and use schoolbook multiplication below it. The finitely +many smaller lengths are included by enlarging the implicit constant. +With $\lg n=\max\{\lceil\log_2n\rceil,1\}$, the resulting single +fixed-alphabet, fixed-tape deterministic machine has worst-case time +$O(n(\lg n)^{1-\kappa})$ for every input length and produces precisely +the required $2n$-bit product. diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex new file mode 100644 index 0000000000..4c7a1d63c9 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/09-exact-arithmetic.tex @@ -0,0 +1,154 @@ +\section{Exact division and integer square root} +\label{sec:exact-arithmetic-proof} + +Let $n$ be the supplied input width, let $a$ be the nonnegative dividend +or radicand, and let $b>0$ be the divisor for the division task, with +the values and output conventions of Corollary~\ref{cor:exact-arithmetic}. +Here $p\ge1$ denotes an integer target precision for a Newton routine. + +\begin{proof}[Proof of Corollary~\ref{cor:exact-arithmetic}] +We use the classical Newton reductions as presented by +Brent~\cite[Lemmas 2.1--2.4]{Brent1976}, with their tape costs made +explicit. Set $B(p)=p(\lg p)^{1-\kappa}$. A linear scan handles a zero +dividend or radicand and finds the significant bits of a positive input. +For division write $b=2^h c$, where $0\le ha$, and increment it if +$(s_0+1)^2\le a$; otherwise retain it. The remainder and square tests +cover exact quotients and perfect squares. All final significands, trial +answers and exact test products have $O(n)$ bits; their computation costs +$O(B(n))$, and output padding is linear. Leading zeroes +affect neither normalization bound, since $n$ is the supplied input +length. +\end{proof} diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex new file mode 100644 index 0000000000..e69cc82762 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/10-transposition.tex @@ -0,0 +1,48 @@ +\section{A consequence for matrix transposition} +\label{sec:transposition} + +For positive integers $n_1,n_2,b$, a row-major $n_1\times n_2$ array +of $b$-bit strings stores +entry $(i,j)$, where $0\le i0$; the bounded cases are absorbed +using the stated convention for $\lg$. Thus the cited transposition +cost is $O(m(\lg m)^{1-\kappa})$. Taking $m=n_1n_2b$ expresses this +bound in matrix bits. In particular, an +$n\times n$ binary matrix can be transposed in +$O(n^2(\lg n)^{1-\kappa})$ time. Dimensions equal to one cause no +exception, since our convention gives $\lg1=1$. diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex new file mode 100644 index 0000000000..44439c716c --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/build/sections/11-grouped-rectangles.tex @@ -0,0 +1,160 @@ +\section{Packed additions on grouped rectangles} +\label{sec:grouped-rectangles} + +The simultaneous-layer construction uses the rectangular layout of +Lemma~\ref{lem:packed-selected-bit-rectangle}. We record here a more +general version in which a supplied descriptor lists groups with different +spectator lengths. Each group is a complete rectangle, so the full +rectangular algorithm, including its deterministic repair, can be applied +to one group at a time. The only additional work is reading the group +descriptors and passing consecutive groups through the same local tapes. + +\begin{definition}[Grouped packed stream] +\label{def:grouped-packed-stream} +Let $M,R\ge1$, $K\ge6$, $f\ge1$, $L=fK$, and $0\le\rho7/8" + authors: ["OpenAI"] + id: ../preprints/The-Quasi-Riemann-Hypothesis-September-30-2026/paper.pdf + type: article + + - title: "The second Kahn–Kalai conjecture" + authors: ["OpenAI"] + id: ../preprints/The-second-Kahn-Kalai-conjecture-September-24-2026/paper.pdf + type: article + + - title: "The sharp factor-of-IID threshold for the free Ising model on regular trees" + authors: ["OpenAI"] + id: ../preprints/The-sharp-factor-of-IID-threshold-for-the-free-Ising-model-on-regular-trees-September-26-2026/article.pdf + type: article + + - title: "The strong thin tree conjecture" + authors: ["OpenAI"] + id: ../preprints/The-strong-thin-tree-conjecture-September-23-2026/paper.pdf + type: article + + - title: "The Subcritical Hénon–Lane–Emden Conjecture" + authors: ["OpenAI"] + id: ../preprints/The-Subcritical-Henon-Lane-Emden-Conjecture-September-24-2026/paper.pdf + type: article + + - title: "The symmetric Mahler conjecture and its equality cases" + authors: ["OpenAI"] + id: ../preprints/The-symmetric-Mahler-conjecture-and-its-equality-cases-September-22-2026/paper.pdf + type: article + + - title: "The Unique Games Theorem" + authors: ["OpenAI"] + id: ../preprints/The-Unique-Games-Theorem-September-23-2026/paper.pdf + type: article + + - title: "The weak pinned planar distance theorem" + authors: ["OpenAI"] + id: ../preprints/The-weak-pinned-planar-distance-theorem-September-23-2026/paper.pdf + type: article + + - title: "Thompson's group F is nonamenable" + authors: ["OpenAI"] + id: ../preprints/Thompsons-group-F-is-nonamenable-September-23-2026/paper.pdf + type: article + + - title: "Three fixed points on the symplectic quadric threefold" + authors: ["OpenAI"] + id: ../preprints/A-degenerate-counterexample-to-the-critical-number-Arnold-bound-September-23-2026/paper.pdf + type: article + + - title: "Threshold parallel repetition for finite-dimensional entangled games" + authors: ["OpenAI"] + id: ../preprints/Threshold-parallel-repetition-for-finite-dimensional-entangled-games-September-25-2026/paper.pdf + type: article + + - title: "Tracial projection methods and uniform property Γ" + authors: ["OpenAI"] + id: ../preprints/Tracial-projection-methods-and-uniform-property-Gamma-September-23-2026/paper.pdf + type: article + + - title: "Two limit cycles for quintic Liénard systems" + authors: ["OpenAI"] + id: ../preprints/two-limit-cycles-for-quintic-lienard-systems-September-24-2026/two-limit-cycles-for-quintic-lienard-systems-September-24-2026.pdf + type: article + + - title: "Uniform Bi-Hölder Transport from Weak MTW" + authors: ["OpenAI"] + id: ../preprints/Uniform-Bi-Holder-Transport-from-Weak-MTW-September-25-2026/paper.pdf + type: article + + - title: "Uniform exclusion of Landau–Siegel zeros" + authors: ["OpenAI"] + id: ../preprints/Uniform-exclusion-of-Landau-Siegel-zeros-October-1-2026/paper.pdf + type: article + + - title: "Unitarizability implies amenability for discrete groups" + authors: ["OpenAI"] + id: ../preprints/Unitarizability-Implies-Amenability-for-Countable-Groups-September-23-2026/paper.pdf + type: article + + - title: "Universal-cover splitting for compact Kähler manifolds" + authors: ["OpenAI"] + id: ../preprints/Universal-cover-splitting-for-compact-Kahler-manifolds-September-23-2026/paper.pdf + type: article + + - title: "Weak Hessian bounds along every geodesic in RCD spaces" + authors: ["OpenAI"] + id: ../preprints/Weak-Hessian-bounds-along-every-geodesic-in-RCD-spaces-September-24-2026/weak-hessian-geodesics.pdf + type: article + +related_formalizations: + # Imported libraries, ordered by direct import count in project Lean sources. + - id: https://github.com/leanprover-community/mathlib4 + relationship: builds-on + + - id: https://github.com/AlexKontorovich/PrimeNumberTheoremAnd + relationship: builds-on + + - id: https://github.com/n-yamaguchi-0729/ClassFieldTheory + relationship: builds-on + + - id: https://github.com/CBirkbeck/AINTLIB + relationship: builds-on + + - id: https://github.com/math-inc/strongpnt + relationship: builds-on + + - id: https://github.com/abenenson/rellich-kondrachov + relationship: builds-on + + - id: https://github.com/harfe/fixed-point-theorems-lean4 + relationship: builds-on + + - id: https://github.com/TauCetiProject/TauCeti + relationship: builds-on + + - id: https://github.com/fpvandoorn/carleson + relationship: builds-on + + - id: https://github.com/lana-agents/heights + relationship: builds-on + + - id: https://github.com/Aaron1011/gromov + relationship: builds-on + + - id: https://github.com/lana-agents/iut + relationship: builds-on + + - id: https://github.com/alonamaloh/schoenflies-lean + relationship: builds-on + + - id: https://github.com/leanprover-community/sphere-eversion + relationship: builds-on + + - id: https://github.com/ahhwuhu/zeta_3_irrational + relationship: builds-on + + - id: https://github.com/BennyAvelin/AbsorptionCutoff + relationship: builds-on + + - id: https://github.com/lana-agents/belyi + relationship: builds-on + + - id: https://github.com/PatrickMassot/checkdecls + relationship: builds-on + + - id: https://github.com/leanprover/doc-gen4 + relationship: builds-on + + - id: https://github.com/lana-agents/elliptic-curves + relationship: builds-on + + - id: https://github.com/lana-agents/formal-schemes + relationship: builds-on + + - id: https://github.com/lana-agents/genl + relationship: builds-on + + - id: https://github.com/hanwenzhu/LeanArchitect + relationship: builds-on + + - id: https://github.com/alerad/leancert + relationship: builds-on + + - id: https://github.com/lana-agents/oka + relationship: builds-on + + - id: https://github.com/lana-agents/orbicurve-cores + relationship: builds-on + + - id: https://github.com/lana-agents/pi1 + relationship: builds-on + + - id: https://github.com/b-mehta/PrimeCert + relationship: builds-on + + - id: https://github.com/lana-agents/tate-curves-theta + relationship: builds-on + + - id: https://github.com/lana-agents/tempered-fundamental-groups + relationship: builds-on + +status: + scope: "Partial progress." + # Entries use source-qualified declaration names and the files containing them. + main_results: + - comparator_config: ComparatorChallenges/AbhyankarSathaye.json + declaration: OAI.AbhyankarSathaye.exists_noncoordinate_polynomial + file: OAI/AlgebraicGeometry/AbhyankarSathaye/Counterexample.lean + + - comparator_config: ComparatorChallenges/AmplitudeDamping.json + declaration: OAI.GAD.main + file: OAI/InformationTheory/AmplitudeDamping/Main.lean + + - comparator_config: ComparatorChallenges/ArnoldCounterexample.json + declaration: OAI.ArnoldCounterexample.main + file: OAI/Geometry/Arnold/Main.lean + + - comparator_config: ComparatorChallenges/ArtinCAT0.json + declaration: OAI.ArtinCAT0.main + file: OAI/GroupTheory/ArtinCAT0/Main.lean + + - comparator_config: ComparatorChallenges/AsymptoticallyMinimalLittlewood.json + declaration: OAI.AsymptoticallyMinimalLittlewood.main + file: OAI/Analysis/Littlewood/Main.lean + + - comparator_config: ComparatorChallenges/AuslanderReiten.json + declaration: OAI.ArExplicit.Statement.main + file: OAI/Algebra/AuslanderReiten/All.lean + + - comparator_config: ComparatorChallenges/BackwardIntertwiners.json + declaration: OAI.BackwardIntertwiners.direct_algebra_corollary + file: OAI/Analysis/BackwardIntertwiners/AlgebraCorollary.lean + + - comparator_config: ComparatorChallenges/BassTrace.json + declaration: OAI.BassTrace.RightProjective.bassTraceModules_vanishing_and_support + file: OAI/RingTheory/BassTrace/Main.lean + + - comparator_config: ComparatorChallenges/BiholderTransport.json + declaration: OAI.WeakMTWTransport.uniform_biHolder_transport + file: OAI/Analysis/BiholderTransport/Main.lean + + - comparator_config: ComparatorChallenges/BinPackingGap.json + declaration: OAI.BinPackingGap.main_results + file: OAI/Computability/BinPacking/Main.lean + + - comparator_config: ComparatorChallenges/BinaryMatching.json + declaration: OAI.BinaryMatching.deterministic_approximate_counting + file: OAI/Computability/MatchingCount/BinarySolve.lean + + - comparator_config: ComparatorChallenges/BinarySweep.json + declaration: OAI.binary_sweep_contraction_and_mixing + file: OAI/Probability/BinarySweep/Main.lean + + - comparator_config: ComparatorChallenges/BipartiteCrossing.json + declaration: OAI.Zarankiewicz.mainTarget_proof + file: OAI/Combinatorics/Crossing/Main.lean + + - comparator_config: ComparatorChallenges/BorsukNine.json + declaration: OAI.BorsukNine.main_theorem + file: OAI/Geometry/Borsuk/Counterexample.lean + + - comparator_config: ComparatorChallenges/BoundedRecovery.json + declaration: OAI.BoundedRecovery.bounded_recovery + file: OAI/Analysis/ModularRecovery/Recovery.lean + + - comparator_config: ComparatorChallenges/BoundedTreePotentials.json + declaration: OAI.BoundedTreePotentials.TreeCalculus.main_counterexample + file: OAI/Analysis/TreePotential/Main.lean + + - comparator_config: ComparatorChallenges/BoundedTreewidthL1.json + declaration: OAI.BoundedTreewidthL1.main_theorem + file: OAI/Combinatorics/TreewidthL1/Main.lean + + - comparator_config: ComparatorChallenges/Brennan.json + declaration: OAI.Brennan.main_theorem + file: OAI/Analysis/IntegralMeans/Main.lean + + - comparator_config: ComparatorChallenges/BrennanSharp.json + declaration: OAI.Brennan.Sharp.sharp_endpoints + file: OAI/Analysis/IntegralMeans/SharpEndpoints.lean + + - comparator_config: ComparatorChallenges/C0Absorption.json + declaration: OAI.C0Absorption.main_result + file: OAI/Analysis/C0Absorption/Main.lean + + - comparator_config: ComparatorChallenges/CHObstruction.json + declaration: OAI.CHObstruction.main + file: OAI/ModelTheory/Categoricity/Main.lean + + - comparator_config: ComparatorChallenges/CharacterCriterion.json + declaration: OAI.KirchbergRordam.character_criterion + file: OAI/Analysis/CharacterCriterion/Main.lean + + - comparator_config: ComparatorChallenges/ChoicelessPolynomialTime.json + declaration: OAI.CPTSeparation.main + file: OAI/ModelTheory/Choiceless/Separation.lean + + - comparator_config: ComparatorChallenges/CirculantHadamard.json + declaration: OAI.CirculantHadamard.exists_iff_order_one_or_four + file: OAI/LinearAlgebra/CirculantHadamard/Main.lean + + - comparator_config: ComparatorChallenges/ClassicalON.json + declaration: OAI.ClassicalON.main + file: OAI/Probability/ClassicalON/Main.lean + + - comparator_config: ComparatorChallenges/CliqueFreeLog.json + declaration: OAI.CliqueFreeLog.logarithmic_independence_bound + file: OAI/Combinatorics/CliqueFree/Main.lean + + - comparator_config: ComparatorChallenges/CommonBasesFPRAS.json + declaration: OAI.common_bases_fpras + file: OAI/Combinatorics/MatroidCounting/CommonBases.lean + + - comparator_config: ComparatorChallenges/CommutingDerivations.json + declaration: OAI.AbhyankarSathaye.CommutingDerivations.commuting_derivations_with_ordinary_extras + file: OAI/AlgebraicGeometry/CommutingDerivations/OrdinaryExtraMain.lean + + - comparator_config: ComparatorChallenges/CompactBanach.json + declaration: OAI.CompactBanach.main + file: OAI/Geometry/DoublingHilbert/CompactBanach.lean + + - comparator_config: ComparatorChallenges/CompleteCrossing.json + declaration: OAI.Paper170.complete_graph_crossing_number + file: OAI/Combinatorics/CompleteCrossing/Main.lean + + - comparator_config: ComparatorChallenges/CompleteCrouzeix.json + declaration: OAI.CompleteCrouzeix.main + file: OAI/Analysis/NumericalRange/Main.lean + + - comparator_config: ComparatorChallenges/ComplexCancellation.json + declaration: OAI.ComplexCancellation.main + file: OAI/Algebra/AffineCancellation/Main.lean + + - comparator_config: ComparatorChallenges/Conductivity.json + declaration: OAI.ScalarConductivity.main_nonuniqueness + file: OAI/Analysis/Conductivity/Main.lean + + - comparator_config: ComparatorChallenges/ConjugatePoints.json + declaration: OAI.ThreeManifold.main_theorem + file: OAI/Geometry/ConjugatePoints/ThreeManifold.lean + + - comparator_config: ComparatorChallenges/ContinuumTransition.json + declaration: OAI.ContinuumTemperature.main_theorem + file: OAI/Probability/ContinuumTransition/Main.lean + + - comparator_config: ComparatorChallenges/CoordinateSweeps.json + declaration: OAI.CoordinateSweeps.conditional_main + file: OAI/Probability/CoordinateSweeps/Main.lean + + - comparator_config: ComparatorChallenges/Cotype.json + declaration: OAI.Cotype.mainTarget_proved + file: OAI/Analysis/Cotype/Main.lean + + - comparator_config: ComparatorChallenges/CoulombIonization.json + declaration: OAI.CoulombAtom.generalized_ionization + file: OAI/Analysis/CoulombIonization/Main.lean + + - comparator_config: ComparatorChallenges/CourtadeKumar.json + declaration: OAI.LeanBlast.CourtadeKumar.courtadeKumarAndAttainment + file: OAI/InformationTheory/BooleanNoise/Main.lean + + - comparator_config: ComparatorChallenges/CriticalSK.json + declaration: OAI.CriticalSK.covariance_and_linear_tests + file: OAI/MathematicalPhysics/CriticalSK/Rayleigh.lean + + - comparator_config: ComparatorChallenges/CriticalSKMixing.json + declaration: OAI.CriticalSK.critical_mixing_bounds + file: OAI/MathematicalPhysics/CriticalMixing/Main.lean + + - comparator_config: ComparatorChallenges/CriticalZ3.json + declaration: OAI.CriticalZ3.critical_no_infinite + file: OAI/Probability/CriticalZ3/Main.lean + + - comparator_config: ComparatorChallenges/CycleDecomposition.json + declaration: OAI.ErdosGallai.erdos_gallai + file: OAI/Combinatorics/CycleDecomposition/Main.lean + + - comparator_config: ComparatorChallenges/DaugavetModuli.json + declaration: OAI.ExactModuli.exact_example + file: OAI/Analysis/Daugavet/Main.lean + + - comparator_config: ComparatorChallenges/DegreeRigidity.json + declaration: OAI.TuringRigidity.ManuscriptMain.rigidity + file: OAI/Computability/DegreeRigidity/Main.lean + + - comparator_config: ComparatorChallenges/DeligneDrinfeld.json + declaration: OAI.DeligneDrinfeld.main + file: OAI/Algebra/Drinfeld/Completion.lean + + - comparator_config: ComparatorChallenges/DepthThree.json + declaration: OAI.DepthThreeLowerBound.exists_polynomial_time_language_depth_three_lower_bound + file: OAI/Computability/DepthThree/Main.lean + + - comparator_config: ComparatorChallenges/DiamondDistortion.json + declaration: OAI.DiamondDistortion.headline_all_pairs + file: OAI/Analysis/DiamondDistortion/Descent.lean + + - comparator_config: ComparatorChallenges/DirectCrouzeix.json + declaration: OAI.DirectCrouzeix.complete_crouzeix + file: OAI/Analysis/DirectCrouzeix/CompleteBound.lean + + - comparator_config: ComparatorChallenges/DirectionalBallisticity.json + declaration: OAI.DirectionalTransience.directional_transience_implies_ballisticity + file: OAI/Probability/Ballisticity/Main.lean + + - comparator_config: ComparatorChallenges/DirichletSevenEighths.json + declaration: OAI.DirichletCharacter.LFunction_ne_zero_of_seven_eighths_lt_re + file: OAI/NumberTheory/DirichletL/Nonvanishing.lean + + - comparator_config: ComparatorChallenges/DixmierAllDiscrete.json + declaration: OAI.Dixmier.current_main_theorem + file: OAI/Analysis/Unitarizability/AllDiscrete.lean + + - comparator_config: ComparatorChallenges/DoublingHilbert.json + declaration: OAI.DoublingHilbert.main + file: OAI/Geometry/DoublingHilbert/Main.lean + + - comparator_config: ComparatorChallenges/EgyptianFractions.json + declaration: OAI.Problem337.main_double_log_order + file: OAI/NumberTheory/EgyptianFractions/Main.lean + + - comparator_config: ComparatorChallenges/EgyptianFractions.json + declaration: OAI.Problem337.counting_double_log_order + file: OAI/NumberTheory/EgyptianFractions/Main.lean + + - comparator_config: ComparatorChallenges/EgyptianFractions.json + declaration: OAI.Problem337.prescribed_denominator_corollary + file: OAI/NumberTheory/EgyptianFractions/Main.lean + + - comparator_config: ComparatorChallenges/EntangledGames.json + declaration: OAI.ThresholdParallelRepetition.threshold_parallel_repetition + file: OAI/Probability/EntangledGames/Main.lean + + - comparator_config: ComparatorChallenges/EuclideanFiveColor.json + declaration: OAI.EuclideanFiveColor.no_proper_five_coloring + file: OAI/Geometry/PlaneColoring/Five.lean + + - comparator_config: ComparatorChallenges/EuclideanRamsey.json + declaration: OAI.EuclideanRamsey.classification + file: OAI/Combinatorics/EuclideanRamsey/Main.lean + + - comparator_config: ComparatorChallenges/ExactFourier.json + declaration: OAI.ExactFourier.main_theorem + file: OAI/Computability/FourierCircuit/Main.lean + + - comparator_config: ComparatorChallenges/FactorGeneration.json + declaration: OAI.Generator.single_generation_of_II1_separable_predual + file: OAI/Analysis/FactorGeneration/Main.lean + + - comparator_config: ComparatorChallenges/FinitisticAsymmetry.json + declaration: OAI.LittleFinitistic.extreme_left_right_asymmetry + file: OAI/Algebra/FinitisticAsymmetry/Main.lean + + - comparator_config: ComparatorChallenges/ForestSpace.json + declaration: OAI.ForestSpace.main_theorem + file: OAI/Analysis/ForestSpace/Main.lean + + - comparator_config: ComparatorChallenges/FoulkesHowe.json + declaration: OAI.Problem346.canonical_foulkes_howe_surjective + file: OAI/RepresentationTheory/FoulkesHowe/Stabilization.lean + + - comparator_config: ComparatorChallenges/FreeIsing.json + declaration: OAI.Problem367.free_ising_factor_iff_threshold + file: OAI/Probability/FreeIsing/Main.lean + + - comparator_config: ComparatorChallenges/GaussianMoat.json + declaration: OAI.GaussianMoat.fullMain + file: OAI/NumberTheory/GaussianMoat/Main.lean + + - comparator_config: ComparatorChallenges/GaussianPropeller.json + declaration: OAI.GaussianPropeller.all_partitions + file: OAI/Probability/GaussianPropeller/Main.lean + + - comparator_config: ComparatorChallenges/GaussianReplacement.json + declaration: OAI.CurrentProjection.hybridBlockMain + file: OAI/Probability/GaussianReplacement/Hybrid.lean + + - comparator_config: ComparatorChallenges/GaussianReplacement.json + declaration: OAI.CurrentProjection.fiberBlockMain + file: OAI/Probability/GaussianReplacement/FiberBlock.lean + + - comparator_config: ComparatorChallenges/GotsmanLinial.json + declaration: OAI.LeanBlast.GotsmanLinial.gotsmanLinialStatement + file: OAI/Combinatorics/GotsmanLinial/Main.lean + + - comparator_config: ComparatorChallenges/GrahamSpherical.json + declaration: OAI.GrahamSpherical.full_main + file: OAI/Combinatorics/SphericalRamsey/Main.lean + + - comparator_config: ComparatorChallenges/GrothendieckElementaryExpansion.json + declaration: OAI.Grothendieck.elementary_expansion + file: OAI/CategoryTheory/Globular/ElementaryExpansion.lean + + - comparator_config: ComparatorChallenges/GroupRingDeterminant.json + declaration: OAI.GroupRingDeterminant.main + file: OAI/Analysis/GroupDeterminants/Main.lean + + - comparator_config: ComparatorChallenges/HarmonicArtin.json + declaration: OAI.HarmonicArtin.salvetti_cover_contractible + file: OAI/Topology/ArtinGroups/Realizations/SalvettiCoverContractible.lean + + - comparator_config: ComparatorChallenges/HarmonicGrowth.json + declaration: OAI.HarmonicCounterexample.main + file: OAI/Geometry/HarmonicGrowth/Main.lean + + - comparator_config: ComparatorChallenges/HeckeSevenEighths.json + declaration: OAI.SevenEighths.HeckeFamily.LFunction_ne_zero_of_seven_eighths_lt_re + file: OAI/NumberTheory/DirichletL/Hecke/Nonvanishing.lean + + - comparator_config: ComparatorChallenges/HenonEmden.json + declaration: OAI.HenonLaneEmden.main_nonexistence + file: OAI/Analysis/HenonEmden/Main.lean + + - comparator_config: ComparatorChallenges/HyperbolicCones.json + declaration: OAI.Paper256.main_result + file: OAI/Analysis/HyperbolicCones/Main.lean + + - comparator_config: ComparatorChallenges/HyperbolicObstruction.json + declaration: OAI.HyperbolicObstruction.main + file: OAI/Geometry/HyperbolicGroups/Main.lean + + - comparator_config: ComparatorChallenges/IndependentProducts.json + declaration: OAI.IndependentProducts.main_general + file: OAI/Analysis/ProductSpaces/WeakNullity.lean + + - comparator_config: ComparatorChallenges/IndependentProducts.json + declaration: OAI.IndependentProducts.main_exponential + file: OAI/Analysis/ProductSpaces/Main.lean + + - comparator_config: ComparatorChallenges/IndependentSets.json + declaration: OAI.LargeIndependentSets.mainTheoremReal + file: OAI/Combinatorics/IndependentSets/Main.lean + + - comparator_config: ComparatorChallenges/InfiniteMatroid.json + declaration: OAI.InfiniteMatroidCounterexample.main + file: OAI/Combinatorics/InfiniteMatroid/Main.lean + + - comparator_config: ComparatorChallenges/IsometricImmersion.json + declaration: OAI.SmoothLocal.Geometry.exists_local_metric_without_local_immersion + file: OAI/Geometry/IsometricImmersion/Main.lean + + - comparator_config: ComparatorChallenges/Jacobsthal.json + declaration: OAI.Erdos970.Erdos970Final.erdos_970_quadratic + file: OAI/NumberTheory/Jacobsthal/Conclusions/QuadraticBound.lean + + - comparator_config: ComparatorChallenges/KMedianRecovery.json + declaration: OAI.MetricKMedianRecovery.global_application + file: OAI/Combinatorics/KMedianRecovery/Main.lean + + - comparator_config: ComparatorChallenges/KahlerSplitting.json + declaration: OAI.UniversalCoverSplitting.main + file: OAI/Geometry/KahlerSplitting/Main.lean + + - comparator_config: ComparatorChallenges/KaplanskyFinitelyPresented.json + declaration: OAI.KaplanskyCounterexample.finitelyPresented_counterexample + file: OAI/RingTheory/DirectFiniteness/FinitelyPresented.lean + + - comparator_config: ComparatorChallenges/KaplanskyQuasitrace.json + declaration: OAI.Kaplansky.kaplansky_quasitrace_counterexample + file: OAI/Analysis/Kaplansky/Main.lean + + - comparator_config: ComparatorChallenges/Laughlin.json + declaration: OAI.Laughlin.mainTarget_proved + file: OAI/Analysis/Laughlin/Main.lean + + - comparator_config: ComparatorChallenges/LiebThirring.json + declaration: OAI.SharpLiebThirring.sharp_lieb_thirring + file: OAI/Analysis/LiebThirring/Main.lean + + - comparator_config: ComparatorChallenges/LipschitzEquivalence.json + declaration: OAI.LipschitzCounterexample.main + file: OAI/Analysis/LipschitzEquivalence/Main.lean + + - comparator_config: ComparatorChallenges/LittleFinitistic.json + declaration: OAI.LittleFinitistic.Main.exists_counterexample + file: OAI/Algebra/Finitistic/Main.lean + + - comparator_config: ComparatorChallenges/LogBrunnMinkowski.json + declaration: OAI.LogBrunnMinkowski.main + file: OAI/Geometry/LogVolume/BrunnMinkowski.lean + + - comparator_config: ComparatorChallenges/LogConcaveQuery.json + declaration: OAI.LogConcaveSampling.exact_source_main + file: OAI/Probability/LogConcave/Main.lean + + - comparator_config: ComparatorChallenges/MahlerConjecture.json + declaration: OAI.SymmetricMahler.symmetric_mahler + file: OAI/Analysis/Mahler/MainTheorem.lean + + - comparator_config: ComparatorChallenges/MarkovType.json + declaration: OAI.MarkovSuperreflexivity.hasNontrivialMarkovType_iff_hasEquivalentUCNorm + file: OAI/Analysis/MarkovType/Main.lean + + - comparator_config: ComparatorChallenges/MatchingEntropy.json + declaration: OAI.MatchingEntropy.entropy_main + file: OAI/Combinatorics/PerfectMatching/Main.lean + + - comparator_config: ComparatorChallenges/MatrixFields.json + declaration: OAI.MatrixAllFields.MatrixMultiplication.AllFieldMain.omega_lt_source_constant + file: OAI/LinearAlgebra/MatrixFields/Conclusions/AllFieldsBound.lean + + - comparator_config: ComparatorChallenges/MatrixMultiplication.json + declaration: OAI.MatrixMultiplication.complex_omega_le_nine_quarters + file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean + + - comparator_config: ComparatorChallenges/MatrixMultiplication.json + declaration: OAI.MatrixMultiplication.complex_alpha_gt_93_div_200 + file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean + + - comparator_config: ComparatorChallenges/MatrixMultiplication.json + declaration: OAI.MatrixMultiplication.complex_rectangular_omega_lt_523_div_250 + file: OAI/LinearAlgebra/MatrixMultiplication/Main.lean + + - comparator_config: ComparatorChallenges/MatrixRemoval.json + declaration: OAI.Problem348.no_polynomial_removal_bound + file: OAI/Combinatorics/MatrixRemoval/Main.lean + + - comparator_config: ComparatorChallenges/MaximalSeshadriConstants.json + declaration: OAI.MaximalSeshadri.Geometry.maximalSeshadriConstants + file: OAI/AlgebraicGeometry/Seshadri/Main.lean + + - comparator_config: ComparatorChallenges/MemoryPrecision.json + declaration: OAI.MemoryPrecision.main + file: OAI/Probability/MemoryPrecision/Main.lean + + - comparator_config: ComparatorChallenges/MetricEntropyDuality.json + declaration: OAI.MetricEntropyDuality.exists_entropy_duality_counterexample_with_covers + file: OAI/Analysis/MetricEntropy/Main.lean + + - comparator_config: ComparatorChallenges/MidpointLenses.json + declaration: OAI.SegmentLenses.midpoint_lens_main + file: OAI/Analysis/SegmentLenses/Main.lean + + - comparator_config: ComparatorChallenges/Nagata.json + declaration: OAI.Nagata.nagata_conjecture + file: OAI/AlgebraicGeometry/PlaneCurves/Nagata.lean + + - comparator_config: ComparatorChallenges/OddKaplansky.json + declaration: OAI.OddKaplansky.main_theorem + file: OAI/Algebra/OddKaplansky/Main.lean + + - comparator_config: ComparatorChallenges/OneWayLiveness.json + declaration: OAI.OneWayLiveness.main_theorem + file: OAI/Combinatorics/Automata/Main.lean + + - comparator_config: ComparatorChallenges/OptimalMaxCut.json + declaration: OAI.OptimalMaxCut.main + file: OAI/Computability/MaxCut/Main.lean + + - comparator_config: ComparatorChallenges/PartitionPrinciple.json + declaration: OAI.PartitionPilot.Forcing.TransitiveGround.exists_model_partitionPrinciple_without_choice + file: OAI/SetTheory/PartitionPrinciple/Models/Separation.lean + + - comparator_config: ComparatorChallenges/PerfectCompleteness.json + declaration: OAI.PerfectCompleteness.Theorem11.exists_reduction + file: OAI/Computability/PerfectCompleteness/Theorem11.lean + + - comparator_config: ComparatorChallenges/PeriodicTilingThree.json + declaration: OAI.PeriodicTilingThree.periodic_tiling_counterexample_and_minimality + file: OAI/Geometry/PeriodicTiling/Counterexample.lean + + - comparator_config: ComparatorChallenges/PettyProjectionVolume.json + declaration: OAI.PettyProjection.petty_projection_volume + file: OAI/Geometry/ProjectionBodies/Main.lean + + - comparator_config: ComparatorChallenges/PinchedKahler.json + declaration: OAI.PinchedHartogs.main_theorem + file: OAI/Geometry/Kahler/Main.lean + + - comparator_config: ComparatorChallenges/PinnedDistances.json + declaration: OAI.WeakPinned.main + file: OAI/Geometry/PinnedDistances/Main.lean + + - comparator_config: ComparatorChallenges/PlanarFalconer.json + declaration: OAI.PlanarFalconer.mainTarget_proved + file: OAI/MeasureTheory/Falconer/Main.lean + + - comparator_config: ComparatorChallenges/PlanarFirstPassage.json + declaration: OAI.PlanarFPP.manuscriptMain + file: OAI/Probability/FirstPassage/BoundaryCurve.lean + + - comparator_config: ComparatorChallenges/PlanarL1.json + declaration: OAI.PlanarL1.planar_graph_metrics_embed_L1 + file: OAI/Combinatorics/PlanarL1/Embedding.lean + + - comparator_config: ComparatorChallenges/PlaneColoring.json + declaration: OAI.Problem160.properColoring_seven + file: OAI/Geometry/PlaneColoring/Seven.lean + + - comparator_config: ComparatorChallenges/PosteriorReplicas.json + declaration: OAI.PosteriorReplicas.source_main + file: OAI/Probability/PosteriorReplicas/Main.lean + + - comparator_config: ComparatorChallenges/PowerFreeValues.json + declaration: OAI.QuarticPowerFree.allDegrees + file: OAI/NumberTheory/PowerFree/Main.lean + + - comparator_config: ComparatorChallenges/ProjectionCounterexample.json + declaration: OAI.ProjectionCounterexample.universal_simplex_upper_bound_false + file: OAI/Geometry/ProjectionBody/Counterexample.lean + + - comparator_config: ComparatorChallenges/ProjectionMoments.json + declaration: OAI.ProjectionMoments.main + file: OAI/Probability/ProjectionMoments/Main.lean + + - comparator_config: ComparatorChallenges/ProjectionVolume.json + declaration: OAI.Paper092.product_counterexample + file: OAI/Geometry/ProjectionVolume/ProductCounterexample.lean + + - comparator_config: ComparatorChallenges/QACParity.json + declaration: OAI.QAC.parity_lower_bound + file: OAI/InformationTheory/QuantumCircuit/Parity.lean + + - comparator_config: ComparatorChallenges/QuadricBundles.json + declaration: OAI.QuadricCounterexample.main_theorem + file: OAI/Geometry/QuadricBundles/Main.lean + + - comparator_config: ComparatorChallenges/QuantitativeVanDerWaerden.json + declaration: OAI.QuantitativeVanDerWaerden.uniform_lower_bound + file: OAI/Combinatorics/ProgressionColoring/Main.lean + + - comparator_config: ComparatorChallenges/QuasiRiemannHypothesis.json + declaration: OAI.riemannZeta_ne_zero_of_seven_eighths_lt_re + file: OAI/NumberTheory/DirichletL/Nonvanishing.lean + + - comparator_config: ComparatorChallenges/QuinticLienard.json + declaration: OAI.QuinticLienard.main + file: OAI/Analysis/LienardCycles/Main.lean + + - comparator_config: ComparatorChallenges/RadialTransition.json + declaration: OAI.RadialTransition.main + file: OAI/Probability/RadialTransition/Main.lean + + - comparator_config: ComparatorChallenges/RandomizedMeanPayoff.json + declaration: OAI.randomized_quasipolynomial_mean_payoff + file: OAI/Computability/RandomMean/Main.lean + + - comparator_config: ComparatorChallenges/RationalHitting.json + declaration: OAI.RationalHitting.main + file: OAI/Computability/RationalHitting/Main.lean + + - comparator_config: ComparatorChallenges/RecursivePotentials.json + declaration: OAI.ComparatorModel.RecursivePotentials.main + file: OAI/Analysis/RecursivePotentials/Challenge.lean + + - comparator_config: ComparatorChallenges/ReflexiveFixedPoints.json + declaration: OAI.ReflexiveFixedPoints.exists_fixedPoint_of_canonicallyReflexive + file: OAI/Analysis/Nonexpansive/Main.lean + + - comparator_config: ComparatorChallenges/RegularParity.json + declaration: OAI.QAC.parity_lower_bound_polynomial_size + file: OAI/InformationTheory/QuantumCircuit/Main.lean + + - comparator_config: ComparatorChallenges/RieszQuantitative.json + declaration: OAI.RieszRectifiability.quantitative_higher_codimension_riesz_rectifiability + file: OAI/Analysis/RieszRectifiability/Uniformity/Rectifiability.lean + + - comparator_config: ComparatorChallenges/RyserCovering.json + declaration: OAI.RyserCoveringCounterexample.exists_prime_eventually_counterexampleRank + file: OAI/Combinatorics/Ryser/Construction/Main.lean + + - comparator_config: ComparatorChallenges/RyserOddExtensions.json + declaration: OAI.RyserOdd.eventualOddFailures_and_infinite + file: OAI/Combinatorics/Ryser/OddExtensions.lean + + - comparator_config: ComparatorChallenges/Saxl.json + declaration: OAI.Saxl.saxl_conjecture + file: OAI/RepresentationTheory/Saxl/Main.lean + + - comparator_config: ComparatorChallenges/SecondKahnKalai.json + declaration: OAI.LeanBlast.SecondKahnKalai.secondKahnKalaiBounds + file: OAI/Combinatorics/GraphThreshold/Main.lean + + - comparator_config: ComparatorChallenges/SelfSimilar.json + declaration: OAI.EntropyRateDimension.entropy_rate_dimension + file: OAI/MeasureTheory/SelfSimilar/Main.lean + + - comparator_config: ComparatorChallenges/SensitivitySeparation.json + declaration: OAI.Paper320.quantitative_separation + file: OAI/Combinatorics/Sensitivity/Separation.lean + + - comparator_config: ComparatorChallenges/SeymourSecondNeighborhood.json + declaration: OAI.SeymourSecondNeighborhood.exists_goodVertex + file: OAI/Combinatorics/SecondNeighborhood/Main.lean + + - comparator_config: ComparatorChallenges/SiegelZeros.json + declaration: OAI.SiegelZeros.WeightedTorusJets.exists_absolute_real_zero_gap + file: OAI/NumberTheory/SiegelZeros/Conclusions/Theorem.lean + + - comparator_config: ComparatorChallenges/SignedFiniteBand.json + declaration: OAI.SignedDisk.CenteredDiskEndpoint.main_signed_finite_band + file: OAI/Analysis/SignedDisk/Main.lean + + - comparator_config: ComparatorChallenges/SimpleAmenable.json + declaration: OAI.SimpleAmenable.main + file: OAI/GroupTheory/SimpleAmenable/Main.lean + + - comparator_config: ComparatorChallenges/SingleFold.json + declaration: OAI.SingleFold.main + file: OAI/NumberTheory/SingleFold/Main.lean + + - comparator_config: ComparatorChallenges/SingleLatticeCovering.json + declaration: OAI.SingleLatticeCovering.single_lattice_covering + file: OAI/Geometry/LatticeCovering/Main.lean + + - comparator_config: ComparatorChallenges/SingletonLoopMatching.json + declaration: OAI.LoopMatching.fullEndpoint + file: OAI/Computability/LoopMatching/Main.lean + + - comparator_config: ComparatorChallenges/SmoothYau.json + declaration: OAI.YauCounterexamples.sphere_three + file: OAI/Geometry/SmoothYau/SphereMetric/ThreeSphere.lean + + - comparator_config: ComparatorChallenges/SmoothYau.json + declaration: OAI.YauCounterexamples.sphere_two_torus_two + file: OAI/Geometry/SmoothYau/ProductMetric/SphereProduct.lean + + - comparator_config: ComparatorChallenges/SteinitzBergstrom.json + declaration: OAI.EuclideanSteinitzBergstrom.main + file: OAI/Analysis/Steinitz/Main.lean + + - comparator_config: ComparatorChallenges/StrictMeans.json + declaration: OAI.StrictInverseFirstPower.main + file: OAI/Analysis/StrictMeans/Main.lean + + - comparator_config: ComparatorChallenges/StrongThinTree.json + declaration: OAI.StrongThinTree.strongThinTree + file: OAI/Combinatorics/ThinTrees/Main.lean + + - comparator_config: ComparatorChallenges/StructuralCrouzeix.json + declaration: OAI.StructuralCrouzeixReference.challenge + file: OAI/Analysis/StructuralCrouzeix/Endpoint.lean + + - comparator_config: ComparatorChallenges/SubpolynomialLp.json + declaration: OAI.SubpolynomialLp.source_main + file: OAI/Analysis/LpDimension/Main.lean + + - comparator_config: ComparatorChallenges/SubsphereCurrent.json + declaration: OAI.SubsphereCurrent.full_current_main_scope + file: OAI/Probability/Subsphere/Main.lean + + - comparator_config: ComparatorChallenges/Superstring.json + declaration: OAI.Superstring.main + file: OAI/Computability/Superstring/Main.lean + + - comparator_config: ComparatorChallenges/SymmetricDomains.json + declaration: OAI.Release061.main + file: OAI/Analysis/SymmetricDomains/Main.lean + + - comparator_config: ComparatorChallenges/SymmetricMahlerEquality.json + declaration: OAI.SymmetricMahler.symmetric_mahler_equality + file: OAI/Analysis/Mahler/Classification.lean + + - comparator_config: ComparatorChallenges/SymmetricPolar.json + declaration: OAI.SymmetricPolar.symmetric_polar_main + file: OAI/Geometry/PolarProducts/Main.lean + + - comparator_config: ComparatorChallenges/Tachikawa.json + declaration: OAI.Tachikawa.main_theorem + file: OAI/RingTheory/Tachikawa/Counterexample.lean + + - comparator_config: ComparatorChallenges/TalagrandDiscreteConvexity.json + declaration: OAI.TalagrandDiscreteConvexity.talagrand_discrete_convexity + file: OAI/Combinatorics/DiscreteConvexity/Main.lean + + - comparator_config: ComparatorChallenges/TalagrandExpectationThreshold.json + declaration: OAI.TalagrandThreshold.talagrand_expectation_threshold_equivalence + file: OAI/Combinatorics/ExpectationThreshold/Main.lean + + - comparator_config: ComparatorChallenges/TamingCompatibility.json + declaration: OAI.TamingCompatibility.taming_implies_compatibility + file: OAI/Geometry/TamingCompatibility/Main.lean + + - comparator_config: ComparatorChallenges/ThompsonNonamenability.json + declaration: OAI.ThompsonNonamenability.thompson_F_nonamenable_composition + file: OAI/GroupTheory/Thompson/Main.lean + + - comparator_config: ComparatorChallenges/ThorpRouting.json + declaration: OAI.ThorpNine.main + file: OAI/Probability/ThorpRouting/Main.lean + + - comparator_config: ComparatorChallenges/ThorpWeightedCompatibility.json + declaration: OAI.ThorpCompatibility.weightedCompatibility_main + file: OAI/Probability/ThorpCompatibility/Main.lean + + - comparator_config: ComparatorChallenges/TingleySphereIsometry.json + declaration: OAI.Tingley.tingley_sphere_isometry_full + file: OAI/Analysis/SphereIsometry/Extension.lean + + - comparator_config: ComparatorChallenges/TorsionFreeHyperbolic.json + declaration: OAI.Release075.main + file: OAI/GroupTheory/Hyperbolic/Main.lean + + - comparator_config: ComparatorChallenges/TorsionFreeZeroDivisors.json + declaration: OAI.TorsionFreeZeroDivisors.main + file: OAI/Algebra/GroupRing/Main.lean + + - comparator_config: ComparatorChallenges/TriangularHilbert.json + declaration: OAI.TriangularHilbert.main_estimate + file: OAI/Analysis/TriangularHilbert/Main.lean + + - comparator_config: ComparatorChallenges/TwoWayComplementation.json + declaration: OAI.TwoWayComplementation.complementation_lower_bound_finite + file: OAI/Combinatorics/TwoWayAutomata/Main.lean + + - comparator_config: ComparatorChallenges/TwoWayDeterminization.json + declaration: OAI.TwoWayComplementation.explicit_family_main + file: OAI/Combinatorics/TwoWayAutomata/ExplicitFamily.lean + + - comparator_config: ComparatorChallenges/UniformGamma.json + declaration: OAI.ComparatorModel.CurrentMain.main + file: OAI/Analysis/TracialSplitting/Challenge.lean + + - comparator_config: ComparatorChallenges/UniformSparsestCut.json + declaration: OAI.UniformSparsestCut.mainGap + file: OAI/Combinatorics/SparsestCut/Main.lean + + - comparator_config: ComparatorChallenges/UniqueGamesTheorem.json + declaration: OAI.UniqueGamesTheorem.theorem11 + file: OAI/Computability/UniqueGames/Theorem.lean + + - comparator_config: ComparatorChallenges/UniversalFInfinity.json + declaration: OAI.UniversalFInfinity.universal_group_of_type_FInfinity + file: OAI/GroupTheory/UniversalGroup/Main.lean + + - comparator_config: ComparatorChallenges/VertexCover.json + declaration: OAI.VertexCover.every_fixed_factor_below_two + file: OAI/Computability/VertexCover/Main.lean + + - comparator_config: ComparatorChallenges/VlasovMaxwell.json + declaration: OAI.RVM.global_classical_solution + file: OAI/Analysis/VlasovMaxwell/Main.lean + + - comparator_config: ComparatorChallenges/WeakHessian.json + declaration: OAI.WeakHessian.every_geodesic + file: OAI/Geometry/WeakHessian/Main.lean + + - comparator_config: ComparatorChallenges/WeakMTWGlobalSupport.json + declaration: OAI.WeakMTWGlobalSupport.current_main_convexity + file: OAI/Geometry/WeakMTW/Convexity.lean + + - comparator_config: ComparatorChallenges/YauCounterexample.json + declaration: OAI.Yau.Target.yau_nodal_set_upper_bound_counterexample + file: OAI/Geometry/NodalSets/Main.lean + +automation: + methods: + - method: agent + +review: + status: unchecked + +acknowledgements: >- + Thank you very much to the authors of Lean 4, mathlib, and the other imported + libraries listed above, as well as to the authors of Lake, Comparator, + lean4export, and related tools. diff --git a/research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json b/research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json new file mode 100644 index 0000000000..01c309e34d --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/frozen/upstream/manifest.json @@ -0,0 +1,83 @@ +{ + "commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a", + "files": { + "LICENSE": { + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/LICENSE" + }, + "README.md": { + "sha256": "8d1ceff898a4e0e681679f91c4def485820be9e99f04e4861f2ce601a364723e", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/README.md" + }, + "build/figures/multiplication-flow.tex": { + "sha256": "3654d2728b0c98919d61760e1802804ed616546a747f9167a93e17bb8697f320", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/figures/multiplication-flow.tex" + }, + "build/figures/proof-map.tex": { + "sha256": "76d4deacf07bea355412abcfd798c7cbe6dcccef29a4a420a9e2a7b158f23848", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/figures/proof-map.tex" + }, + "build/main.tex": { + "sha256": "42f0f506976bc2084374a71e97edc1549689a7accf35dda4db2a18af4f13c1aa", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/main.tex" + }, + "build/references.bib": { + "sha256": "33cc2df13ccf85330849e8fb34d4ac7613b23f625787457a5b7b9aa6d7369476", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/references.bib" + }, + "build/sections/00-introduction.tex": { + "sha256": "98721f03682ccf1cc7d0850b07adabaa2d8f3afe552e3861753eba9d284d0da0", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/00-introduction.tex" + }, + "build/sections/01-history.tex": { + "sha256": "798956c8150c31e3e2f5f29c47110d25ce619faad1374f4d3a0f15fa3ee33ead", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/01-history.tex" + }, + "build/sections/02-streams.tex": { + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/02-streams.tex" + }, + "build/sections/03-motifs.tex": { + "sha256": "ed76761194988a01af77ead0ea6469cb5dcd29690ab985a0b5a4006b0f2b69bb", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/03-motifs.tex" + }, + "build/sections/04-swap.tex": { + "sha256": "412b170ccaab38dba96e95e3cbfae09f4876a9818f8d278776a746b0f8044906", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/04-swap.tex" + }, + "build/sections/05-layers.tex": { + "sha256": "20cfc8d12099d4e4ed9e3e7eeb6162edd9b6e0e076f24693364cd24377252594", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/05-layers.tex" + }, + "build/sections/06-transforms.tex": { + "sha256": "924316e4bc905066281d8f9e8746a49d8829aeb393688608deb1e61c3c87853c", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/06-transforms.tex" + }, + "build/sections/07-resampling.tex": { + "sha256": "8a6b91670f9163afb54892489fa2210c77fe1b058f0325ec7d18b44b94be6e2c", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/07-resampling.tex" + }, + "build/sections/08-assembly.tex": { + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/08-assembly.tex" + }, + "build/sections/09-exact-arithmetic.tex": { + "sha256": "5714e5d0656c78c6a1fde8d01fd11f1ba856a7ea94149b283bd9a50fdbf516c3", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/09-exact-arithmetic.tex" + }, + "build/sections/10-transposition.tex": { + "sha256": "c14ad8d56112f6578678a58211bc8d63c3a4b60e55078ac73bc38f7348e713cb", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/10-transposition.tex" + }, + "build/sections/11-grouped-rectangles.tex": { + "sha256": "6525cd0a01980e56accfeaf06e9d875bc699197ba42c6e22b69435e352275174", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/preprints/Integer-multiplication-below-n-log-n-September-23-2026/build/sections/11-grouped-rectangles.tex" + }, + "formalization.yaml": { + "sha256": "2dcbd0d6e6a22475f53d49bfdfcac9b6d2b470653c332a9f56522f5be166edb9", + "url": "https://raw.githubusercontent.com/openai/math/adc7f1241b42e322a6451854ab7e4b4c146bf78a/lean/formalization.yaml" + } + }, + "paper": "preprints/Integer-multiplication-below-n-log-n-September-23-2026", + "repository": "https://github.com/openai/math" +} diff --git a/research/h25-bookkeeping/payload/baseline/full_B.py b/research/h25-bookkeeping/payload/baseline/full_B.py new file mode 100644 index 0000000000..d6f10b7908 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/full_B.py @@ -0,0 +1,11 @@ +"""Unchanged full-driver baseline entry; output supplied only by replay guard.""" +from hashlib import sha256 +import json +from pathlib import Path +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('full_B.py','archive_support.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('entry source pin: '+name) +namespace=dict(__file__=str(ROOT/'archive_support.py')) +exec(compile((ROOT/'archive_support.py').read_bytes(),namespace['__file__'],'exec'),namespace) +namespace['full_entry']('B') diff --git a/research/h25-bookkeeping/payload/baseline/full_C.py b/research/h25-bookkeeping/payload/baseline/full_C.py new file mode 100644 index 0000000000..b835526096 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/full_C.py @@ -0,0 +1,11 @@ +"""Unchanged full-driver candidate entry; output supplied only by replay guard.""" +from hashlib import sha256 +import json +from pathlib import Path +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('full_C.py','archive_support.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('entry source pin: '+name) +namespace=dict(__file__=str(ROOT/'archive_support.py')) +exec(compile((ROOT/'archive_support.py').read_bytes(),namespace['__file__'],'exec'),namespace) +namespace['full_entry']('C') diff --git a/research/h25-bookkeeping/payload/baseline/full_driver.py b/research/h25-bookkeeping/payload/baseline/full_driver.py new file mode 100644 index 0000000000..f4ff2a4313 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/full_driver.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python3 +"""One complete frozen complex-network CLI with retained exact observations. + +Parent-owned serial wall/RSS/aggregate guard is mandatory. Profile mode is one +literal baseline diagnostic/anchor, not a performance sample. Both benchmark +modes require its immutable anchor. No search, retry, orchestration or network. +""" +from __future__ import annotations + +import time +START_WALL = time.perf_counter() +import argparse +from contextlib import redirect_stdout +from fractions import Fraction +import hashlib +import importlib +import io +import json +import os +from pathlib import Path +import resource +import runpy +import shutil +import stat +import sys + +sys.dont_write_bytecode = True +HERE = Path(__file__).resolve().parent +BASE = "19fdb086ea96af9a9f87936a2b888e10af4ed810" +UPSTREAM = "adc7f1241b42e322a6451854ab7e4b4c146bf78a" +PIN_SHA = "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" +REFERENCE_SHA = "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" +ENGINE_PINS = { + "native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", +} +COMPLEMENT_EXPECTED = { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838", + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", +} +EXPECTED_STDOUT = ( + "PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000\n" + "Side roles per invocation 108195 vs original 3693800\n" +) + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + + +def cpu(): + own = resource.getrusage(resource.RUSAGE_SELF) + children = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + children.ru_utime + children.ru_stime + + +def inventory(root, pins, *, exact=True): + need(root.is_dir() and not root.is_symlink(), "Missing or symlinked input root") + files = {} + for path in sorted(root.rglob("*")): + need(not path.is_symlink(), "Symlink in frozen inputs: " + str(path)) + if path.is_file(): + relative = str(path.relative_to(root)) + if relative not in pins: + need(not exact, "Undeclared frozen input: " + relative) + continue + raw = path.read_bytes() + expected = pins[relative][0] if type(pins[relative]) is list else pins[relative] + need(sha(raw) == expected, "Frozen input digest changed: " + relative) + files[relative] = {"sha256": sha(raw), "mode": stat.S_IMODE(path.stat().st_mode), "bytes": len(raw)} + need(set(files) == set(pins), "Frozen input inventory incomplete") + return files + + +def typed(value): + """Lossless full return representation, including order and exact types.""" + kind = type(value) + if kind is Fraction: + return ["Fraction", value.numerator, value.denominator] + if value is None: + return ["None"] + if kind is bool: + return ["bool", value] + if kind is int: + return ["int", str(value)] + if kind is float: + return ["float", value.hex()] + if kind is str: + return ["str", value] + if kind is list or kind is tuple: + return [kind.__name__, [typed(item) for item in value]] + if kind is dict: + return ["dict", [[typed(key), typed(item)] for key, item in value.items()]] + raise TypeError("Unsupported exact full-certificate return type: " + kind.__name__) + + +class Phases: + """Observational wrappers delegate each call and preserve its return.""" + def __init__(self): + self.rows = {} + + def call(self, name, function, *args, **kwargs): + wall, used = time.perf_counter(), cpu() + try: + return function(*args, **kwargs) + finally: + row = self.rows.setdefault(name, {"calls": 0, "wall_seconds": 0.0, "cpu_seconds_with_children": 0.0}) + row["calls"] += 1 + row["wall_seconds"] += time.perf_counter() - wall + row["cpu_seconds_with_children"] += cpu() - used + + def wrap(self, owner, attribute, name): + original = getattr(owner, attribute) + def observed(*args, **kwargs): + return self.call(name, original, *args, **kwargs) + setattr(owner, attribute, observed) + return original, observed + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--frozen-root", type=Path, required=True) + parser.add_argument("--reference", type=Path, required=True, help="Pinned original complex-network.json file") + parser.add_argument("--mode", choices=("profile", "baseline", "candidate"), required=True) + parser.add_argument("--output", type=Path, required=True, help="New external directory; every write stays below it") + parser.add_argument("--anchor", type=Path, help="Frozen anchor.json emitted by the one profile run") + args = parser.parse_args() + need(sys.flags.optimize == 0, "Every full-caller mode requires original assertions") + need(sys.implementation.name == "cpython" and sys.version_info[:2] == (3, 12), "Frozen CPython 3.12 required") + need((args.mode == "profile") == (args.anchor is None), "Profile creates the anchor; both benchmark arms require --anchor") + frozen, reference = args.frozen_root.resolve(), args.reference.resolve() + output = args.output.resolve() + need(not output.exists(), "Refusing to overwrite run evidence") + need(not output.is_relative_to(HERE) and not output.is_relative_to(frozen), "Output must be outside immutable sources") + need(reference.is_file() and not reference.is_symlink(), "Reference certificate missing or symlinked") + source_pin_bytes = (HERE / "SOURCE-PINS.json").read_bytes() + need(sha(source_pin_bytes) == PIN_SHA, "Source inventory pin changed") + pins = json.loads(source_pin_bytes) + need(len(pins) == 32, "Frozen closure must contain twelve scripts, manifest and nineteen payloads") + reference_bytes = reference.read_bytes() + need(sha(reference_bytes) == REFERENCE_SHA, "Original full certificate reference changed") + driver_before = Path(__file__).read_bytes() + anchor_bytes = None if args.anchor is None else args.anchor.read_bytes() + expected_anchor = None if anchor_bytes is None else json.loads(anchor_bytes) + if expected_anchor is not None: + need(expected_anchor.get("schema") == "gf2-full-network-anchor-v1" and + expected_anchor.get("base_commit") == BASE and expected_anchor.get("source_pin_sha256") == PIN_SHA and + expected_anchor.get("driver_sha256") == sha(driver_before) and + expected_anchor.get("engine_pins") == ENGINE_PINS, + "Anchor source/driver/engine identity differs; no benchmark permitted") + output.mkdir(parents=True) + compiler_tmp = output / "compiler-tmp" + compiler_tmp.mkdir() + os.environ["TMPDIR"] = str(compiler_tmp) + phases = Phases() + frozen_before = phases.call("input_custody", inventory, frozen, pins) + engine_before = phases.call("engine_custody", inventory, HERE / "engine", ENGINE_PINS) + manifest = json.loads((frozen / "upstream/manifest.json").read_bytes()) + need(manifest["commit"] == UPSTREAM and len(manifest["files"]) == 19, "Wrong pinned upstream manifest") + need({"upstream/" + name for name in manifest["files"]} == + {name for name in pins if name.startswith("upstream/") and name != "upstream/manifest.json"}, + "Source verifier payload closure changed") + for name, info in manifest["files"].items(): + need(info["sha256"] == pins["upstream/" + name][0], "Manifest payload hash differs from independent frozen pin") + + runtime, engine = output / "runtime-root", output / "engine" + phases.call("fresh_root_copy", shutil.copytree, frozen, runtime) + phases.call("fresh_engine_copy", shutil.copytree, HERE / "engine", engine) + # copytree retains readonly source directory permissions. Only this new + # private root is made writable for the original CLI certificate output. + runtime.chmod(0o755) + (runtime / "certificates").mkdir() + runtime_before = inventory(runtime, pins) + copied_engine_before = inventory(engine, ENGINE_PINS) + need(runtime_before == frozen_before and copied_engine_before == engine_before, "Copy changed input bytes or modes") + for name in ("complex_network.py", "complex_circuit.py"): + need((engine / "source" / name).read_bytes() == (runtime / "scripts" / name).read_bytes(), + "PR5929 engine/source differs from the full caller closure") + script_names = {Path(name).stem for name in pins if name.startswith("scripts/")} + engine_names = {"native_backend", "finite_controls", "compare_side_verifier", "profile_side_verifier"} + need(not (script_names | engine_names) & set(sys.modules), "Scientific module already loaded; fresh process required") + sys.path[:0] = [str(engine), str(runtime / "scripts")] + backend = phases.call("cold_engine_import", importlib.import_module, "native_backend") + comparison = importlib.import_module("compare_side_verifier") + native = None + finite = None + build = None + if args.mode == "candidate": + native, build = phases.call("cold_compile_link_load", backend.build_native, output / "cold-build") + finite = phases.call("all_native_finite_independent_controls", importlib.import_module("finite_controls").run_controls, native) + (output / "finite-controls.json").write_bytes(canonical(finite) + b"\n") + + circuit_module = phases.call("cold_complex_module_load", backend.load_source, "complex_circuit") + sys.modules["complex_circuit"] = circuit_module + rank_calls = [] + complement = backend.ComplementTrace(circuit_module.Label) + binding = None + if args.mode == "candidate": + binding = backend.bind(circuit_module, native, rank_calls, complement) + else: + backend.guard_module(circuit_module) + backend.attach_trace(circuit_module, rank_calls, complement) + captures = {} + phases.wrap(circuit_module.ComplexSideCircuit, "__init__", "side_construction") + phases.wrap(circuit_module.Checks, "__init__", "checks_initialization") + phases.wrap(circuit_module, "compile_roles", "compile_roles") + phases.wrap(circuit_module.Checks, "verify_map", "verify_map") + phases.wrap(circuit_module.Checks, "verify_labels", "verify_labels") + original_roles = circuit_module.verify_role_frames + def observe_roles(c, checks, code=None): + need("side" not in captures and code is not None, "Unexpected role-frame invocation") + result = phases.call("verify_role_frames", original_roles, c, checks, code) + captures["side"] = (c, checks, code, result) + return result + circuit_module.verify_role_frames = observe_roles + + certify = phases.call("cold_certify_import", importlib.import_module, "certify") + phases.wrap(certify, "verify_sources", "original_upstream_verify_sources") + prepare = phases.call("cold_prepare_import", importlib.import_module, "prepare_layers") + search = importlib.import_module("search_network") + phases.wrap(search, "log_integer_bounds", "full_log_integer_bounds") + original_serializable = prepare.serializable + depth = 0 + def observe_serializable(value): + nonlocal depth + outer = depth == 0 + if outer: + need("full_return" not in captures and type(value) is dict, "Unexpected outer serialization") + captures["full_return"] = value + depth += 1 + try: + # Recursion still delegates the original serializable exactly once + # per value; only the outer call is captured/timed. + if outer: + return phases.call("original_serializable", original_serializable, value) + return original_serializable(value) + finally: + depth -= 1 + prepare.serializable = observe_serializable + + caller = runtime / "scripts/complex_network.py" + old_argv = sys.argv + stdout = io.StringIO() + try: + sys.argv = [str(caller)] + with redirect_stdout(stdout): + namespace = phases.call("complete_original_cli", runpy.run_path, str(caller), run_name="__main__") + finally: + sys.argv = old_argv + cli_stdout = stdout.getvalue() + need(cli_stdout == EXPECTED_STDOUT, "Original CLI stdout changed") + certificate_bytes = (runtime / "certificates/complex-network.json").read_bytes() + need(certificate_bytes == reference_bytes, "Original CLI certificate bytes differ from the pinned reference") + need(sys.modules["complex_circuit"] is circuit_module and + namespace["ComplexSideCircuit"] is circuit_module.ComplexSideCircuit and + namespace["Checks"] is circuit_module.Checks and namespace["compile_roles"] is circuit_module.compile_roles and + namespace["verify_role_frames"] is observe_roles and namespace["serializable"] is observe_serializable, + "Caller used a different scientific module or observation binding") + need(captures.keys() == {"side", "full_return"}, "Missing exact caller observations") + c, checks, code, role_result = captures["side"] + full_return = captures["full_return"] + need(full_return["role_frames"] is role_result and full_return["upstream_commit"] == UPSTREAM, + "Role return or actual source verification boundary changed") + for name in ("side_construction", "checks_initialization", "compile_roles", "verify_map", "verify_labels", + "verify_role_frames", "original_upstream_verify_sources", "full_log_integer_bounds", + "original_serializable", "complete_original_cli"): + need(phases.rows.get(name, {}).get("calls") == 1, "Original phase was omitted or repeated: " + name) + imports = {} + for name in script_names - {"complex_network"}: + module = sys.modules.get(name) + expected_path = engine / "source/complex_circuit.py" if name == "complex_circuit" else runtime / "scripts" / (name + ".py") + need(module is not None and Path(module.__file__).resolve() == expected_path.resolve(), "Unpinned scientific import: " + name) + imports[name] = str(module.__file__) + if binding is not None: + binding["runtime_guard"].check() + need(binding["counters"] == {"complement_native": 238685, "complement_fallback": 0, + "gram_native": 59959, "gram_fallback": 0}, "Native full-call coverage changed") + + side_result = {key: full_return[key] for key in ("circuit", "side_map", "labels", "role_frames")} + witness = { + "support": c.support, "args": c.args, "kind": c.kind, "active": sorted(c.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) for target, node, coefficient in c.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + side_output = output / "side-observations" + side_output.mkdir() + side_receipt = phases.call("identical_lossless_side_serialization", comparison.write_scientific, + side_output, side_result, witness, rank_calls) + complement_receipt = complement.receipt() + need(complement_receipt == COMPLEMENT_EXPECTED, "Every ordered complement observation must match PR5929") + full_typed_bytes = canonical(typed(full_return)) + (output / "full-return.lossless.json").write_bytes(full_typed_bytes) + (output / "original-stdout.txt").write_text(cli_stdout, encoding="utf-8") + (output / "complement-transcript.json").write_bytes(canonical(complement_receipt) + b"\n") + science = { + "full_cli_certificate_sha256": sha(certificate_bytes), "full_cli_stdout_sha256": sha(cli_stdout.encode("utf-8")), + "full_return_lossless_sha256": sha(full_typed_bytes), "side": side_receipt, + "ordered_complements": complement_receipt, "upstream_commit": UPSTREAM, + } + anchor = {"schema": "gf2-full-network-anchor-v1", "base_commit": BASE, "source_pin_sha256": PIN_SHA, + "driver_sha256": sha(driver_before), "engine_pins": ENGINE_PINS, "science": science} + if expected_anchor is not None: + need(anchor == expected_anchor, "Complete certificate/types/ordered observations differ from frozen anchor") + else: + (output / "anchor.json").write_bytes(canonical(anchor) + b"\n") + need(inventory(frozen, pins) == frozen_before and inventory(HERE / "engine", ENGINE_PINS) == engine_before, + "Immutable source bytes/modes changed") + need(inventory(runtime, pins, exact=False) == runtime_before and inventory(engine, ENGINE_PINS) == copied_engine_before, + "Runtime scientific source bytes/modes changed") + runtime_files = {str(path.relative_to(runtime)) for path in runtime.rglob("*") if path.is_file()} + need(runtime_files == set(pins) | {"certificates/complex-network.json"}, "Unexpected full-caller file side effect") + need(Path(__file__).read_bytes() == driver_before and reference.read_bytes() == reference_bytes and + (anchor_bytes is None or args.anchor.read_bytes() == anchor_bytes), "Driver/reference/anchor changed during run") + receipt = { + "status": "FULL_NETWORK_PROFILE_ANCHOR_PASS" if args.mode == "profile" else "FULL_NETWORK_COMPLETE_PASS", + "mode": args.mode, "science": science, "base_commit": BASE, "native_predecessor_pr": 5929, + "driver_sha256": sha(driver_before), "source_pin_sha256": PIN_SHA, + "frozen_custody": frozen_before, "engine_custody": engine_before, "scientific_imports": imports, + "build": build, "finite_controls": finite, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "compiler_tmpdir": str(compiler_tmp), + "native_calls": None if binding is None else dict(binding["counters"]), + "phases": phases.rows, "process_wall_seconds_before_receipt": time.perf_counter() - START_WALL, + "process_and_compiler_cpu_seconds_before_receipt": cpu(), + "environment": {"python": sys.version, "executable": sys.executable, "platform": sys.platform}, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + } + (output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + sys.stdout.write(cli_stdout) + print(json.dumps({"status": receipt["status"], "mode": args.mode, "science": science, + "wall_seconds": receipt["process_wall_seconds_before_receipt"], + "cpu_seconds_with_compiler": receipt["process_and_compiler_cpu_seconds_before_receipt"], + "phases": phases.rows}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/payload/baseline/guard.py b/research/h25-bookkeeping/payload/baseline/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/guard.py @@ -0,0 +1,120 @@ +"""Serial bounded Linux measurements; preserve the complete frozen precision contract.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import platform +import signal +import statistics +import subprocess +import sys +import tempfile +import time + +HERE = Path(__file__).resolve().parent +SOURCE = HERE +CLOSURE = ('frozen.py','primitive_profile.py','guard.py','dispatch.py','inputs/PR5848.tar','../feasibility/fraction_table.py','../feasibility/finite.py','/usr/lib/python3.12/fractions.py','../feasibility/actual_audit.py') +TIMEOUT = 180 +RSS_CAP = 1024**3 +OUTPUT_CAP = 2*1024**2 +AGGREGATE = 600 +PREVIOUS_WALL_SECONDS = 0 + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + +def inventory(): + result = {} + for name in CLOSURE: + path = SOURCE / name + if path.is_symlink() or not path.is_file(): + raise ValueError('Regular complete runtime file: ' + name) + result[name] = [sha(path.read_bytes()), path.stat().st_mode & 0o777] + return result + +def group_rss(group): + total = 0 + count = 0 + for p in Path('/proc').iterdir(): + if not p.name.isdigit(): + continue + try: + raw = (p/'stat').read_text() + fields = raw[raw.rfind(')')+2:].split() + if int(fields[2]) == group: + total += int(fields[21])*os.sysconf('SC_PAGE_SIZE') + count += 1 + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + return total, count + +def run(label, script, optimized=False): + records = HERE/'runs' + records.mkdir(exist_ok=True) + prior = list(records.glob('*/receipt.json')) + spent = PREVIOUS_WALL_SECONDS + sum(json.loads(p.read_bytes())['wall_seconds'] for p in prior) + if spent >= AGGREGATE: + raise ValueError('Aggregate budget consumed') + folder = records/label + folder.mkdir() + before = inventory() + env = os.environ.copy() + for key in ('PYTHONPATH','PYTHONOPTIMIZE','PYTHONINSPECT','PYTHONSTARTUP','PYTHONPYCACHEPREFIX'): + env.pop(key,None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC') + usage = folder/'usage.json' + with tempfile.TemporaryDirectory(prefix='linux5757-bytecode-') as cache: + command = ['/usr/bin/python3.12', '-B', '-X', 'pycache_prefix='+cache] + if optimized: + command.append('-O') + command.append(str(SOURCE/script)) + timed = ['/usr/bin/time','-f','{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', '-o', str(usage),'--',*command] + start = time.monotonic() + peak = 0 + stop = None + with (folder/'stdout.txt').open('wb') as out, (folder/'stderr.txt').open('wb') as err: + p = subprocess.Popen(timed, cwd=SOURCE, env=env, stdout=out, stderr=err, start_new_session=True) + try: + while p.poll() is None: + rss, _ = group_rss(p.pid) + peak = max(peak,rss) + elapsed = time.monotonic()-start + if rss > RSS_CAP: + stop='sampled_group_rss_cap' + elif elapsed > min(TIMEOUT,AGGREGATE-spent): + stop='wall_or_aggregate_cap' + elif max((folder/'stdout.txt').stat().st_size,(folder/'stderr.txt').stat().st_size)>OUTPUT_CAP: + stop='output_cap' + if stop: + os.killpg(p.pid,signal.SIGKILL) + break + time.sleep(0.05) + code=p.wait() + finally: + try: os.killpg(p.pid,signal.SIGKILL) + except ProcessLookupError: pass + p.wait() + elapsed = time.monotonic()-start + stdout=(folder/'stdout.txt').read_bytes() + stderr=(folder/'stderr.txt').read_bytes() + after=inventory() + measurement=None + if usage.exists(): + try: measurement=json.loads(usage.read_bytes()) + except json.JSONDecodeError: measurement={'raw':usage.read_text()} + receipt={'label':label,'script':script,'optimized':optimized,'wall_seconds':elapsed, + 'exit':code,'termination':stop,'sampled_process_group_rss_bytes':peak, + 'usage':measurement,'stdout_sha256':sha(stdout),'stdout_bytes':len(stdout), + 'stderr_sha256':sha(stderr),'stderr_bytes':len(stderr), + 'source_inventory_sha256':sha(json.dumps(before,sort_keys=True,separators=(',',':')).encode()), + 'source_bytes_and_modes_unchanged':before==after, + 'python':sys.version,'platform':platform.platform(), + 'runner_sha256':sha(Path(__file__).read_bytes()),'runtime_policy_sha256':sha(json.dumps(CLOSURE).encode())} + receipt['status']='PASS' if code==0 and stop is None and not stderr and before==after else 'STOP' + (folder/'receipt.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + print(json.dumps(receipt,sort_keys=True),flush=True) + if receipt['status']!='PASS': + raise SystemExit(1) + return receipt diff --git a/research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json b/research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json new file mode 100644 index 0000000000..62a6091887 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/reference/certificates/complex-network.json @@ -0,0 +1,143 @@ +{ + "bit_saving": "37/12500000000", + "circuit": { + "additions": 80595, + "disjoint_additions": 68595, + "h": 25, + "injections": 27600, + "pair_star_additions": 12000, + "roles": 108195, + "roles_per_target": 47.041, + "v": 2300 + }, + "complex_counts": { + "I": 15870000, + "L": 10315500000, + "N": 12167000000, + "W": 1741801270000, + "central_roles": 26, + "deficit": 3703000000, + "eta": "28/205789375", + "h": 25, + "m": 15625, + "original_side_wires_per_invocation": 3693800, + "s": 27215641140750000, + "side_roles_per_invocation": 108195, + "v": 2300 + }, + "complex_deficit_slack": "6761797/8231575000000000", + "complex_saving": "7/500000000", + "gates": { + "gates_per_invocation": 340784, + "total_gates": 5408242080000, + "twelve_W": 20901615240000 + }, + "improvement_over_compact_control": "590/83", + "labels": { + "active_nodes": 82895, + "all_labels_nondegenerate": true, + "all_residuals_have_odd_vectors": true, + "checked_inclusions": 188790 + }, + "log_enclosure": [ + "1003674733095412338935264801206694829502804118660273821722358572561777951813562324984581151664909098376456139346987946438356114944865114544057566309229396051200891281693308045036569381219925884240815457348697380244265196736/103936362434495646010619550865033734742948881177937982419226476521510946436948314218071351858470876811875561920539687733866419026027866373569756270393100104240876895441796280524990301784985328254889750901950661699188332905", + "119905674780465260758132999318298249674205865631153226854493684575647168973933813765866273005815485563618924127097549911779010579460799218169313950759672923946122257420539013677630274686709038285230521425787947340179037163618384721/12416930765507746510068682343342696843957626338057657633016923061769841067667425271918924168691987416458733797440474694605908192976129102762466882436295692453310093108779928980052174719912913882184162241086372384329699504384000000" + ], + "log_m_upper": "483/50", + "role_frames": { + "forward_frames_nested": true, + "reverse_complement_frames_nested": true, + "roles": 108195 + }, + "scope": "Conditional on the pinned upstream interfaces, the compact-control movement and guard proofs, the paired bit network, and the written binary-frame transfer for this complex side circuit. Exact arithmetic and finite checks are not formal verification.", + "scoped_ceiling": { + "below_2_to_minus_30": true, + "scope": "Published h=50 paired bit network and retained Gaussian margin; not a bound on other networks or algorithms.", + "upper": "37/62500000000" + }, + "side_map": { + "coefficients": "+1/2 disjoint, -1/2 intersection two", + "nonzero_coefficients": 3693800, + "side_map_exact": true, + "targets": 2300 + }, + "status": "CONDITIONAL 59/10^11 WITNESS; COMPRESSED COMPLEX SIDE CIRCUIT; NOT FORMAL VERIFICATION", + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a", + "witness": { + "absorption_gap": "29261/25000000000000000", + "constraint_slacks": { + "K_dominates_log_p": "19979001/100000000", + "K_smaller_than_ell": "60021999/100000000", + "alpha_below_sqrt_p": "80001/400000", + "beta_below_one": "999/1000", + "beta_positive": "1/1000", + "c_positive": "999/1000", + "crt_layout": "2960037/1250000000000000", + "delta_below_one_eighth": "124999/1000000", + "delta_positive": "1/1000000", + "dimension_upper_bound": "40003/300000", + "epsilon_positive": "19999/100000", + "gamma_sublinear": "40003/200000", + "gaussian_cost": "23/2000000", + "guard_width": "829961/1000000000", + "kappa_positive": "59/100000000000", + "lambda_above_sigma": "5521/500000000000", + "lambda_above_tau": "1/500000000000", + "lambda_below_one": "1479/500000000000", + "lambda_prime_above_lambda": "1/500000000000", + "lambda_prime_below_one": "739/250000000000", + "leaf_cost": "1103/100000000000", + "packed_overhead": "1/500000000000", + "prefix_cost": "60021999/100000000", + "prime_interval_growth": "30001/50000", + "r_superpolynomial": "80001/100000", + "reserved_axes": "249749999261/250000000000", + "scalar_cost": "800009/1000000", + "sigma_below_one": "7/500000000", + "sigma_positive": "499999993/500000000", + "tau_below_one": "37/12500000000", + "tau_positive": "12499999963/12500000000" + }, + "guard": { + "B": 338201706233372774319109678801287590064, + "C0": 321727027889740762489223803495350305328695729120143793284991524019954162292886152000000, + "C1": "49961/10000", + "E": 338201706233372774319082463160146840064, + "beta": "1/1000", + "m": 15625, + "s": 27215641140750000, + "zeta": "1/10000" + }, + "limiting_margins": [ + "g3" + ], + "margins": { + "g1": "60021999/100000000", + "g2": "739223037/1250000000000000000", + "g3": "14779261/25000000000000000", + "g4": "2960037/1250000000000000", + "g5": "23/2000000", + "g6": "800009/1000000", + "g7": "19999/100000" + }, + "minimum_margin": "14779261/25000000000000000", + "parameters": { + "C1": "49961/10000", + "beta": "1/1000", + "c": "999/1000", + "delta": "1/1000000", + "epsilon": "19999/100000", + "kappa": "59/100000000000", + "lam": "499999998521/500000000000", + "lamp": "249999999261/250000000000", + "sigma": "499999993/500000000", + "tau": "12499999963/12500000000" + }, + "recurrence": { + "internal": "12499999963/12500000000", + "layer": "12499999963/12500000000", + "leaf": "499999993007/500000000000", + "preprocessing": "1/1000" + } + } +} diff --git a/research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json b/research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json new file mode 100644 index 0000000000..581f8d8700 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/reference/certificates/selected-result.json @@ -0,0 +1,112 @@ +{ + "status": "Selected maintainer-reviewed conditional P104 helper-subspace construction with exact Linux primary and independent caller replays", + "kappa": "62009/20000000", + "decimal": "0.00310045", + "source_prs": [ + 5599, + 5565, + 5580, + 5569, + 5561, + 5551, + 5545, + 5544, + 5550, + 5567, + 2305, + 2152, + 2219, + 5398, + 5400, + 4610, + 5241, + 4470, + 4447, + 4441, + 4440, + 4416, + 4433, + 4359, + 4268, + 3945, + 4085, + 2979, + 4076, + 4088, + 1673, + 1758, + 1786, + 23, + 555, + 589 + ], + "source_manifest": "certificates/frontier5599-source.json", + "certificate": "certificates/frontier5599/CLAIM.json", + "certificate_sha256": "66fbb5b21f32f1c4ba544c20d5a44ebcdfd11bce2bfa2d609c656ae520d3b21e", + "proof": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "proof_supplements": { + "notes/batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/semantic-bulk/pr23/semantic-bulk-17-note.tex": "652242b05174bb776ffc6165af170df9c8cf220dbd0fc26c24d778f320dbabc8", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1", + "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "docs/research/pr-intake-evidence/pr4359/PROOF-REVIEW.md": "7d67bb814285f7634029fbd378c6457156545f0b38858cc1c6ec34b68cd9d162", + "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b", + "docs/research/pr-intake-evidence/pr4416/PROOF-REVIEW.md": "2c2bbe6fe1bab44778192118f27e59a0d23dbe02c47aa8a42845093f1ce46f49", + "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md": "b84f833e3072cbab372fbda2ece98fbc031c15e590cf73003ddea35a5222e148", + "research/final4610-independent-admission/PROOF.md": "e573cbbe6fa5481c0533e773de404e10f4dc7907b5ebfe404bdcd02dcf9844d8", + "research/final4610-independent-admission/SPECIALIZATION.md": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md": "7688e5d8bf40fcdfb5bea43ba47e1f8d60a77a91ede6c307bb8163a9a7e16b3f", + "research/p104-helper-subspace-splits/PROOF.md": "f4c68acf9373e34d88e14e1a7791b4b739c8b5297a1ae4c0121f579a02fde04e", + "research/p104-productive-controller/PROOF.md": "f4c4e400092954562252df6c4dd157a9b4c1642252168ce72738cdbecfc5ad41", + "research/p104-caller-independent-audit/PROOF.md": "d73ff9587a85db8063391919ffc4a17521ccd5759cdaf6338ba036703239d839", + "research/p104-free-endpoint-contract-audit/PROOF.md": "43aeae1c090b5657f326fd7c56a5e5fbe062db29591b660a903305ca58ce9598" + }, + "review": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "validation": "docs/research/pr-intake-evidence/pr5599-completion/VALIDATION.json", + "integration": "docs/research/pr-intake-evidence/pr5599-completion/INTEGRATION.json", + "reproduce": "make frontier5599-verify", + "scope": "Conditional P104 helper-subspace splitting and all-forward productive caller. The five inherited framework assumptions remain; no materialized uniform word or complete rounded multiplier.", + "previous_kappa": "605457647/200000000000", + "previous_record": "certificates/checkpoints/frontier5413.json", + "audited_source_head": "09dd0965711ca7eeb169057a420abab1c9052137", + "source_certificate": "research/p104-helper-subspace-splits/RESULT.json", + "source_certificate_sha256": "1d92e587915052110dfb3aca8890df5afdaf496164efa5a4a52e69ceeb3c70f3", + "replay_mode": "Fresh serial Linux normal and optimized primary replays, exact original caller positive control, and independent caller inventory adaptation. All under sampled 1 GiB descendant RSS guards. Prior selected framework/BIT foundation is explicitly reused.", + "contributors": "docs/research/community-p1045599-contributors.md", + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "audit_pr": 5550, + "audit_head": "6125c07ae8ba4b8550e2a0a28a2c6be503153059" +} diff --git a/research/h25-bookkeeping/payload/baseline/replay.py b/research/h25-bookkeeping/payload/baseline/replay.py new file mode 100644 index 0000000000..5269c08908 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/replay.py @@ -0,0 +1,51 @@ +"""One serial complete replay; no automatic retries or performance selection.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('replay.py','archive_support.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('replay source pin: '+name) +S=types.ModuleType('_gf2_full_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def run(arm,evidence,timeout=180): + import fcntl + import os + import tempfile + S.need(arm in ('B','C') and type(timeout) is int and 1<=timeout<=180,'bounded single B/C replay') + S.need(sys.platform=='linux' and sys.version_info[:2]==(3,12) and sys.flags.optimize==0,'Linux CPython3.12 with full assertions') + manifest=S.authenticate();evidence=S.external(evidence) + guard=S.source_module('_gf2_full_guard',ROOT/'guard.py') + lock_path=Path(tempfile.gettempdir())/('croc-gf2-full-'+sha256(str(ROOT).encode()).hexdigest()[:20]+'.lock') + with lock_path.open('a') as lock: + fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) + evidence.mkdir(parents=True) + guard.HERE=evidence;guard.SOURCE=ROOT + guard.CLOSURE=tuple(sorted(set(manifest['files'])|{'CODE-SOURCES.json'})) + guard.TIMEOUT=timeout;guard.RSS_CAP=1024**3;guard.AGGREGATE=timeout + prior=os.environ.get('CROC_GF2_FULL_OUTPUT') + os.environ['CROC_GF2_FULL_OUTPUT']=str(evidence/'scientific') + try: + receipt=guard.run('complete-'+arm,'full_'+arm+'.py',False) + finally: + if prior is None:os.environ.pop('CROC_GF2_FULL_OUTPUT',None) + else:os.environ['CROC_GF2_FULL_OUTPUT']=prior + S.authenticate() + scientific=json.loads((evidence/'scientific/receipt.json').read_text()) + anchor=json.loads((ROOT/'anchor.json').read_text()) + S.need(receipt['status']=='PASS' and scientific['status']=='FULL_NETWORK_COMPLETE_PASS' and scientific['science']==anchor['science'],'complete frozen caller and retained exact science') + S.need(scientific['mode']==('baseline' if arm=='B' else 'candidate'),'requested complete arm') + return dict(guard=receipt,scientific=scientific,evidence=str(evidence),automatic_retries=0) + + +def main(): + S.need(len(sys.argv)==3 and sys.argv[1] in ('B','C'),'replay.py B|C NEW_EXTERNAL_EVIDENCE_DIRECTORY') + result=run(sys.argv[1],Path(sys.argv[2])) + print(json.dumps(dict(status='PASS_FRESH_FULL_REPLAY',evidence=result['evidence'],new_timings_replace_fixed_samples=False))) + + +if __name__=='__main__':main() diff --git a/research/h25-bookkeeping/payload/baseline/verify.py b/research/h25-bookkeeping/payload/baseline/verify.py new file mode 100644 index 0000000000..c4e2f80853 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/verify.py @@ -0,0 +1,45 @@ +"""Fresh unchanged finite controls in normal or optimized interpreter mode.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('verify.py','archive_support.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('finite wrapper source pin: '+name) +S=types.ModuleType('_gf2_finite_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def main(): + import os + import runpy + import shutil + import tempfile + S.need(len(sys.argv)==1,'no alternate finite workload') + S.authenticate();temporary=Path(tempfile.mkdtemp(prefix='gf2-full-finite-')) + old_argv=sys.argv[:];old_path=sys.path[:];old_cache=sys.pycache_prefix;old_dont=sys.dont_write_bytecode + prior_tmp=os.environ.get('TMPDIR') + try: + sys.pycache_prefix=str(temporary/'bytecode');sys.dont_write_bytecode=True + os.environ['TMPDIR']=str(temporary) + sys.path.insert(0,str(ROOT/'engine')) + driver=ROOT/'engine/compare_side_verifier.py' + sys.argv=[str(driver),'--mode','finite','--output',str(temporary/'evidence')] + runpy.run_path(str(driver),run_name='__main__') + receipt=json.loads((temporary/'evidence/receipt.json').read_text()) + S.need(receipt['status']=='FINITE_PASS' and receipt['mode']=='finite' and receipt['environment']['optimization']==sys.flags.optimize,'complete unchanged finite suite in requested interpreter mode') + S.authenticate() + except BaseException as error: + error.add_note('Failed finite build/control evidence retained at '+str(temporary)) + raise + else:shutil.rmtree(temporary) + finally: + sys.argv=old_argv;sys.path[:]=old_path;sys.pycache_prefix=old_cache;sys.dont_write_bytecode=old_dont + if prior_tmp is None:os.environ.pop('TMPDIR',None) + else:os.environ['TMPDIR']=prior_tmp + print(json.dumps(dict(status='PASS_GF2_FULL_FINITE_CONTROLS',optimization=sys.flags.optimize,complete_cli_not_run=True))) + + +if __name__=='__main__':main() diff --git a/research/h25-bookkeeping/payload/baseline/verify_full.py b/research/h25-bookkeeping/payload/baseline/verify_full.py new file mode 100644 index 0000000000..79fa04f262 --- /dev/null +++ b/research/h25-bookkeeping/payload/baseline/verify_full.py @@ -0,0 +1,36 @@ +"""One complete C correctness replay; never a hosted performance-factor claim.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +ROOT=Path(__file__).resolve().parent +pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] +for name in ('verify_full.py','archive_support.py','replay.py'): + if sha256((ROOT/name).read_bytes()).hexdigest()!=pins[name]:raise ValueError('full correctness wrapper pin: '+name) +S=types.ModuleType('_gf2_verify_full_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def main(): + import shutil + import tempfile + S.need(len(sys.argv)==1 and sys.flags.optimize==0,'one full correctness run with original assertions') + S.authenticate();temporary=Path(tempfile.mkdtemp(prefix='gf2-full-correctness-')) + replay=S.source_module('_gf2_verify_full_replay',ROOT/'replay.py') + try: + result=replay.run('C',temporary/'run',timeout=150) + S.need(result['scientific']['science']==json.loads((ROOT/'anchor.json').read_text())['science'],'full exact anchor equality') + S.authenticate() + # Only fresh private clone directories become writable, after all checks. + # Read-only input/package paths are never changed. + for directory in temporary.rglob('*'): + if directory.is_dir() and not directory.is_symlink():directory.chmod(0o755) + shutil.rmtree(temporary) + except BaseException as error: + error.add_note('Full correctness evidence retained at '+str(temporary)) + raise + print(json.dumps(dict(status='PASS_GF2_FULL_C_CORRECTNESS',hosted_performance_factor_claim=False,fixed_benchmark_sample=False,inner_timeout_seconds=150))) + + +if __name__=='__main__':main() diff --git a/research/h25-bookkeeping/payload/freeze_stage.py b/research/h25-bookkeeping/payload/freeze_stage.py new file mode 100644 index 0000000000..e502494232 --- /dev/null +++ b/research/h25-bookkeeping/payload/freeze_stage.py @@ -0,0 +1,61 @@ +"""Source custody only: freeze a new stage without imports or scientific runs.""" +import argparse +import ast +import hashlib +import json +from pathlib import Path +import shutil + +HERE = Path(__file__).resolve().parent + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('name') + args = parser.parse_args() + if not args.name or any(c not in 'abcdefghijklmnopqrstuvwxyz0123456789-_' for c in args.name): + raise ValueError('Simple new stage name required') + stage = HERE / 'stages' / args.name + stage.mkdir() + shutil.copytree(HERE / 'baseline', stage / 'baseline') + for name in ('PLAN.md', 'PLAN.json', 'run_guarded.py', 'freeze_stage.py'): + shutil.copy2(HERE / name, stage / name) + for directory in ('integration', 'priorities'): + for source in sorted((HERE / directory).rglob('*')): + if source.is_symlink(): + raise ValueError('Symlinked working source') + if source.is_file() and source.suffix in ('.py', '.c', '.json', '.md'): + if source.suffix == '.py': + ast.parse(source.read_bytes()) + target = stage / source.relative_to(HERE) + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(source, target) + jobs = {} + for lane in ('none', 'sets', 'guards', 'trace', 'all'): + jobs['finite-' + lane] = {'lanes': lane, 'finite_only': True} + jobs['finite-O-' + lane] = {'lanes': lane, 'finite_only': True, 'optimized': True} + jobs['full-' + lane] = {'lanes': lane, 'finite_only': False} + (stage / 'JOBS.json').write_text(json.dumps(jobs, indent=2, sort_keys=True) + '\n') + rows = {} + for path in sorted(stage.rglob('*')): + if path.is_file(): + path.chmod(0o444 | (path.stat().st_mode & 0o111)) + rows[str(path.relative_to(stage))] = {'sha256': hashlib.sha256(path.read_bytes()).hexdigest(), + 'mode': path.stat().st_mode & 0o777} + receipt = {'schema': 'h25-bookkeeping-immutable-stage-v1', 'files': rows, + 'runner_sha256': hashlib.sha256((HERE / 'run_guarded.py').read_bytes()).hexdigest(), + 'baseline_head': '4f4159820c37f01d245784d1186bd51fcbc8ebb6', + 'baseline_arm': 'native C, original controls and observations retained', + 'scientific_execution_during_freeze': False} + (stage / 'STAGE.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + (stage / 'STAGE.json').chmod(0o444) + for path in sorted(stage.rglob('*'), reverse=True): + if path.is_dir(): + path.chmod(0o555) + stage.chmod(0o555) + print(json.dumps({'stage': str(stage), 'files': len(rows), + 'stage_sha256': hashlib.sha256((stage / 'STAGE.json').read_bytes()).hexdigest()})) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/payload/integration/DERIVATION.json b/research/h25-bookkeeping/payload/integration/DERIVATION.json new file mode 100644 index 0000000000..c0c881859a --- /dev/null +++ b/research/h25-bookkeeping/payload/integration/DERIVATION.json @@ -0,0 +1,78 @@ +{ + "both_new_arms_use_original_native_C_mode": true, + "derived_driver_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "exact_inverse_restores_original_bytes": true, + "old_controls_and_observer_reference_unmodified": true, + "patches": [ + { + "new": "import adapters\nROUND = Path(__file__).resolve().parent.parent\nHERE = ROUND / \"baseline\"\nREFERENCE_DRIVER_SHA = \"0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36\"", + "old": "HERE = Path(__file__).resolve().parent" + }, + { + "new": "parser.add_argument(\"--frozen-root\", type=Path, default=HERE / \"frozen\")", + "old": "parser.add_argument(\"--frozen-root\", type=Path, required=True)" + }, + { + "new": "parser.add_argument(\"--reference\", type=Path, default=HERE / \"reference/certificates/complex-network.json\")", + "old": "parser.add_argument(\"--reference\", type=Path, required=True, help=\"Pinned original complex-network.json file\")" + }, + { + "new": "parser.add_argument(\"--lanes\", choices=(\"none\", \"sets\", \"guards\", \"trace\", \"all\"), required=True)\n parser.add_argument(\"--finite-only\", action=\"store_true\")", + "old": "parser.add_argument(\"--mode\", choices=(\"profile\", \"baseline\", \"candidate\"), required=True)" + }, + { + "new": "parser.add_argument(\"--anchor\", type=Path, default=HERE / \"anchor.json\")", + "old": "parser.add_argument(\"--anchor\", type=Path, help=\"Frozen anchor.json emitted by the one profile run\")" + }, + { + "new": "args = parser.parse_args()\n args.mode = \"candidate\" # Every new arm starts from the original native C configuration.\n need(args.finite_only or sys.flags.optimize == 0, \"Every full-caller mode requires original assertions\")", + "old": "args = parser.parse_args()\n need(sys.flags.optimize == 0, \"Every full-caller mode requires original assertions\")" + }, + { + "new": "driver_before = Path(__file__).read_bytes()\n new_custody_before = adapters.custody(ROUND, args.lanes)\n reference_driver_before = (HERE / \"full_driver.py\").read_bytes()\n need(sha(reference_driver_before) == REFERENCE_DRIVER_SHA, \"Reference driver pin changed\")", + "old": "driver_before = Path(__file__).read_bytes()" + }, + { + "new": "expected_anchor.get(\"driver_sha256\") == REFERENCE_DRIVER_SHA", + "old": "expected_anchor.get(\"driver_sha256\") == sha(driver_before)" + }, + { + "new": "extensions = phases.call(\"new_adapter_preparation\", adapters.prepare, ROUND, backend, native, output, args.lanes, phases)\n finite = phases.call(\"all_native_finite_independent_controls\", importlib.import_module(\"finite_controls\").run_controls, native)\n phases.call(\"all_new_controls\", adapters.run_controls, extensions, backend, native, phases)", + "old": "finite = phases.call(\"all_native_finite_independent_controls\", importlib.import_module(\"finite_controls\").run_controls, native)" + }, + { + "new": " if args.finite_only:\n need(inventory(frozen, pins) == frozen_before and inventory(HERE / \"engine\", ENGINE_PINS) == engine_before, \"Finite immutable source custody changed\")\n need(inventory(runtime, pins) == runtime_before and inventory(engine, ENGINE_PINS) == copied_engine_before, \"Finite copied source custody changed\")\n need(adapters.custody(ROUND, args.lanes) == new_custody_before, \"Finite new source custody changed\")\n result = {\"status\": \"H25_BOOKKEEPING_FINITE_PASS\", \"lanes\": args.lanes,\n \"optimized\": sys.flags.optimize, \"original_controls\": finite,\n \"new_controls\": extensions[\"controls\"], \"new_source_custody\": new_custody_before,\n \"driver_sha256\": sha(driver_before),\n \"reference_driver_sha256\": REFERENCE_DRIVER_SHA, \"phases\": phases.rows}\n (output / \"receipt.json\").write_text(json.dumps(result, indent=2, sort_keys=True) + \"\\n\")\n print(json.dumps(result, sort_keys=True))\n return\n\n circuit_module = phases.call(\"cold_complex_module_load\", backend.load_source, \"complex_circuit\")", + "old": " circuit_module = phases.call(\"cold_complex_module_load\", backend.load_source, \"complex_circuit\")" + }, + { + "new": "complement = extensions[\"trace_type\"](circuit_module.Label)\n phases.call(\"private_set_adapter_installation\", adapters.install_set, extensions, circuit_module)", + "old": "complement = backend.ComplementTrace(circuit_module.Label)" + }, + { + "new": " phases.call(\"private_set_lease_sealing\", adapters.seal, extensions)\n caller = runtime / \"scripts/complex_network.py\"", + "old": " caller = runtime / \"scripts/complex_network.py\"" + }, + { + "new": " try:\n adapters.arm(extensions)\n sys.argv = [str(caller)]", + "old": " try:\n sys.argv = [str(caller)]" + }, + { + "new": " finally:\n sys.argv = old_argv\n adapters.disarm(extensions)", + "old": " finally:\n sys.argv = old_argv" + }, + { + "new": "\"driver_sha256\": REFERENCE_DRIVER_SHA, \"engine_pins\": ENGINE_PINS, \"science\": science", + "old": "\"driver_sha256\": sha(driver_before), \"engine_pins\": ENGINE_PINS, \"science\": science" + }, + { + "new": " \"mode\": args.mode, \"lanes\": args.lanes, \"bookkeeping\": adapters.receipt(extensions),\n \"reference_driver_sha256\": REFERENCE_DRIVER_SHA,\n \"science\": science, \"base_commit\": BASE, \"native_predecessor_pr\": 5995,", + "old": " \"mode\": args.mode, \"science\": science, \"base_commit\": BASE, \"native_predecessor_pr\": 5929," + }, + { + "new": " need(adapters.custody(ROUND, args.lanes) == new_custody_before, \"New source custody changed\")\n receipt = {\n \"new_source_custody\": new_custody_before,\n \"status\":", + "old": " receipt = {\n \"status\":" + } + ], + "reference_driver_sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36", + "source_only_derivation_no_scientific_execution": true +} diff --git a/research/h25-bookkeeping/payload/integration/adapters.py b/research/h25-bookkeeping/payload/integration/adapters.py new file mode 100644 index 0000000000..fa0e234a23 --- /dev/null +++ b/research/h25-bookkeeping/payload/integration/adapters.py @@ -0,0 +1,220 @@ +"""Parent-owned integration; called only inside the serial scientific runner.""" +import hashlib +import importlib.util +import json +from pathlib import Path +import shlex +import subprocess +import sys +import sysconfig +from types import BuiltinFunctionType, ModuleType + + +def custody(root, lanes): + """Pay selected new source authentication inside every measured process.""" + selected = set() if lanes == 'none' else ({'sets', 'guards', 'trace'} if lanes == 'all' else {lanes}) + files = ['integration/full_driver.py', 'integration/adapters.py', 'integration/derive_driver.py', + 'integration/DERIVATION.json', 'PLAN.md', 'PLAN.json'] + for lane, directory in (('sets', 'set-reuse'), ('guards', 'runtime-guards'), ('trace', 'trace-encoding')): + if lane in selected: + files.extend(str(path.relative_to(root)) for path in sorted((root / 'priorities' / directory).iterdir()) + if path.is_file() and path.suffix in ('.py', '.c')) + manifest = json.loads((root / 'STAGE.json').read_bytes()) + result = {} + for name in files: + path = root / name + if path.is_symlink() or not path.is_file(): + raise RuntimeError('Missing or symlinked new source: ' + name) + row = {'sha256': hashlib.sha256(path.read_bytes()).hexdigest(), 'mode': path.stat().st_mode & 0o777} + if row != manifest['files'][name]: + raise RuntimeError('New source custody failed: ' + name) + result[name] = row + return result + + +def load(path, name): + if name in sys.modules: + raise RuntimeError('Isolated adapter name already imported: ' + name) + spec = importlib.util.spec_from_file_location(name, path) + if spec is None or spec.loader is None: + raise RuntimeError('Missing isolated adapter loader') + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + try: + spec.loader.exec_module(module) + except BaseException: + sys.modules.pop(name, None) + raise + return module + + +def build_encoder(source, directory): + if directory.exists(): + raise RuntimeError('Refusing to reuse a trace build directory') + directory.mkdir() + raw = source.read_bytes() + target = directory / ('_trace_encoding' + sysconfig.get_config_var('EXT_SUFFIX')) + command = shlex.split(sysconfig.get_config_var('CC') or 'cc') + [ + '-shared', '-fPIC', '-O3', '-std=c11', '-Wall', '-Wextra', '-Werror', + '-I' + sysconfig.get_paths()['include'], str(source), '-o', str(target)] + completed = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, timeout=90, check=False) + receipt = {'command': command, 'returncode': completed.returncode, + 'stdout': completed.stdout, 'stderr': completed.stderr, + 'source_sha256': hashlib.sha256(raw).hexdigest(), 'no_cached_binary': True} + (directory / 'build.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + if completed.returncode != 0 or source.read_bytes() != raw: + raise RuntimeError('Trace compilation or source custody failed; no retry') + receipt['extension_sha256'] = hashlib.sha256(target.read_bytes()).hexdigest() + module = load(target, '_trace_encoding') + (directory / 'build.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + return module, receipt + + +def extra_guard_type(base, backend, entries): + """Check the new encoder's owner/entry at every original guard boundary.""" + _type, _get = backend._TYPE, backend._DICT_GET + error = backend._RUNTIME_ERROR + for owner, name, function in entries: + if not (_type(owner) is ModuleType and _type(function) is BuiltinFunctionType and + function.__self__ is owner and _get(owner.__dict__, name) is function): + raise error('Invalid trace encoder owner or entry') + + class ExtendedGuard(base): + def __init__(self, module, label, native, original_functions): + self._h25_entries = entries + base.__init__(self, module, label, native, original_functions) + + def check(self): + base.check(self) + for owner, name, function in self._h25_entries: + if not (_type(owner) is ModuleType and _get(owner.__dict__, name) is function): + raise error('Runtime drift: trace encoder entry point ' + name) + + return ExtendedGuard + + +def prepare(root, backend, native, output, lanes, phases): + selected = set() if lanes == 'none' else ({'sets', 'guards', 'trace'} if lanes == 'all' else {lanes}) + if not selected <= {'sets', 'guards', 'trace'}: + raise RuntimeError('Unsupported frozen lane selection') + state = {'selected': selected, 'controls': {}, 'trace_type': backend.ComplementTrace, + 'set_binding': None, 'encoder_build': None, 'encoder': None} + if 'guards' in selected: + state['guard_adapter'] = load(root / 'priorities/runtime-guards/guard_candidate.py', '_h25_guard_candidate') + state['guard_controls'] = load(root / 'priorities/runtime-guards/guard_controls.py', '_h25_guard_controls') + state['reference_backend'] = load(Path(backend.__file__), '_h25_reference_backend') + backend.RuntimeGuard = state['guard_adapter'].make_runtime_guard(backend) + if 'trace' in selected: + directory = root / 'priorities/trace-encoding' + encoder, build = phases.call('trace_cold_compile_link_load', build_encoder, + directory / 'trace_encoder.c', output / 'trace-cold-build') + adapter = load(directory / 'trace_adapter.py', 'trace_adapter') + trace_type = adapter.make_trace_type(backend, encoder) + state.update(encoder=encoder, encoder_build=build, trace_type=trace_type, + trace_controls=load(directory / 'trace_controls.py', '_h25_trace_controls')) + backend.RuntimeGuard = extra_guard_type(backend.RuntimeGuard, backend, trace_type._h25_native_entries) + if 'sets' in selected: + directory = root / 'priorities/set-reuse' + state['set_adapter'] = load(directory / 'set_reuse.py', 'set_reuse') + state['set_controls'] = load(directory / 'finite_set_controls.py', '_h25_set_controls') + return state + + +def run_controls(state, backend, native, phases): + result = state['controls'] + if 'guards' in state['selected']: + result['guards'] = phases.call('new_guard_differential_controls', + state['guard_controls'].run_guard_controls, + state['reference_backend'], backend, native) + if 'trace' in state['selected']: + result['trace'] = phases.call('new_trace_original_differential_controls', + state['trace_controls'].run_controls, backend, state['encoder']) + result['trace_entry_freshness'] = phases.call('new_trace_entry_freshness_controls', + entry_controls, backend, native, state) + if 'sets' in state['selected']: + result['sets'] = phases.call('new_private_set_controls', + state['set_controls'].run_controls, backend, state['set_adapter']) + return result + + +def entry_controls(backend, native, state): + module = backend.load_source('_h25_trace_entry_controls') + trace = state['trace_type'](module.Label) + calls = [] + binding = backend.bind(module, native, calls, trace) + small, big = object.__new__(module.Label), object.__new__(module.Label) + small.basis, big.basis = {0: 1}, {0: 1, 1: 2} + wide_small, wide_big = object.__new__(module.Label), object.__new__(module.Label) + wide_small.basis, wide_big.basis = {0: 1 << 100}, {0: 1, 1: 1 << 100} + original = state['encoder'].encode_record + outcomes = [] + before = (dict(binding['counters']), list(calls), trace.receipt()) + try: + state['encoder'].encode_record = lambda *args: b'corrupt' + for action in (binding['runtime_guard'].check, small.nondegenerate, lambda: small.complement_in(big), + wide_small.nondegenerate, lambda: wide_small.complement_in(wide_big)): + try: + action() + except RuntimeError as error: + if str(error) != 'Runtime drift: trace encoder entry point encode_record': + raise + outcomes.append(str(error)) + else: + raise RuntimeError('Changed trace entry was not rejected before arithmetic') + if (dict(binding['counters']), list(calls), trace.receipt()) != before: + raise RuntimeError('Changed trace entry executed arithmetic or observations') + finally: + state['encoder'].encode_record = original + binding['runtime_guard'].check() + return {'status': 'PASS', 'negative_actions': len(outcomes), 'rejected_before_arithmetic_and_observation': True} + + +def install_set(state, module): + if 'sets' not in state['selected']: + return + binding = state['set_adapter'].bind_verify_map(module) + module.Checks.verify_map = binding['verify_map'] + owner = binding['owner'] + circuit_init, checks_init = module.ComplexSideCircuit.__init__, module.Checks.__init__ + + def captured_circuit(self, *args, **kwargs): + circuit_init(self, *args, **kwargs) + owner.capture_c(self) + + def captured_checks(self, *args, **kwargs): + checks_init(self, *args, **kwargs) + owner.capture_checks(self) + + module.ComplexSideCircuit.__init__ = captured_circuit + module.Checks.__init__ = captured_checks + state['set_binding'] = binding + + +def seal(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].seal() + + +def arm(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].arm_cli() + + +def disarm(state): + if state['set_binding'] is not None: + state['set_binding']['owner'].disarm_cli() + + +def receipt(state): + result = {'lanes': sorted(state['selected']), 'new_controls': state['controls'], + 'encoder_build': state['encoder_build'], + 'original_observer_retained_for_old_controls': True} + if state['set_binding'] is not None: + result['set_reuse'] = dict(state['set_binding']['receipt']) + if result['set_reuse']['fast_admissions'] != 1 or result['set_reuse']['fallback_calls'] != 0: + raise RuntimeError('Complete caller did not use the single admitted set-reuse lease') + if (result['set_reuse']['private_operand_sets_constructed'] != 2300 or + result['set_reuse']['reservations'] != 1 or result['set_reuse']['reservations_expired'] != 1): + raise RuntimeError('Private set construction or one-use lease count changed') + return result diff --git a/research/h25-bookkeeping/payload/integration/derive_driver.py b/research/h25-bookkeeping/payload/integration/derive_driver.py new file mode 100644 index 0000000000..fe64141540 --- /dev/null +++ b/research/h25-bookkeeping/payload/integration/derive_driver.py @@ -0,0 +1,83 @@ +"""Derive an explicit engineering driver with a reversible, bounded edit list. + +This script edits source text only. It never imports or executes scientific code. +The science anchor's driver digest names the immutable reference driver, while +each engineering receipt separately records the actual derived driver digest. +""" +from pathlib import Path +import ast +import hashlib +import json + +ROOT = Path(__file__).resolve().parent.parent +REFERENCE_SHA = '0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36' +PATCHES = [ + ('HERE = Path(__file__).resolve().parent', + 'import adapters\nROUND = Path(__file__).resolve().parent.parent\nHERE = ROUND / "baseline"\nREFERENCE_DRIVER_SHA = "' + REFERENCE_SHA + '"'), + ('parser.add_argument("--frozen-root", type=Path, required=True)', + 'parser.add_argument("--frozen-root", type=Path, default=HERE / "frozen")'), + ('parser.add_argument("--reference", type=Path, required=True, help="Pinned original complex-network.json file")', + 'parser.add_argument("--reference", type=Path, default=HERE / "reference/certificates/complex-network.json")'), + ('parser.add_argument("--mode", choices=("profile", "baseline", "candidate"), required=True)', + 'parser.add_argument("--lanes", choices=("none", "sets", "guards", "trace", "all"), required=True)\n parser.add_argument("--finite-only", action="store_true")'), + ('parser.add_argument("--anchor", type=Path, help="Frozen anchor.json emitted by the one profile run")', + 'parser.add_argument("--anchor", type=Path, default=HERE / "anchor.json")'), + ('args = parser.parse_args()\n need(sys.flags.optimize == 0, "Every full-caller mode requires original assertions")', + 'args = parser.parse_args()\n args.mode = "candidate" # Every new arm starts from the original native C configuration.\n need(args.finite_only or sys.flags.optimize == 0, "Every full-caller mode requires original assertions")'), + ('driver_before = Path(__file__).read_bytes()', + 'driver_before = Path(__file__).read_bytes()\n new_custody_before = adapters.custody(ROUND, args.lanes)\n reference_driver_before = (HERE / "full_driver.py").read_bytes()\n need(sha(reference_driver_before) == REFERENCE_DRIVER_SHA, "Reference driver pin changed")'), + ('expected_anchor.get("driver_sha256") == sha(driver_before)', + 'expected_anchor.get("driver_sha256") == REFERENCE_DRIVER_SHA'), + ('finite = phases.call("all_native_finite_independent_controls", importlib.import_module("finite_controls").run_controls, native)', + 'extensions = phases.call("new_adapter_preparation", adapters.prepare, ROUND, backend, native, output, args.lanes, phases)\n finite = phases.call("all_native_finite_independent_controls", importlib.import_module("finite_controls").run_controls, native)\n phases.call("all_new_controls", adapters.run_controls, extensions, backend, native, phases)'), + (' circuit_module = phases.call("cold_complex_module_load", backend.load_source, "complex_circuit")', + ' if args.finite_only:\n need(inventory(frozen, pins) == frozen_before and inventory(HERE / "engine", ENGINE_PINS) == engine_before, "Finite immutable source custody changed")\n need(inventory(runtime, pins) == runtime_before and inventory(engine, ENGINE_PINS) == copied_engine_before, "Finite copied source custody changed")\n need(adapters.custody(ROUND, args.lanes) == new_custody_before, "Finite new source custody changed")\n result = {"status": "H25_BOOKKEEPING_FINITE_PASS", "lanes": args.lanes,\n "optimized": sys.flags.optimize, "original_controls": finite,\n "new_controls": extensions["controls"], "new_source_custody": new_custody_before,\n "driver_sha256": sha(driver_before),\n "reference_driver_sha256": REFERENCE_DRIVER_SHA, "phases": phases.rows}\n (output / "receipt.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\\n")\n print(json.dumps(result, sort_keys=True))\n return\n\n circuit_module = phases.call("cold_complex_module_load", backend.load_source, "complex_circuit")'), + ('complement = backend.ComplementTrace(circuit_module.Label)', + 'complement = extensions["trace_type"](circuit_module.Label)\n phases.call("private_set_adapter_installation", adapters.install_set, extensions, circuit_module)'), + (' caller = runtime / "scripts/complex_network.py"', + ' phases.call("private_set_lease_sealing", adapters.seal, extensions)\n caller = runtime / "scripts/complex_network.py"'), + (' try:\n sys.argv = [str(caller)]', + ' try:\n adapters.arm(extensions)\n sys.argv = [str(caller)]'), + (' finally:\n sys.argv = old_argv', + ' finally:\n sys.argv = old_argv\n adapters.disarm(extensions)'), + ('"driver_sha256": sha(driver_before), "engine_pins": ENGINE_PINS, "science": science', + '"driver_sha256": REFERENCE_DRIVER_SHA, "engine_pins": ENGINE_PINS, "science": science'), + (' "mode": args.mode, "science": science, "base_commit": BASE, "native_predecessor_pr": 5929,', + ' "mode": args.mode, "lanes": args.lanes, "bookkeeping": adapters.receipt(extensions),\n "reference_driver_sha256": REFERENCE_DRIVER_SHA,\n "science": science, "base_commit": BASE, "native_predecessor_pr": 5995,'), + (' receipt = {\n "status":', + ' need(adapters.custody(ROUND, args.lanes) == new_custody_before, "New source custody changed")\n receipt = {\n "new_source_custody": new_custody_before,\n "status":'), +] + + +def main(): + source = (ROOT / 'baseline/full_driver.py').read_bytes() + if hashlib.sha256(source).hexdigest() != REFERENCE_SHA: + raise ValueError('Pinned reference driver differs') + original = source.decode() + result = original + for old, new in PATCHES: + if result.count(old) != 1: + raise ValueError('Driver edit does not have exactly one original match: ' + old[:100]) + result = result.replace(old, new, 1) + ast.parse(result) + reverse = result + for old, new in PATCHES[::-1]: + if reverse.count(new) != 1: + raise ValueError('Driver inverse is ambiguous') + reverse = reverse.replace(new, old, 1) + if reverse != original: + raise ValueError('Driver exact inverse failed') + (ROOT / 'integration/full_driver.py').write_text(result) + receipt = {'reference_driver_sha256': REFERENCE_SHA, + 'derived_driver_sha256': hashlib.sha256(result.encode()).hexdigest(), + 'patches': [{'old': old, 'new': new} for old, new in PATCHES], + 'exact_inverse_restores_original_bytes': True, + 'old_controls_and_observer_reference_unmodified': True, + 'both_new_arms_use_original_native_C_mode': True, + 'source_only_derivation_no_scientific_execution': True} + (ROOT / 'integration/DERIVATION.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps({k: v for k, v in receipt.items() if k != 'patches'}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/payload/integration/full_driver.py b/research/h25-bookkeeping/payload/integration/full_driver.py new file mode 100644 index 0000000000..dfcefae1ae --- /dev/null +++ b/research/h25-bookkeeping/payload/integration/full_driver.py @@ -0,0 +1,387 @@ +#!/usr/bin/env python3 +"""One complete frozen complex-network CLI with retained exact observations. + +Parent-owned serial wall/RSS/aggregate guard is mandatory. Profile mode is one +literal baseline diagnostic/anchor, not a performance sample. Both benchmark +modes require its immutable anchor. No search, retry, orchestration or network. +""" +from __future__ import annotations + +import time +START_WALL = time.perf_counter() +import argparse +from contextlib import redirect_stdout +from fractions import Fraction +import hashlib +import importlib +import io +import json +import os +from pathlib import Path +import resource +import runpy +import shutil +import stat +import sys + +sys.dont_write_bytecode = True +import adapters +ROUND = Path(__file__).resolve().parent.parent +HERE = ROUND / "baseline" +REFERENCE_DRIVER_SHA = "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36" +BASE = "19fdb086ea96af9a9f87936a2b888e10af4ed810" +UPSTREAM = "adc7f1241b42e322a6451854ab7e4b4c146bf78a" +PIN_SHA = "88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7" +REFERENCE_SHA = "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" +ENGINE_PINS = { + "native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "profile_side_verifier.py": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a", + "source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", +} +COMPLEMENT_EXPECTED = { + "calls": 238685, + "canonical_stream_bytes": 55839507, + "sha256": "7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838", + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors", +} +EXPECTED_STDOUT = ( + "PASS conditional 59/100000000000 > 2^-31; minimum margin 14779261/25000000000000000\n" + "Side roles per invocation 108195 vs original 3693800\n" +) + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def sha(data): + return hashlib.sha256(data).hexdigest() + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + + +def cpu(): + own = resource.getrusage(resource.RUSAGE_SELF) + children = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + children.ru_utime + children.ru_stime + + +def inventory(root, pins, *, exact=True): + need(root.is_dir() and not root.is_symlink(), "Missing or symlinked input root") + files = {} + for path in sorted(root.rglob("*")): + need(not path.is_symlink(), "Symlink in frozen inputs: " + str(path)) + if path.is_file(): + relative = str(path.relative_to(root)) + if relative not in pins: + need(not exact, "Undeclared frozen input: " + relative) + continue + raw = path.read_bytes() + expected = pins[relative][0] if type(pins[relative]) is list else pins[relative] + need(sha(raw) == expected, "Frozen input digest changed: " + relative) + files[relative] = {"sha256": sha(raw), "mode": stat.S_IMODE(path.stat().st_mode), "bytes": len(raw)} + need(set(files) == set(pins), "Frozen input inventory incomplete") + return files + + +def typed(value): + """Lossless full return representation, including order and exact types.""" + kind = type(value) + if kind is Fraction: + return ["Fraction", value.numerator, value.denominator] + if value is None: + return ["None"] + if kind is bool: + return ["bool", value] + if kind is int: + return ["int", str(value)] + if kind is float: + return ["float", value.hex()] + if kind is str: + return ["str", value] + if kind is list or kind is tuple: + return [kind.__name__, [typed(item) for item in value]] + if kind is dict: + return ["dict", [[typed(key), typed(item)] for key, item in value.items()]] + raise TypeError("Unsupported exact full-certificate return type: " + kind.__name__) + + +class Phases: + """Observational wrappers delegate each call and preserve its return.""" + def __init__(self): + self.rows = {} + + def call(self, name, function, *args, **kwargs): + wall, used = time.perf_counter(), cpu() + try: + return function(*args, **kwargs) + finally: + row = self.rows.setdefault(name, {"calls": 0, "wall_seconds": 0.0, "cpu_seconds_with_children": 0.0}) + row["calls"] += 1 + row["wall_seconds"] += time.perf_counter() - wall + row["cpu_seconds_with_children"] += cpu() - used + + def wrap(self, owner, attribute, name): + original = getattr(owner, attribute) + def observed(*args, **kwargs): + return self.call(name, original, *args, **kwargs) + setattr(owner, attribute, observed) + return original, observed + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--frozen-root", type=Path, default=HERE / "frozen") + parser.add_argument("--reference", type=Path, default=HERE / "reference/certificates/complex-network.json") + parser.add_argument("--lanes", choices=("none", "sets", "guards", "trace", "all"), required=True) + parser.add_argument("--finite-only", action="store_true") + parser.add_argument("--output", type=Path, required=True, help="New external directory; every write stays below it") + parser.add_argument("--anchor", type=Path, default=HERE / "anchor.json") + args = parser.parse_args() + args.mode = "candidate" # Every new arm starts from the original native C configuration. + need(args.finite_only or sys.flags.optimize == 0, "Every full-caller mode requires original assertions") + need(sys.implementation.name == "cpython" and sys.version_info[:2] == (3, 12), "Frozen CPython 3.12 required") + need((args.mode == "profile") == (args.anchor is None), "Profile creates the anchor; both benchmark arms require --anchor") + frozen, reference = args.frozen_root.resolve(), args.reference.resolve() + output = args.output.resolve() + need(not output.exists(), "Refusing to overwrite run evidence") + need(not output.is_relative_to(HERE) and not output.is_relative_to(frozen), "Output must be outside immutable sources") + need(reference.is_file() and not reference.is_symlink(), "Reference certificate missing or symlinked") + source_pin_bytes = (HERE / "SOURCE-PINS.json").read_bytes() + need(sha(source_pin_bytes) == PIN_SHA, "Source inventory pin changed") + pins = json.loads(source_pin_bytes) + need(len(pins) == 32, "Frozen closure must contain twelve scripts, manifest and nineteen payloads") + reference_bytes = reference.read_bytes() + need(sha(reference_bytes) == REFERENCE_SHA, "Original full certificate reference changed") + driver_before = Path(__file__).read_bytes() + new_custody_before = adapters.custody(ROUND, args.lanes) + reference_driver_before = (HERE / "full_driver.py").read_bytes() + need(sha(reference_driver_before) == REFERENCE_DRIVER_SHA, "Reference driver pin changed") + anchor_bytes = None if args.anchor is None else args.anchor.read_bytes() + expected_anchor = None if anchor_bytes is None else json.loads(anchor_bytes) + if expected_anchor is not None: + need(expected_anchor.get("schema") == "gf2-full-network-anchor-v1" and + expected_anchor.get("base_commit") == BASE and expected_anchor.get("source_pin_sha256") == PIN_SHA and + expected_anchor.get("driver_sha256") == REFERENCE_DRIVER_SHA and + expected_anchor.get("engine_pins") == ENGINE_PINS, + "Anchor source/driver/engine identity differs; no benchmark permitted") + output.mkdir(parents=True) + compiler_tmp = output / "compiler-tmp" + compiler_tmp.mkdir() + os.environ["TMPDIR"] = str(compiler_tmp) + phases = Phases() + frozen_before = phases.call("input_custody", inventory, frozen, pins) + engine_before = phases.call("engine_custody", inventory, HERE / "engine", ENGINE_PINS) + manifest = json.loads((frozen / "upstream/manifest.json").read_bytes()) + need(manifest["commit"] == UPSTREAM and len(manifest["files"]) == 19, "Wrong pinned upstream manifest") + need({"upstream/" + name for name in manifest["files"]} == + {name for name in pins if name.startswith("upstream/") and name != "upstream/manifest.json"}, + "Source verifier payload closure changed") + for name, info in manifest["files"].items(): + need(info["sha256"] == pins["upstream/" + name][0], "Manifest payload hash differs from independent frozen pin") + + runtime, engine = output / "runtime-root", output / "engine" + phases.call("fresh_root_copy", shutil.copytree, frozen, runtime) + phases.call("fresh_engine_copy", shutil.copytree, HERE / "engine", engine) + # copytree retains readonly source directory permissions. Only this new + # private root is made writable for the original CLI certificate output. + runtime.chmod(0o755) + (runtime / "certificates").mkdir() + runtime_before = inventory(runtime, pins) + copied_engine_before = inventory(engine, ENGINE_PINS) + need(runtime_before == frozen_before and copied_engine_before == engine_before, "Copy changed input bytes or modes") + for name in ("complex_network.py", "complex_circuit.py"): + need((engine / "source" / name).read_bytes() == (runtime / "scripts" / name).read_bytes(), + "PR5929 engine/source differs from the full caller closure") + script_names = {Path(name).stem for name in pins if name.startswith("scripts/")} + engine_names = {"native_backend", "finite_controls", "compare_side_verifier", "profile_side_verifier"} + need(not (script_names | engine_names) & set(sys.modules), "Scientific module already loaded; fresh process required") + sys.path[:0] = [str(engine), str(runtime / "scripts")] + backend = phases.call("cold_engine_import", importlib.import_module, "native_backend") + comparison = importlib.import_module("compare_side_verifier") + native = None + finite = None + build = None + if args.mode == "candidate": + native, build = phases.call("cold_compile_link_load", backend.build_native, output / "cold-build") + extensions = phases.call("new_adapter_preparation", adapters.prepare, ROUND, backend, native, output, args.lanes, phases) + finite = phases.call("all_native_finite_independent_controls", importlib.import_module("finite_controls").run_controls, native) + phases.call("all_new_controls", adapters.run_controls, extensions, backend, native, phases) + (output / "finite-controls.json").write_bytes(canonical(finite) + b"\n") + + if args.finite_only: + need(inventory(frozen, pins) == frozen_before and inventory(HERE / "engine", ENGINE_PINS) == engine_before, "Finite immutable source custody changed") + need(inventory(runtime, pins) == runtime_before and inventory(engine, ENGINE_PINS) == copied_engine_before, "Finite copied source custody changed") + need(adapters.custody(ROUND, args.lanes) == new_custody_before, "Finite new source custody changed") + result = {"status": "H25_BOOKKEEPING_FINITE_PASS", "lanes": args.lanes, + "optimized": sys.flags.optimize, "original_controls": finite, + "new_controls": extensions["controls"], "new_source_custody": new_custody_before, + "driver_sha256": sha(driver_before), + "reference_driver_sha256": REFERENCE_DRIVER_SHA, "phases": phases.rows} + (output / "receipt.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") + print(json.dumps(result, sort_keys=True)) + return + + circuit_module = phases.call("cold_complex_module_load", backend.load_source, "complex_circuit") + sys.modules["complex_circuit"] = circuit_module + rank_calls = [] + complement = extensions["trace_type"](circuit_module.Label) + phases.call("private_set_adapter_installation", adapters.install_set, extensions, circuit_module) + binding = None + if args.mode == "candidate": + binding = backend.bind(circuit_module, native, rank_calls, complement) + else: + backend.guard_module(circuit_module) + backend.attach_trace(circuit_module, rank_calls, complement) + captures = {} + phases.wrap(circuit_module.ComplexSideCircuit, "__init__", "side_construction") + phases.wrap(circuit_module.Checks, "__init__", "checks_initialization") + phases.wrap(circuit_module, "compile_roles", "compile_roles") + phases.wrap(circuit_module.Checks, "verify_map", "verify_map") + phases.wrap(circuit_module.Checks, "verify_labels", "verify_labels") + original_roles = circuit_module.verify_role_frames + def observe_roles(c, checks, code=None): + need("side" not in captures and code is not None, "Unexpected role-frame invocation") + result = phases.call("verify_role_frames", original_roles, c, checks, code) + captures["side"] = (c, checks, code, result) + return result + circuit_module.verify_role_frames = observe_roles + + certify = phases.call("cold_certify_import", importlib.import_module, "certify") + phases.wrap(certify, "verify_sources", "original_upstream_verify_sources") + prepare = phases.call("cold_prepare_import", importlib.import_module, "prepare_layers") + search = importlib.import_module("search_network") + phases.wrap(search, "log_integer_bounds", "full_log_integer_bounds") + original_serializable = prepare.serializable + depth = 0 + def observe_serializable(value): + nonlocal depth + outer = depth == 0 + if outer: + need("full_return" not in captures and type(value) is dict, "Unexpected outer serialization") + captures["full_return"] = value + depth += 1 + try: + # Recursion still delegates the original serializable exactly once + # per value; only the outer call is captured/timed. + if outer: + return phases.call("original_serializable", original_serializable, value) + return original_serializable(value) + finally: + depth -= 1 + prepare.serializable = observe_serializable + + phases.call("private_set_lease_sealing", adapters.seal, extensions) + caller = runtime / "scripts/complex_network.py" + old_argv = sys.argv + stdout = io.StringIO() + try: + adapters.arm(extensions) + sys.argv = [str(caller)] + with redirect_stdout(stdout): + namespace = phases.call("complete_original_cli", runpy.run_path, str(caller), run_name="__main__") + finally: + sys.argv = old_argv + adapters.disarm(extensions) + cli_stdout = stdout.getvalue() + need(cli_stdout == EXPECTED_STDOUT, "Original CLI stdout changed") + certificate_bytes = (runtime / "certificates/complex-network.json").read_bytes() + need(certificate_bytes == reference_bytes, "Original CLI certificate bytes differ from the pinned reference") + need(sys.modules["complex_circuit"] is circuit_module and + namespace["ComplexSideCircuit"] is circuit_module.ComplexSideCircuit and + namespace["Checks"] is circuit_module.Checks and namespace["compile_roles"] is circuit_module.compile_roles and + namespace["verify_role_frames"] is observe_roles and namespace["serializable"] is observe_serializable, + "Caller used a different scientific module or observation binding") + need(captures.keys() == {"side", "full_return"}, "Missing exact caller observations") + c, checks, code, role_result = captures["side"] + full_return = captures["full_return"] + need(full_return["role_frames"] is role_result and full_return["upstream_commit"] == UPSTREAM, + "Role return or actual source verification boundary changed") + for name in ("side_construction", "checks_initialization", "compile_roles", "verify_map", "verify_labels", + "verify_role_frames", "original_upstream_verify_sources", "full_log_integer_bounds", + "original_serializable", "complete_original_cli"): + need(phases.rows.get(name, {}).get("calls") == 1, "Original phase was omitted or repeated: " + name) + imports = {} + for name in script_names - {"complex_network"}: + module = sys.modules.get(name) + expected_path = engine / "source/complex_circuit.py" if name == "complex_circuit" else runtime / "scripts" / (name + ".py") + need(module is not None and Path(module.__file__).resolve() == expected_path.resolve(), "Unpinned scientific import: " + name) + imports[name] = str(module.__file__) + if binding is not None: + binding["runtime_guard"].check() + need(binding["counters"] == {"complement_native": 238685, "complement_fallback": 0, + "gram_native": 59959, "gram_fallback": 0}, "Native full-call coverage changed") + + side_result = {key: full_return[key] for key in ("circuit", "side_map", "labels", "role_frames")} + witness = { + "support": c.support, "args": c.args, "kind": c.kind, "active": sorted(c.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) for target, node, coefficient in c.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + side_output = output / "side-observations" + side_output.mkdir() + side_receipt = phases.call("identical_lossless_side_serialization", comparison.write_scientific, + side_output, side_result, witness, rank_calls) + complement_receipt = complement.receipt() + need(complement_receipt == COMPLEMENT_EXPECTED, "Every ordered complement observation must match PR5929") + full_typed_bytes = canonical(typed(full_return)) + (output / "full-return.lossless.json").write_bytes(full_typed_bytes) + (output / "original-stdout.txt").write_text(cli_stdout, encoding="utf-8") + (output / "complement-transcript.json").write_bytes(canonical(complement_receipt) + b"\n") + science = { + "full_cli_certificate_sha256": sha(certificate_bytes), "full_cli_stdout_sha256": sha(cli_stdout.encode("utf-8")), + "full_return_lossless_sha256": sha(full_typed_bytes), "side": side_receipt, + "ordered_complements": complement_receipt, "upstream_commit": UPSTREAM, + } + anchor = {"schema": "gf2-full-network-anchor-v1", "base_commit": BASE, "source_pin_sha256": PIN_SHA, + "driver_sha256": REFERENCE_DRIVER_SHA, "engine_pins": ENGINE_PINS, "science": science} + if expected_anchor is not None: + need(anchor == expected_anchor, "Complete certificate/types/ordered observations differ from frozen anchor") + else: + (output / "anchor.json").write_bytes(canonical(anchor) + b"\n") + need(inventory(frozen, pins) == frozen_before and inventory(HERE / "engine", ENGINE_PINS) == engine_before, + "Immutable source bytes/modes changed") + need(inventory(runtime, pins, exact=False) == runtime_before and inventory(engine, ENGINE_PINS) == copied_engine_before, + "Runtime scientific source bytes/modes changed") + runtime_files = {str(path.relative_to(runtime)) for path in runtime.rglob("*") if path.is_file()} + need(runtime_files == set(pins) | {"certificates/complex-network.json"}, "Unexpected full-caller file side effect") + need(Path(__file__).read_bytes() == driver_before and reference.read_bytes() == reference_bytes and + (anchor_bytes is None or args.anchor.read_bytes() == anchor_bytes), "Driver/reference/anchor changed during run") + need(adapters.custody(ROUND, args.lanes) == new_custody_before, "New source custody changed") + receipt = { + "new_source_custody": new_custody_before, + "status": "FULL_NETWORK_PROFILE_ANCHOR_PASS" if args.mode == "profile" else "FULL_NETWORK_COMPLETE_PASS", + "mode": args.mode, "lanes": args.lanes, "bookkeeping": adapters.receipt(extensions), + "reference_driver_sha256": REFERENCE_DRIVER_SHA, + "science": science, "base_commit": BASE, "native_predecessor_pr": 5995, + "driver_sha256": sha(driver_before), "source_pin_sha256": PIN_SHA, + "frozen_custody": frozen_before, "engine_custody": engine_before, "scientific_imports": imports, + "build": build, "finite_controls": finite, + "private_root_permission": "runtime-root is0755; copied input file modes are retained and checked; immutable stages are never chmodded", + "compiler_tmpdir": str(compiler_tmp), + "native_calls": None if binding is None else dict(binding["counters"]), + "phases": phases.rows, "process_wall_seconds_before_receipt": time.perf_counter() - START_WALL, + "process_and_compiler_cpu_seconds_before_receipt": cpu(), + "environment": {"python": sys.version, "executable": sys.executable, "platform": sys.platform}, + "measurement": "Parent outer guard is authoritative. Phases are nested observations, not additive costs. Profile is excluded from performance selection. Every timed arm includes copies, source checks, original CLI and retained full witnesses/transcripts; candidate additionally pays cold build/load/all finite controls.", + "scope": "Complete frozen historical complex-network CLI with retained observations; conditional certificate only. No bare-CLI factor, selected-frontier, new kappa or PR5864 speed claim.", + } + (output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + sys.stdout.write(cli_stdout) + print(json.dumps({"status": receipt["status"], "mode": args.mode, "science": science, + "wall_seconds": receipt["process_wall_seconds_before_receipt"], + "cpu_seconds_with_compiler": receipt["process_and_compiler_cpu_seconds_before_receipt"], + "phases": phases.rows}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/CALL-BUDGET.json b/research/h25-bookkeeping/payload/priorities/runtime-guards/CALL-BUDGET.json new file mode 100644 index 0000000000..234839c0ed --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/CALL-BUDGET.json @@ -0,0 +1,210 @@ +{ + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "baseline_pr": 5995, + "call_groups": [ + { + "after_per_kernel_entry": 1, + "basis": "Both wrapper bodies call once at entry; constructor and final calls also retained.", + "before_per_kernel_entry": 1, + "classification": "retained semantic boundary", + "name": "RuntimeGuard.check dispatch", + "removed_complete": 0, + "retained_complete": 298644 + }, + { + "after_inline_failure_predicates": 59, + "after_per_check": 0, + "before_per_check": 61, + "breakdown_before": { + "builtins": 14, + "class_items": 8, + "class_length": 1, + "closure_cells": 14, + "function_records": 13, + "label_dispatch": 1, + "native_entries": 2, + "native_module": 1, + "source_globals": 6, + "source_module": 1 + }, + "classification": "Python helper call elimination; distinct predicates still evaluated", + "name": "require helper dispatch inside check", + "removed_complete": 18217284 + }, + { + "after_redundant_per_check": 0, + "attribute_identity_reads_removed_complete": 3583728, + "before_redundant_per_check": 2, + "classification": "true identity deduplication; not cached verification", + "name": "repeated identical-function record predicates", + "removed_complete": 597288 + }, + { + "after_per_successful_check": 0, + "before_per_check": 30, + "classification": "lazy failure-only work; concatenation is not counted as a Python helper call", + "name": "dynamic failure-message concatenation", + "removed_complete": 8959320 + }, + { + "after_per_check": 3, + "before_per_check": 3, + "classification": "retained", + "name": "anchored _TYPE calls", + "retained_complete": 895932 + }, + { + "after_per_check": 22, + "before_per_check": 22, + "breakdown": { + "builtins": 14, + "native_entries": 2, + "source_globals": 6 + }, + "classification": "retained", + "name": "anchored _DICT_GET calls", + "retained_complete": 6570168 + }, + { + "after_per_check": 2, + "before_per_check": 2, + "classification": "retained", + "name": "anchored _LEN calls", + "retained_complete": 597288 + }, + { + "after_per_check": 8, + "before_per_check": 8, + "classification": "retained", + "name": "class mappingproxy .get calls", + "retained_complete": 2389152 + }, + { + "after_per_check": 1, + "before_per_check": 1, + "classification": "retained", + "name": "canonical builtin dictionary .items call", + "retained_complete": 298644 + } + ], + "count_convention": { + "complete_kernel_entry_checks": 298644, + "excludes": [ + "Constructor check", + "Final driver check", + "Finite-control calls", + "Failure-path early termination", + "Implicit interpreter descriptor machinery not written as Call expressions" + ], + "integration_warning": "Counts must be updated if parent adds or replaces wrappers with a different closure inventory; formulas remain valid.", + "not_measured": "All numeric values below are manual source inventories or their products; no scientific imports, compiler, call census or benchmark has run.", + "unit": "Successful fully traced RuntimeGuard.check invocation in original PR5995 bind." + }, + "equivalent_failure_path": { + "direct_raise": "The first failed predicate constructs the same message and raises the same anchored RuntimeError. Successful predicates make no require call.", + "first_failure": "Earlier failures short-circuit before later reads exactly as before. Removed duplicate checks cannot uniquely fail under the supported stable serial runtime.", + "lookup_errors": "Exceptions raised while evaluating a predicate propagate unchanged; empty cell remains ValueError: Cell is empty.", + "predicate_order": "Identical order and short-circuit order; later duplicate records removed only because the same function was already checked with the same saved identities in this serial no-mutation-during-call boundary.", + "state_observation": "Rejected wrapper calls leave counters, arithmetic dispatch, observer prefixes and modified-helper callback logs unchanged.", + "tracebacks": "Inline raises remove the require stack frame; type/message and externally observed failure/counter/prefix behavior are the preserved contract.", + "unsupported": "Mutation during guard execution or arbitrary backend/native process-memory mutation remains outside the original stable runtime contract." + }, + "inputs_and_state": { + "canonical_builtin_names": 14, + "class_items": 8, + "current_label_functions": 4, + "current_rank": 1, + "global_items": 6, + "native_items": 2, + "original_functions": 8, + "records_before": 13, + "total_cells_traced": 14, + "traced_wrapper_cells": { + "complement_in": [ + "complement_trace", + "counters", + "label", + "native_complement", + "original_complement", + "runtime" + ], + "nondegenerate": [ + "counters", + "label", + "native_gram", + "original_nondegenerate", + "rank_calls", + "runtime" + ], + "traced_rank": [ + "original_rank", + "rank_calls" + ] + }, + "unique_records_traced": 11, + "unique_records_untraced": 10, + "why_repeated": "Original helper/method preservation is concatenated with installed method/rank capture, repeating unchanged __init__ and contains identities. All require arguments are evaluated before dispatch, so each success constructs its dynamic error strings." + }, + "measurement_boundary": { + "parent_diagnostic": "A bounded call census may verify dispatch counts, but instrumented times cannot establish a complete gain.", + "parent_only_scientific_runner": true, + "performance_evidence_required": "Fresh unprofiled complete B/C processes including all new costs and later fixed combined qualification; counts imply no wall/CPU percentage.", + "source_counts_support": "Mechanism selection and control construction only." + }, + "priority": "P2-runtime-guards", + "replacement_calls_and_new_costs": { + "deferred_alternative": "Native loop would move work to C and requires a separate cost/gate record; not part of this primary candidate.", + "inline_predicates_per_check": 59, + "new_compile_units": 0, + "per_binding": [ + "Source-authenticated candidate import and make_runtime_guard factory invocation", + "Candidate class installation into isolated backend before bind", + "At most 13 starting objects deduplicated with nested is-only comparisons; no equality or hash calls", + "11 traced/10 untraced snapshots retained by strong references", + "Original constructor native admission require calls and initial self.check remain" + ], + "per_successful_check_new_helper_calls": 0, + "validation": [ + "Differential old/new fixture loads and binds", + "Mutation, restoration and exact outcome comparisons", + "Normal/-O finite qualification", + "Complete cold pilot with original observations", + "Receipt/file authentication and serialization" + ] + }, + "reuse_evidence": [ + "An object has stable identity; first-occurrence is-only comparison retains each distinct exact function.", + "Current supported runtime explicitly forbids mutation during calls.", + "Snapshots retain strong references; no id-address reuse assumptions are needed.", + "Separate global/class/native slot checks remain even if the referenced function record is deduplicated.", + "No check result, arithmetic result, PASS or mutable input is reused across calls." + ], + "schema": "h25-bookkeeping-call-budget-v1", + "source_pin": "native_backend.py:e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "status": "SOURCE_DERIVED_NOT_PROFILED", + "summary_per_successful_traced_check": { + "closure_cell_reads_after": 14, + "closure_cell_reads_before": 14, + "distinct_freshness_predicates_after": 59, + "distinct_freshness_predicates_before": 59, + "dynamic_message_concatenations_after": 0, + "dynamic_message_concatenations_before": 30, + "explicit_calls_inside_check_after": 36, + "explicit_calls_inside_check_before": 97, + "no_work_moved_to_c": true, + "record_predicates_after": 11, + "record_predicates_before": 13, + "successful_require_calls_eliminated": 61 + }, + "untraced_variant": { + "closure_cell_reads_after": 12, + "closure_cell_reads_before": 12, + "distinct_predicates_after": 56, + "distinct_predicates_before": 56, + "note": "Untraced rank remains the original function and is deduplicated too; this is a finite/control path, not the stated complete traced workload.", + "records_after": 10, + "records_before": 13, + "require_calls_after": 0, + "require_calls_before": 59 + } +} diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/IMPLEMENTATION.md b/research/h25-bookkeeping/payload/priorities/runtime-guards/IMPLEMENTATION.md new file mode 100644 index 0000000000..c8423a817a --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/IMPLEMENTATION.md @@ -0,0 +1,35 @@ +# P2 implementation handoff + +Status: source implemented; AST parsed; runtime correctness and performance remain untested. Parent is the sole scientific runner. These files stay inside the runtime-guards lane; PR5995, shared harnesses and other lanes are unchanged. + +## API and installation + +`guard_candidate.make_runtime_guard(backend)` returns a `RuntimeGuard` class. It has the original `(module, label, native, original_functions)` constructor, `check(self)` method and original public state fields. It supports the existing `backend._OBJECT.__new__(RuntimeGuard)` followed by explicit constructor invocation. The constructor retains its final virtual `self.check()` call. + +The parent loads the candidate file inside the authenticated candidate source closure, calls the factory once with the isolated candidate backend, and assigns the result to `candidate_backend.RuntimeGuard` before any candidate `bind`. The untouched reference backend must be a different module object with its original class. Neither factory creation nor installation changes the original backend, source helpers, arithmetic or trace observer. + +Finalize helper/trace replacements and all source-wrapper closure-cell identities before guard construction. If combined integration adds encoder owner/entry checks through a subclass, initialize those extra snapshot fields before calling this base constructor: the constructor's virtual check will already invoke the combined check. Parent owns that extension. The primary implementation retains the original two native entries and does not claim to protect P3's encoder by itself. + +The factory captures the backend's original anchored operations, types and constants. This has the same stated supported scope as the original backend: serial stable runtime with no mutation during a call; arbitrary alteration of the backend itself is unsupported. No per-call result or PASS is cached. + +## Exact change + +The constructor filters the small incoming function sequence using nested `is` comparisons and preserves the first occurrence. Traced records fall from 13 to 11; untraced records from 13 to 10. Same-code distinct functions remain. All separate global/class/native slot checks remain. + +The ten syntactic predicate/message templates in `check` are unchanged. They now branch directly to the same anchored RuntimeError, which eliminates successful `require` dispatch and eager string construction. The original predicate and short-circuit order, captured-cell access, type and message survive. Ordinary lookup failures and empty-cell ValueError propagate; the engineering traceback no longer contains a `require` frame. + +`STATIC-CHECK.json` records an AST-only comparison of all ten predicate/message templates against immutable PR5995 and the source hashes. AST parsing is not runtime verification. No extension was compiled, module imported for scientific execution, corpus decoded, numerical case run or benchmark performed here. + +## Controls API and bill + +`guard_controls.run_guard_controls(reference_backend, candidate_backend, native)` returns a JSON-serializable receipt or raises. Supply two distinct, source-authenticated backend modules and the already cold-built real native module. Install the candidate guard first. The controls do not install classes or build extensions. The original independent finite suite must still run unchanged; the returned receipt explicitly states that requirement. + +The new suite makes four source loads and bindings: traced and untraced reference/candidate. Two additional directly constructed guard objects per mode test same-code distinct functions, without additional source loads. Each binding is held privately and reused only after mutations are restored in `finally` and its live guard passes again. + +Meaningful comparisons include successful native/wide/container behavior followed by mutation, every distinct function's code/default/keyword-default identity, every wrapper/rank closure cell rebound and emptied, all six global slots changed/deleted, fourteen builtin shadows and fourteen shared builtin replacements, writable class methods/metadata and callback-bearing descriptors, both native entries changed/deleted, module subclass dispatch, and four first-failure precedence cases. A same-code separate function must still reject its own mutation. + +Each drift is tested through a held guard and both saved wrapper entries for native, wide-integer and custom-container inputs. Outcomes compare exact value/error type and message. State comparisons cover native/fallback counters, complete rank lists, trace prefix receipts and ordered callback logs. No drift may advance those observations or call a modified helper. Shared runtime-cell mutation additionally compares the actual wrapper's original AttributeError/NameError behavior. Immutable/read-only function globals/builtins pointers and MRO are covered by retained source predicates and original admission controls; no ctypes or unsupported layout mutation is used. + +The source-derived expected matrix has 115 untraced and 122 traced mutation pairs, seven action pairs each: 237 mutation pairs / 1,659 action pairs, plus 14 stable action pairs. Parent execution must confirm these counts; no measured receipt exists yet. Baseline/candidate failures are retained by the parent runner rather than automatically retried. + +Every candidate process pays source custody/import/factory/deduplication, the four module loads, temporary metadata and perturbation fixtures, outcome comparisons and transcript serialization. Existing cold native build/load, old independent controls, full verifier and final observations remain payable. There is no new compiler unit. The source-derived call budget is in `CALL-BUDGET.json`; combined integration must revise it if new wrappers or native checks change the inventory. None of these counts establish a wall or CPU saving. diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/PROPOSAL.json b/research/h25-bookkeeping/payload/priorities/runtime-guards/PROPOSAL.json new file mode 100644 index 0000000000..5688a52aa2 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/PROPOSAL.json @@ -0,0 +1,252 @@ +{ + "adapter": { + "candidate_sources_to_create_after_gate": [ + "guard_candidate.py", + "guard_controls.py", + "IMPLEMENTATION.md" + ], + "capture_order": "Finalize helper/trace replacements and runtime closure cells, then construct records and perform initial self.check. No replacement after capture.", + "constructor": "(module, label, native, original_functions)", + "factory": "make_runtime_guard(backend) -> RuntimeGuard-compatible class", + "fallback": "Unchanged original arithmetic fallback, reached only after a successful fresh guard.", + "file": "guard_candidate.py", + "method": "check(self) -> None or original failure", + "parent_integration": "Assign factory result to isolated candidate backend.RuntimeGuard before bind; do not change baseline backend or source. Parent owns all shared bind/harness edits.", + "preserved_state_fields": [ + "module", + "namespace", + "label", + "mro", + "class_items", + "global_items", + "functions", + "native", + "native_items" + ], + "read_boundary_anchors": [ + "native_backend.py:182 constructor", + "native_backend.py:339 complement entry before observer/admission", + "native_backend.py:361 gram entry before admission", + "full_driver.py:291 final check" + ], + "reference_independence": "Untouched PR5995 backend class retained in separate baseline module/process; original arithmetic and dense oracles are unchanged." + }, + "baseline": { + "arm": "native C with complete original qualification", + "canonical_planning_main": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "engine_pins": { + "finite_controls.py": "df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a", + "native_backend.py": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "native_gf2.c": "e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source/complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "path": "outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "pr": 5995, + "priority_revision": 8 + }, + "call_budget": "CALL-BUDGET.json", + "control_plan": { + "exact_comparison": [ + "Return type/value", + "Exception type name and exact message", + "Native/fallback counters", + "Observer prefix/count/bytes/hash receipts", + "Modified helper/descriptor callback log", + "First-failure precedence" + ], + "existing_suite": "Run unmodified run_controls/native controls and all v2_binding_and_trace_controls in normal and -O modes; original full verifier remains assertion-on.", + "new_cases": [ + { + "id": "inventory", + "test": "Traced 13-to-11 and untraced 13-to-10 first-occurrence identity equivalence; same-code distinct function objects survive." + }, + { + "id": "function_mutation", + "test": "Code/defaults/kwdefaults drift for every distinct original and wrapper/traced-rank function; direct guard and both wrapper entries reject before work." + }, + { + "id": "closure_mutation", + "test": "Rebind every captured wrapper/rank closure cell, and empty a selected cell; compare old/new exceptions exactly; shared runtime-cell changes also compare actual wrapper-entry failure." + }, + { + "id": "slot_mutation", + "test": "Changed/deleted source helper, builtin shadow, real builtin, class metadata/member/descriptor, MRO/module class where legal, native gram and complement entry. Restore shared state in finally." + }, + { + "id": "fallback_boundary", + "test": "Cross drift with native-eligible, unsupported integer width, exact-container/subclass and custom-values fallback fixtures; no native/fallback count, observer prefix or callback advance." + }, + { + "id": "freshness", + "test": "Successful first call then drift before next call; candidate must reject at next entry." + }, + { + "id": "precedence", + "test": "Simultaneous drifts in different check groups and within ordered function records preserve baseline first exception." + }, + { + "id": "captured_environment", + "test": "Retain existing forged effective-builtins rejection and module builtins-owner rejection; no ctypes mutation of read-only function globals/builtins fields." + } + ], + "run_owner": "Parent only, serialized guarded queue", + "worker_executions": 0 + }, + "implementation_files": { + "IMPLEMENTATION.md": "a6809f40f406188af9bf70df2d6c3ac2b31292c4a08bbf2a99ebd17b92dd6605", + "guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "implementation_static_check": "STATIC-CHECK.json", + "new_bill": [ + "Candidate file authentication/copy/import", + "Factory construction and candidate-only installation", + "Per-binding is-only O(n^2) scan with at most 13 starting function records in current bind", + "Unique strong-reference snapshots and ordinary check loop iteration", + "Differential guard negative-control source loads/binds/mutations/restoration/execution", + "Receipt serialization and source/control closure authentication", + "All current retained costs; no micro/profile total converted to claimed wall reduction" + ], + "next_discriminating_test": { + "admission": "All outputs/types/order/traces/control outcomes agree; review complete measured wall and CPU before integration.", + "sequence": [ + "Independent source review and parent design approval", + "Freeze candidate source/control bill", + "Parent finite old/new differential controls normal and -O", + "One complete cold PR5995-native B/candidate C pilot with all new costs" + ], + "target": "Combined >=15% further wall and CPU reduction; no individual 15% requirement and no percentage promise." + }, + "owner": "/root/bookkeeping_guards", + "ownership": "outputs/h25-bookkeeping-swarm-20261028/priorities/runtime-guards/**", + "primary_design": { + "initial_environment_evidence": "Retained PR5995 evidence/ENVIRONMENT.json records CPython 3.12.3, Linux x86_64, GCC13.3.0; parent revalidates current runtime.", + "name": "first-identity-dedup-and-failure-only-raises", + "no_cached_pass": true, + "no_new_c_unit": true, + "steps": [ + "Preserve first-occurrence function order with a short nested is-only scan before recording attributes.", + "Copy each original check predicate and short-circuit order into if-not/failure branches using anchored RuntimeError and identical messages.", + "Keep all global/class/native slot checks separate, even if their values are already among function records.", + "Retain constructor, wrapper entry and complete-driver final checks." + ], + "supported_runtime": "Existing CPython 3.12 Linux serial execution; no mutation during a call; no sandbox against arbitrary backend/native-memory mutation." + }, + "primary_sources": [ + { + "supports": "is compares object identity; immutable tuples can hold mutable objects.", + "url": "https://docs.python.org/3.12/reference/datamodel.html" + }, + { + "supports": "Borrowed-reference function getters; optional NULL defaults/closure; function watcher event scope.", + "url": "https://docs.python.org/3.12/c-api/function.html" + }, + { + "supports": "Exact minor-source header, limited API exclusion, kwdefaults getter, no builtins getter declaration.", + "url": "https://github.com/python/cpython/blob/v3.12.3/Include/cpython/funcobject.h" + }, + { + "supports": "Borrowed dict lookups and suppression-versus-propagation behavior.", + "url": "https://docs.python.org/3.12/c-api/dict.html" + }, + { + "supports": "GetAttr returns a new reference and preserves attribute-access failures; general attribute calls can dispatch.", + "url": "https://docs.python.org/3.12/c-api/object.html" + }, + { + "supports": "Cell getter reference ownership and NULL semantics.", + "url": "https://docs.python.org/3.12/c-api/cell.html" + }, + { + "supports": "Python cell_contents getter raises ValueError Cell is empty for NULL cell contents.", + "url": "https://github.com/python/cpython/blob/v3.12.3/Objects/cellobject.c" + } + ], + "priority": "P2-runtime-guards", + "research_activity_boundary": { + "allowed_activities": [ + "Source/metadata reads and hashes", + "Primary documentation/source web reads", + "This research/proposal file creation" + ], + "browser_writes": 0, + "compilers": 0, + "corpus_decode_or_generation": 0, + "delegation": 0, + "git_mutations": 0, + "implementation_files_created": 2, + "scientific_imports": 0, + "scientific_runs": 0 + }, + "retained_work": [ + "Cold source/builtin/integer descriptor/class/code admission unchanged", + "Every distinct module/class/global/builtin/function/default/kwdefault/closure-cell/native-entry live check at original boundary", + "Global/class/native slot multiplicity independent of function record dedup", + "Original fallback and exception propagation, including ValueError for an empty cell", + "Original finite controls, independent dense oracle, complete typed result/witness/rank/complement observations", + "Existing cold native compile/link/load and cleanup" + ], + "schema": "h25-bookkeeping-priority-proposal-v1", + "source_counts": { + "additional_checks": "Constructor/final/finite checks excluded from these workload-derived counts", + "basis": "Manual source inventory; no scientific import/execution", + "complete_kernel_calls": 298644, + "concatenation_components": { + "builtins": 14, + "class_members": 8, + "globals": 6, + "native_entries": 2 + }, + "dynamic_message_concatenations_per_successful_check": 30, + "performance_claim": null, + "repeated_function_attribute_identity_checks_removed": 3583728, + "repeated_record_visits_removed_in_complete_kernel_entries": 597288, + "successful_message_concatenations_removed": 8959320, + "traced_duplicate_functions": [ + "Label.__init__", + "Label.contains" + ], + "traced_function_records_after": 11, + "traced_function_records_before": 13, + "untraced_additional_duplicate": "rank", + "untraced_function_records_after": 10, + "untraced_function_records_before": 13 + }, + "source_only_alternatives": [ + { + "added_costs": [ + "New source authentication/compilation/loading", + "Record/key/expected-value ownership", + "C error/refcount cleanup controls", + "Additional build and portability gate" + ], + "hazards": [ + "Function APIs are outside Py_LIMITED_API in v3.12.3 header.", + "No public builtins getter is listed in v3.12.3 function header: checked PyObject_GetAttr needed; no private struct-field assumption.", + "PyFunction_GetDefaults/GetClosure may return NULL without error, unlike Python None values.", + "PyCell_Get returns a new reference and NULL for empty cells; must reproduce Python ValueError Cell is empty rather than generic drift.", + "PyDict_GetItem and GetItemString suppress lookup exceptions; error-aware lookup is required.", + "Strong references must outlive borrowed results; hold GIL; prevent leaks or unsafe decrefs on every failure.", + "Generic attribute APIs can invoke descriptors unless exact-type admission and original dispatch boundaries remain intact.", + "No release of GIL or arbitrary concurrent/reentrant mutation support." + ], + "mechanism": "C iteration over held reference records; same live read order and failure boundaries.", + "name": "native_live_check_loop", + "status": "DEFER_PENDING_PYTHON_CANDIDATE_EVIDENCE_AND_SEPARATE_GATE" + }, + { + "name": "watcher-or-version-pass-cache", + "reason": "Cannot replace every required live per-entry read; function watchers omit closure-cell mutation and other guarded owners.", + "status": "REJECTED_BY_CONTRACT" + }, + { + "name": "precompute-all-error-strings", + "reason": "Preserves success require calls and adds cold storage; failure-only branches remove both eager formatting and call overhead with a smaller state contract.", + "status": "SOURCE_ONLY_NOT_SELECTED" + } + ], + "status": "IMPLEMENTED_SOURCE_ONLY_AWAITING_INDEPENDENT_CODE_REVIEW_AND_PARENT_RUN" +} diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/RESEARCH.md b/research/h25-bookkeeping/payload/priorities/runtime-guards/RESEARCH.md new file mode 100644 index 0000000000..5982d9b3a7 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/RESEARCH.md @@ -0,0 +1,33 @@ +# P2 runtime guard research — source-only design + +Baseline: PR5995 `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, native-C complete qualification. Canonical planning main is `19fdb086ea96af9a9f87936a2b888e10af4ed810`; no scientific migration is proposed. Local file hashes were checked: `native_backend.py` = `e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5`; `finite_controls.py` = `df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a`; `native_gf2.c` = `e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc`. Full pins and references are in PROPOSAL.json. + +## Primary design + +In `RuntimeGuard.__init__` (159–182), preserve the first occurrence of each function object using `is`, then snapshot each distinct object's code, globals, effective builtins, defaults, keyword defaults, closure and cells exactly as before. A tiny nested identity scan avoids introducing hashing, equality callbacks or a new builtin dependency. Distinct functions sharing code must remain distinct. Source helpers, class slots and native slots retain their separate checks even when they point to already-recorded functions. + +In `check` (184–209), replace each `require(condition, message)` with an explicit failing branch and the same anchored RuntimeError/message. Preserve expression order and short-circuit order. Concatenated messages are constructed only when their predicate fails. Attribute-access exceptions continue to propagate; an empty captured cell continues to raise `ValueError("Cell is empty")`, rather than being converted to a drift error. + +For traced binding, the source constructs 13 records: four original helpers, four original Label methods, four current methods, and current rank. Original `__init__` and `contains` repeat, giving 11 distinct objects. Untraced binding also repeats rank, giving 10. The successful path constructs 30 name-bearing messages: six globals, fourteen builtins, eight class members, two native entries. Across the stated 298,644 complete kernel calls this removes 597,288 repeated function-record visits, 3,583,728 repeated attribute identity checks and 8,959,320 string concatenation evaluations. These are source-derived counts, not timings; constructor/final and finite-control checks are additional. No speed factor is inferred. `CALL-BUDGET.json` itemizes 61 eliminated successful helper calls per traced check, 59 retained distinct predicates, 36 retained explicit lookup/type/length calls and every new cost. + +## Ownership and integration + +Implement only `guard_candidate.py`, `guard_controls.py` and lane documentation inside this owned directory after approval. Export a factory `make_runtime_guard(backend)` returning a compatible class with the original constructor and `check` signatures and fields. Parent installs it only into the isolated candidate backend before binding. The factory does not alter source modules, arithmetic, observers, counters, baseline classes or shared harnesses. + +Parent must finalize all helper/trace replacements and runtime closure-cell values before invoking the constructor. Retain constructor `self.check()`, both wrapper-entry checks (339 and 361), and `full_driver.py:291` final check. Each entry still checks before tracing, eligibility, native execution or fallback. Integration cannot reuse a captured guard after changing wrappers. No cached PASS or once-per-run replacement is allowed. + +## Retained contract and bill + +Keep cold source authentication, builtin/integer-descriptor admission, source class shape, original arithmetic and dense independent oracle, all finite cases, every live distinct freshness predicate, failures and final observations. The supported contract remains serial execution with no mutation during a call; arbitrary backend/process-memory mutation and concurrent/reentrant mutation are outside it. Identity checks retain their existing granularity: this is no new deep-content detector. + +New costs are candidate source copy/authentication/import, class-factory creation, cold deduplication, retained strong-reference records, additional differential finite controls and serialized receipts. Existing native cold compile/load remains; no new compiler unit is required. All costs enter the complete candidate bill. Baseline controls execute unchanged against its original guard; candidate controls execute against the installed class, with separate backend/source instances. + +## Controls and discriminating next test + +Retain every existing finite/normal/O control. Add first-occurrence record-order and exact-identity inventory checks for traced/untraced binds; retain distinct functions with equal code. Differentially mutate code/defaults/kwdefaults of every distinct saved function, wrapper/traced-rank cells (including deletion), all relevant global/builtin/class/native slots, and simultaneous drifts to check first-failure precedence. Restore mutations in finally. Compare exact outcome type/message and unchanged native/fallback counters, observer receipts and helper callback logs; exercise both wrapper entries on native-eligible and unsupported-width/container inputs. Shared runtime-cell mutation must compare actual baseline exceptions as well as direct held-guard checks. Test PASS, later mutation, then rejection to exclude stale acceptance. + +After source review, parent runs this finite matrix against untouched PR5995 and candidate, then one complete cold B/C pilot with all control costs. Exact output/call/trace equality is mandatory; complete wall/CPU determine disposition. The combined 15% goal is not an individual promise. + +## Source-only alternatives and C hazards + +A C loop could reduce interpreter dispatch but adds compilation, state ownership, cleanup and error-conversion work. Public [function APIs](https://docs.python.org/3.12/c-api/function.html) expose borrowed code/globals/defaults/closure references; optional NULL values need Python-None normalization. The [3.12.3 header](https://github.com/python/cpython/blob/v3.12.3/Include/cpython/funcobject.h) excludes function APIs from the limited API and supplies no builtins getter; use checked attribute access rather than private layout assumptions. [Dictionary APIs](https://docs.python.org/3.12/c-api/dict.html) require error-aware lookup, and [cell APIs](https://docs.python.org/3.12/c-api/cell.html) alone do not reproduce Python empty-cell exceptions; [cell source](https://github.com/python/cpython/blob/v3.12.3/Objects/cellobject.c) establishes that behavior. Strong references, GIL-held serial checks and every error cleanup path need review. No broad portability claim is warranted. Watcher/version-based PASS caches are rejected: they omit required live reads and closure-cell coverage. First test the smaller Python change; a native alternative requires a new gate. diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/STATIC-CHECK.json b/research/h25-bookkeeping/payload/priorities/runtime-guards/STATIC-CHECK.json new file mode 100644 index 0000000000..832fe2fd63 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/STATIC-CHECK.json @@ -0,0 +1,14 @@ +{ + "baseline_native_backend_sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "files": { + "guard_candidate.py": "320435ec4125544f2b2aedf74f21469b232d08683fe76f0913607516254bbd29", + "guard_controls.py": "514e3d08793323cf216c7a1f76cafdc8dbba4ab4656e64167c788985f9e63291" + }, + "limits": [ + "AST syntax and predicate/message template identity only; no imported scientific modules, compiled extension, runtime outcome, resource result or performance measurement.", + "First-occurrence identity semantics and loop/control integration remain subject to independent source review and parent execution." + ], + "predicate_message_templates": 10, + "scientific_execution": false, + "status": "AST_PARSE_AND_LITERAL_CHECK_PREDICATES_MATCH" +} diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_candidate.py b/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_candidate.py new file mode 100644 index 0000000000..328ea860a5 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_candidate.py @@ -0,0 +1,98 @@ +"""P2: candidate-only live guard with identity dedup and failure-only raises. + +The caller installs the returned class into an isolated candidate backend before +binding. Original source admission, wrappers, arithmetic, observers and baseline +modules are not changed here. The original serial stable-runtime policy applies. +""" + + +def make_runtime_guard(backend): + """Return a class compatible with backend.bind and object.__new__. + + Parent integration must finalize every helper/trace binding and wrapper cell + before constructing this guard. Subclasses adding owner checks must initialize + their own state before this constructor calls self.check(). + """ + _TYPE = backend._TYPE + _LEN = backend._LEN + _LIST = backend._LIST + _TUPLE = backend._TUPLE + _RUNTIME_ERROR = backend._RUNTIME_ERROR + _DICT_GET = backend._DICT_GET + _BUILTINS = backend._BUILTINS + _CANONICAL_BUILTINS = backend._CANONICAL_BUILTINS + _HELPER_NAMES = backend._HELPER_NAMES + FunctionType = backend.FunctionType + ModuleType = backend.ModuleType + BuiltinFunctionType = backend.BuiltinFunctionType + require = backend.require + + class RuntimeGuard: + """Run every distinct freshness check at each original boundary.""" + + def __init__(self, module, label, native, original_functions): + self.module = module + self.namespace = module.__dict__ + self.label = label + self.mro = label.__mro__ + self.class_items = _TUPLE(label.__dict__.items()) + self.global_items = _TUPLE((name, self.namespace[name]) for name in _HELPER_NAMES + ("Label", "__builtins__")) + functions = _LIST(original_functions) + functions.extend(value for _, value in self.class_items if _TYPE(value) is FunctionType) + functions.append(self.namespace["rank"]) + # Identity only: no hashing, user equality or saved PASS. Keep first + # occurrence order and retain distinct functions sharing code. + unique_functions = [] + for function in functions: + for previous in unique_functions: + if function is previous: + break + else: + unique_functions.append(function) + self.functions = _TUPLE((function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, function.__closure__, + () if function.__closure__ is None else + _TUPLE((cell, cell.cell_contents) for cell in function.__closure__)) + for function in unique_functions) + self.native = native + require(_TYPE(native) is ModuleType, "Unexpected native module type") + self.native_items = _TUPLE((name, native.__dict__[name]) for name in ("gram_rank", "complement")) + for name, function in self.native_items: + require(_TYPE(function) is BuiltinFunctionType and function.__self__ is native, + "Changed native entry point: " + name) + self.check() + + def check(self): + # Predicates and their short-circuit order match PR5995. Attribute + # failures, including an empty cell's ValueError, propagate directly. + if not (_TYPE(self.module) is ModuleType and self.module.__dict__ is self.namespace): + raise _RUNTIME_ERROR("Runtime drift: source module dispatch") + if not (_TYPE(self.label) is _TYPE and self.label.__mro__ is self.mro): + raise _RUNTIME_ERROR("Runtime drift: Label class dispatch") + for name, value in self.global_items: + if not (_DICT_GET(self.namespace, name) is value): + raise _RUNTIME_ERROR("Runtime drift: source helper " + name) + for name, expected in _CANONICAL_BUILTINS.items(): + if not (name not in self.namespace and _DICT_GET(_BUILTINS, name) is expected): + raise _RUNTIME_ERROR("Runtime drift: builtin lookup " + name) + attributes = self.label.__dict__ + if not (_LEN(attributes) == _LEN(self.class_items)): + raise _RUNTIME_ERROR("Runtime drift: Label descriptors") + for name, value in self.class_items: + if not (attributes.get(name) is value): + raise _RUNTIME_ERROR("Runtime drift: Label member " + name) + for function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells in self.functions: + if not (function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure): + raise _RUNTIME_ERROR("Runtime drift: function code or calling environment") + for cell, value in cells: + if not (cell.cell_contents is value): + raise _RUNTIME_ERROR("Runtime drift: wrapper closure") + if not (_TYPE(self.native) is ModuleType): + raise _RUNTIME_ERROR("Runtime drift: native module dispatch") + for name, function in self.native_items: + if not (_DICT_GET(self.native.__dict__, name) is function): + raise _RUNTIME_ERROR("Runtime drift: native entry point " + name) + + return RuntimeGuard diff --git a/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_controls.py b/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_controls.py new file mode 100644 index 0000000000..4d1de6f5da --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/runtime-guards/guard_controls.py @@ -0,0 +1,363 @@ +"""Bounded differential P2 controls; parent runner executes this module. + +Four fresh source modules are loaded (traced/untraced reference/candidate). Each +private binding is safely restored and reused across negative cases. This suite +supplements, and never replaces, PR5995's independent finite controls. +""" +from __future__ import annotations + +import builtins +import hashlib +import json +from types import FunctionType, ModuleType + +_TYPE = type +_LEN = len +_TUPLE = tuple +_DICT = dict +_LIST = list +_OBJECT = object +_SETATTR = setattr +_DELATTR = delattr +_GETATTR = getattr +_STR = str +_RUNTIME_ERROR = RuntimeError +_MISSING = object() + + +def _require(condition, message): + if not condition: + raise _RUNTIME_ERROR(message) + + +def _capture(action): + try: + value = action() + except Exception as error: + return ("error", _TYPE(error).__name__, _STR(error)) + return ("value", _TYPE(value).__name__, value) + + +def _attribute_patch(owner, name, value=_MISSING): + """Prepare a reversible patch; absent attributes use exact owner dictionaries.""" + namespace = owner.__dict__ + present = name in namespace + original = namespace[name] if present else _MISSING + + def apply(): + if value is _MISSING: + _DELATTR(owner, name) + else: + _SETATTR(owner, name, value) + + def restore(): + if present: + _SETATTR(owner, name, original) + else: + _DELATTR(owner, name) + + return apply, restore + + +def _function_patch(function, name, value): + original = _GETATTR(function, name) + + def apply(): + _SETATTR(function, name, value) + + def restore(): + _SETATTR(function, name, original) + + return apply, restore + + +def _cell_patch(cell, empty): + original = cell.cell_contents + replacement = _OBJECT() + + def apply(): + if empty: + del cell.cell_contents + else: + cell.cell_contents = replacement + + def restore(): + cell.cell_contents = original + + return apply, restore + + +def _combined_patch(*patches): + def apply(): + completed = [] + try: + for forward, backward in patches: + forward() + completed.append(backward) + except Exception: + while completed: + completed.pop()() + raise + + def restore(): + for _, backward in patches[::-1]: + backward() + + return apply, restore + + +def _snapshot(env): + trace = env["trace"] + return (_DICT(env["state"]["counters"]), _TUPLE(env["rank_calls"]), + None if trace is None else trace.receipt(), _TUPLE(env["callbacks"])) + + +def _functions(env): + module, state = env["module"], env["state"] + label = state["label"] + rows = [("echelon", module.echelon), ("reduce", module.reduce), + ("dot", state["original_dot"]), ("original_rank", state["original_rank"]), + ("Label.__init__", label.__init__), ("Label.contains", label.contains), + ("original_nondegenerate", state["original_nondegenerate"]), + ("original_complement", state["original_complement"]), + ("installed_nondegenerate", label.nondegenerate), + ("installed_complement", label.complement_in)] + if env["traced"]: + rows.append(("traced_rank", module.rank)) + return rows + + +def _make_env(backend, native, traced, suffix): + module = backend.load_source("_h25_p2_" + suffix) + callbacks = [] + + def bad_helper(*args, **kwargs): + callbacks.append("modified helper executed") + return 0 + + class ProbeValues: + def values(self): + callbacks.append("fallback values executed") + raise ValueError("P2 fallback values sentinel") + + class ChangedModule(ModuleType): + def __getattribute__(self, name): + callbacks.append("modified module dispatch executed") + return _OBJECT.__getattribute__(self, name) + + rank_calls = [] + trace = backend.ComplementTrace(module.Label) if traced else None + state = backend.bind(module, native, rank_calls if traced else None, trace) + label = state["label"] + + def raw(rows, custom=False): + obj = _OBJECT.__new__(label) + obj.basis = ProbeValues() if custom else {i: value for i, value in enumerate(rows)} + return obj + + small, big = raw((1,)), raw((1, 2)) + wide_small, wide_big = raw((1 << 100,)), raw((1, 1 << 100)) + custom_small, custom_big = raw((), True), raw((1, 2)) + # Capture dispatch before class/global mutations. The direct guard reference + # also remains usable when a wrapper's shared runtime closure is emptied. + ordinary_gram = small.nondegenerate + ordinary_complement = small.complement_in + wide_gram = wide_small.nondegenerate + wide_complement = wide_small.complement_in + custom_gram = custom_small.nondegenerate + custom_complement = custom_small.complement_in + actions = [("held_guard", state["runtime_guard"].check), + ("native_gram", ordinary_gram), + ("native_complement", lambda: ordinary_complement(big)), + ("wide_gram", wide_gram), + ("wide_complement", lambda: wide_complement(wide_big)), + ("container_gram", custom_gram), + ("container_complement", lambda: custom_complement(custom_big))] + return {"backend": backend, "module": module, "state": state, + "native": native, "trace": trace, "rank_calls": rank_calls, + "callbacks": callbacks, "traced": traced, "actions": actions, + "bad_helper": bad_helper, "changed_module_type": ChangedModule} + + +def _case_patches(env): + """Independent behavioral perturbations, not a copy of guard predicates.""" + module, state = env["module"], env["state"] + label, native = state["label"], env["native"] + bad = env["bad_helper"] + cases = [] + for tag, function in _functions(env): + cases.append(("function/code/" + tag, + _function_patch(function, "__code__", function.__code__.replace(co_name="p2_changed_code")))) + cases.append(("function/defaults/" + tag, + _function_patch(function, "__defaults__", (_OBJECT(),)))) + cases.append(("function/kwdefaults/" + tag, + _function_patch(function, "__kwdefaults__", {"p2_probe": _OBJECT()}))) + closure = function.__closure__ + if closure is not None: + for name, cell in zip(function.__code__.co_freevars, closure): + cases.append(("cell/rebind/" + tag + "/" + name, _cell_patch(cell, False))) + cases.append(("cell/empty/" + tag + "/" + name, _cell_patch(cell, True))) + for name in ("echelon", "reduce", "dot", "rank", "Label", "__builtins__"): + cases.append(("global/rebind/" + name, _attribute_patch(module, name, bad))) + cases.append(("global/delete/" + name, _attribute_patch(module, name))) + for name in ("all", "enumerate", "len", "list", "max", "next", "range", + "sorted", "sum", "tuple", "int", "dict", "type", "object"): + cases.append(("builtin/shadow/" + name, _attribute_patch(module, name, bad))) + cases.append(("builtin/shared/" + name, _attribute_patch(builtins, name, bad))) + for name in ("__init__", "contains", "nondegenerate", "complement_in"): + cases.append(("class/rebind/" + name, _attribute_patch(label, name, bad))) + cases.append(("class/delete/" + name, _attribute_patch(label, name))) + for name in ("__module__", "__doc__"): + cases.append(("class/metadata/" + name, _attribute_patch(label, name, "P2 changed metadata"))) + cases.append(("class/basis_descriptor", _attribute_patch(label, "basis", property(bad)))) + cases.append(("class/getattribute", _attribute_patch(label, "__getattribute__", bad))) + for name in ("gram_rank", "complement"): + cases.append(("native/rebind/" + name, _attribute_patch(native, name, bad))) + cases.append(("native/delete/" + name, _attribute_patch(native, name))) + original_module_type = _TYPE(module) + cases.append(("module/dispatch", ( + lambda: _SETATTR(module, "__class__", env["changed_module_type"]), + lambda: _SETATTR(module, "__class__", original_module_type)))) + cases.append(("precedence/global-before-builtin", _combined_patch( + _attribute_patch(module, "dot", bad), _attribute_patch(module, "sum", bad)))) + cases.append(("precedence/builtin-before-class", _combined_patch( + _attribute_patch(module, "sum", bad), _attribute_patch(label, "contains", bad)))) + cases.append(("precedence/function-before-native", _combined_patch( + _function_patch(state["original_dot"], "__defaults__", (_OBJECT(),)), + _attribute_patch(native, "gram_rank", bad)))) + # Empty-cell access has a different exception from function metadata drift, + # making this an observable check of order within the function-record group. + wrapper = label.nondegenerate + first_cell = wrapper.__closure__[0] + cases.append(("precedence/original-function-before-wrapper-cell", _combined_patch( + _function_patch(state["original_dot"], "__defaults__", (_OBJECT(),)), + _cell_patch(first_cell, True)))) + return cases + + +def _exercise_patch(env, patch): + apply, restore = patch + observations = [] + apply() + try: + for tag, action in env["actions"]: + before = _snapshot(env) + outcome = _capture(action) + after = _snapshot(env) + observations.append((tag, outcome)) + _require(outcome[0] == "error", "P2 drift was accepted: " + tag) + _require(before == after, "P2 drift reached work or callbacks: " + tag) + finally: + restore() + # A restored binding must be live again; this also catches incomplete cleanup + # before the next perturbation reuses it. + env["state"]["runtime_guard"].check() + return observations + + +def _inventory(env, candidate): + guard = env["state"]["runtime_guard"] + records = guard.functions + expected = _functions(env) + expected_count = (11 if env["traced"] else 10) if candidate else 13 + _require(_LEN(records) == expected_count, "P2 function record count changed") + unique = [] + for record in records: + function = record[0] + if not any(function is previous for previous in unique): + unique.append(function) + _require(_LEN(unique) == _LEN(expected), "P2 distinct function coverage changed") + for _, function in expected: + _require(any(function is seen for seen in unique), "P2 lost a distinct function") + # Derive required first occurrence order from bind's original-preservation + # contract, independently of the candidate deduplication implementation. + module, state = env["module"], env["state"] + original = [module.echelon, module.reduce, state["original_dot"], state["original_rank"], + state["label"].__init__, state["label"].contains, + state["original_nondegenerate"], state["original_complement"]] + current = [value for value in state["label"].__dict__.values() if _TYPE(value) is FunctionType] + incoming = original + current + [module.rank] + expected_first = [] + for function in incoming: + if not any(function is seen for seen in expected_first): + expected_first.append(function) + _require(_LEN(unique) == _LEN(expected_first) and all(a is b for a, b in zip(unique, expected_first)), + "P2 first-distinct record order changed") + # Same code is not same identity. Two live functions must survive even if + # they share code/globals/builtins and are repeated in the input sequence. + dot = state["original_dot"] + twin = FunctionType(dot.__code__, dot.__globals__) + cls = env["backend"].RuntimeGuard + extra = _OBJECT.__new__(cls) + cls.__init__(extra, module, state["label"], env["native"], [twin, dot, twin]) + stored = [record[0] for record in extra.functions] + _require(sum(item is twin for item in stored) == (1 if candidate else 2), + "P2 same-object identity multiplicity changed") + _require(sum(item is dot for item in stored) == 1, "P2 same-code distinct function disappeared") + original_defaults = twin.__defaults__ + try: + twin.__defaults__ = (_OBJECT(),) + outcome = _capture(extra.check) + finally: + twin.__defaults__ = original_defaults + _require(outcome == ("error", "RuntimeError", "Runtime drift: function code or calling environment"), + "P2 distinct same-code function drift was accepted") + extra.check() + return {"records": _LEN(records), "distinct_functions": _LEN(unique), + "captured_cell_reads": sum(_LEN(record[7]) for record in records), + "same_code_distinct_function_rejected": True} + + +def run_guard_controls(reference_backend, candidate_backend, native): + """Run finite old/new failure and state comparisons using one real C module. + + Backends must be distinct objects; reference must contain untouched PR5995 + RuntimeGuard, and the candidate class must be installed before this call. + The parent must also run all original independent finite controls. + """ + _require(reference_backend is not candidate_backend, "P2 requires separate backend modules") + _require(reference_backend.RuntimeGuard is not candidate_backend.RuntimeGuard, + "P2 reference and candidate guards are not independent") + transcript = hashlib.sha256() + counts = {"source_loads": 0, "binding_modes": 0, "mutation_pairs": 0, + "mutation_action_pairs": 0, "stable_action_pairs": 0, + "same_code_distinct_controls": 0} + inventories = {} + for traced in (False, True): + suffix = "traced" if traced else "untraced" + reference = _make_env(reference_backend, native, traced, "reference_" + suffix) + candidate = _make_env(candidate_backend, native, traced, "candidate_" + suffix) + counts["source_loads"] += 2 + counts["binding_modes"] += 1 + inventories[suffix] = {"reference": _inventory(reference, False), + "candidate": _inventory(candidate, True)} + counts["same_code_distinct_controls"] += 2 + # Initial live successes and unsupported-input behavior establish that + # the later PASS-then-mutate tests do not use an always-rejecting guard. + for (tag_r, action_r), (tag_c, action_c) in zip(reference["actions"], candidate["actions"]): + _require(tag_r == tag_c, "P2 stable action tags differ") + result_r, result_c = _capture(action_r), _capture(action_c) + _require(result_r == result_c and _snapshot(reference) == _snapshot(candidate), + "P2 stable native/fallback behavior differs: " + tag_r) + transcript.update(json.dumps((suffix, "stable", tag_r, result_r), + separators=(",", ":"), sort_keys=True).encode("ascii") + b"\n") + counts["stable_action_pairs"] += 1 + cases_r, cases_c = _case_patches(reference), _case_patches(candidate) + _require(_LEN(cases_r) == _LEN(cases_c), "P2 mutation case counts differ") + for (tag_r, patch_r), (tag_c, patch_c) in zip(cases_r, cases_c): + _require(tag_r == tag_c, "P2 mutation tags differ") + observed_r = _exercise_patch(reference, patch_r) + observed_c = _exercise_patch(candidate, patch_c) + _require(observed_r == observed_c, "P2 failure outcome differs: " + tag_r) + _require(_snapshot(reference) == _snapshot(candidate), "P2 restored state differs: " + tag_r) + transcript.update(json.dumps((suffix, tag_r, observed_r), + separators=(",", ":"), sort_keys=True).encode("ascii") + b"\n") + counts["mutation_pairs"] += 1 + counts["mutation_action_pairs"] += _LEN(observed_r) + reference["state"]["runtime_guard"].check() + candidate["state"]["runtime_guard"].check() + return {"status": "P2_DIFFERENTIAL_RUNTIME_GUARD_CONTROLS_PASS", "counts": counts, + "inventories": inventories, "transcript_sha256": transcript.hexdigest(), + "old_finite_controls_still_required": True, + "comparison": "exact exception type/message, state/prefix/counter/callback effects; traceback frames excluded", + "scope": "serial stable runtime, first-distinct identities, live entry checks; no arbitrary concurrent mutation"} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/CALL-BUDGET.json b/research/h25-bookkeeping/payload/priorities/set-reuse/CALL-BUDGET.json new file mode 100644 index 0000000000..5ccb7c7e03 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/CALL-BUDGET.json @@ -0,0 +1,40 @@ +{ + "schema": "h25-bookkeeping-call-budget-v1", + "priority": "P1-set-reuse", + "status": "SOURCE_ONLY_NO_MEASUREMENT_NO_IMPLEMENTATION", + "baseline": {"pr": 5995, "head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", "arm": "native C with all complete checks", "source_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", "function_lines": [313, 333]}, + "inputs": {"N": 2300, "N_source": "Frozen complete certificate targets and caller H25 combinations", "P_pieces": 27600, "P_source": "Frozen reference/certificates/complex-network.json circuit.injections", "per_pair": "Two positional exact triples, independently tested for disjointness and intersection cardinality two"}, + "why_repeated": "Each of two ordered N-by-N generator expressions re-materializes both unchanged triple operands with set(S) and set(T). Repetition is metadata construction; original pairwise verification remains required.", + "call_rows": [ + {"operation": "operand set constructors", "baseline_formula": "4*N*N", "baseline": 21160000, "candidate_formula": "N", "candidate": 2300, "eliminated": 21157700, "classification": "invocation-local value representation reuse; no result/PASS caching; no work moved into C"}, + {"operation": "set intersection operations and new result sets", "baseline_formula": "2*N*N", "baseline": 10580000, "candidate": 10580000, "eliminated": 0, "classification": "retained semantic checks; independent first and second loops"}, + {"operation": "intersection len calls in second loop", "baseline_formula": "N*N", "baseline": 5290000, "candidate": 5290000, "eliminated": 0, "classification": "retained cardinality predicate"}, + {"operation": "sum calls for target masks", "baseline_formula": "2*N", "baseline": 4600, "candidate": 4600, "eliminated": 0, "classification": "retained aggregation and bit-position order"}, + {"operation": "inner enumerate calls", "baseline_formula": "2*N", "baseline": 4600, "candidate": 4600, "eliminated": 0, "classification": "retained inner source position enumeration; any new outer pairing is separately billed"}, + {"operation": "zero/two int.bit_count calls", "baseline_formula": "2*N", "baseline": 4600, "candidate": 4600, "eliminated": 0, "classification": "retained nonzero accounting"}, + {"operation": "Q constructor calls across prefix and successful tail", "baseline_formula": "2*P+2*N", "baseline": 59800, "candidate": 59800, "eliminated": 0, "classification": "retained original coefficient construction and assertion order; early failure short-circuits identically"}, + {"operation": "got.get calls across prefix and successful tail", "baseline_formula": "2*P+2*N", "baseline": 59800, "candidate": 59800, "eliminated": 0, "classification": "retained original piece overlaps, support accumulation and exact equalities"}, + {"operation": "target len and output dict construction", "baseline": 2, "candidate": 2, "eliminated": 0, "classification": "one len(c.triples) and one dict(...) return, unchanged"} + ], + "constructor_element_work": {"baseline_tuple_member_visits": 63480000, "candidate_tuple_member_visits": 6900, "basis": "Exactly three members per admitted positional triple and three iterable visits per operand constructor; source-derived, not a hardware/instruction or timing count", "intersection_member_processing": "retained and input-dependent; not counted as eliminated"}, + "new_call_bill": [ + {"item": "adapter source/AST/closure binding checks and creation", "scope": "once per fresh candidate process", "calls": "unknown until implementation frozen", "wall_cpu_bytes": "unknown, not zero"}, + {"item": "constructor provenance captures plus private single-use lease arm/check/consume/revoke", "scope": "one circuit, one Checks, one verify_map invocation", "calls": "unknown until implementation frozen", "wall_cpu_bytes": "unknown, not zero"}, + {"item": "trace/profile/monitoring/signal/GC/concurrency and relevant binding checks", "scope": "lease issuance/admission boundary, read-only", "calls": "unknown until implementation frozen", "wall_cpu_bytes": "unknown, not zero"}, + {"item": "post-prefix exact triple membership/type checks", "scope": "N positional triples and 3*N integer elements", "calls": "implementation-dependent; at least all relevant shape checks remain", "wall_cpu_bytes": "unknown, not zero"}, + {"item": "post-prefix got key/value admission", "scope": "Every existing got key and value, without custom equality or hash", "calls": "unknown until actual got count/implementation census", "wall_cpu_bytes": "unknown, not zero"}, + {"item": "private operand-set sequence and N constructors", "scope": "one verify_map invocation", "calls": "2300 set constructors plus container build/iteration; any positional pairing or defensive snapshot/final scan is additional", "wall_cpu_bytes": "unknown CPU/wall and retained peak memory"}, + {"item": "fallback dispatch, finite normal/O controls, receipts and cleanup", "scope": "all candidate-required work", "calls": "unknown until control set and implementation frozen", "wall_cpu_bytes": "unknown, included in complete candidate"} + ], + "ownership_and_fallback": { + "contract": "OWNERSHIP.md revision 2: NEW whole-tail invariant independently established for the fresh frozen complete caller; NOT inherited from per-kernel RuntimeGuard", + "lease": "Private source-fixed single-use identity record for actual construction-observed circuit/Checks/triples within the original assertion-on CLI; reserve/consume at method entry, verify after prefix, expire in finally; no arbitrary policy callable", + "admission": "After original prefix; exact builtin integer triples, ordinary class dispatch and exact callback-free got keys/values; unchanged relevant Fraction/builtin environment", + "fallback": "Missing/mismatched/used lease, unsupported shapes, hooks or bindings select literal original tail after prefix; no prefix replay; binding rejection before prefix can call original whole method once", + "no_cache_reuse_between_calls": true, + "baseline_domain_unchanged": true + }, + "independence": {"two_ordered_predicate_loops": "retained", "intersection_result_sharing": "not implemented or authorized; separate research branch", "loop_fusion": "not implemented or authorized; separate research branch", "optional_branch_gate": "Must independently review loss of duplicate set observations, callback/error order, predicate independence, finite controls and complete added costs before implementation"}, + "measurement_boundary": {"counts": "source-derived for successful frozen H25 verification; failed-prefix/tail counts vary with original failure point", "call_census": "Parent may run one bounded diagnostic census; not a performance sample", "micro": "mechanism evidence only", "full": "fresh same-session PR5995 native baseline/candidate complete runs with all old/new controls and observations", "predicted_speedup": null, "individual_15_percent_required": false, "combined_15_percent_wall_and_cpu_required": true}, + "scientific_execution": {"imports": 0, "compilations": 0, "corpus_generation_or_decoding": 0, "correctness_runs": 0, "timed_runs": 0} +} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/IMPLEMENTATION.md b/research/h25-bookkeeping/payload/priorities/set-reuse/IMPLEMENTATION.md new file mode 100644 index 0000000000..57245ede42 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/IMPLEMENTATION.md @@ -0,0 +1,33 @@ +# P1 source implementation, revision 4 portability pending parent execution + +`set_reuse.py` exposes `bind_verify_map(module)`, returning `verify_map`, `owner`, `receipt`, and the untouched original method. Supply an isolated candidate module before adding the parent's constructor or map phase wrappers. A separate unchanged module/process remains the reference. The factory authenticates source SHA/code shapes and the active Fraction source against the two exact reviewed hashes in `PORTABILITY.md`; generates the original prefix and literal fallback from the frozen AST; adds only the private optimized tail; and retains the candidate module's live globals. Its temporary factory name is removed immediately. The lease owner is reachable through private closure cells and the returned parent binding, never stored on scientific instances or published as a module global. This is no protection against hostile introspection/native memory changes. + +Parent integration order: + +1. Load/authenticate the candidate scientific module and install the existing native backend. +2. Call `binding = bind_verify_map(circuit_module)` while `Checks` and `ComplexSideCircuit` retain their original source methods. +3. Install `binding['verify_map']` as `Checks.verify_map`. Install the usual phase wrappers and parent-owned constructor observation wrappers. After a successful original circuit constructor, call `owner.capture_c(self)`; after a successful original Checks constructor, call `owner.capture_checks(self)`. Constructor return values remain unchanged. +4. Call `owner.seal()` after all class/phase wrapper installation. Sealing records final class/function/closure identities, allowing no later wrapper replacement. Then call `owner.arm_cli()` immediately before the authenticated original assertion-on `runpy.run_path`. Construction captures occur inside this active interval. +5. In the enclosing parent `finally`, call `owner.disarm_cli()`. Preserve the original CLI return/stdout/witness/native guards and all original phase counts. Require the receipt to show one successful construction pair, one reservation/admission/expiry, zero fallback calls and 2300 private operand constructions for the complete H25 fast arm. Receipt fields are separate from scientific output. + +`reserve` consumes the one-use allowance at method entry before the prefix. Wrong Checks/circuit, missing/spent allowance, changed bindings and known hooks take the original whole method once. A reserved call executes the original prefix once, then `admit` examines actual exact triple and got-key/value shapes. Post-prefix denial executes the original tail AST once. Both optimized comprehensions still enumerate `c.triples` and independently form a new set intersection; only the operands are supplied by a private positional list. Additional outer enumeration and positional index lookups are new paid work. + +The cached left operand is a closure cell shared with the comprehensions. The `finally` block clears the operand list with an anchored builtin and sets both the list and left-operand cells to `None`, then expires the reservation. Generator loop variable `T` remains the original triple, so a retained traceback has no cached operand-set loop variable. There is no set cache on Checks, circuit, module or lease owner. Allocation failure is propagated without retry; exact allocation-failure timing is not promised. + +The new whole-tail condition remains independently parent-established: actual source-created identities in the fixed fresh CLI, callback-free admitted tail, no concurrent/reentrant mutator. Hook denial observes trace/profile/monitoring/GC callback/thread/signal state and never changes GC policy. It is not generic ownership detection. Ordinary API calls continue through literal fallback. + +`finite_set_controls.py` exposes `run_controls(backend, set_adapter)`, using the already loaded modules rather than relying on a `set_reuse` import path. The backend's trusted loader receives two distinct module names for original and candidate. Tiny raw fixture objects use an explicit test-only issuer rather than pretending to prove full CLI provenance. Controls cover all intersection sizes, duplicates/order, empty/large/negative integer cases, missing/wrong/used capability, reentry, prefix mutation/failure, callback-bearing tuple and got-key fallback, live set binding, hook denial, between-call mutation and retained-traceback cleanup. Parent runs both ordinary and `-O` finite controls; full qualification remains assertion-on. + +All binding/AST/Fraction authentication, lease capture/guards, hook queries, exact data scans, new enumeration/indexing, metadata allocation, finite controls and cleanup are in the complete candidate bill. Runtime and memory costs are unknown. No scientific import, compile, finite execution or measurement was performed by this worker while writing these files. Independent source review and parent serial correctness execution remain required. + +## Retained optimized-mode fixture failure and revision 3 + +Parent reports normal finite controls passed for immutable stage v2. The parent-owned `finite-P1-O-v2` run stopped after 2.8227 seconds with `RuntimeError: Collision fixture did not reach custom equality`; its raw stderr remains at `runtime/runs/finite-P1-O-v2/stderr.txt`. This was a fixture-expectation error: the relevant collision lookup occurs inside the original tail assertion, so `-O` correctly removes it. The exact original/candidate outcome and callback-list comparison had already matched before the unconditional callback-presence requirement failed. + +Revision 3 changes only the collision fixture's callback-presence expectation and the later Q-constructor fixture's equivalent assertion-only expectation. Normal mode still requires observed callbacks. Optimized mode explicitly requires empty event lists from both original and candidate, while preserving their existing exact differential outcomes/events, fast/fallback counts and all other controls. The Q correction is source-derived: every original `verify_map` Q constructor call appears inside an assertion. `set_reuse.py` is unchanged. Immutable v1/v2, the failed receipt, elapsed resource cost and original performance target remain untouched. This worker performed only source edits and static AST parsing; parent reruns and review are pending. + +## Revision 4 exact Fraction source portability + +Parent authorized the two exact source hashes after source-only comparison showed the official CPython 3.12.15 file differs solely in `Fraction.__pow__`, outside the admitted constructor/hash/equality path. `_fraction_source_profile` accepts only exact strings matching the recorded local `cf335...` or official `d52d1...` digest. All existing runtime-local compilation/code comparison, slot/property checks, class/function/global captures, hook denial and per-admission freshness checks remain. The receipt now reports the actual file digest and source profile selected; unknown files are still rejected before binding. The downloaded official source is reference evidence only, never imported or used to replace runtime Fraction. + +Five bounded policy controls recognize the two explicit pins and reject an unknown digest, empty string and string subclass. Each ordinary binding verifies receipt/profile agreement. They do not execute alternate source or certify a second interpreter. The fixed allowlist scan, actual-digest/profile receipt and new controls are included in the future complete candidate bill. Parent's ongoing immutable-v3 measurements remain evidence for v3 only; revision 4 requires its own applicable gates and fresh combined stage. No worker scientific execution occurred. diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/OWNERSHIP.md b/research/h25-bookkeeping/payload/priorities/set-reuse/OWNERSHIP.md new file mode 100644 index 0000000000..1d6c001aab --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/OWNERSHIP.md @@ -0,0 +1,23 @@ +# P1 whole-tail ownership design, revision 2 + +This is a proposed **new candidate admission invariant**. PR5995 native_backend.py:1–8 promises stable serial native calls; it does not establish that no mutation can occur during the complete `verify_map` tail. The baseline and its accepted input behavior remain unchanged. If the new invariant is unavailable, the candidate runs the literal original tail with the original callback/error behavior. + +The new invariant is justified only for the fresh complete frozen CLI and data it constructs. `complex_circuit.py:26–40` constructs `triples` as a list of tuples from integer combinations and stores ordinary lists, dictionaries and integer support masks. `complex_network.py:90–93` constructs a local circuit, then local Checks and role code, and immediately calls `checks.verify_map()`. The parent full_driver's existing construction/check wrappers and one-call phase counts supply locations to attest the identities. Its scientific capture of `(c, checks, code)` occurs later in `observe_roles`, after `verify_map`; no earlier public observation publishes the private operand sets. + +Source-only scanning found no `__del__`, weak-reference callback registration, threading, signal handlers or GC callbacks in the frozen scientific scripts or native engine; the two `__weakref__` hits are class-descriptor validation. This is bounded source evidence, not a theorem about every Python process or standard-library finalizer. The new corridor therefore also requires the parent-created fresh process and unchanged pinned invocation environment, without arbitrary user code installed around the call. + +## Concrete issuance boundary + +1. Parent installs the adapter only in the candidate, after validating the frozen scientific closure and binding exact original methods. Baseline still receives the unchanged method. +2. Parent-owned source-fixed wrappers observe successful completion of the original circuit constructor and Checks constructor. They save exactly one private record holding the actual `c`, `checks`, original triples list and a unique nonce by identity. They do not deduce provenance from value equality, class name, refcount or supplied flags. Original constructors execute exactly once. +3. Parent arms that record only while its original `runpy.run_path` invocation of the pinned assertion-on CLI is active, with the expected sole `verify_map` phase entry. The source-fixed wrapper reserves and consumes the nonce at method entry, before executing the prefix, using only identity checks against the captured Checks object. It passes the reserved opaque record privately to this invocation; nested/reentrant calls cannot borrow it. The owner is source-fixed driver code, not a caller-provided callable. General adapter calls have no record. +4. The adapter executes the original prefix once. At the original `nonzero=0` boundary, it checks the reserved private record and objects using anchored `type`, `is`, ordinary tuple/list/dict primitives and source-bound class metadata. It requires the same privately observed circuit/triples objects, current exact triple/key/value shapes and unchanged relevant builtin/Fraction resolutions. A reserved lease can authorize only this invocation's tail; a post-prefix mismatch falls back and cannot rearm it. +5. Parent denies an optimized lease when the fresh-process/source corridor is absent; constructors or call-site ownership are not attested; the record is missing, consumed or mismatched; classes/functions/globals changed; or observable trace/profile/monitoring, user signal, GC callback, or concurrent execution hooks are installed. Checking hooks is read-only; it does not disable hooks or change baseline runtime policy. Exact hook checks and their costs must be frozen in implementation before any run. The source-bound fresh process/no-arbitrary-user-code condition covers the narrower finalizer/reentry claim; a generic process cannot be admitted merely because hook lists look empty. +6. Unsupported post-prefix admission executes the literal original tail. Unsupported initial binding delegates the full original method once, before running any prefix. Existing mandatory native drift rejection still occurs at its original native boundary. A failed prefix needs no lease or fallback and propagates its original exception immediately. +7. Every exit revokes the record and drops private operand sets, including exceptions. A second call needs a fresh explicit record; copied tuples, equal circuits, changed arrays and stale nonces cannot reuse it. Finite controls may use an explicitly separate trusted fixture issuer, never an unrestricted truthy argument. + +## What this proves and does not prove + +For the admitted source-bound whole tail, exact integer tuple values cannot mutate; private exact sets are not published; both ordered intersection loops and coefficient/equality checks are still evaluated; the local `got` mapping has no custom collision keys; and no admitted callback can mutate the source list between these operations. Consequently each reused operand denotes the same value as the original repeated `set(triple)` evaluation. The claim concerns these values and checks, not original object-allocation identity or allocation-failure timing. + +It does not prove generic alias safety, safe arbitrary tracing, preemption immunity, or absence of hostile native-memory changes. Those calls retain the literal fallback rather than silently extending or narrowing baseline semantics. The single-use lease, source inspection, hook checks, full relevant binding checks, data admission, local metadata construction and cleanup are all new candidate costs. Implementation remains pending the parent/reviewer contract gate. diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY-SOURCE.json b/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY-SOURCE.json new file mode 100644 index 0000000000..b0b93578d6 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY-SOURCE.json @@ -0,0 +1,32 @@ +{ + "adapter_checked_method_AST_equal": { + "__eq__": true, + "__hash__": true, + "__new__": true, + "denominator": true, + "numerator": true + }, + "changed_fraction_methods": [ + "__pow__" + ], + "changed_top_level_functions": [], + "cross_interpreter_runtime_validation": false, + "hash_algorithm_AST_equal": true, + "local": { + "bytes": 38067, + "path": "/usr/lib/python3.12/fractions.py", + "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231" + }, + "method_names_equal": true, + "official": { + "bytes": 38147, + "commit": "e848e4b09ca4bc67c0041c9ce7526dae471d4c36", + "sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "tag": "v3.12.15", + "tag_object": "f9e83c56c657be0a74ede2b5c523de4f9191d117", + "url": "https://raw.githubusercontent.com/python/cpython/e848e4b09ca4bc67c0041c9ce7526dae471d4c36/Lib/fractions.py", + "version": "3.12.15" + }, + "science_imports_or_execution": false, + "status": "SOURCE_ONLY_AST_COMPARISON" +} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY.md b/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY.md new file mode 100644 index 0000000000..15a8953eff --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/PORTABILITY.md @@ -0,0 +1,29 @@ +# P1 Fraction source portability: source-only finding + +**The earlier single-hash adapter rejects the official CPython 3.12.15 Fraction source.** The required interface and the six source functions it authenticates are compatible by static inspection. Parent authorized revision 4's exact second source digest; that source change and policy-only controls are now prepared, with runtime validation still pending. + +| Source profile | Bytes | SHA256 | +| --- | ---: | --- | +| Current local `/usr/lib/python3.12/fractions.py`, environment labelled CPython 3.12.3 | 38,067 | `cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231` | +| Official CPython tag `v3.12.15`, `Lib/fractions.py` | 38,147 | `d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0` | + +The [official 3.12.15 release page](https://www.python.org/downloads/release/python-31215/) identifies the release. Read-only `git ls-remote` resolves its annotated tag object to `f9e83c56c657be0a74ede2b5c523de4f9191d117`, peeled commit `e848e4b09ca4bc67c0041c9ce7526dae471d4c36`. Downloads from the tag and [that exact commit](https://raw.githubusercontent.com/python/cpython/e848e4b09ca4bc67c0041c9ce7526dae471d4c36/Lib/fractions.py) have the same SHA. The latter is the durable source reference. A read-only copy is retained as `cpython-3.12.15-fractions.py`; preserve CPython/PSF attribution if it is included in publication. + +The complete textual diff changes only `Fraction.__pow__`: its final general branch now accepts `float`/`complex` explicitly and returns `NotImplemented` otherwise. This is outside P1's constructor/hash/equality path. Static AST comparison, ignoring source-position attributes, found only `__pow__` changed, no top-level function changes, and identical Fraction method-name sets. `__new__`, `__hash__`, `__eq__`, `numerator`, `denominator`, and `_hash_algorithm` are each AST-identical. Exact slots, property access, the LRU hash wrapper and `numbers.Rational` inheritance remain present. Machine-readable evidence is `PORTABILITY-SOURCE.json`. + +Filename-first discovery located the prior narrow pin at `outputs/fraction-native-cache-20261027/repo/research/fraction-native-qualification/SOURCES.json:114–119`: it records the same local `cf335...` hash and Linux x86_64 CPython 3.12.3 environment. Its `guard.py:18` includes the local Fraction file in the source closure. Selected earlier Fraction primitive/type-gate source records supplied no additional matching 3.12.15 pin in this bounded lookup. This does not claim exhaustive historical coverage. + +## Minimal authorized revision 4 admission change + +1. Replace the single accepted digest with a fixed two-entry allowlist containing the exact hashes above and explicit provenance labels. Keep CPython 3.12 as the supported interpreter family. Do not accept an arbitrary file merely because the version string says 3.12.15, and do not accept unknown files based only on a few matching methods. +2. Read and hash the active `fractions.__file__` exactly as now, select its explicit source profile, then retain the current source-local compilation/code comparison, descriptor checks, Fraction/global snapshots and per-admission freshness checks. Compare loaded functions with source compiled by that same running interpreter; do not compare bytecode serialized under different patch releases. +3. Return the actual selected digest/profile from source authentication into the receipt. The current hard-coded `fraction_sha256` receipt must not continue reporting the local digest when the official digest was selected. No fallback or scientific arithmetic changes are needed for this proposal. +4. Preserve unknown-digest rejection. Add bounded source-pin negative controls and normal/`-O` controls for each admitted runtime, plus the complete assertion-on hosted replay. An allowlist source check alone does not establish hosted runtime compatibility. + +The small fixed allowlist lookup, provenance/receipt allocation and any added controls are paid costs, with measured size/time still unknown. Existing file hashing and compilation remain. If the parent changes the adapter, it needs a new immutable source revision and the applicable review/validation/performance treatment; local stage-v3 results must not silently become evidence for changed source. Keeping the current implementation unchanged instead limits P1 to the local Fraction source and would fail a hosted runner carrying the official digest. + +## Remaining boundary + +The claimed CI interpreter version is currently a parent-supplied expectation; this pass did not inspect a live runner's installed Fraction bytes. Distribution patches can alter files without changing the version string. Confirm the active file digest and actual runtime in the hosted receipt. P1's source-level interface compatibility does not certify the whole historical CLI across interpreters, and hosted correctness never transfers local wall/CPU measurements. + +The initial investigation changed no adapter or controls. Following explicit parent authorization, revision 4 implements the two-entry policy and actual selected-digest/profile receipt, retaining all existing runtime checks. Controls test the literal pin policy and receipt consistency only; they do not load the reference file. No scientific module was imported, no code was compiled/executed, and no numerical or corpus run occurred in this worker. Source reads, retrieval, hashing/diffing, inert AST comparison and source edits are the evidence here. diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/PROPOSAL.json b/research/h25-bookkeeping/payload/priorities/set-reuse/PROPOSAL.json new file mode 100644 index 0000000000..4e6e7f2e9b --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/PROPOSAL.json @@ -0,0 +1,129 @@ +{ + "schema": "h25-bookkeeping-proposal-v1", + "revision": 2, + "revision_reason": "Explicit repeated-call budget and repair of whole-tail ownership scope; the native per-kernel contract does not imply a verify_map-wide lease", + "priority": "P1-set-reuse", + "status": "SOURCE_RESEARCH_COMPLETE_AWAITING_PARENT_CONTRACT_COST_GATE", + "implementation_authorized": false, + "scientific_execution": {"imports": 0, "compilations": 0, "corpus_decodes": 0, "correctness_runs": 0, "timed_runs": 0}, + "source_pins": { + "baseline_pr": 5995, + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "arm": "native C plus all existing complete qualification controls", + "package_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/gf2-full-network-20261028/publication-repo/research/gf2-full-network", + "code_manifest_sha256": "0ce6a3c120fc4f8f7ab98f044b3d7a72ce72310972c3846a4835bfc01e16a0d7", + "frozen/scripts/complex_circuit.py": {"sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", "lines": [313, 333]}, + "frozen/scripts/complex_network.py": {"sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", "caller_lines": [90, 93]}, + "engine/native_backend.py": {"sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", "relevant_contract": "Calls run serially with no mutation during a call; detected boundary drift rejected before arithmetic or fallback"}, + "full_driver.py": {"sha256": "0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36"}, + "local_fraction_source": {"path": "/usr/lib/python3.12/fractions.py", "sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "status": "read-only current environment observation, not yet admitted as a new package pin"}, + "canonical_main_guidance_only": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "priority_revision": 8 + }, + "primary_sources": [ + {"url": "https://docs.python.org/3.12/library/stdtypes.html#set-types-set-frozenset", "finding": "set is mutable, inputs are hashed, intersection returns the common elements"}, + {"url": "https://docs.python.org/3.12/reference/datamodel.html#object.__hash__", "finding": "hash collection operations call custom hash/equality; tuple immutability does not make contained objects immutable"}, + {"url": "https://raw.githubusercontent.com/python/cpython/v3.12.3/Objects/setobject.c", "finding": "set_intersection retains an exact set operation; identical operand pointer uses set_copy; rich comparison may invoke arbitrary code"} + ], + "candidate": { + "name": "invocation-private positional operand sets", + "placement": "After the untouched original node/piece prefix, before nonzero=0", + "representation": "One ordinary builtin set for each current positional triple; no global, instance or cross-call cache", + "order": "Outer triples and inner source bit indices retain their original positional order, including duplicates", + "predicates": ["not (S_set & T_set)", "len(S_set & T_set) == 2"], + "two_loops_retained": true, + "answers_cached": false, + "bitmask_oracle_substitution": false, + "diagonal_alias_note": "S_set and T_set are identical on the positional diagonal; CPython's ordinary set-and copies this operand. Exact set value/type and predicate still match, with no callback-bearing members admitted." + }, + "adapter_interface": { + "proposed_factory": "bind_verify_map(module, original_verify_map) -> (candidate_verify_map, private_parent_lease_owner, receipt)", + "call": "candidate_verify_map(self) -> original exact dict or original exception", + "integration_owner": "parent only", + "standalone_general_purpose_api": false, + "original_reference": "Untouched pinned method retained separately; candidate must not change its globals or the baseline driver binding", + "generation_rule": "Use a source-bound function retaining the original prefix and literal fallback tail, with admitted optimized tail at the same boundary. Validate allowed AST/source substitutions before binding; all preparation is timed.", + "no_prefix_replay": true, + "receipt": "Only optimization counters/source/admission receipts; no scientific-return or witness fields added", + "ownership": "Parent establishes a NEW whole-tail invariant for one actual frozen full-caller invocation; the original native per-kernel contract is insufficient. Reserve/consume opaque nonce at entry, check actual data after prefix, expire in finally. See OWNERSHIP.md. No arbitrary policy callback.", + "cleanup": "Local references released on return or exception; no retained sets on Checks, circuit or module" + }, + "admission": { + "when": "After prefix, without executing user-defined operations", + "requires": [ + "NEW scoped whole-tail invariant established by the parent: a private single-use identity record for actual construction-observed Checks/circuit objects, accepted only within the exact fresh full CLI; never inferred from native per-kernel guards", + "Exact source-bound Checks and ComplexSideCircuit objects, original class/attribute dispatch and ordinary instance dictionaries", + "Exact list of exact length-three tuples containing only exact int members; reject bool and int/container subclasses", + "Anchored ordinary set, len, sum, enumerate, dict and related builtin resolutions, and unchanged original function/global/builtin calling environment", + "Source-bound original Fraction constructor/hash/equality/property/global environment with ordinary exact integer slot values", + "Every local got key is an exact pair of an exact integer triple and exact Fraction, and every got value is an exact int; avoids callback-bearing collision keys", + "No trace/signal/GC/custom-key/concurrent callback can mutate observed data in this leased dynamic extent" + ], + "mutable_policy": "The frozen caller's exact list is accepted only under the NEW explicitly established whole-tail lease; arbitrary mutable or unowned inputs fall back. Baseline behavior/domain is unchanged. Rebuild on every invocation, including changed values between invocations.", + "unsupported": "Execute literal original tail once after prefix; perform no eager custom iteration/hash/equality and no whole-method replay", + "binding_drift": "Fallback before prefix when initial admission/binding fails; if drift is first observed after prefix, select literal tail. Retain any pre-existing backend mandatory fail-closed guard behavior.", + "allocation_errors": "Propagate without retry or error swallowing; exact allocation-failure instruction/timing is not promised" + }, + "source_operation_counts": { + "N": 2300, + "baseline_operand_set_constructions": 21160000, + "candidate_operand_set_constructions": 2300, + "removed_operand_constructions": 21157700, + "retained_intersection_operations_and_result_allocations": 10580000, + "counts_are_source_derived_not_measured": true, + "performance_forecast": null + }, + "retained_work": [ + "All node-order/support-disjointness/union assertions", + "All original piece coefficient, overlap and support accumulation checks", + "Both independent all-pair set intersection passes per target", + "All original coefficient constructions, equality short-circuit/order, bit counts and target order", + "Full certificate, stdout, exact typed return, witness/rank/complement observations", + "All baseline native controls, source checks, cold compiler/binding costs and cleanup" + ], + "new_cost_bill": [ + {"item": "source AST/closure validation and adapter creation/binding", "cost": "unknown, included in complete candidate"}, + {"item": "ownership lease and class/function/global/builtin/Fraction freshness checks", "cost": "unknown, paid every applicable boundary"}, + {"item": "post-prefix scan of N triples and got dictionary exact keys/values", "cost": "unknown; linear in inspected data"}, + {"item": "N set allocations/hash inserts, retained positional references and optional snapshot/final custody scan", "cost": "unknown CPU/wall and peak bytes; not zero"}, + {"item": "pair-loop positional lookup/unpacking overhead", "cost": "unknown; retain all pair operations"}, + {"item": "fallback dispatch, receipts, normal/O finite controls, full observations and cleanup", "cost": "unknown, charged in complete candidate bill"} + ], + "fallback_alternative": { + "name": "literal original pairwise tail", + "reason": "Necessary for callback-bearing inputs, unsupported dispatch or absent ownership; no generalized caching theorem claimed", + "performance": "No claimed saving; admission overhead may make unsupported calls slower", + "other_rejected_routes": ["cached intersection predicates", "one intersection reused across both original checks", "isdisjoint or integer bitmask oracle substitution", "persistent cache keyed only by triple identity", "eager cache before prefix", "complete-method replay after partially executed prefix"] + }, + "finite_fixture_plan": [ + "N small with intersections 0,1,2,3; empty, repeated and reordered triples; negative and arbitrary-width exact ints", + "Typed dictionary values/key order and unchanged support/pieces/triples witnesses against separate original reference", + "Bad node ordering, overlap, coefficient and target-mask failures; exact exception type/args and earliest failing assertion", + "Exact-looking list/tuple/int subclasses, generators, unhashable and custom hash/equality values: literal fallback with identical callback trace", + "Prefix callback mutates triples; admission observes post-prefix state, never eager stale sets", + "Custom got collision key mutates an alias during later lookup: fallback, no cached representation", + "Missing lease and unsupported class dispatch: fallback without extra user attribute callbacks", + "Mutate/replace/reorder triples between invocations: fresh sets, no cross-call reuse", + "Changed set/Q/builtin/function/default/closure or class descriptor bindings: original fallback or existing mandated rejection", + "Normal and optimized-interpreter finite tests; assertion-on complete run only" + ], + "discriminating_next_test": { + "fixture": "Two-stage negative control: a prefix callback that raises before triples are usable, followed by a prefix mutation plus custom got collision-key scenario", + "required_result": "First preserves prefix-first error/callback trace with zero eager set construction; second selects literal tail and matches original callback sequence/exception or output", + "failure_implication": "Reject adapter placement or admission, before any performance pilot" + }, + "full_vs_micro_boundary": { + "micro": "Can validate operation-count mechanism and finite semantics only; cannot establish complete wall or CPU saving", + "full": "Parent-owned fresh native-baseline/candidate complete pilot, then reviewed combination and fixed BCCBBC qualification with all costs and observations", + "individual_fifteen_percent_required": false, + "combined_target": "At least 15% further complete wall AND CPU reduction vs fresh PR5995 native baseline, plus declared noise gates", + "inherited_percentages": false + }, + "planned_owned_files_after_gate": ["set_reuse.py", "finite_set_controls.py", "IMPLEMENTATION.md"], + "open_risks": [ + "Parent/reviewer must approve the concrete OWNERSHIP.md single-use identity lease and frozen Fraction closure validation before implementation", + "Full runtime benefit and new peak memory remain unknown", + "Preserving generic mutation/callback semantics is not possible using exact triple checks alone", + "New lane source and binding checks must be isolated from baseline and priced with combined guard/trace changes" + ] +} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/RESEARCH.md b/research/h25-bookkeeping/payload/priorities/set-reuse/RESEARCH.md new file mode 100644 index 0000000000..cf44b7f124 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/RESEARCH.md @@ -0,0 +1,29 @@ +# P1: invocation-private operand sets + +Source-only proposal; no scientific imports, compilation, corpus decoding, correctness execution, timing or implementation performed. + +Baseline is PR5995 `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, native C configuration with complete controls. `frozen/scripts/complex_circuit.py` SHA256 is `d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1`; its `Checks.verify_map` occupies lines 313–333. The frozen caller creates the circuit locally and calls this method once at `complex_network.py:90–93`. This source is distinct from current-main research guidance. + +Each of two ordered N-by-N loops constructs both operands anew. At N=2300 the source implies 4N²=21,160,000 operand-set constructions, plus 2N²=10,580,000 intersections. These are operation counts, not timing measurements or a 15% forecast. + +## Primary design and preserved checks + +Build one exact builtin set per admitted triple, in original positional order, after the untouched node/piece prefix and immediately before the original `nonzero = 0` boundary. Keep these sets private to that invocation and release them on return/error. Use a positional sequence, never a dictionary keyed by triples, so duplicates and ordering are preserved. In each target iteration evaluate every `not (S_set & T_set)` in the first loop and every `len(S_set & T_set) == 2` in the second. Retain both sums, source bit positions, coefficient construction, short-circuit equality assertion, bit counts and exact return dictionary. Do not combine the loops, replace intersection with bit arithmetic/isdisjoint, cache predicate answers, or alter witnesses. + +The original independent set operation remains the oracle against constructed support masks. Sharing operand representations does not share any predicate answer. CPython uses a copy when both `&` operands are identical; the diagonal still evaluates the original set intersection expression and produces the same exact set for this callback-free domain. [CPython 3.12.3 set implementation](https://raw.githubusercontent.com/python/cpython/v3.12.3/Objects/setobject.c), `set_intersection`, lines 1099–1140. + +## Admission, ownership and fallback + +Exact tuple/int checks alone do not establish safety. Lists are mutable, and hashed collections can invoke user hash/equality methods. [Python data model](https://docs.python.org/3.12/reference/datamodel.html#object.__hash__). Sets are mutable distinct-member collections; creating them once changes allocation and callback counts. [Python set documentation](https://docs.python.org/3.12/library/stdtypes.html#set-types-set-frozenset). + +Admission requires a **new, scoped whole-tail ownership invariant**, independently established by the parent for this frozen full caller. The original native guard's per-kernel no-mutation promise does not establish it. Capture the actual circuit and Checks identities in the parent-owned construction wrappers, arm one invocation only within the fresh assertion-on CLI, and check an opaque identity record after the prefix. No caller-supplied policy function executes. Deny the lease for unrecognized construction/call boundaries, active mutation hooks, changed source/dispatch, or reentry; use literal fallback. Source-bound exact classes, ordinary attributes, an exact list of exact length-three integer tuples, original builtins and the frozen Fraction environment complete admission. See `OWNERSHIP.md` for issuance, denial and revocation. This is an explicit candidate restriction, not a strengthened claim about baseline Python behavior or generic alias detection. + +Run admission after the original prefix, since earlier prefix operations can mutate aliases. Also inspect the local `got` dictionary without custom equality: every key must be an exact pair of an exact integer triple and an exact Fraction with exact integer slot values; every value must be an exact int. Otherwise a custom collision key retained by the prefix could run equality during later lookups and invalidate reuse. Inspect through anchored type/container primitives, never custom iteration or descriptors. Verify the relevant class, function/global/builtin/Fraction resolutions at admission; new checks and any source-binding preparation are paid costs. + +Unsupported input or absent ownership lease selects the literal original pairwise tail in the same call, after the already executed prefix. Do not call the complete original method again and repeat prefix callbacks. Binding rejection before executing the prefix may delegate the complete original once. Preserve original exceptions and assertion order; propagate allocation failures without retry. Identical allocation-failure timing is outside the existing resource-bounded execution contract and cannot be promised by an allocation optimization. + +## Costs, validation and discriminating test + +Remove 4N²−N operand constructions; retain all 2N² intersection allocations/checks. Add source binding, admission scans of N triples and the `got` keys, ownership bookkeeping, N retained sets, positional references, any defensive snapshot/final custody scan, cleanup and finite controls. Runtime and peak-memory costs remain unknown until measured. + +Finite fixtures cover intersections 0/1/2/3, duplicates, reordered triples, negative/large ints, empty inputs, exact returns, failed node/piece assertions, custom hash/equality/iterators/subclasses, a custom `got` collision key, prefix mutation, missing/reused lease, between-call mutation and binding drift. Compare error type/args and callback order in fallback; run normal and optimized-interpreter finite controls. The discriminating test is a failing-prefix callback fixture followed by a post-prefix mutation/collision fixture: any eager cache or whole-method fallback must fail these controls. Parent then runs complete baseline/candidate pilots with original certificate, stdout, typed return, witnesses, ranks and complements unchanged. Micro results establish only mechanism; complete fresh native-baseline timing establishes benefit. `CALL-BUDGET.json` separates eliminated metadata construction from retained checks. Intersection-result sharing or loop fusion is a separate unapproved research branch, requiring independence/error-order review. diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/SOURCE-READINESS.json b/research/h25-bookkeeping/payload/priorities/set-reuse/SOURCE-READINESS.json new file mode 100644 index 0000000000..69567b34c3 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/SOURCE-READINESS.json @@ -0,0 +1,54 @@ +{ + "schema": "h25-set-source-readiness-v1", + "revision": 4, + "status": "EXACT_TWO_PIN_PORTABILITY_READY_FOR_REVIEW_AND_PARENT_SERIAL_EXECUTION", + "interface": {"adapter": "bind_verify_map(module)", "controls": "run_controls(backend, set_adapter)"}, + "files": { + "set_reuse.py": "eeeead34731e73f74dff250f354e57b72314c4e18670848bfa9f48c87de1305d", + "finite_set_controls.py": "760f151efd18b281c7045e979d2c3f95ce58c5d8bb1340e34d2afa68bd072919", + "IMPLEMENTATION.md": "6b0a86226046bc421134f18a0cd77ebc4d5dce07e0feb3b67de8c2a852856452", + "PORTABILITY.md": "8f2e5b95ade7b100634d1d875d7ac8fbef608ed74e2539f340a22d0c17a212e1", + "PORTABILITY-SOURCE.json": "2c385ad61b64fb7e58d915ac597eb223d65365fcf1737dbd6320a2b438f3cc82" + }, + "previous_revision_3": { + "adapter_sha256": "d375bb352ddff7a922bf1413d2911935b977d3bcce670db4954f6939afa15f29", + "control_sha256": "9fbe76c6d5ce123d12fc3c231786a9a85996fad41102835e08112768dd75738d", + "measurements_remain_for_revision_3_only": true + }, + "retained_failure": { + "run": "finite-P1-O-v2", + "stderr": "runtime/runs/finite-P1-O-v2/stderr.txt", + "reported_wall_seconds": 2.8227, + "error": "RuntimeError: Collision fixture did not reach custom equality", + "cause": "Control required a callback from an original assertion that optimized interpreter mode removes", + "normal_finite_v2": "PASS reported by parent", + "raw_evidence_and_cost_preserved": true + }, + "retained_revision_3_repair": { + "adapter_changed": false, + "controls_removed": 0, + "unconditional_differential_comparisons_retained": true, + "normal_expectation": "Collision equality and Q-constructor callback fixtures still require nonempty original events and exactly equal candidate events", + "optimized_expectation": "Both fixtures explicitly require empty original and candidate event lists, because the relevant source calls are assertion-only; exact output/error and fallback/token comparisons remain", + "second_fixture_basis": "Static source inspection: all verify_map Q(...) calls occur inside prefix/tail assertions" + }, + "revision_4_portability": { + "authorization": "Parent explicitly authorized minimal exact two-source allowlist, actual selected digest receipt and bounded source-pin policy controls", + "allowed_sources": [ + {"sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "profile": "recorded-local-cpython-3.12.3", "bytes": 38067}, + {"sha256": "d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", "profile": "official-cpython-3.12.15-e848e4b09ca4bc67c0041c9ce7526dae471d4c36", "bytes": 38147, "tag": "v3.12.15", "tag_object": "f9e83c56c657be0a74ede2b5c523de4f9191d117", "commit": "e848e4b09ca4bc67c0041c9ce7526dae471d4c36", "source_url": "https://raw.githubusercontent.com/python/cpython/e848e4b09ca4bc67c0041c9ce7526dae471d4c36/Lib/fractions.py", "tag_and_commit_download_hashes_agree": true} + ], + "source_only_difference": "Only Fraction.__pow__ changed; constructor/hash/equality/properties/_hash_algorithm AST identical", + "admission": "Exact digest allowlist followed by every existing runtime-local source/code/descriptor/freshness check; unknown hashes remain rejected", + "receipt": "Actual active file fraction_sha256 and fraction_source_profile are reported", + "policy_controls": {"known_pins_recognized": 2, "unknown_or_nonexact_values_rejected": 3, "actual_binding_receipt_policy_consistency": true}, + "alternate_source_imported_or_executed": false, + "runtime_Fraction_replaced_or_vendored": false, + "hosted_3_12_15_runtime_validation": "not performed; actual runner digest and complete replay still required" + }, + "worker_validation": {"static_ast_parse": "PASS", "scientific_imports": 0, "compilations_or_executions": 0, "correctness_runs": 0, "timed_runs": 0}, + "pending": ["Independent review of exact two-pin portability", "Parent serial revision-4 normal/O finite execution", "Fresh combined full-caller correctness/performance gates", "Actual hosted runner digest and complete replay"], + "immutable_stages_modified": [], + "performance_claim": null, + "combined_target_unchanged": "At least 15 percent further complete wall AND CPU saving versus fresh PR5995 native baseline, with declared noise gates" +} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py b/research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py new file mode 100644 index 0000000000..e3a8bbcfb3 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/cpython-3.12.15-fractions.py @@ -0,0 +1,990 @@ +# Originally contributed by Sjoerd Mullender. +# Significantly modified by Jeffrey Yasskin . + +"""Fraction, infinite-precision, rational numbers.""" + +from decimal import Decimal +import functools +import math +import numbers +import operator +import re +import sys + +__all__ = ['Fraction'] + + +# Constants related to the hash implementation; hash(x) is based +# on the reduction of x modulo the prime _PyHASH_MODULUS. +_PyHASH_MODULUS = sys.hash_info.modulus +# Value to be used for rationals that reduce to infinity modulo +# _PyHASH_MODULUS. +_PyHASH_INF = sys.hash_info.inf + +@functools.lru_cache(maxsize = 1 << 14) +def _hash_algorithm(numerator, denominator): + + # To make sure that the hash of a Fraction agrees with the hash + # of a numerically equal integer, float or Decimal instance, we + # follow the rules for numeric hashes outlined in the + # documentation. (See library docs, 'Built-in Types'). + + try: + dinv = pow(denominator, -1, _PyHASH_MODULUS) + except ValueError: + # ValueError means there is no modular inverse. + hash_ = _PyHASH_INF + else: + # The general algorithm now specifies that the absolute value of + # the hash is + # (|N| * dinv) % P + # where N is self._numerator and P is _PyHASH_MODULUS. That's + # optimized here in two ways: first, for a non-negative int i, + # hash(i) == i % P, but the int hash implementation doesn't need + # to divide, and is faster than doing % P explicitly. So we do + # hash(|N| * dinv) + # instead. Second, N is unbounded, so its product with dinv may + # be arbitrarily expensive to compute. The final answer is the + # same if we use the bounded |N| % P instead, which can again + # be done with an int hash() call. If 0 <= i < P, hash(i) == i, + # so this nested hash() call wastes a bit of time making a + # redundant copy when |N| < P, but can save an arbitrarily large + # amount of computation for large |N|. + hash_ = hash(hash(abs(numerator)) * dinv) + result = hash_ if numerator >= 0 else -hash_ + return -2 if result == -1 else result + +_RATIONAL_FORMAT = re.compile(r""" + \A\s* # optional whitespace at the start, + (?P[-+]?) # an optional sign, then + (?=\d|\.\d) # lookahead for digit or .digit + (?P\d*|\d+(_\d+)*) # numerator (possibly empty) + (?: # followed by + (?:\s*/\s*(?P\d+(_\d+)*))? # an optional denominator + | # or + (?:\.(?P\d*|\d+(_\d+)*))? # an optional fractional part + (?:E(?P[-+]?\d+(_\d+)*))? # and optional exponent + ) + \s*\Z # and optional whitespace to finish +""", re.VERBOSE | re.IGNORECASE) + + +# Helpers for formatting + +def _round_to_exponent(n, d, exponent, no_neg_zero=False): + """Round a rational number to the nearest multiple of a given power of 10. + + Rounds the rational number n/d to the nearest integer multiple of + 10**exponent, rounding to the nearest even integer multiple in the case of + a tie. Returns a pair (sign: bool, significand: int) representing the + rounded value (-1)**sign * significand * 10**exponent. + + If no_neg_zero is true, then the returned sign will always be False when + the significand is zero. Otherwise, the sign reflects the sign of the + input. + + d must be positive, but n and d need not be relatively prime. + """ + if exponent >= 0: + d *= 10**exponent + else: + n *= 10**-exponent + + # The divmod quotient is correct for round-ties-towards-positive-infinity; + # In the case of a tie, we zero out the least significant bit of q. + q, r = divmod(n + (d >> 1), d) + if r == 0 and d & 1 == 0: + q &= -2 + + sign = q < 0 if no_neg_zero else n < 0 + return sign, abs(q) + + +def _round_to_figures(n, d, figures): + """Round a rational number to a given number of significant figures. + + Rounds the rational number n/d to the given number of significant figures + using the round-ties-to-even rule, and returns a triple + (sign: bool, significand: int, exponent: int) representing the rounded + value (-1)**sign * significand * 10**exponent. + + In the special case where n = 0, returns a significand of zero and + an exponent of 1 - figures, for compatibility with formatting. + Otherwise, the returned significand satisfies + 10**(figures - 1) <= significand < 10**figures. + + d must be positive, but n and d need not be relatively prime. + figures must be positive. + """ + # Special case for n == 0. + if n == 0: + return False, 0, 1 - figures + + # Find integer m satisfying 10**(m - 1) <= abs(n)/d <= 10**m. (If abs(n)/d + # is a power of 10, either of the two possible values for m is fine.) + str_n, str_d = str(abs(n)), str(d) + m = len(str_n) - len(str_d) + (str_d <= str_n) + + # Round to a multiple of 10**(m - figures). The significand we get + # satisfies 10**(figures - 1) <= significand <= 10**figures. + exponent = m - figures + sign, significand = _round_to_exponent(n, d, exponent) + + # Adjust in the case where significand == 10**figures, to ensure that + # 10**(figures - 1) <= significand < 10**figures. + if len(str(significand)) == figures + 1: + significand //= 10 + exponent += 1 + + return sign, significand, exponent + + +# Pattern for matching float-style format specifications; +# supports 'e', 'E', 'f', 'F', 'g', 'G' and '%' presentation types. +_FLOAT_FORMAT_SPECIFICATION_MATCHER = re.compile(r""" + (?: + (?P.)? + (?P[<>=^]) + )? + (?P[-+ ]?) + (?Pz)? + (?P\#)? + # A '0' that's *not* followed by another digit is parsed as a minimum width + # rather than a zeropad flag. + (?P0(?=[0-9]))? + (?P0|[1-9][0-9]*)? + (?P[,_])? + (?:\.(?P0|[1-9][0-9]*))? + (?P[eEfFgG%]) +""", re.DOTALL | re.VERBOSE).fullmatch + + +class Fraction(numbers.Rational): + """This class implements rational numbers. + + In the two-argument form of the constructor, Fraction(8, 6) will + produce a rational number equivalent to 4/3. Both arguments must + be Rational. The numerator defaults to 0 and the denominator + defaults to 1 so that Fraction(3) == 3 and Fraction() == 0. + + Fractions can also be constructed from: + + - numeric strings similar to those accepted by the + float constructor (for example, '-2.3' or '1e10') + + - strings of the form '123/456' + + - float and Decimal instances + + - other Rational instances (including integers) + + """ + + __slots__ = ('_numerator', '_denominator') + + # We're immutable, so use __new__ not __init__ + def __new__(cls, numerator=0, denominator=None): + """Constructs a Rational. + + Takes a string like '3/2' or '1.5', another Rational instance, a + numerator/denominator pair, or a float. + + Examples + -------- + + >>> Fraction(10, -8) + Fraction(-5, 4) + >>> Fraction(Fraction(1, 7), 5) + Fraction(1, 35) + >>> Fraction(Fraction(1, 7), Fraction(2, 3)) + Fraction(3, 14) + >>> Fraction('314') + Fraction(314, 1) + >>> Fraction('-35/4') + Fraction(-35, 4) + >>> Fraction('3.1415') # conversion from numeric string + Fraction(6283, 2000) + >>> Fraction('-47e-2') # string may include a decimal exponent + Fraction(-47, 100) + >>> Fraction(1.47) # direct construction from float (exact conversion) + Fraction(6620291452234629, 4503599627370496) + >>> Fraction(2.25) + Fraction(9, 4) + >>> Fraction(Decimal('1.47')) + Fraction(147, 100) + + """ + self = super(Fraction, cls).__new__(cls) + + if denominator is None: + if type(numerator) is int: + self._numerator = numerator + self._denominator = 1 + return self + + elif isinstance(numerator, numbers.Rational): + self._numerator = numerator.numerator + self._denominator = numerator.denominator + return self + + elif isinstance(numerator, (float, Decimal)): + # Exact conversion + self._numerator, self._denominator = numerator.as_integer_ratio() + return self + + elif isinstance(numerator, str): + # Handle construction from strings. + m = _RATIONAL_FORMAT.match(numerator) + if m is None: + raise ValueError('Invalid literal for Fraction: %r' % + numerator) + numerator = int(m.group('num') or '0') + denom = m.group('denom') + if denom: + denominator = int(denom) + else: + denominator = 1 + decimal = m.group('decimal') + if decimal: + decimal = decimal.replace('_', '') + scale = 10**len(decimal) + numerator = numerator * scale + int(decimal) + denominator *= scale + exp = m.group('exp') + if exp: + exp = int(exp) + if exp >= 0: + numerator *= 10**exp + else: + denominator *= 10**-exp + if m.group('sign') == '-': + numerator = -numerator + + else: + raise TypeError("argument should be a string " + "or a Rational instance") + + elif type(numerator) is int is type(denominator): + pass # *very* normal case + + elif (isinstance(numerator, numbers.Rational) and + isinstance(denominator, numbers.Rational)): + numerator, denominator = ( + numerator.numerator * denominator.denominator, + denominator.numerator * numerator.denominator + ) + else: + raise TypeError("both arguments should be " + "Rational instances") + + if denominator == 0: + raise ZeroDivisionError('Fraction(%s, 0)' % numerator) + g = math.gcd(numerator, denominator) + if denominator < 0: + g = -g + numerator //= g + denominator //= g + self._numerator = numerator + self._denominator = denominator + return self + + @classmethod + def from_float(cls, f): + """Converts a finite float to a rational number, exactly. + + Beware that Fraction.from_float(0.3) != Fraction(3, 10). + + """ + if isinstance(f, numbers.Integral): + return cls(f) + elif not isinstance(f, float): + raise TypeError("%s.from_float() only takes floats, not %r (%s)" % + (cls.__name__, f, type(f).__name__)) + return cls._from_coprime_ints(*f.as_integer_ratio()) + + @classmethod + def from_decimal(cls, dec): + """Converts a finite Decimal instance to a rational number, exactly.""" + from decimal import Decimal + if isinstance(dec, numbers.Integral): + dec = Decimal(int(dec)) + elif not isinstance(dec, Decimal): + raise TypeError( + "%s.from_decimal() only takes Decimals, not %r (%s)" % + (cls.__name__, dec, type(dec).__name__)) + return cls._from_coprime_ints(*dec.as_integer_ratio()) + + @classmethod + def _from_coprime_ints(cls, numerator, denominator, /): + """Convert a pair of ints to a rational number, for internal use. + + The ratio of integers should be in lowest terms and the denominator + should be positive. + """ + obj = super(Fraction, cls).__new__(cls) + obj._numerator = numerator + obj._denominator = denominator + return obj + + def is_integer(self): + """Return True if the Fraction is an integer.""" + return self._denominator == 1 + + def as_integer_ratio(self): + """Return a pair of integers, whose ratio is equal to the original Fraction. + + The ratio is in lowest terms and has a positive denominator. + """ + return (self._numerator, self._denominator) + + def limit_denominator(self, max_denominator=1000000): + """Closest Fraction to self with denominator at most max_denominator. + + >>> Fraction('3.141592653589793').limit_denominator(10) + Fraction(22, 7) + >>> Fraction('3.141592653589793').limit_denominator(100) + Fraction(311, 99) + >>> Fraction(4321, 8765).limit_denominator(10000) + Fraction(4321, 8765) + + """ + # Algorithm notes: For any real number x, define a *best upper + # approximation* to x to be a rational number p/q such that: + # + # (1) p/q >= x, and + # (2) if p/q > r/s >= x then s > q, for any rational r/s. + # + # Define *best lower approximation* similarly. Then it can be + # proved that a rational number is a best upper or lower + # approximation to x if, and only if, it is a convergent or + # semiconvergent of the (unique shortest) continued fraction + # associated to x. + # + # To find a best rational approximation with denominator <= M, + # we find the best upper and lower approximations with + # denominator <= M and take whichever of these is closer to x. + # In the event of a tie, the bound with smaller denominator is + # chosen. If both denominators are equal (which can happen + # only when max_denominator == 1 and self is midway between + # two integers) the lower bound---i.e., the floor of self, is + # taken. + + if max_denominator < 1: + raise ValueError("max_denominator should be at least 1") + if self._denominator <= max_denominator: + return Fraction(self) + + p0, q0, p1, q1 = 0, 1, 1, 0 + n, d = self._numerator, self._denominator + while True: + a = n//d + q2 = q0+a*q1 + if q2 > max_denominator: + break + p0, q0, p1, q1 = p1, q1, p0+a*p1, q2 + n, d = d, n-a*d + k = (max_denominator-q0)//q1 + + # Determine which of the candidates (p0+k*p1)/(q0+k*q1) and p1/q1 is + # closer to self. The distance between them is 1/(q1*(q0+k*q1)), while + # the distance from p1/q1 to self is d/(q1*self._denominator). So we + # need to compare 2*(q0+k*q1) with self._denominator/d. + if 2*d*(q0+k*q1) <= self._denominator: + return Fraction._from_coprime_ints(p1, q1) + else: + return Fraction._from_coprime_ints(p0+k*p1, q0+k*q1) + + @property + def numerator(a): + return a._numerator + + @property + def denominator(a): + return a._denominator + + def __repr__(self): + """repr(self)""" + return '%s(%s, %s)' % (self.__class__.__name__, + self._numerator, self._denominator) + + def __str__(self): + """str(self)""" + if self._denominator == 1: + return str(self._numerator) + else: + return '%s/%s' % (self._numerator, self._denominator) + + def __format__(self, format_spec, /): + """Format this fraction according to the given format specification.""" + + # Backwards compatiblility with existing formatting. + if not format_spec: + return str(self) + + # Validate and parse the format specifier. + match = _FLOAT_FORMAT_SPECIFICATION_MATCHER(format_spec) + if match is None: + raise ValueError( + f"Invalid format specifier {format_spec!r} " + f"for object of type {type(self).__name__!r}" + ) + elif match["align"] is not None and match["zeropad"] is not None: + # Avoid the temptation to guess. + raise ValueError( + f"Invalid format specifier {format_spec!r} " + f"for object of type {type(self).__name__!r}; " + "can't use explicit alignment when zero-padding" + ) + fill = match["fill"] or " " + align = match["align"] or ">" + pos_sign = "" if match["sign"] == "-" else match["sign"] + no_neg_zero = bool(match["no_neg_zero"]) + alternate_form = bool(match["alt"]) + zeropad = bool(match["zeropad"]) + minimumwidth = int(match["minimumwidth"] or "0") + thousands_sep = match["thousands_sep"] + precision = int(match["precision"] or "6") + presentation_type = match["presentation_type"] + trim_zeros = presentation_type in "gG" and not alternate_form + trim_point = not alternate_form + exponent_indicator = "E" if presentation_type in "EFG" else "e" + + # Round to get the digits we need, figure out where to place the point, + # and decide whether to use scientific notation. 'point_pos' is the + # relative to the _end_ of the digit string: that is, it's the number + # of digits that should follow the point. + if presentation_type in "fF%": + exponent = -precision + if presentation_type == "%": + exponent -= 2 + negative, significand = _round_to_exponent( + self._numerator, self._denominator, exponent, no_neg_zero) + scientific = False + point_pos = precision + else: # presentation_type in "eEgG" + figures = ( + max(precision, 1) + if presentation_type in "gG" + else precision + 1 + ) + negative, significand, exponent = _round_to_figures( + self._numerator, self._denominator, figures) + scientific = ( + presentation_type in "eE" + or exponent > 0 + or exponent + figures <= -4 + ) + point_pos = figures - 1 if scientific else -exponent + + # Get the suffix - the part following the digits, if any. + if presentation_type == "%": + suffix = "%" + elif scientific: + suffix = f"{exponent_indicator}{exponent + point_pos:+03d}" + else: + suffix = "" + + # String of output digits, padded sufficiently with zeros on the left + # so that we'll have at least one digit before the decimal point. + digits = f"{significand:0{point_pos + 1}d}" + + # Before padding, the output has the form f"{sign}{leading}{trailing}", + # where `leading` includes thousands separators if necessary and + # `trailing` includes the decimal separator where appropriate. + sign = "-" if negative else pos_sign + leading = digits[: len(digits) - point_pos] + frac_part = digits[len(digits) - point_pos :] + if trim_zeros: + frac_part = frac_part.rstrip("0") + separator = "" if trim_point and not frac_part else "." + trailing = separator + frac_part + suffix + + # Do zero padding if required. + if zeropad: + min_leading = minimumwidth - len(sign) - len(trailing) + # When adding thousands separators, they'll be added to the + # zero-padded portion too, so we need to compensate. + leading = leading.zfill( + 3 * min_leading // 4 + 1 if thousands_sep else min_leading + ) + + # Insert thousands separators if required. + if thousands_sep: + first_pos = 1 + (len(leading) - 1) % 3 + leading = leading[:first_pos] + "".join( + thousands_sep + leading[pos : pos + 3] + for pos in range(first_pos, len(leading), 3) + ) + + # We now have a sign and a body. Pad with fill character if necessary + # and return. + body = leading + trailing + padding = fill * (minimumwidth - len(sign) - len(body)) + if align == ">": + return padding + sign + body + elif align == "<": + return sign + body + padding + elif align == "^": + half = len(padding) // 2 + return padding[:half] + sign + body + padding[half:] + else: # align == "=" + return sign + padding + body + + def _operator_fallbacks(monomorphic_operator, fallback_operator): + """Generates forward and reverse operators given a purely-rational + operator and a function from the operator module. + + Use this like: + __op__, __rop__ = _operator_fallbacks(just_rational_op, operator.op) + + In general, we want to implement the arithmetic operations so + that mixed-mode operations either call an implementation whose + author knew about the types of both arguments, or convert both + to the nearest built in type and do the operation there. In + Fraction, that means that we define __add__ and __radd__ as: + + def __add__(self, other): + # Both types have numerators/denominator attributes, + # so do the operation directly + if isinstance(other, (int, Fraction)): + return Fraction(self.numerator * other.denominator + + other.numerator * self.denominator, + self.denominator * other.denominator) + # float and complex don't have those operations, but we + # know about those types, so special case them. + elif isinstance(other, float): + return float(self) + other + elif isinstance(other, complex): + return complex(self) + other + # Let the other type take over. + return NotImplemented + + def __radd__(self, other): + # radd handles more types than add because there's + # nothing left to fall back to. + if isinstance(other, numbers.Rational): + return Fraction(self.numerator * other.denominator + + other.numerator * self.denominator, + self.denominator * other.denominator) + elif isinstance(other, Real): + return float(other) + float(self) + elif isinstance(other, Complex): + return complex(other) + complex(self) + return NotImplemented + + + There are 5 different cases for a mixed-type addition on + Fraction. I'll refer to all of the above code that doesn't + refer to Fraction, float, or complex as "boilerplate". 'r' + will be an instance of Fraction, which is a subtype of + Rational (r : Fraction <: Rational), and b : B <: + Complex. The first three involve 'r + b': + + 1. If B <: Fraction, int, float, or complex, we handle + that specially, and all is well. + 2. If Fraction falls back to the boilerplate code, and it + were to return a value from __add__, we'd miss the + possibility that B defines a more intelligent __radd__, + so the boilerplate should return NotImplemented from + __add__. In particular, we don't handle Rational + here, even though we could get an exact answer, in case + the other type wants to do something special. + 3. If B <: Fraction, Python tries B.__radd__ before + Fraction.__add__. This is ok, because it was + implemented with knowledge of Fraction, so it can + handle those instances before delegating to Real or + Complex. + + The next two situations describe 'b + r'. We assume that b + didn't know about Fraction in its implementation, and that it + uses similar boilerplate code: + + 4. If B <: Rational, then __radd_ converts both to the + builtin rational type (hey look, that's us) and + proceeds. + 5. Otherwise, __radd__ tries to find the nearest common + base ABC, and fall back to its builtin type. Since this + class doesn't subclass a concrete type, there's no + implementation to fall back to, so we need to try as + hard as possible to return an actual value, or the user + will get a TypeError. + + """ + def forward(a, b): + if isinstance(b, Fraction): + return monomorphic_operator(a, b) + elif isinstance(b, int): + return monomorphic_operator(a, Fraction(b)) + elif isinstance(b, float): + return fallback_operator(float(a), b) + elif isinstance(b, complex): + return fallback_operator(complex(a), b) + else: + return NotImplemented + forward.__name__ = '__' + fallback_operator.__name__ + '__' + forward.__doc__ = monomorphic_operator.__doc__ + + def reverse(b, a): + if isinstance(a, numbers.Rational): + # Includes ints. + return monomorphic_operator(Fraction(a), b) + elif isinstance(a, numbers.Real): + return fallback_operator(float(a), float(b)) + elif isinstance(a, numbers.Complex): + return fallback_operator(complex(a), complex(b)) + else: + return NotImplemented + reverse.__name__ = '__r' + fallback_operator.__name__ + '__' + reverse.__doc__ = monomorphic_operator.__doc__ + + return forward, reverse + + # Rational arithmetic algorithms: Knuth, TAOCP, Volume 2, 4.5.1. + # + # Assume input fractions a and b are normalized. + # + # 1) Consider addition/subtraction. + # + # Let g = gcd(da, db). Then + # + # na nb na*db ± nb*da + # a ± b == -- ± -- == ------------- == + # da db da*db + # + # na*(db//g) ± nb*(da//g) t + # == ----------------------- == - + # (da*db)//g d + # + # Now, if g > 1, we're working with smaller integers. + # + # Note, that t, (da//g) and (db//g) are pairwise coprime. + # + # Indeed, (da//g) and (db//g) share no common factors (they were + # removed) and da is coprime with na (since input fractions are + # normalized), hence (da//g) and na are coprime. By symmetry, + # (db//g) and nb are coprime too. Then, + # + # gcd(t, da//g) == gcd(na*(db//g), da//g) == 1 + # gcd(t, db//g) == gcd(nb*(da//g), db//g) == 1 + # + # Above allows us optimize reduction of the result to lowest + # terms. Indeed, + # + # g2 = gcd(t, d) == gcd(t, (da//g)*(db//g)*g) == gcd(t, g) + # + # t//g2 t//g2 + # a ± b == ----------------------- == ---------------- + # (da//g)*(db//g)*(g//g2) (da//g)*(db//g2) + # + # is a normalized fraction. This is useful because the unnormalized + # denominator d could be much larger than g. + # + # We should special-case g == 1 (and g2 == 1), since 60.8% of + # randomly-chosen integers are coprime: + # https://en.wikipedia.org/wiki/Coprime_integers#Probability_of_coprimality + # Note, that g2 == 1 always for fractions, obtained from floats: here + # g is a power of 2 and the unnormalized numerator t is an odd integer. + # + # 2) Consider multiplication + # + # Let g1 = gcd(na, db) and g2 = gcd(nb, da), then + # + # na*nb na*nb (na//g1)*(nb//g2) + # a*b == ----- == ----- == ----------------- + # da*db db*da (db//g1)*(da//g2) + # + # Note, that after divisions we're multiplying smaller integers. + # + # Also, the resulting fraction is normalized, because each of + # two factors in the numerator is coprime to each of the two factors + # in the denominator. + # + # Indeed, pick (na//g1). It's coprime with (da//g2), because input + # fractions are normalized. It's also coprime with (db//g1), because + # common factors are removed by g1 == gcd(na, db). + # + # As for addition/subtraction, we should special-case g1 == 1 + # and g2 == 1 for same reason. That happens also for multiplying + # rationals, obtained from floats. + + def _add(a, b): + """a + b""" + na, da = a._numerator, a._denominator + nb, db = b._numerator, b._denominator + g = math.gcd(da, db) + if g == 1: + return Fraction._from_coprime_ints(na * db + da * nb, da * db) + s = da // g + t = na * (db // g) + nb * s + g2 = math.gcd(t, g) + if g2 == 1: + return Fraction._from_coprime_ints(t, s * db) + return Fraction._from_coprime_ints(t // g2, s * (db // g2)) + + __add__, __radd__ = _operator_fallbacks(_add, operator.add) + + def _sub(a, b): + """a - b""" + na, da = a._numerator, a._denominator + nb, db = b._numerator, b._denominator + g = math.gcd(da, db) + if g == 1: + return Fraction._from_coprime_ints(na * db - da * nb, da * db) + s = da // g + t = na * (db // g) - nb * s + g2 = math.gcd(t, g) + if g2 == 1: + return Fraction._from_coprime_ints(t, s * db) + return Fraction._from_coprime_ints(t // g2, s * (db // g2)) + + __sub__, __rsub__ = _operator_fallbacks(_sub, operator.sub) + + def _mul(a, b): + """a * b""" + na, da = a._numerator, a._denominator + nb, db = b._numerator, b._denominator + g1 = math.gcd(na, db) + if g1 > 1: + na //= g1 + db //= g1 + g2 = math.gcd(nb, da) + if g2 > 1: + nb //= g2 + da //= g2 + return Fraction._from_coprime_ints(na * nb, db * da) + + __mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul) + + def _div(a, b): + """a / b""" + # Same as _mul(), with inversed b. + nb, db = b._numerator, b._denominator + if nb == 0: + raise ZeroDivisionError('Fraction(%s, 0)' % db) + na, da = a._numerator, a._denominator + g1 = math.gcd(na, nb) + if g1 > 1: + na //= g1 + nb //= g1 + g2 = math.gcd(db, da) + if g2 > 1: + da //= g2 + db //= g2 + n, d = na * db, nb * da + if d < 0: + n, d = -n, -d + return Fraction._from_coprime_ints(n, d) + + __truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv) + + def _floordiv(a, b): + """a // b""" + return (a.numerator * b.denominator) // (a.denominator * b.numerator) + + __floordiv__, __rfloordiv__ = _operator_fallbacks(_floordiv, operator.floordiv) + + def _divmod(a, b): + """(a // b, a % b)""" + da, db = a.denominator, b.denominator + div, n_mod = divmod(a.numerator * db, da * b.numerator) + return div, Fraction(n_mod, da * db) + + __divmod__, __rdivmod__ = _operator_fallbacks(_divmod, divmod) + + def _mod(a, b): + """a % b""" + da, db = a.denominator, b.denominator + return Fraction((a.numerator * db) % (b.numerator * da), da * db) + + __mod__, __rmod__ = _operator_fallbacks(_mod, operator.mod) + + def __pow__(a, b): + """a ** b + + If b is not an integer, the result will be a float or complex + since roots are generally irrational. If b is an integer, the + result will be rational. + + """ + if isinstance(b, numbers.Rational): + if b.denominator == 1: + power = b.numerator + if power >= 0: + return Fraction._from_coprime_ints(a._numerator ** power, + a._denominator ** power) + elif a._numerator > 0: + return Fraction._from_coprime_ints(a._denominator ** -power, + a._numerator ** -power) + elif a._numerator == 0: + raise ZeroDivisionError('Fraction(%s, 0)' % + a._denominator ** -power) + else: + return Fraction._from_coprime_ints((-a._denominator) ** -power, + (-a._numerator) ** -power) + else: + # A fractional power will generally produce an + # irrational number. + return float(a) ** float(b) + elif isinstance(b, (float, complex)): + return float(a) ** b + else: + return NotImplemented + + def __rpow__(b, a): + """a ** b""" + if b._denominator == 1 and b._numerator >= 0: + # If a is an int, keep it that way if possible. + return a ** b._numerator + + if isinstance(a, numbers.Rational): + return Fraction(a.numerator, a.denominator) ** b + + if b._denominator == 1: + return a ** b._numerator + + return a ** float(b) + + def __pos__(a): + """+a: Coerces a subclass instance to Fraction""" + return Fraction._from_coprime_ints(a._numerator, a._denominator) + + def __neg__(a): + """-a""" + return Fraction._from_coprime_ints(-a._numerator, a._denominator) + + def __abs__(a): + """abs(a)""" + return Fraction._from_coprime_ints(abs(a._numerator), a._denominator) + + def __int__(a, _index=operator.index): + """int(a)""" + if a._numerator < 0: + return _index(-(-a._numerator // a._denominator)) + else: + return _index(a._numerator // a._denominator) + + def __trunc__(a): + """math.trunc(a)""" + if a._numerator < 0: + return -(-a._numerator // a._denominator) + else: + return a._numerator // a._denominator + + def __floor__(a): + """math.floor(a)""" + return a._numerator // a._denominator + + def __ceil__(a): + """math.ceil(a)""" + # The negations cleverly convince floordiv to return the ceiling. + return -(-a._numerator // a._denominator) + + def __round__(self, ndigits=None): + """round(self, ndigits) + + Rounds half toward even. + """ + if ndigits is None: + d = self._denominator + floor, remainder = divmod(self._numerator, d) + if remainder * 2 < d: + return floor + elif remainder * 2 > d: + return floor + 1 + # Deal with the half case: + elif floor % 2 == 0: + return floor + else: + return floor + 1 + shift = 10**abs(ndigits) + # See _operator_fallbacks.forward to check that the results of + # these operations will always be Fraction and therefore have + # round(). + if ndigits > 0: + return Fraction(round(self * shift), shift) + else: + return Fraction(round(self / shift) * shift) + + def __hash__(self): + """hash(self)""" + return _hash_algorithm(self._numerator, self._denominator) + + def __eq__(a, b): + """a == b""" + if type(b) is int: + return a._numerator == b and a._denominator == 1 + if isinstance(b, numbers.Rational): + return (a._numerator == b.numerator and + a._denominator == b.denominator) + if isinstance(b, numbers.Complex) and b.imag == 0: + b = b.real + if isinstance(b, float): + if math.isnan(b) or math.isinf(b): + # comparisons with an infinity or nan should behave in + # the same way for any finite a, so treat a as zero. + return 0.0 == b + else: + return a == a.from_float(b) + else: + # Since a doesn't know how to compare with b, let's give b + # a chance to compare itself with a. + return NotImplemented + + def _richcmp(self, other, op): + """Helper for comparison operators, for internal use only. + + Implement comparison between a Rational instance `self`, and + either another Rational instance or a float `other`. If + `other` is not a Rational instance or a float, return + NotImplemented. `op` should be one of the six standard + comparison operators. + + """ + # convert other to a Rational instance where reasonable. + if isinstance(other, numbers.Rational): + return op(self._numerator * other.denominator, + self._denominator * other.numerator) + if isinstance(other, float): + if math.isnan(other) or math.isinf(other): + return op(0.0, other) + else: + return op(self, self.from_float(other)) + else: + return NotImplemented + + def __lt__(a, b): + """a < b""" + return a._richcmp(b, operator.lt) + + def __gt__(a, b): + """a > b""" + return a._richcmp(b, operator.gt) + + def __le__(a, b): + """a <= b""" + return a._richcmp(b, operator.le) + + def __ge__(a, b): + """a >= b""" + return a._richcmp(b, operator.ge) + + def __bool__(a): + """a != 0""" + # bpo-39274: Use bool() because (a._numerator != 0) can return an + # object which is not a bool. + return bool(a._numerator) + + # support for pickling, copy, and deepcopy + + def __reduce__(self): + return (self.__class__, (self._numerator, self._denominator)) + + def __copy__(self): + if type(self) == Fraction: + return self # I'm immutable; therefore I am my own clone + return self.__class__(self._numerator, self._denominator) + + def __deepcopy__(self, memo): + if type(self) == Fraction: + return self # My components are also immutable + return self.__class__(self._numerator, self._denominator) diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/finite_set_controls.py b/research/h25-bookkeeping/payload/priorities/set-reuse/finite_set_controls.py new file mode 100644 index 0000000000..98af4d85b5 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/finite_set_controls.py @@ -0,0 +1,455 @@ +"""Bounded P1 controls. Parent runner alone imports/executes this module. + +run_controls(backend, set_adapter) takes the existing trusted backend and the +already loaded set adapter; it performs no implicit module-name import. +The two module instances keep the literal reference independent. Tiny raw +fixtures use an explicitly trusted finite-fixture lease issuer; these fixtures +do not establish the complete CLI's constructor provenance. +""" +from __future__ import annotations + +import gc +import sys + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def typed(value): + if type(value) is dict: + return ("dict", tuple((typed(key), typed(item)) for key, item in value.items())) + if type(value) is list or type(value) is tuple: + return (type(value).__name__, tuple(typed(item) for item in value)) + return (type(value).__name__, value) + + +def outcome(function, checks): + try: + return ("value", typed(function(checks))) + except Exception as error: + return ("error", type(error).__name__, error.args) + + +def configure(module, circuit, triples, *, keep_list=False): + if keep_list: + circuit.triples[:] = triples + else: + circuit.triples = list(triples) + circuit.active = set() + circuit.args = [None] + circuit.support = [0] + circuit.pieces = [] + seen = set() + for target in circuit.triples: + if target in seen: + continue + seen.add(target) + for coefficient, predicate in ((module.Q(1, 2), lambda size: size == 0), + (module.Q(-1, 2), lambda size: size == 2)): + mask = sum(1 << index for index, other in enumerate(circuit.triples) + if predicate(len(set(target) & set(other)))) + if mask: + circuit.support.append(mask) + circuit.args.append(None) + circuit.pieces.append((target, len(circuit.support)-1, coefficient)) + + +def raw(module, triples): + circuit = object.__new__(module.ComplexSideCircuit) + configure(module, circuit, triples) + checks = object.__new__(module.Checks) + checks.c = circuit + return circuit, checks + + +class Prefix: + def __init__(self, events, action=None): + self.events = events + self.action = action + + def __iter__(self): + self.events.append("prefix") + if self.action is not None: + self.action() + return iter(()) + + +class RecursivePrefix: + def __init__(self, events): + self.events = events + self.action = None + self.entered = False + + def __iter__(self): + self.events.append("prefix") + if not self.entered: + self.entered = True + self.action() + return iter(()) + + +def run_controls(backend, set_adapter): + load_source = backend.load_source + bind_verify_map = set_adapter.bind_verify_map + # Policy-only checks use literal digests, never import/execute alternate + # Fraction source. Actual loaded code still receives the existing checks. + source_pin_cases = [] + for digest, expected_profile in ( + ("cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "recorded-local-cpython-3.12.3"), + ("d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "official-cpython-3.12.15-e848e4b09ca4bc67c0041c9ce7526dae471d4c36")): + need(set_adapter._fraction_source_profile(digest) == expected_profile, + "Reviewed Fraction source pin was not recognized") + source_pin_cases.append({"digest": digest, "outcome": "recognized"}) + class StringSubclass(str): + pass + for unsupported in ("0"*64, "", StringSubclass(digest)): + try: + set_adapter._fraction_source_profile(unsupported) + except RuntimeError as error: + need(error.args == ("Set reuse Fraction source differs",), "Unknown source-pin rejection changed") + else: + raise RuntimeError("Unreviewed or non-exact source digest was admitted") + source_pin_cases.append({"input_type": type(unsupported).__name__, "outcome": "rejected"}) + oracle = load_source("_h25_set_controls_original") + candidate = load_source("_h25_set_controls_candidate") + original_candidate = candidate.Checks.verify_map + literal = oracle.Checks.verify_map + rows = [] + standard = [(0, 1, 2), (3, 4, 5), (0, 1, 3), (0, 4, 5)] + + def binding(): + candidate.Checks.verify_map = original_candidate + result = bind_verify_map(candidate) + need(set_adapter._fraction_source_profile(result["receipt"]["fraction_sha256"]) == + result["receipt"]["fraction_source_profile"], "Receipt misreports selected Fraction source") + candidate.Checks.verify_map = result["verify_map"] + result["owner"].seal() + return result + + def fixture_issue(result, circuit, checks): + # Explicit trusted test-only issuer. The full driver must use actual + # post-original-constructor captures, never raw fixture provenance. + owner = result["owner"] + owner.arm_cli() + need(owner.capture_c(circuit), "Fixture circuit capture failed") + need(owner.capture_checks(checks), "Fixture Checks capture failed") + + def compare(name, result, left, right, left_events=(), right_events=(), *, fast=0, fallbacks=1): + expected = outcome(literal, left) + actual = outcome(result["verify_map"], right) + need(actual == expected, "Set control outcome differs: " + name) + need(list(right_events) == list(left_events), "Set control callback order differs: " + name) + need(result["receipt"]["fast_admissions"] == fast, "Set control fast-path count differs: " + name) + need(result["receipt"]["fallback_calls"] == fallbacks, "Set control fallback count differs: " + name) + need(result["owner"].current is None, "Set control retained an active token: " + name) + rows.append({"name": name, "outcome": actual[0], "fast_admissions": fast, "fallback_calls": fallbacks}) + result["owner"].disarm_cli() + + # Exact values, all intersection sizes, duplication/order, and integer width. + for name, triples in ( + ("all-intersection-sizes", standard), + ("duplicate-positional-triples", standard + [standard[0]]), + ("reordered-triples", list(reversed(standard))), + ("negative-and-wide-integers", [(-5, 1 << 100, 9), (-5, 1 << 100, 10), (2, 3, 4)]), + ("empty-triples", [])): + result = binding() + _, left = raw(oracle, triples) + circuit, right = raw(candidate, triples) + fixture_issue(result, circuit, right) + compare(name, result, left, right, fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(triples), + "Set construction count differs from positional triple count") + need(result["receipt"]["reservations_expired"] == 1, "Successful lease did not expire") + + # No allowance: ordinary source method executes, including prefix once. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events), Prefix(right_events) + compare("no-allowance-prefix-once", result, left, right, left_events, right_events) + need(left_events == ["prefix"], "Missing-lease fixture did not cover prefix") + + # Correctly shaped objects cannot borrow another Checks identity. + result = binding() + _, left = raw(oracle, standard) + right_c, captured = raw(candidate, standard) + right = object.__new__(candidate.Checks) + right.c = right_c + fixture_issue(result, right_c, captured) + compare("wrong-checks-identity", result, left, right) + + result = binding() + _, left = raw(oracle, standard) + captured_c, right = raw(candidate, standard) + other_c, _ = raw(candidate, standard) + fixture_issue(result, captured_c, right) + right.c = other_c + compare("wrong-circuit-link", result, left, right) + + # Reservation is spent before a prefix can reenter the method. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = RecursivePrefix(left_events), RecursivePrefix(right_events) + left_c.active.action = lambda: literal(left) + right_c.active.action = lambda: result["verify_map"](right) + fixture_issue(result, right_c, right) + compare("prefix-reentry-single-reservation", result, left, right, left_events, right_events, + fast=1, fallbacks=1) + need(left_events == ["prefix", "prefix"] and result["receipt"]["reservations"] == 1, + "Recursive fixture did not consume one outer reservation") + + # The post-prefix state, not an earlier eager snapshot, supplies operands. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + changed = [(10, 11, 12), (10, 11, 13), (20, 21, 22)] + left_events, right_events = [], [] + left_c.active = Prefix(left_events, lambda: configure(oracle, left_c, changed, keep_list=True)) + right_c.active = Prefix(right_events, lambda: configure(candidate, right_c, changed, keep_list=True)) + fixture_issue(result, right_c, right) + compare("post-prefix-mutated-values", result, left, right, left_events, right_events, + fast=1, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == len(changed), + "Set cache preceded prefix mutation") + + # Prefix exceptions happen before set construction, even with a valid lease. + def fail_prefix(): + raise ValueError("prefix sentinel") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.active, right_c.active = Prefix(left_events, fail_prefix), Prefix(right_events, fail_prefix) + fixture_issue(result, right_c, right) + compare("failing-prefix-no-eager-cache", result, left, right, left_events, right_events, + fast=0, fallbacks=0) + need(result["receipt"]["private_operand_sets_constructed"] == 0, "Failing prefix built sets") + + # Callback-bearing triple subclasses must use literal post-prefix tail. + def callback_triple(events, base): + class Triple(tuple): + def __iter__(self): + events.append("triple-iter") + return tuple.__iter__(self) + return Triple(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = callback_triple(left_events, standard[0]) + right_c.triples[0] = callback_triple(right_events, standard[0]) + fixture_issue(result, right_c, right) + compare("tuple-subclass-callback-fallback", result, left, right, left_events, right_events) + need(left_events, "Tuple callback fixture did not execute callbacks") + + def callback_integer(events, value): + class Integer(int): + def __hash__(self): + events.append("integer-hash") + return int.__hash__(self) + return Integer(value) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + left_c.triples[0] = (callback_integer(left_events, 0), 1, 2) + right_c.triples[0] = (callback_integer(right_events, 0), 1, 2) + fixture_issue(result, right_c, right) + compare("integer-subclass-hash-fallback", result, left, right, left_events, right_events) + need(left_events, "Integer callback fixture did not execute callbacks") + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.triples[0] = (False, 1, 2) + right_c.triples[0] = (False, 1, 2) + fixture_issue(result, right_c, right) + compare("bool-member-exact-type-fallback", result, left, right) + + # The got dictionary can retain a hostile equality key from the prefix. + def collision_key(circuit, events, base): + class Target(tuple): + __hash__ = tuple.__hash__ + fired = False + + def __eq__(self, other): + events.append("collision-equality") + if not self.fired: + self.fired = True + circuit.triples.reverse() + return tuple.__eq__(self, other) + return Target(base) + + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + for circuit, events in ((left_c, left_events), (right_c, right_events)): + target, node, coefficient = circuit.pieces[0] + circuit.pieces[0] = (collision_key(circuit, events, target), node, coefficient) + fixture_issue(result, right_c, right) + compare("got-collision-key-fallback", result, left, right, left_events, right_events) + if sys.flags.optimize: + # This fixture's collision lookup is in the original tail assert. + need(left_events == [] and right_events == [], + "Optimized collision fixture unexpectedly executed assertion-only equality") + else: + need(left_events, "Collision fixture did not reach custom equality") + + # Runtime source-global drift retains original live resolution in fallback. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + def logging_set(events): + def wrapped(values): + events.append("set") + return set(values) + return wrapped + oracle.set, candidate.set = logging_set(left_events), logging_set(right_events) + fixture_issue(result, right_c, right) + try: + compare("live-source-set-resolution", result, left, right, left_events, right_events) + need(len(left_events) == 4*len(standard)**2, "Literal fallback lost original set calls") + finally: + del oracle.set + del candidate.set + + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_events, right_events = [], [] + original_q = candidate.Q + def logging_q(events): + def wrapped(*args): + events.append("Q") + return original_q(*args) + return wrapped + fixture_issue(result, right_c, right) + oracle.Q, candidate.Q = logging_q(left_events), logging_q(right_events) + try: + compare("live-Fraction-global-resolution", result, left, right, left_events, right_events) + if sys.flags.optimize: + # Every original verify_map Q(...) call is inside an assert. + need(left_events == [] and right_events == [], + "Optimized Fraction fixture unexpectedly executed assertion-only constructors") + else: + need(left_events, "Fraction callback fixture did not execute callbacks") + finally: + oracle.Q = candidate.Q = original_q + + # The exact Fraction class is mutable: unchanged class identity alone is + # insufficient. A changed method after binding must deny optimization. + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + original_hash = original_q.__hash__ + hash_events = [] + def traced_hash(value): + hash_events.append("fraction-hash") + return original_hash(value) + original_q.__hash__ = traced_hash + try: + expected = outcome(literal, left) + expected_events = list(hash_events) + hash_events.clear() + actual = outcome(result["verify_map"], right) + need(actual == expected and hash_events == expected_events and hash_events, + "Changed Fraction method fallback differs") + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Changed Fraction method was admitted") + finally: + original_q.__hash__ = original_hash + result["owner"].disarm_cli() + rows.append({"name": "changed-Fraction-hash", "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # A used capability cannot cache values for a later invocation. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + need(outcome(result["verify_map"], right) == outcome(literal, left), "Initial leased call differs") + configure(oracle, left_c, changed) + configure(candidate, right_c, changed) + compare("used-capability-changed-later-input", result, left, right, fast=1, fallbacks=1) + need(result["receipt"]["private_operand_sets_constructed"] == len(standard), + "Used capability constructed a second private cache") + + # Observable known hooks deny optimization without changing hook policy. + for hook in ("trace", "profile", "gc-callback"): + result = binding() + _, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + fixture_issue(result, right_c, right) + def quiet_trace(frame, event, arg): + return quiet_trace + def quiet_gc(phase, info): + return None + if hook == "trace": + sys.settrace(quiet_trace) + elif hook == "profile": + sys.setprofile(quiet_trace) + else: + gc.callbacks.append(quiet_gc) + try: + actual = outcome(result["verify_map"], right) + finally: + if hook == "trace": + sys.settrace(None) + elif hook == "profile": + sys.setprofile(None) + else: + gc.callbacks.remove(quiet_gc) + need(actual == outcome(literal, left), "Hook-denied fallback differs: " + hook) + need(result["receipt"]["fast_admissions"] == 0 and result["receipt"]["fallback_calls"] == 1, + "Known hook was admitted: " + hook) + result["owner"].disarm_cli() + rows.append({"name": "known-hook-" + hook, "outcome": actual[0], "fast_admissions": 0, "fallback_calls": 1}) + + # Deliberate tail assertion failure retains a traceback: cached operands + # must have been cleared/reset even while the frame itself remains live. + result = binding() + left_c, left = raw(oracle, standard) + right_c, right = raw(candidate, standard) + left_c.support[1] ^= 1 << 20 + right_c.support[1] ^= 1 << 20 + fixture_issue(result, right_c, right) + expected = outcome(literal, left) + retained = None + try: + actual = ("value", typed(result["verify_map"](right))) + except Exception as error: + actual = ("error", type(error).__name__, error.args) + retained = error.__traceback__ + need(actual == expected, "Tail-failure outcome differs") + if not sys.flags.optimize: + need(actual[0] == "error" and actual[1] == "AssertionError", "Tail-failure fixture did not fail") + found = False + while retained is not None: + if retained.tb_frame.f_code is result["verify_map"].__code__: + found = True + values = retained.tb_frame.f_locals + need(values["_h25_sr_sets"] is None and values["_h25_sr_left"] is None, + "Retained traceback kept private cached operands") + retained = retained.tb_next + need(found, "Candidate traceback frame was not inspected") + need(result["owner"].current is None, "Tail error retained lease") + need(result["receipt"]["fast_admissions"] == 1, "Tail cleanup fixture did not use cached sets") + result["owner"].disarm_cli() + rows.append({"name": "traceback-cleanup", "outcome": actual[0], "fast_admissions": 1, "fallback_calls": 0}) + + candidate.Checks.verify_map = original_candidate + need(oracle.Checks.verify_map is literal, "Independent source reference was changed") + return {"status": "P1_FINITE_SET_CONTROLS_PASS", "optimize": sys.flags.optimize, + "cases": len(rows), "rows": rows, "source_pin_policy_cases": source_pin_cases, + "scope": "Bounded finite semantics and negative controls; not full-caller ownership or performance evidence"} diff --git a/research/h25-bookkeeping/payload/priorities/set-reuse/set_reuse.py b/research/h25-bookkeeping/payload/priorities/set-reuse/set_reuse.py new file mode 100644 index 0000000000..e4edc81a51 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/set-reuse/set_reuse.py @@ -0,0 +1,469 @@ +"""Private operand-set reuse for one authenticated frozen full-caller phase. + +The parent owns the new whole-tail execution invariant. This is not inherited +from the native kernel guard and is not a generic alias/security detector. +Standalone, unsupported and unleased calls delegate the literal source. +No scientific module is imported here; the parent supplies an isolated module. +""" +from __future__ import annotations + +import _thread +import ast +import builtins +import copy +import fractions +import gc +import hashlib +from pathlib import Path +import signal +import sys +from types import CodeType, FunctionType, GetSetDescriptorType, MemberDescriptorType, ModuleType + +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +FRACTION_SOURCE_PINS = ( + ("cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "recorded-local-cpython-3.12.3"), + ("d52d1ab9d5be26924e4914a5e40069c992bbfa68f773694c2e5ee8452d0766a0", + "official-cpython-3.12.15-e848e4b09ca4bc67c0041c9ce7526dae471d4c36"), +) +_TYPE, _OBJECT, _DICT, _LIST, _TUPLE, _INT = type, object, dict, list, tuple, int +_STR = str +_LEN, _SET, _COMPILE = len, set, compile +_GET = dict.get +_OBJGET = object.__getattribute__ +_TYPEGET = type.__getattribute__ +_CLEAR = list.clear +_BUILTINS = builtins.__dict__ +_FRACTION = fractions.Fraction +_BUILTIN_NAMES = ("type", "object", "set", "len", "sum", "enumerate", "dict", + "int", "list", "tuple", "all", "range", "hash", "abs", "pow", + "isinstance", "super") +_BUILTIN_RECORD = tuple((name, _BUILTINS[name]) for name in _BUILTIN_NAMES) +_SOURCE_LOOKUPS = ("set", "len", "sum", "enumerate", "dict") + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +def _function_record(function): + if _TYPE(function) is not FunctionType: + return None + closure = function.__closure__ + cells = () if closure is None else _TUPLE((cell, cell.cell_contents) for cell in closure) + return (function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, closure, cells) + + +def _function_fresh(record): + function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells = record + if not (function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure): + return False + for cell, value in cells: + try: + if cell.cell_contents is not value: + return False + except ValueError: + return False + return True + + +def _ordinary_class(cls): + if _TYPE(cls) is not _TYPE or _TYPEGET(cls, "__mro__") != (cls, _OBJECT): + return False + attributes = _TYPEGET(cls, "__dict__") + if "__getattr__" in attributes or _TYPEGET(cls, "__getattribute__") is not _OBJECT.__getattribute__: + return False + if _TYPEGET(cls, "__new__") is not _OBJECT.__new__: + return False + for name in ("__dict__", "__weakref__"): + descriptor = attributes.get(name) + if _TYPE(descriptor) is not GetSetDescriptorType or descriptor.__objclass__ is not cls: + return False + return True + + +def _ordinary_dict(value, cls): + if _TYPE(value) is not cls or not _ordinary_class(cls): + return None + namespace = _OBJGET(value, "__dict__") + return namespace if _TYPE(namespace) is _DICT else None + + +def _triple(value): + return (_TYPE(value) is _TUPLE and _LEN(value) == 3 and + _TYPE(value[0]) is _INT and _TYPE(value[1]) is _INT and _TYPE(value[2]) is _INT) + + +def _hooks_clear(): + """Known instrumentation denial only; not a generic finalizer theorem.""" + if sys.gettrace() is not None or sys.getprofile() is not None: + return False + if _TYPE(gc.callbacks) is not _LIST or _LEN(gc.callbacks) != 0 or _thread._count() != 0: + return False + monitoring = getattr(sys, "monitoring", None) + if monitoring is not None: + for tool in range(6): + if monitoring.get_tool(tool) is not None: + return False + for number in signal.valid_signals(): + handler = signal.getsignal(number) + if handler is not signal.SIG_DFL and handler is not signal.SIG_IGN and handler is not signal.default_int_handler: + return False + return True + + +def _code_named(code, name): + return next(item for item in code.co_consts if _TYPE(item) is CodeType and item.co_name == name) + + +def _authenticate_function(function, expected, namespace): + _need(_TYPE(function) is FunctionType and function.__globals__ is namespace and + function.__builtins__ is _BUILTINS and function.__code__ == expected, + "Set reuse requires the exact original source function") + + +class _Token: + __slots__ = () + + +class _LeaseOwner: + """Parent-private one-call capability; only identity/state, never operand sets.""" + + def __init__(self, module, original, source_functions, class_names, receipt): + self.module = module + self.namespace = module.__dict__ + self.original = original + self.circuit_class = self.namespace["ComplexSideCircuit"] + self.checks_class = self.namespace["Checks"] + self.class_names = class_names + self.source_functions = source_functions + self.receipt = receipt + self.sealed = False + self.cli_active = False + self.used = False + self.current = None + self.circuit = self.checks = self.triples = None + self.class_records = () + self.function_records = () + self.fraction_globals = _TUPLE(fractions.__dict__.items()) + self.fraction_classes = _TUPLE((cls, _TYPEGET(cls, "__mro__"), + _TUPLE(_TYPEGET(cls, "__dict__").items())) + for cls in _FRACTION.__mro__ if cls is not _OBJECT) + self.math_gcd = fractions.math.gcd + self.rational = fractions.numbers.Rational + self.complex = fractions.numbers.Complex + self.hash_wrapper = fractions._hash_algorithm + self.hash_wrapped = fractions._hash_algorithm.__wrapped__ + fraction_functions = [] + for _, _, attributes in self.fraction_classes: + for _, value in attributes: + if _TYPE(value) is FunctionType: + fraction_functions.append(value) + elif _TYPE(value) is property: + fraction_functions.extend(item for item in (value.fget, value.fset, value.fdel) if item is not None) + fraction_functions.append(self.hash_wrapped) + self.fraction_functions = _TUPLE(_function_record(function) for function in fraction_functions) + + def seal(self): + """Parent calls once after installing all constructor/map phase wrappers.""" + _need(not self.sealed and not self.cli_active, "Set reuse owner already sealed or active") + classes = (self.circuit_class, self.checks_class) + records = [] + functions = _LIST(self.source_functions) + for cls, names in zip(classes, self.class_names): + _need(_ordinary_class(cls), "Set reuse requires ordinary frozen class dispatch") + attributes = _TYPEGET(cls, "__dict__") + _need(_SET(attributes) == names, "Set reuse class member shape changed") + records.append((cls, _TYPEGET(cls, "__mro__"), _TUPLE(attributes.items()))) + functions.extend(value for value in attributes.values() if _TYPE(value) is FunctionType) + self.class_records = _TUPLE(records) + self.function_records = _TUPLE(_function_record(function) for function in functions) + self.sealed = True + + def arm_cli(self): + """Parent attests the pinned fresh CLI; do not call for a generic API use.""" + _need(self.sealed and not self.cli_active and self.circuit is None and not self.used, + "Set reuse allowance cannot be reused") + self.cli_active = True + self.receipt["allowances_armed"] += 1 + + def capture_c(self, circuit): + """Called only after the parent-observed original constructor returns.""" + if not self.cli_active or self.circuit is not None or self.used: + return False + namespace = _ordinary_dict(circuit, self.circuit_class) + if namespace is None: + return False + triples = _GET(namespace, "triples") + if _TYPE(triples) is not _LIST: + return False + self.circuit, self.triples = circuit, triples + self.receipt["circuits_captured"] += 1 + return True + + def capture_checks(self, checks): + """Called only after the parent-observed original Checks init returns.""" + if not self.cli_active or self.circuit is None or self.checks is not None or self.used: + return False + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return False + self.checks = checks + self.receipt["checks_captured"] += 1 + return True + + def _fresh(self): + if (_TYPE(self.module) is not ModuleType or self.module.__dict__ is not self.namespace or + _GET(self.namespace, "Checks") is not self.checks_class or + _GET(self.namespace, "ComplexSideCircuit") is not self.circuit_class or + _GET(self.namespace, "Q") is not _FRACTION or + _GET(self.namespace, "__builtins__") is not _BUILTINS): + return False + for name, expected in _BUILTIN_RECORD: + if _GET(_BUILTINS, name) is not expected: + return False + for name in _SOURCE_LOOKUPS: + if name in self.namespace: + return False + for cls, mro, items in self.class_records + self.fraction_classes: + if _TYPEGET(cls, "__mro__") is not mro: + return False + attributes = _TYPEGET(cls, "__dict__") + if _LEN(attributes) != _LEN(items): + return False + for name, value in items: + if attributes.get(name) is not value: + return False + for record in self.function_records + self.fraction_functions: + if not _function_fresh(record): + return False + if _LEN(fractions.__dict__) != _LEN(self.fraction_globals): + return False + for name, value in self.fraction_globals: + if _GET(fractions.__dict__, name) is not value: + return False + return (fractions.math.gcd is self.math_gcd and + fractions.numbers.Rational is self.rational and + fractions.numbers.Complex is self.complex and + fractions._hash_algorithm is self.hash_wrapper and + self.hash_wrapper.__wrapped__ is self.hash_wrapped) + + def reserve(self, checks): + """Consumed before prefix; wrong or unleased objects get literal fallback.""" + self.receipt["entries"] += 1 + if not self.cli_active or self.used or self.current is not None or checks is not self.checks: + return None + namespace = _ordinary_dict(checks, self.checks_class) + if namespace is None or _GET(namespace, "c") is not self.circuit: + return None + self.used = True + if not self._fresh() or not _hooks_clear(): + return None + token = _Token() + self.current = token + self.receipt["reservations"] += 1 + return token + + def admit(self, token, checks, circuit, got): + """Called after the original prefix, using its actual local got mapping.""" + if (token is None or token is not self.current or not self.cli_active or + checks is not self.checks or circuit is not self.circuit or + not self._fresh() or not _hooks_clear()): + return False + check_dict = _ordinary_dict(checks, self.checks_class) + circuit_dict = _ordinary_dict(circuit, self.circuit_class) + if check_dict is None or circuit_dict is None or _GET(check_dict, "c") is not circuit: + return False + triples = _GET(circuit_dict, "triples") + if triples is not self.triples or _TYPE(triples) is not _LIST: + return False + for triple in triples: + if not _triple(triple): + return False + if _TYPE(got) is not _DICT: + return False + for key, value in got.items(): + if (_TYPE(key) is not _TUPLE or _LEN(key) != 2 or not _triple(key[0]) or + _TYPE(key[1]) is not _FRACTION or _TYPE(value) is not _INT): + return False + coefficient = key[1] + if (_TYPE(_OBJGET(coefficient, "_numerator")) is not _INT or + _TYPE(_OBJGET(coefficient, "_denominator")) is not _INT): + return False + self.receipt["fast_admissions"] += 1 + return True + + def fallback(self): + self.receipt["fallback_calls"] += 1 + + def constructed(self, count): + self.receipt["private_operand_sets_constructed"] += count + + def expire(self, token): + if token is not None and token is self.current: + self.current = None + self.receipt["reservations_expired"] += 1 + + def disarm_cli(self): + self.current = None + self.cli_active = False + self.circuit = self.checks = self.triples = None + + +def _fraction_source_profile(digest): + """Exact reviewed source allowlist; no version-only or shape-only admission.""" + if _TYPE(digest) is _STR: + for expected, profile in FRACTION_SOURCE_PINS: + if digest == expected: + return profile + raise RuntimeError("Set reuse Fraction source differs") + + +def _fraction_source_check(): + raw = Path(fractions.__file__).read_bytes() + digest = hashlib.sha256(raw).hexdigest() + profile = _fraction_source_profile(digest) + compiled = _COMPILE(raw, fractions.__file__, "exec", dont_inherit=True, optimize=sys.flags.optimize) + fraction_code = _code_named(compiled, "Fraction") + _need(_TYPEGET(_FRACTION, "__getattribute__") is _OBJECT.__getattribute__, + "Set reuse Fraction attribute dispatch differs") + for name in ("_numerator", "_denominator"): + descriptor = _TYPEGET(_FRACTION, name) + _need(_TYPE(descriptor) is MemberDescriptorType and descriptor.__objclass__ is _FRACTION, + "Set reuse Fraction slot descriptor differs") + _need(fractions.numbers.Rational is _FRACTION.__mro__[1] and + fractions.numbers.Complex in _FRACTION.__mro__, + "Set reuse Fraction number-class resolution differs") + for name in ("__new__", "__hash__", "__eq__"): + _authenticate_function(_TYPEGET(_FRACTION, name), _code_named(fraction_code, name), fractions.__dict__) + for name in ("numerator", "denominator"): + _authenticate_function(_TYPEGET(_FRACTION, name).fget, _code_named(fraction_code, name), fractions.__dict__) + _authenticate_function(fractions._hash_algorithm.__wrapped__, _code_named(compiled, "_hash_algorithm"), fractions.__dict__) + return digest, profile + + +def _generate(module, method_ast, owner, original): + """Only original prefix/tail AST plus declared private bookkeeping changes.""" + _need(_LEN(method_ast.body) == 7 and _TYPE(method_ast.body[3]) is ast.For and + _TYPE(method_ast.body[4]) is ast.Assign and _TYPE(method_ast.body[5]) is ast.For, + "Unexpected pinned verify_map AST layout") + prefix = copy.deepcopy(method_ast.body[:4]) + fallback_tail = copy.deepcopy(method_ast.body[4:]) + template = ast.parse(''' +def _h25_sr_factory(_h25_sr_enter, _h25_sr_admit, _h25_sr_expire, _h25_sr_original, + _h25_sr_fallback, _h25_sr_constructed, _h25_sr_clear): + def verify_map(self): + _h25_sr_token = _h25_sr_enter(self) + _h25_sr_sets = None + _h25_sr_left = None + try: + if _h25_sr_token is None: + _h25_sr_fallback() + return _h25_sr_original(self) + _H25_PREFIX + if not _h25_sr_admit(_h25_sr_token, self, c, got): + _h25_sr_fallback() + _H25_FALLBACK + _h25_sr_sets = [set(T) for T in c.triples] + _h25_sr_constructed(len(_h25_sr_sets)) + nonzero = 0 + for _h25_sr_position, S in enumerate(c.triples): + _h25_sr_left = _h25_sr_sets[_h25_sr_position] + zero = sum(1 << i for i, T in enumerate(c.triples) + if not _h25_sr_left & _h25_sr_sets[i]) + two = sum(1 << i for i, T in enumerate(c.triples) + if len(_h25_sr_left & _h25_sr_sets[i]) == 2) + assert got.get((S, Q(1, 2)), 0) == zero and got.get((S, Q(-1, 2)), 0) == two + nonzero += zero.bit_count()+two.bit_count() + return dict(targets=len(c.triples), nonzero_coefficients=nonzero, + side_map_exact=True, coefficients='+1/2 disjoint, -1/2 intersection two') + finally: + if _h25_sr_sets is not None: + _h25_sr_clear(_h25_sr_sets) + _h25_sr_left = None + _h25_sr_sets = None + _h25_sr_expire(_h25_sr_token) + return verify_map +''') + method = template.body[0].body[0] + guarded = method.body[3] + _need(_TYPE(guarded) is ast.Try, "Internal set adapter AST layout changed") + replaced = [] + for statement in guarded.body: + if _TYPE(statement) is ast.Expr and _TYPE(statement.value) is ast.Name and statement.value.id == "_H25_PREFIX": + replaced.extend(prefix) + elif _TYPE(statement) is ast.If and statement.body and any( + _TYPE(item) is ast.Expr and _TYPE(item.value) is ast.Name and item.value.id == "_H25_FALLBACK" + for item in statement.body): + statement.body = statement.body[:1] + fallback_tail + replaced.append(statement) + else: + replaced.append(statement) + guarded.body = replaced + ast.fix_missing_locations(template) + namespace = module.__dict__ + name = "_h25_sr_factory" + _need(name not in namespace, "Set reuse helper name collision") + try: + exec(_COMPILE(template, "", "exec", dont_inherit=True, + optimize=sys.flags.optimize), namespace) + factory = namespace[name] + function = factory(owner.reserve, owner.admit, owner.expire, original, + owner.fallback, owner.constructed, _CLEAR) + finally: + namespace.pop(name, None) + return function + + +def bind_verify_map(module): + """Return verify_map/owner/receipt; parent installs, wraps, seals, then arms. + + This factory must receive an isolated candidate module. Keep the unchanged + baseline/reference in another module/process; existing globals are never + copied or rebound, so ordinary fallback retains live source resolution. + """ + _need(_TYPE(module) is ModuleType, "Set reuse needs an exact source module") + namespace = module.__dict__ + path = Path(namespace["__file__"]) + raw = path.read_bytes() + _need(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Set reuse scientific source differs") + _need(_GET(namespace, "__builtins__") is _BUILTINS and _GET(namespace, "Q") is _FRACTION, + "Set reuse source calling environment differs") + for name, value in _BUILTIN_RECORD: + _need(_GET(_BUILTINS, name) is value, "Set reuse builtin identity differs") + for name in _SOURCE_LOOKUPS: + _need(name not in namespace, "Set reuse source shadows a builtin") + compiled = _COMPILE(raw, str(path), "exec", dont_inherit=True, optimize=sys.flags.optimize) + source_functions = [] + class_names = [] + for name in ("ComplexSideCircuit", "Checks"): + cls = namespace[name] + _need(_ordinary_class(cls), "Set reuse source class dispatch differs") + class_code = _code_named(compiled, name) + attributes = _TYPEGET(cls, "__dict__") + expected_names = {"__module__", "__doc__", "__dict__", "__weakref__"} + for code in class_code.co_consts: + if _TYPE(code) is CodeType: + expected_names.add(code.co_name) + function = attributes.get(code.co_name) + _authenticate_function(function, code, namespace) + source_functions.append(function) + _need(_SET(attributes) == expected_names, "Set reuse source class members differ") + class_names.append(expected_names) + fraction_digest, fraction_profile = _fraction_source_check() + original = namespace["Checks"].verify_map + parsed = ast.parse(raw, filename=str(path)) + checks_ast = next(item for item in parsed.body if _TYPE(item) is ast.ClassDef and item.name == "Checks") + method_ast = next(item for item in checks_ast.body if _TYPE(item) is ast.FunctionDef and item.name == "verify_map") + receipt = {"schema": "h25-private-set-reuse-v1", "source_sha256": SOURCE_SHA256, + "fraction_sha256": fraction_digest, "fraction_source_profile": fraction_profile, + "allowances_armed": 0, "circuits_captured": 0, + "checks_captured": 0, "entries": 0, "reservations": 0, "fast_admissions": 0, + "fallback_calls": 0, "private_operand_sets_constructed": 0, "reservations_expired": 0} + owner = _LeaseOwner(module, original, _TUPLE(source_functions), _TUPLE(class_names), receipt) + candidate = _generate(module, method_ast, owner, original) + return {"verify_map": candidate, "owner": owner, "receipt": receipt, "original": original} diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/ADAPTER.md b/research/h25-bookkeeping/payload/priorities/trace-encoding/ADAPTER.md new file mode 100644 index 0000000000..c76fad2230 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/ADAPTER.md @@ -0,0 +1,54 @@ +# P3 source integration contract + +This directory contains source only. The lane did not import scientific modules, compile the extension, or run its controls. The parent owns immutable staging, cold compilation/load, live freshness integration, serial controls, full pilots and all costs. The original GF(2) source remains `e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc`. + +## Files and public interfaces + +- `trace_encoder.c`: standalone extension `_trace_encoding` with `encode_record(call, us, vs, output)`. It uses `METH_FASTCALL`, exactly four positional arguments and no keywords. +- `trace_adapter.py`: `make_trace_type(backend, native_encoder_module)` returns a candidate trace subclass. It does not change `backend.ComplementTrace` or any backend/global/native method. +- `trace_controls.py`: `run_controls(backend, native_encoder_module)` returns a JSON-safe receipt or raises. It does not compile, time, write files, or invoke the complete caller. The parent must have both Python modules available from the same source-checked isolated stage. + +Keep `backend.ComplementTrace` original. The old finite controls must continue comparing their original observers. Construct the candidate class and full-run trace explicitly: + +```python +CandidateTrace = make_trace_type(backend, trace_native) +trace = CandidateTrace(circuit_module.Label) +# Parent finalizes the guarded adapter environment before bind captures cells. +binding = backend.bind(circuit_module, gf2_native, rank_calls, trace) +``` + +The final line assumes the parent's guard integration below is already installed. Neither the factory nor direct `trace.after` adds a per-call native freshness check itself. This avoids silently claiming protection at an unimplemented boundary or charging the same check twice. + +## Mandatory parent-owned freshness + +`CandidateTrace._h25_native_entries` is a tuple containing `(exact_owner_module, "encode_record", exact_builtin_entry)`. These strong references are stable metadata, not a cached verification result. The `after` closure uses that same fixed native entry. Before every original arithmetic/fallback boundary, check the captured owner is an exact `ModuleType` and its exact dictionary slot still contains the captured entry by identity. Capture only after validating that the entry is a `BuiltinFunctionType` whose `__self__` is its owner. + +Add the check after the old distinct guard checks, before either arithmetic or fallback, to preserve the old rejection ordering. If attached to the general guard, charge all 298,644 original guard boundaries, including Gram calls. Keep the original constructor and final guard checks too. Set up the guard class, trace object, owner/entry records, all helper replacements and wrapper closure identities **before** `RuntimeGuard` captures state. No post-capture replacement or rebuilding after drift to bless new values. + +The parent must execute a new integration control: replace the public encoder slot while a wrapper retains the old callable, then call the guarded arithmetic path. Require rejection before arithmetic, unchanged old native counters and unchanged trace prefix; restore the exact original slot in `finally`. Exercise both complement and Gram guard paths if the entry is checked globally. A new factory rejecting a replacement is covered locally but is not this live-drift control. + +## Exact encoding domain and behavior + +The native domain is an exact nonnegative uint64 count; exact tuple `us`/`vs`; and None or an exact list output. Each vector contains at most 64 exact nonnegative uint64 integers. Bool, integer subclasses, negative/wide integers, larger vectors and other container shapes return `NotImplemented`. The Python adapter retains the original output validation before this dispatch, so unsupported output types still raise the same original error. + +Native bytes are the literal sorted-key, compact, ASCII JSON record with final LF: record key order `call,result,us,vs`; list result order `type,values`; None result has only `type`. Decimal conversion uses unsigned arithmetic, never floating point or masks. The longest admitted record is 4112 bytes: 192 twenty-digit vector values, 189 commas, one twenty-digit count and 63 schema/punctuation bytes. The 8192-byte stack buffer checks every append despite that bound. + +For fallback, the adapter builds the original result/record dictionaries and executes the literal original `json.dumps(..., sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + b"\n"`. Count is read once and the same object is used for admission and fallback. This preserves ordinary JSON handling of negative/wide integers, direct-call input shapes, and decimal-limit errors. The supported environment is the frozen ordinary CPython 3.12 JSON runtime, not arbitrary monkeypatch equivalence. + +`before` and `receipt` are inherited unchanged. `after` retains original unpacking, output validation, `hasher.update(encoded)`, `bytes += len(encoded)` and `count += 1` order. Every completed record is immediately visible. No cross-call buffers, cached receipts, changed checksum, new per-record performance counters or output-object mutation are introduced. Hash failure or a later counter failure preserves the original partial-state behavior. + +## C ownership, errors and optional embedding + +The encoder holds the GIL throughout. Exact-container borrowed references are consumed within the owning argument lifetime; no container reference or scratch pointer is retained. `PyLong_AsUnsignedLongLong` is preceded by exact type admission, and `PyErr_Occurred` distinguishes valid UINT64_MAX from failure. Only `OverflowError` is cleared to choose fallback. Other conversion errors and final bytes-allocation failure propagate. A rejected partially built record never escapes. The only returned allocation is `PyBytes_FromStringAndSize` copying the initialized prefix. + +All implementation identifiers use `h25_trace_` or `H25_TRACE_`. Defining `H25_TRACE_EMBEDDED` excludes only the standalone method table/module definition/init. The parent may include this same C source before its own combined method table and register the unchanged static `h25_trace_encode_record` with `METH_FASTCALL`. The kernel source and logic are otherwise unchanged. A combined source is a new pinned parent artifact and must include the trace entry in its native freshness inventory. This option establishes no build-cost amortization claim; standalone compilation is the default. + +The calling convention and reference/error requirements follow the [CPython C API](https://docs.python.org/3.12/c-api/structures.html#c.METH_FASTCALL), [integer conversion](https://docs.python.org/3.12/c-api/long.html), and [bytes ownership](https://docs.python.org/3.12/c-api/bytes.html) documentation. + +## Controls and complete cost bill + +The local control suite compares the original observer, a separate literal JSON oracle and the candidate. It covers every byte and intermediate hash/receipt; None/list distinctions; order; decimal and uint64 boundaries; the 4112-byte maximum; 64/65 entries; negative/wide values; bool/subclasses/custom callbacks; unpacking and output errors; failing hash updates before/after mutation; failing byte/count increments; snapshots and later mutations; no retained caller references; sentinel/error clearing; arity/keyword rejection; and factory owner/entry rejection. Decimal-limit settings and temporary native-entry replacement are restored in `finally`. + +The parent runs it in normal and optimized finite modes, retains all original controls, adds the live freshness controls above, then keeps the complete caller assertion-on. The control suite intentionally creates no native coverage counters in the hot path: its receipt reports direct finite admissions/fallbacks, not measured full coverage. Full exact receipts and the unchanged old native counters remain mandatory. + +Charge source preparation/custody, both cold build/load and all new controls, added live entry checks, native dispatch/conversion/decimal/buffer/bytes work, original snapshots/hash/counters, fallback costs, failed attempts and cleanup. Exact byte arithmetic and source call budgets are not speed measurements. Only the parent's complete frozen-baseline/candidate pilots can establish performance evidence. diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/CALL-BUDGET.json b/research/h25-bookkeeping/payload/priorities/trace-encoding/CALL-BUDGET.json new file mode 100644 index 0000000000..45336f3ace --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/CALL-BUDGET.json @@ -0,0 +1,103 @@ +{ + "schema_version": 1, + "lane": "P3", + "status": "SOURCE_DERIVED_PROPOSAL_NOT_MEASURED", + "authorization_update": "Repeated-call reduction explicitly added to PLAN.md; no inter-call buffering", + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "evidence": { + "observer": "engine/native_backend.py ComplementTrace.before/after/receipt; e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5", + "json_dumps": "/usr/lib/python3.12/json/__init__.py; d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "json_encoder": "/usr/lib/python3.12/json/encoder.py; af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869", + "native_admission": "engine/native_gf2.c read_vectors/complement; e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc", + "N": 238685, + "N_source": "Frozen full anchor and driver expected successful complement-native count; not rerun", + "new_fast_lane_coverage": "All N expected from existing native admission: nonnegative uint64 inputs, k+n<=64, exact list of uint64 output, call index exact bytes including newline | NotImplemented; NULL only for genuine Python errors", + "fast_domain": { + "call": "exact int in [0, 2**64-1]", + "us": "exact tuple, 0..64 entries, each exact int in [0, 2**64-1]", + "vs": "exact tuple, 0..64 entries, each exact int in [0, 2**64-1]", + "output": "None or exact list, 0..64 entries, each exact int in [0, 2**64-1]" + }, + "fallback": "Any unsupported count, vector shape, length, exact type, negative sign or width returns NotImplemented without callbacks or state mutation; after retains the original output validation, builds original result/record dictionaries and calls the original json.dumps(...sort_keys=True,separators=(',',':'),ensure_ascii=True).encode('ascii') + newline expression", + "order": ["unpack inputs", "original output validation", "encode complete record", "existing hasher.update(encoded)", "existing bytes += len(encoded)", "existing count += 1"], + "canonical_key_order": {"record": ["call", "result", "us", "vs"], "list_result": ["type", "values"], "none_result": ["type"]}, + "runtime_admission": "Frozen ordinary CPython 3.12 JSON runtime; serial calls without mutation within call. No claim of arbitrary JSON monkeypatch equivalence. Native entry replacement is checked at the live guard boundary.", + "binding_requirement": "Parent extends native ownership/entry freshness records before RuntimeGuard construction. Separate extension requires additional owner and callable checks; combined module requires encoder in native_items. Never alter captured wrapper closure identities afterward.", + "memory": "8192-byte checked per-call stack buffer, one immutable bytes allocation/copy, no shared scratch, no retained input/output refs, GIL held while accessing exact container borrowed refs", + "conversion": "PyLong_CheckExact before PyLong_AsUnsignedLongLong; check PyErr_Occurred, clear only OverflowError for fallback, propagate other errors; no mask conversion or double conversion", + "digit_rendering": "Unsigned division/remainder decimal rendering; fixed ASCII punctuation/literals and final LF; locale independent", + "parent_integration_choice": "Separate _trace_encoding extension with charged cold build, or parent-owned merge of encoder fragment into combined native module; lane does not edit existing native_gf2.c" + }, + "private_future_files": ["trace_encoder.c", "trace_adapter.py", "trace_controls.py", "ADAPTER.md"], + "unchanged": [ + "All original arithmetic and independent checks", + "before snapshot timing and exact integer vectors", + "original after unpacking and output validation", + "output object identity and no output mutation", + "immediate SHA256 update with identical complete bytes", + "hash/counters/receipt visibility after each successful record", + "original counter update and partial-failure ordering", + "all full witnesses, rank traces and complete receipts", + "arbitrary-width and sign behavior through JSON fallback" + ], + "removed_hot_path_work": [ + "result dictionary allocation", + "record dictionary allocation", + "json.dumps keyword dispatch and per-call JSONEncoder construction", + "general JSON container dispatch/sorted keys for fixed schema", + "intermediate unicode result and ASCII encoding", + "newline bytes concatenation" + ], + "retained_costs": ["tuple snapshots", "exact-output Python validation", "all old runtime/native checks", "all canonical bytes", "one immediate original SHA256 update", "original counters/receipt", "all old controls", "full frozen caller and witnesses"], + "new_costs": ["native-call dispatch", "exact-type/length admission", "checked integer conversion", "decimal rendering and checked buffer append", "one bytes allocation/copy", "native encoder entry freshness", "source custody", "cold compile/link/load", "new finite/failure controls", "failure retention and private build cleanup"], + "cost_status": "Unknown until parent serial complete runs; unknown is not zero; no component or 15-percent gain claimed", + "alternatives": [ + {"name": "Cross-call buffering", "disposition": "REJECT_SOURCE_CONTRACT", "reason": "Public hash prefixes and hash-update failure boundaries are immediate"}, + {"name": "Drop or delay before snapshots", "disposition": "REJECT_SOURCE_CONTRACT", "reason": "Breaks ordered alias snapshots before arithmetic"}, + {"name": "Cache a JSONEncoder", "disposition": "RESERVE_ONLY", "reason": "Smaller implementation but retains dictionaries/unicode/ASCII/newline and general C encoder work; only execute after new discriminating evidence"}, + {"name": "Custom native SHA or checksum", "disposition": "REJECT_SCOPE", "reason": "SHA already native; target is Python bookkeeping, and checksum change prohibited"} + ], + "controls": { + "old": ["All finite_controls.run_controls including independent dense oracle", "7 original trace pairs", "4 original trace negatives", "arbitrary-width arithmetic fallback", "all existing runtime-drift rejections"], + "new_bytes_and_prefix": ["Exact literal JSON bytes including LF per record", "empty list versus None", "input and output order permutations", "decimal digit transitions", "uint64 maximum", "negative values", "2**64 and 2**100", "64 versus 65 entries", "wide decimal digit-limit success/error", "every receipt and hasher.copy() prefix"], + "new_boundaries": ["bool and int/list/tuple subclasses", "malformed inputs unpacking", "invalid output exact types/values", "basis mutation after before", "output mutation after after", "custom input shape fallback without early callbacks", "failing hasher update before and after its own state mutation", "counter failure after successful hash update", "native-entry mutation before arithmetic", "fallback sentinel followed by valid call has no stale error", "no retained aliases/references"], + "modes": ["normal finite", "optimized finite", "assertion-on full caller"], + "failure_comparison": "Compare exception type/message, hasher prefix, byte count and call count at the same boundary; do not reduce to success-only final digest" + }, + "hazards": [ + "Fixed buffer must have checked append and a proved all-admitted-domain bound; never expose partial bytes", + "UINT64_MAX is also an error sentinel from conversion, so the error indicator is mandatory", + "PyTuple/List item references are borrowed; retain GIL and own container reference during access", + "Fall back instead of truncating wide or negative values", + "JSON digit-limit failure belongs to original fallback and must remain visible", + "Avoid delayed counters, hash buffering or replacing hasher object", + "Never mutate original frozen source or captured wrapper cells after binding", + "Separate native owner/entry checks and compile costs may erase serialization savings", + "Do not broaden claims to arbitrary mutation of json/backend/process memory", + "Make only fresh private build/runtime directories writable for cleanup" + ], + "primary_sources": [ + {"url": "https://docs.python.org/3.12/library/json.html", "use": "sort_keys, compact separators, ASCII and unicode output contract"}, + {"url": "https://docs.python.org/3.12/c-api/long.html", "use": "exact types, overflow/error indicators, no mask conversion"}, + {"url": "https://docs.python.org/3.12/c-api/bytes.html", "use": "bytes allocation and buffer ownership"}, + {"url": "https://docs.python.org/3.12/c-api/tuple.html", "use": "exact tuples and borrowed item references"}, + {"url": "https://docs.python.org/3.12/c-api/list.html", "use": "exact lists and borrowed item references"}, + {"url": "https://docs.python.org/3.12/library/hashlib.html", "use": "prefix exposure, GIL threshold and existing native SHA implementations"} + ], + "inspected_local_stdlib": { + "/usr/lib/python3.12/json/__init__.py": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "/usr/lib/python3.12/json/encoder.py": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + "discriminating_next_test": "After parent and independent design gate: one parent cold compile and exact byte/prefix/failure finite comparison; if correct, one complete native-baseline/candidate pilot including all new costs and old controls. No lane-owned run.", + "stage_actions_performed": ["source reads", "bounded primary documentation reads", "file SHA256 reads", "write these two proposal documents"], + "stage_actions_not_performed": ["implementation", "scientific imports", "compilers", "numerical runs", "corpus generation/decoding", "Git mutations", "browser writes", "delegation"] +} diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/RESEARCH.md b/research/h25-bookkeeping/payload/priorities/trace-encoding/RESEARCH.md new file mode 100644 index 0000000000..b509b54a44 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/RESEARCH.md @@ -0,0 +1,35 @@ +# P3: one-record native trace encoding + +Source-only proposal; no implementation, scientific imports, compilation, corpus decoding, or numerical execution occurred. Ownership is exclusively this directory. Other agents and every frozen package remain untouched. Implementation awaits the parent gate. + +## Frozen contract and evidence + +Baseline: PR5995 `4f4159820c37f01d245784d1186bd51fcbc8ebb6`, native C arm. Current guidance: `19fdb086ea96af9a9f87936a2b888e10af4ed810`, priority revision 8. `PROPOSAL.json` records exact inspected file hashes. The pinned anchor records 238,685 ordered records, 55,839,507 canonical bytes, digest `7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838`; these are existing observations, not new measurements. + +`ComplementTrace.before` requires exact Label/dict/int objects, snapshots big values then small values into ordered tuples, validates integers, and returns `(us, vs)` before arithmetic. Preserve this method. `after` unpacks inputs, validates exact-list integer output or None, constructs two dictionaries, invokes JSON, ASCII-encodes and appends newline, updates the existing hash, then increments bytes and count. Exceptions before update leave the prefix unchanged; exceptions in later counter arithmetic can leave a changed hash. Preserve this order literally, including the current output validation and return-object identity. + +The sorted encoding order is **call, result, us, vs**, with result keys **type, values** for lists. The schema description is not an instruction to use its displayed key order. Empty list and None differ. Intermediate `receipt()`, public counters and `hasher.copy()/hexdigest()` expose every completed record. + +## Primary design and adapter + +Supply `trace_encoder.c` and `trace_adapter.py` in this private directory after approval. Stateless native `encode_record(call, us, vs, output)` returns exact bytes including newline, or `NotImplemented`. Admit only exact integers in `[0, 2**64-1]`, exact tuple inputs, exact list/None output, and at most 64 entries in each vector. Out-of-domain values use the **literal original** JSON expression. This preserves negative signs, arbitrary-width values, nonstandard direct-after shapes, and decimal digit-limit errors through fallback. + +Use a checked 8192-byte stack buffer, integer division/remainder for locale-independent decimal digits, and one final bytes allocation/copy. Every append checks capacity. Exact-type admission precedes integer conversion; inspect the error indicator and clear only expected overflow when choosing fallback. Hold the GIL; retain no Python references or caller buffers after return. No modular conversion, float conversion, custom callbacks or shared scratch state. + +The parent injects the trace factory and encoder before binding; it finalizes closure identities before `RuntimeGuard` captures state. The parent must include the encoder owner/entry in the existing per-call freshness boundary before arithmetic/fallback. If compiled separately, that adds one native owner and callable check; if merged, extend the existing module's entry list. No post-capture replacement. Original `before`, `receipt`, input snapshots, hash update and counter code remain. A caller's output list is neither retained nor modified. + +Supported environment remains the frozen ordinary CPython 3.12 JSON runtime and serial no-mutation-during-call policy. Local JSON files were inspected and pinned; no general JSON monkeypatch-equivalence or security claim is made. The fallback retains the ordinary original serializer. + +## Alternatives and cost + +Cross-call buffering is rejected: it delays observable hash prefixes and can shift update exceptions. Moving snapshots after arithmetic or storing mutable views is rejected. A cached JSONEncoder is a smaller alternative but retains both record dictionaries, result string, ASCII bytes and newline copy. Native hashing is not proposed: hashlib already uses native implementations. The candidate targets Python construction and dispatch overhead, not a speculative SHA gain. + +Retained costs: every vector snapshot/type check, native kernel/guard, ordered record, 55,839,507 bytes, immediate SHA update, counters, receipts, full witnesses and all old controls. New costs: conversion/type admission, bounded stack work, one extra native crossing, callable freshness, source custody, cold compilation/link/load, new controls, failures and cleanup. Costs and complete gain are **unknown**, not zero; no per-lane 15% promise. Parent-only full pilots decide whether integration is useful. + +## Controls and next gate + +Retain all old finite controls, including seven trace pairs, four trace negatives, width fallback and independent dense checks. New controls compare literal reference bytes and every prefix/receipt/hash copy for empty/list/None, order permutations, decimal boundaries, uint64 maximum, negative/65-bit/100-bit/decimal-limit values, 64/65 entries, exact types versus subclasses/bool, snapshot mutation before after, output mutation after after, malformed unpacking/output, failing hash updates, and counter failure order. Verify callable replacement fails before arithmetic and restored bindings work. Encoder rejection must be side-effect-free and leave no stale error. Controls run normal and optimized modes; complete verification remains assertion-on. + +First discriminating experiment: parent cold-builds once, runs exact byte/prefix/failure controls, then one complete frozen native-baseline/candidate pair including the entire new cost bill. Only correct complete results can justify combination. + +Primary documentation: [JSON parameters](https://docs.python.org/3.12/library/json.html), [exact integers and checked conversion](https://docs.python.org/3.12/c-api/long.html), [bytes ownership](https://docs.python.org/3.12/c-api/bytes.html), [tuple references](https://docs.python.org/3.12/c-api/tuple.html), [list references](https://docs.python.org/3.12/c-api/list.html), [hash prefixes and native implementations](https://docs.python.org/3.12/library/hashlib.html). Local stdlib source confirms this keyword configuration constructs a new JSONEncoder per call and normally invokes its C encoder. diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/SOURCE-READINESS.json b/research/h25-bookkeeping/payload/priorities/trace-encoding/SOURCE-READINESS.json new file mode 100644 index 0000000000..2fa1093f8f --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/SOURCE-READINESS.json @@ -0,0 +1,36 @@ +{ + "schema_version": 1, + "lane": "P3", + "status": "SOURCE_IMPLEMENTATION_COMPLETE_AWAITING_INDEPENDENT_CODE_GATE_AND_PARENT_EXECUTION", + "baseline_pr": 5995, + "baseline_head": "4f4159820c37f01d245784d1186bd51fcbc8ebb6", + "source_sha256": { + "trace_encoder.c": "57d6f0f71d5bfd2145397ac0159837d32990b276fead2ec1b1d6854d8913bd7e", + "trace_adapter.py": "4bdb401271ffd049c52eff0edc28d8d604a11faf66fec419555a82cbd3b32d60", + "trace_controls.py": "527bb08e870dc2ee19bebf101e7353c6db8422a5702a80bca231b54d2a4af447", + "ADAPTER.md": "964464a343806c89472c9965dc976ca47f61323c0b4afae6db276ab97e84d47f" + }, + "native_api": "_trace_encoding.encode_record(call, us, vs, output): exactly four positional arguments, METH_FASTCALL, bytes including LF or NotImplemented; genuine errors propagate", + "python_api": "trace_adapter.make_trace_type(backend, native_encoder_module) returns candidate subclass without mutating backend.ComplementTrace", + "control_api": "trace_controls.run_controls(backend, native_encoder_module) returns JSON-safe finite receipt or raises; no compilation or full-caller execution", + "native_binding_metadata": "CandidateTrace._h25_native_entries == ((exact_owner_module, 'encode_record', fixed_builtin_entry),)", + "parent_obligations": [ + "Keep backend.ComplementTrace original and unchanged for old finite controls", + "Source-pin and cold-build/load the native encoder in the serial parent queue", + "Check extra native owner and entry at every original guard boundary before arithmetic/fallback, after old distinct checks", + "Finalize trace/factory/guard/helper and closure bindings before RuntimeGuard captures state", + "Exercise live replacement rejection before arithmetic with unchanged kernel counters and trace prefix", + "Run all old and new controls in normal and optimized finite modes; full caller remains assertion-on", + "Include all native build/load/guard/control/conversion/allocation/cleanup costs in complete pilots" + ], + "buffer_bytes": 8192, + "maximum_admitted_record_bytes_source_derived": 4112, + "inter_call_buffering": false, + "original_kernel_changed": false, + "source_execution_performed_by_lane": false, + "compiled": false, + "imported_scientific_code": false, + "finite_controls_run": false, + "performance_measured": false, + "remaining_source_work": "None pending independent review findings; no further source edits without a new recorded revision" +} diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_adapter.py b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_adapter.py new file mode 100644 index 0000000000..19fc2ef6d4 --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_adapter.py @@ -0,0 +1,59 @@ +"""Candidate-only trace factory; does not mutate the frozen backend. + +The parent owns source custody, native compilation and the live native-owner / +entry check before arithmetic. Install the final trace object before binding +captures wrapper closures. Ordinary frozen JSON/runtime semantics are assumed; +this is not a compatibility layer for arbitrary serializer/backend mutation. +""" +from types import BuiltinFunctionType, ModuleType + + +def make_trace_type(backend, native_encoder_module): + """Return a trace subclass with the original before/receipt boundaries. + + ``_h25_native_entries`` exposes the exact owner/name/function triple that + must be checked by the parent's RuntimeGuard at every original live check + boundary. It is metadata, not a cached PASS. This factory neither patches + backend.ComplementTrace nor changes any existing guard or native kernel. + """ + require = backend.require + _TYPE = backend._TYPE + _LIST = backend._LIST + _INT = backend._INT + _LEN = backend._LEN + _DICT_GET = backend._DICT_GET + json = backend.json + reference_type = backend.ComplementTrace + require(_TYPE(native_encoder_module) is ModuleType, + "Unexpected trace encoder module type") + native_entry = _DICT_GET(native_encoder_module.__dict__, "encode_record") + require(_TYPE(native_entry) is BuiltinFunctionType and + native_entry.__self__ is native_encoder_module, + "Missing or replaced trace encoder entry point") + + class EncodedComplementTrace(reference_type): + __slots__ = () + _h25_native_entries = ((native_encoder_module, "encode_record", native_entry),) + _h25_reference_type = reference_type + + def after(self, inputs, output): + us, vs = inputs + if output is not None: + require(_TYPE(output) is _LIST and all(_TYPE(value) is _INT for value in output), + "Trace requires an exact integer list or None result") + # Read count once at the same encoding boundary. Unsupported values + # use this same object in the literal JSON fallback. + call = self.count + encoded = native_entry(call, us, vs, output) + if encoded is NotImplemented: + if output is None: + result = {"type": "None"} + else: + result = {"type": "list", "values": output} + record = {"call": call, "us": us, "vs": vs, "result": result} + encoded = json.dumps(record, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + b"\n" + self.hasher.update(encoded) + self.bytes += _LEN(encoded) + self.count += 1 + + return EncodedComplementTrace diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_controls.py b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_controls.py new file mode 100644 index 0000000000..c98467056a --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_controls.py @@ -0,0 +1,404 @@ +"""Bounded finite controls for the P3 one-record encoder. + +The parent imports and runs this in the serial guarded queue, after compiling +and loading the extension. No build, timing, files, network, or orchestration is +performed here. All checks use exceptions and remain active under python -O. +""" +import hashlib +import json +import sys +from types import ModuleType + +from trace_adapter import make_trace_type + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +class _CaptureHash: + def __init__(self, failure=None): + self.digest = hashlib.sha256() + self.chunks = [] + self.failure = failure + + def update(self, data): + _need(type(data) is bytes, "Trace update did not receive exact bytes") + if self.failure == "before": + raise ValueError("injected hash failure before update") + self.digest.update(data) + self.chunks.append(data) + if self.failure == "after": + raise ValueError("injected hash failure after update") + + def copy(self): + return self.digest.copy() + + def hexdigest(self): + return self.digest.hexdigest() + + +class _IntSubclass(int): + pass + + +class _TupleSubclass(tuple): + pass + + +class _ListSubclass(list): + pass + + +def _capture(function): + try: + value = function() + except Exception as error: + return ("error", type(error), str(error)) + return ("return", type(value), value) + + +def _state(trace): + # Exact field types are part of the comparison: bool must not equal int by + # accident. Counter fixtures use ordinary strings/ints only. + return (type(trace.count), trace.count, type(trace.bytes), trace.bytes, + trace.hasher.hexdigest(), trace.hasher.copy().hexdigest(), + tuple(trace.hasher.chunks), trace.receipt()) + + +def _literal(call, inputs, output): + us, vs = inputs + if output is None: + result = {"type": "None"} + else: + result = {"type": "list", "values": output} + record = {"call": call, "us": us, "vs": vs, "result": result} + return json.dumps(record, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + b"\n" + + +def _admitted(call, us, vs, output): + def unsigned(value): + return type(value) is int and 0 <= value <= (1 << 64) - 1 + return (unsigned(call) and type(us) is tuple and type(vs) is tuple and + len(us) <= 64 and len(vs) <= 64 and + all(unsigned(value) for value in us) and + all(unsigned(value) for value in vs) and + (output is None or + (type(output) is list and len(output) <= 64 and + all(unsigned(value) for value in output)))) + + +def run_controls(backend, native_encoder_module): + """Return a JSON-safe receipt; never compile or invoke the full caller. + + Native entry replacement *before arithmetic* is an additional parent-owned + integration control because this standalone factory has no RuntimeGuard. + """ + reference_type = backend.ComplementTrace + candidate_type = make_trace_type(backend, native_encoder_module) + encoder = native_encoder_module.encode_record + _need(candidate_type.before is reference_type.before and + candidate_type.receipt is reference_type.receipt, + "Adapter replaced an original observation boundary") + _need(candidate_type._h25_native_entries == + ((native_encoder_module, "encode_record", encoder),), + "Adapter does not expose the exact native ownership triple") + _need(backend.ComplementTrace is reference_type, + "Trace factory changed the reference backend") + module = backend.load_source("_h25_trace_control_source") + label = module.Label + counts = {"byte_and_prefix_pairs": 0, "native_admitted": 0, + "native_fallback": 0, "error_pairs": 0, + "before_pairs": 0, "native_argument_errors": 0, + "no_alias_checks": 0, "digit_limit_pairs": 0, + "source_module_loads": 1, "factory_rejections": 0} + ledger = hashlib.sha256() + + # Factory admission does not bless a proxy, a Python replacement, or a + # native function belonging to another module. Live drift after binding + # remains the separate parent-owned pre-arithmetic guard obligation. + wrong_owner = ModuleType("_h25_wrong_trace_owner") + wrong_owner.encode_record = encoder + for invalid_owner in (object(), wrong_owner): + outcome = _capture(lambda invalid_owner=invalid_owner: + make_trace_type(backend, invalid_owner)) + _need(outcome[0] == "error" and outcome[1] is RuntimeError, + "Trace factory accepted an invalid native owner") + counts["factory_rejections"] += 1 + try: + native_encoder_module.encode_record = lambda *args: b"replacement" + outcome = _capture(lambda: make_trace_type(backend, native_encoder_module)) + _need(outcome[0] == "error" and outcome[1] is RuntimeError, + "Trace factory accepted a replaced native entry") + counts["factory_rejections"] += 1 + finally: + native_encoder_module.encode_record = encoder + + def pair(failure=None): + oracle = reference_type(label) + candidate = candidate_type(label) + oracle.hasher = _CaptureHash(failure) + candidate.hasher = _CaptureHash(failure) + return oracle, candidate + + def compare_after(oracle, candidate, inputs, output, expected_error=None): + expected = _capture(lambda: oracle.after(inputs, output)) + actual = _capture(lambda: candidate.after(inputs, output)) + _need(actual == expected, "Trace exception/return contract differs") + _need(_state(candidate) == _state(oracle), + "Trace prefix, bytes, count, exact types or receipt differs") + if expected_error is None: + _need(expected == ("return", type(None), None), + "An expected successful trace case failed") + else: + _need(expected[0] == "error" and expected[1] is expected_error, + "Trace fixture did not fail with the expected exact exception") + counts["error_pairs"] += 1 + counts["byte_and_prefix_pairs"] += 1 + ledger.update(expected[0].encode("ascii") + b":" + + expected[1].__name__.encode("ascii") + b"\n") + if expected[0] == "error": + ledger.update(expected[2].encode("utf-8") + b"\n") + ledger.update(oracle.hasher.copy().digest()) + + def record(oracle, candidate, inputs, output): + us, vs = inputs + call = oracle.count + literal = _literal(call, inputs, output) + native = encoder(call, us, vs, output) + if _admitted(call, us, vs, output): + _need(type(native) is bytes and native == literal, + "Native record bytes differ from literal sorted ASCII JSON") + counts["native_admitted"] += 1 + else: + _need(native is NotImplemented, + "Native encoder admitted an unsupported exact domain") + counts["native_fallback"] += 1 + compare_after(oracle, candidate, inputs, output) + _need(oracle.hasher.chunks[-1] == literal and + candidate.hasher.chunks[-1] == literal, + "Adapter lost exact canonical bytes or final LF") + ledger.update(literal) + + # This stream compares every completed prefix, not just the final digest. + maximum = (1 << 64) - 1 + fixtures = [ + (((), ()), []), + (((), ()), None), + (((0,), (0, 1, 2)), [0, 1, 2]), + (((1, 2), (1, 2, 4)), [4]), + (((2, 1), (1, 2, 4)), [4]), + (((1,), (4, 2, 1)), [2, 4]), + (((1,), (4, 2, 1)), [4, 2]), + (((9, 10, 99, 100, 999, 1000), (maximum,)), [maximum, 0]), + (((maximum,) * 64, (maximum,) * 64), [maximum] * 64), + (((0,) * 65, ()), []), + (((), (0,) * 65), []), + (((), ()), [0] * 65), + (((-1,), (0,)), [-2]), + (((1 << 64,), (1 << 100,)), [1 << 100]), + (((True,), ()), []), + (((_IntSubclass(7),), ()), []), + ((_TupleSubclass((1, 2)), (1, 2, 4)), [4]), + (([1, 2], (1, 2, 4)), [4]), + (("lambda: \u03bb", ()), None), + (({"z": 2, "a": 1}, ()), []), + ] + oracle, candidate = pair() + for inputs, output in fixtures: + record(oracle, candidate, inputs, output) + stream_receipt = oracle.receipt() + + # Count itself is serialized, and unsupported count types must use JSON. + for count in (0, 9, 10, 99, 100, maximum, 1 << 64, -1, True, 1.5, _IntSubclass(3)): + left, right = pair() + left.count = right.count = count + record(left, right, ((1,), (1, 2)), [2]) + left, right = pair() + left.count = right.count = maximum + record(left, right, ((maximum,) * 64, (maximum,) * 64), [maximum] * 64) + _need(len(left.hasher.chunks[0]) == 4112, + "Maximum admitted record does not match the checked buffer bound") + + # Native direct-call admission has no user-defined conversion callbacks. + callbacks = [] + class IndexOnly: + def __index__(self): + callbacks.append("index") + return 3 + index_only = IndexOnly() + direct_unsupported = [ + (index_only, (), (), []), (0, (index_only,), (), []), + (0, (), (index_only,), []), (0, (), (), [index_only]), + (0, (), (), _ListSubclass([1])), (0, (), (), (1,)), + (0, (), (), [True]), (0, (), (), [_IntSubclass(1)]), + (0, (), (), object()), + ] + for args in direct_unsupported: + _need(encoder(*args) is NotImplemented, + "Native unsupported-input sentinel changed") + # A valid call after each rejection detects an uncleared error flag. + _need(encoder(0, (), (), []) == _literal(0, ((), ()), []), + "Native fallback left stale error state") + counts["native_fallback"] += 1 + _need(callbacks == [], "Native admission invoked a custom integer callback") + for arguments in ((), (0,), (0, (), ()), (0, (), (), [], None)): + outcome = _capture(lambda arguments=arguments: encoder(*arguments)) + _need(outcome[0] == "error" and outcome[1] is TypeError, + "Native FASTCALL arity error changed") + counts["native_argument_errors"] += 1 + outcome = _capture(lambda: encoder(call=0, us=(), vs=(), output=[])) + _need(outcome[0] == "error" and outcome[1] is TypeError, + "Native FASTCALL unexpectedly admitted keyword arguments") + counts["native_argument_errors"] += 1 + + # Existing after validation must win before any encoding or hash update. + invalid_outputs = [(1,), _ListSubclass([1]), [True], [_IntSubclass(1)], + [index_only], 3, NotImplemented] + for output in invalid_outputs: + left, right = pair() + compare_after(left, right, ((), ()), output, RuntimeError) + _need(left.count == 0 and left.bytes == 0 and left.hasher.chunks == [], + "Invalid output changed the observation prefix") + for inputs, error_type in ((7, TypeError), (((),), ValueError), + (((), (), ()), ValueError)): + left, right = pair() + compare_after(left, right, inputs, [], error_type) + left, right = pair() + compare_after(left, right, ((index_only,), ()), [], TypeError) + _need(callbacks == [], "JSON fallback invoked a custom integer callback") + + # Original input unpacking can run a callback. Each implementation must + # consume it once before encoding and preserve that event order. + unpack_events = [] + class PairInput: + def __iter__(self): + unpack_events.append("unpack") + yield (1,) + yield (1, 2) + left, right = pair() + compare_after(left, right, PairInput(), [2]) + _need(unpack_events == ["unpack", "unpack"], + "Trace changed input-unpacking callback multiplicity") + + # Preserve failures before hash mutation, after hash mutation, and after a + # successful hash but before/between the original counter assignments. + for failure in ("before", "after"): + left, right = pair(failure) + compare_after(left, right, ((1,), (1, 2)), [2], ValueError) + _need(left.count == 0 and left.bytes == 0, + "Hash failure advanced the public counters") + _need(bool(left.hasher.chunks) is (failure == "after"), + "Hash failure test did not exercise its declared boundary") + left, right = pair() + left.bytes = right.bytes = "bad byte counter" + compare_after(left, right, ((1,), (1, 2)), [2], TypeError) + _need(left.count == 0 and len(left.hasher.chunks) == 1, + "Byte-counter failure did not preserve the post-hash boundary") + left, right = pair() + left.count = right.count = "bad call counter" + compare_after(left, right, ((1,), (1, 2)), [2], TypeError) + _need(left.bytes == len(left.hasher.chunks[0]) and + left.count == "bad call counter", + "Call-counter failure did not follow the byte-counter increment") + + # Unsupported wide integers still reach ordinary decimal digit limits. + # Restore the process setting on success or any control failure. + original_limit = sys.get_int_max_str_digits() + try: + sys.set_int_max_str_digits(640) + left, right = pair() + record(left, right, ((10 ** 639,), ()), []) + counts["digit_limit_pairs"] += 1 + for inputs, output in ( + (((10 ** 640,), ()), []), + (((-(10 ** 640),), ()), []), + (((), ()), [10 ** 640]), + ): + left, right = pair() + _need(encoder(0, inputs[0], inputs[1], output) is NotImplemented, + "Wide decimal integer escaped JSON fallback") + compare_after(left, right, inputs, output, ValueError) + _need(left.count == 0 and left.bytes == 0 and left.hasher.chunks == [], + "Decimal-limit failure changed the prefix") + counts["native_fallback"] += 1 + counts["digit_limit_pairs"] += 1 + sys.set_int_max_str_digits(0) + left, right = pair() + record(left, right, ((10 ** 700, -(10 ** 700)), ()), [10 ** 700]) + counts["digit_limit_pairs"] += 1 + finally: + sys.set_int_max_str_digits(original_limit) + + def raw(values, basis_type=dict): + value = object.__new__(label) + value.basis = basis_type(enumerate(values)) + return value + + # Both before methods take private ordered snapshots before later writes. + left, right = pair() + small, big = raw((4, 1)), raw((4, 2, 1)) + left_inputs = left.before(small, big) + right_inputs = right.before(small, big) + _need(left_inputs == right_inputs == ((4, 1), (4, 2, 1)) and + type(right_inputs) is tuple and all(type(row) is tuple for row in right_inputs), + "Before lost exact ordered snapshot tuples") + small.basis.clear() + big.basis[0] = 999 + big.basis[3] = 8 + _need(left_inputs == right_inputs == ((4, 1), (4, 2, 1)), + "Before snapshot aliases a mutable basis") + compare_after(left, right, right_inputs, [2]) + counts["before_pairs"] += 1 + shared = raw((2, 1)) + _need(left.before(shared, shared) == right.before(shared, shared) == ((2, 1), (2, 1)), + "Before changed aliased-label snapshot order") + counts["before_pairs"] += 1 + basis_events = [] + class SideEffectDict(dict): + def values(self): + basis_events.append("values") + return super().values() + class ChildLabel(label): + pass + child = object.__new__(ChildLabel) + child.basis = {0: 1} + missing = object.__new__(label) + bad_before = [object(), child, missing, raw((1,), SideEffectDict), raw((True,))] + for invalid in bad_before: + left, right = pair() + good = raw((1, 2)) + expected = _capture(lambda: left.before(invalid, good)) + actual = _capture(lambda: right.before(invalid, good)) + _need(actual == expected and expected[0] == "error" and + expected[1] is RuntimeError and _state(left) == _state(right), + "Before rejection semantics changed") + counts["before_pairs"] += 1 + _need(basis_events == [], "Before invoked unsupported basis.values") + + # Success must retain no caller vectors or output aliases. Bytes are owned + # immutable copies, so later mutation cannot alter an observed prefix. + left, right = pair() + us, vs, output = (1, 3), (1, 2, 4), [2, 4] + inputs = (us, vs) + before_refs = (sys.getrefcount(us), sys.getrefcount(vs), sys.getrefcount(output)) + record(left, right, inputs, output) + _need((sys.getrefcount(us), sys.getrefcount(vs), sys.getrefcount(output)) == before_refs, + "Trace encoder retained a caller vector or output reference") + before_prefix = _state(right) + output[:] = [999] + _need(_state(right) == before_prefix and _state(left) == before_prefix, + "Observed bytes retain a mutable output alias") + counts["no_alias_checks"] += 2 + + return { + "status": "TRACE_ENCODING_FINITE_CONTROLS_PASS", + "counts": counts, + "fixture_sha256": ledger.hexdigest(), + "ordered_fixture_stream": stream_receipt, + "native_interface": "encode_record(call,us,vs,output): exact bytes with LF or NotImplemented", + "comparison": "Original ComplementTrace, literal sorted ASCII JSON, exact per-record bytes, every prefix and exception/counter state", + "native_entry_freshness": "Parent integration must additionally reject native owner/entry replacement before arithmetic at every original live guard boundary", + "timing_claim": None, + } diff --git a/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_encoder.c b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_encoder.c new file mode 100644 index 0000000000..2f1965210b --- /dev/null +++ b/research/h25-bookkeeping/payload/priorities/trace-encoding/trace_encoder.c @@ -0,0 +1,175 @@ +/* Stateless canonical complement-record encoding for the frozen H25 observer. + * All symbols are trace-prefixed so the parent may include this source in its + * combined extension with H25_TRACE_EMBEDDED defined. No GF(2) code is changed. + */ +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif +#include +#include +#include +#include + +_Static_assert(sizeof(unsigned long long) * CHAR_BIT == 64, + "H25 trace encoding requires 64-bit unsigned long long"); + +#define H25_TRACE_CAPACITY 8192 +#define H25_TRACE_MAX_VECTOR 64 + +typedef struct { + char data[H25_TRACE_CAPACITY]; + Py_ssize_t used; +} h25_trace_buffer; + +/* 1 means admitted, 0 means literal-JSON fallback, -1 means genuine error. + * Exact-type admission prevents __index__ or any other caller callback. + * UINT64_MAX is a valid value: the error indicator, not its bits, decides. + */ +static int h25_trace_u64(PyObject *value, uint64_t *out) { + unsigned long long converted; + if (!PyLong_CheckExact(value)) return 0; + converted = PyLong_AsUnsignedLongLong(value); + if (PyErr_Occurred()) { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + *out = (uint64_t)converted; + return 1; +} + +/* Capacity checks precede every write. A rejected record exposes no bytes. */ +static int h25_trace_append(h25_trace_buffer *buffer, const char *text, + Py_ssize_t length) { + if (length < 0 || length > H25_TRACE_CAPACITY || buffer->used < 0 || + buffer->used > H25_TRACE_CAPACITY - length) return 0; + memcpy(buffer->data + buffer->used, text, (size_t)length); + buffer->used += length; + return 1; +} + +#define H25_TRACE_LITERAL(buffer, literal) \ + h25_trace_append((buffer), (literal), (Py_ssize_t)(sizeof(literal) - 1)) + +static int h25_trace_decimal(h25_trace_buffer *buffer, uint64_t value) { + char reversed[20]; + Py_ssize_t digits = 0; + Py_ssize_t i; + do { + if (digits >= (Py_ssize_t)sizeof(reversed)) return 0; + reversed[digits++] = (char)('0' + value % UINT64_C(10)); + value /= UINT64_C(10); + } while (value != 0); + if (buffer->used < 0 || buffer->used > H25_TRACE_CAPACITY - digits) + return 0; + for (i = digits; i > 0; --i) buffer->data[buffer->used++] = reversed[i - 1]; + return 1; +} + +/* Containers were admitted before this helper. Borrowed references remain + * valid while the native call owns its arguments and holds the GIL. No Python + * callbacks run and no reference is retained when this function returns. + */ +static int h25_trace_vector(h25_trace_buffer *buffer, PyObject *values, + Py_ssize_t length, int is_list) { + Py_ssize_t i; + for (i = 0; i < length; ++i) { + PyObject *value = is_list ? PyList_GET_ITEM(values, i) + : PyTuple_GET_ITEM(values, i); + uint64_t converted; + int admitted = h25_trace_u64(value, &converted); + if (admitted != 1) return admitted; + if (i != 0 && !H25_TRACE_LITERAL(buffer, ",")) return 0; + if (!h25_trace_decimal(buffer, converted)) return 0; + } + return 1; +} + +/* Fixed schema, sorted key order: call,result,us,vs; result type,values. + * At most 192 20-digit vector values plus one 20-digit count, separators and + * fixed ASCII punctuation fit below 8192 bytes. Checks remain mandatory. + */ +static PyObject *h25_trace_encode_record(PyObject *self, + PyObject *const *args, + Py_ssize_t nargs) { + PyObject *call; + PyObject *us; + PyObject *vs; + PyObject *output; + Py_ssize_t us_length; + Py_ssize_t vs_length; + Py_ssize_t output_length = 0; + uint64_t call_value; + int admitted; + h25_trace_buffer buffer; + (void)self; + if (nargs != 4) { + PyErr_Format(PyExc_TypeError, + "encode_record() takes exactly 4 positional arguments (%zd given)", + nargs); + return NULL; + } + call = args[0]; + us = args[1]; + vs = args[2]; + output = args[3]; + if (!PyTuple_CheckExact(us) || !PyTuple_CheckExact(vs) || + (output != Py_None && !PyList_CheckExact(output))) Py_RETURN_NOTIMPLEMENTED; + us_length = PyTuple_GET_SIZE(us); + vs_length = PyTuple_GET_SIZE(vs); + if (output != Py_None) output_length = PyList_GET_SIZE(output); + if (us_length > H25_TRACE_MAX_VECTOR || vs_length > H25_TRACE_MAX_VECTOR || + output_length > H25_TRACE_MAX_VECTOR) Py_RETURN_NOTIMPLEMENTED; + admitted = h25_trace_u64(call, &call_value); + if (admitted < 0) return NULL; + if (!admitted) Py_RETURN_NOTIMPLEMENTED; + buffer.used = 0; + if (!H25_TRACE_LITERAL(&buffer, "{\"call\":")) Py_RETURN_NOTIMPLEMENTED; + if (!h25_trace_decimal(&buffer, call_value)) Py_RETURN_NOTIMPLEMENTED; + if (output == Py_None) { + if (!H25_TRACE_LITERAL(&buffer, ",\"result\":{\"type\":\"None\"}")) + Py_RETURN_NOTIMPLEMENTED; + } else { + if (!H25_TRACE_LITERAL(&buffer, ",\"result\":{\"type\":\"list\",\"values\":[")) + Py_RETURN_NOTIMPLEMENTED; + admitted = h25_trace_vector(&buffer, output, output_length, 1); + if (admitted < 0) return NULL; + if (!admitted) Py_RETURN_NOTIMPLEMENTED; + if (!H25_TRACE_LITERAL(&buffer, "]}")) Py_RETURN_NOTIMPLEMENTED; + } + if (!H25_TRACE_LITERAL(&buffer, ",\"us\":[")) Py_RETURN_NOTIMPLEMENTED; + admitted = h25_trace_vector(&buffer, us, us_length, 0); + if (admitted < 0) return NULL; + if (!admitted) Py_RETURN_NOTIMPLEMENTED; + if (!H25_TRACE_LITERAL(&buffer, "],\"vs\":[")) Py_RETURN_NOTIMPLEMENTED; + admitted = h25_trace_vector(&buffer, vs, vs_length, 0); + if (admitted < 0) return NULL; + if (!admitted) Py_RETURN_NOTIMPLEMENTED; + if (!H25_TRACE_LITERAL(&buffer, "]}\n")) Py_RETURN_NOTIMPLEMENTED; + /* One allocation/copy; no reference to the stack buffer escapes. */ + return PyBytes_FromStringAndSize(buffer.data, buffer.used); +} + +#ifndef H25_TRACE_EMBEDDED +static PyMethodDef h25_trace_methods[] = { + {"encode_record", (PyCFunction)(void (*)(void))h25_trace_encode_record, + METH_FASTCALL, + "Canonical one-record ASCII JSON bytes plus LF, or NotImplemented."}, + {NULL, NULL, 0, NULL} +}; + +static struct PyModuleDef h25_trace_module_definition = { + PyModuleDef_HEAD_INIT, + "_trace_encoding", + "Bounded stateless H25 complement-record encoding.", + -1, + h25_trace_methods, + NULL, NULL, NULL, NULL +}; + +PyMODINIT_FUNC PyInit__trace_encoding(void) { + return PyModule_Create(&h25_trace_module_definition); +} +#endif diff --git a/research/h25-bookkeeping/payload/run_guarded.py b/research/h25-bookkeeping/payload/run_guarded.py new file mode 100644 index 0000000000..27a967b578 --- /dev/null +++ b/research/h25-bookkeeping/payload/run_guarded.py @@ -0,0 +1,170 @@ +#!/usr/bin/env python3 +"""Parent-only serial immutable-stage runner; failed attempts remain charged.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import platform +import signal +import subprocess +import sys +import time + +HERE = Path(__file__).resolve().parent +TIMEOUT = 180 +RSS_CAP = 1024 ** 3 +OUTPUT_CAP = 2 * 1024 ** 2 +TOTAL_CAP = 1500 + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def inventory(stage): + rows = {} + for path in sorted(stage.rglob('*')): + if path.is_symlink(): + raise ValueError('Symlink in immutable stage') + if path.is_file() and path.name != 'STAGE.json': + rows[str(path.relative_to(stage))] = { + 'sha256': digest(path.read_bytes()), + 'mode': path.stat().st_mode & 0o777, + } + return rows + + +def group_rss(group): + total = 0 + for path in Path('/proc').iterdir(): + if not path.name.isdigit(): + continue + try: + raw = (path / 'stat').read_text() + fields = raw[raw.rfind(')') + 2:].split() + if int(fields[2]) == group: + total += int(fields[21]) * os.sysconf('SC_PAGE_SIZE') + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + return total + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('stage') + parser.add_argument('job') + parser.add_argument('label') + args = parser.parse_args() + for value in (args.stage, args.job, args.label): + if not value or any(c not in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_' for c in value): + raise ValueError('Simple immutable stage/job/run names required') + (HERE / 'runtime').mkdir(exist_ok=True) + # A single parent owns this round; never wait behind another scientific run. + with (HERE / 'runtime/science.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + stage = HERE / 'stages' / args.stage + stage_raw = (stage / 'STAGE.json').read_bytes() + declared = json.loads(stage_raw) + before = inventory(stage) + if before != declared['files']: + raise ValueError('Stage bytes/modes differ from declared closure') + jobs = json.loads((stage / 'JOBS.json').read_bytes()) + job = jobs[args.job] + phase_raw = (HERE / 'control/EXECUTION-PHASE.json').read_bytes() + phase = json.loads(phase_raw) + cap = min(TOTAL_CAP, phase['aggregate_cap_seconds']) + if cap not in (600, 1500): + raise ValueError('Unrecognized parent budget phase') + runs = HERE / 'runtime/runs' + runs.mkdir(exist_ok=True) + spent = 0.0 + for run in runs.iterdir(): + if not run.is_dir(): + continue + receipt_path = run / 'receipt.json' + if not receipt_path.exists(): + raise ValueError('Unclosed prior attempt: preserve and reconcile before another run') + spent += json.loads(receipt_path.read_bytes())['wall_seconds'] + if spent >= cap: + raise ValueError('Aggregate budget consumed') + folder = runs / args.label + folder.mkdir() + runner_before = Path(__file__).read_bytes() + if digest(runner_before) != declared['runner_sha256']: + raise ValueError('Actual runner differs from frozen runner source') + fraction_path = Path('/usr/lib/python3.12/fractions.py') + fractions_before = fraction_path.read_bytes() + env = os.environ.copy() + for name in ('PYTHONPATH', 'PYTHONOPTIMIZE', 'PYTHONINSPECT', 'PYTHONSTARTUP', 'PYTHONPYCACHEPREFIX'): + env.pop(name, None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC', PYTHONDONTWRITEBYTECODE='1') + command = ['/usr/bin/python3.12', '-B'] + if job.get('optimized', False): + command.append('-O') + command.extend([str(stage / 'integration/full_driver.py'), + '--output', str(folder / 'science'), + '--lanes', job['lanes']]) + if job.get('finite_only', False): + command.append('--finite-only') + usage = folder / 'usage.json' + timed = ['/usr/bin/time', '-f', '{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', '-o', str(usage), '--', *command] + started = {'command': command, 'stage_sha256': digest(stage_raw), + 'runner_sha256': digest(runner_before), 'fractions_sha256': digest(fractions_before), + 'budget_phase_sha256': digest(phase_raw), 'spent_before_seconds': spent, + 'phase_cap_seconds': cap, 'job': args.job, 'label': args.label} + (folder / 'START.json').write_text(json.dumps(started, indent=2, sort_keys=True) + '\n') + start = time.monotonic() + stop = None + peak = 0 + with (folder / 'stdout.txt').open('wb') as out, (folder / 'stderr.txt').open('wb') as err: + process = subprocess.Popen(timed, cwd=stage, env=env, stdout=out, stderr=err, start_new_session=True) + try: + while process.poll() is None: + peak = max(peak, group_rss(process.pid)) + elapsed = time.monotonic() - start + if peak > RSS_CAP: + stop = 'sampled_group_rss_cap' + elif elapsed > min(TIMEOUT, cap - spent): + stop = 'wall_or_aggregate_cap' + elif max((folder / 'stdout.txt').stat().st_size, (folder / 'stderr.txt').stat().st_size) > OUTPUT_CAP: + stop = 'output_cap' + if stop: + os.killpg(process.pid, signal.SIGKILL) + break + time.sleep(0.05) + code = process.wait() + finally: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + elapsed = time.monotonic() - start + stdout, stderr = (folder / 'stdout.txt').read_bytes(), (folder / 'stderr.txt').read_bytes() + if max(len(stdout), len(stderr)) > OUTPUT_CAP: + stop = stop or 'output_cap' + measurement = None + if usage.exists(): + try: + measurement = json.loads(usage.read_bytes()) + except json.JSONDecodeError: + measurement = {'raw': usage.read_text()} + unchanged = (inventory(stage) == before and (stage / 'STAGE.json').read_bytes() == stage_raw and + Path(__file__).read_bytes() == runner_before and fraction_path.read_bytes() == fractions_before) + receipt = dict(started, exit=code, wall_seconds=elapsed, usage=measurement, + termination=stop, sampled_process_group_rss_bytes=peak, + source_bytes_and_modes_unchanged=unchanged, + stdout_sha256=digest(stdout), stdout_bytes=len(stdout), + stderr_sha256=digest(stderr), stderr_bytes=len(stderr), + python=sys.version, platform=platform.platform(), + status='PASS' if code == 0 and stop is None and not stderr and unchanged else 'STOP') + (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps(receipt, sort_keys=True), flush=True) + if receipt['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-bookkeeping/replay.py b/research/h25-bookkeeping/replay.py new file mode 100644 index 0000000000..84073d30c6 --- /dev/null +++ b/research/h25-bookkeeping/replay.py @@ -0,0 +1,33 @@ +"""One retained B=PR5995-native or C=combined correctness replay; no timing selection.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent +pins = json.loads((ROOT / "CODE-SOURCES.json").read_text())["files"] +for name in ("replay.py", "archive_support.py"): + if sha256((ROOT / name).read_bytes()).hexdigest() != pins[name]: + raise ValueError("Publication bootstrap source pin: " + name) +S = types.ModuleType("_h25_replay_support") +S.__file__ = str(ROOT / "archive_support.py") +exec(compile((ROOT / "archive_support.py").read_bytes(), S.__file__, "exec"), S.__dict__) + + +def run(arm, evidence): + S.need(arm in ("B", "C"), "B=PR5995-native or C=combined required") + return S.run("full-none" if arm == "B" else "full-all", evidence) + + +def main(): + S.need(len(sys.argv) == 3 and sys.argv[1] in ("B", "C"), + "replay.py B|C NEW_EXTERNAL_EVIDENCE_DIRECTORY") + result = run(sys.argv[1], Path(sys.argv[2])) + print(json.dumps({"status": "PASS_H25_FRESH_CORRECTNESS_REPLAY", "evidence": result["evidence"], + "publication": result["publication"], "science": result["scientific"]["science"], + "new_timings_replace_fixed_samples": False}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/verify.py b/research/h25-bookkeeping/verify.py new file mode 100644 index 0000000000..13ec4a8976 --- /dev/null +++ b/research/h25-bookkeeping/verify.py @@ -0,0 +1,34 @@ +"""Complete old/new finite-control union in deliberate normal or -O mode.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent +pins = json.loads((ROOT / "CODE-SOURCES.json").read_text())["files"] +for name in ("verify.py", "archive_support.py"): + if sha256((ROOT / name).read_bytes()).hexdigest() != pins[name]: + raise ValueError("Publication bootstrap source pin: " + name) +S = types.ModuleType("_h25_finite_support") +S.__file__ = str(ROOT / "archive_support.py") +exec(compile((ROOT / "archive_support.py").read_bytes(), S.__file__, "exec"), S.__dict__) + + +def main(): + S.need(len(sys.argv) == 1 and sys.flags.optimize in (0, 1), "Fixed finite union in normal or -O mode") + S.authenticate() + temporary = S.temporary_parent() + try: + result = S.run("finite-O-all" if sys.flags.optimize else "finite-all", temporary / "replay") + S.cleanup_owned(temporary) + except BaseException as error: + error.add_note("Failed finite publication evidence retained at " + str(temporary)) + raise + print(json.dumps({"status": "PASS_H25_COMPLETE_FINITE_UNION", "optimization": sys.flags.optimize, + "publication": result["publication"], "scientific": result["scientific"], + "complete_cli_not_run": True}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bookkeeping/verify_full.py b/research/h25-bookkeeping/verify_full.py new file mode 100644 index 0000000000..056aa9fabf --- /dev/null +++ b/research/h25-bookkeeping/verify_full.py @@ -0,0 +1,34 @@ +"""One complete combined assertion-on correctness replay; no performance-factor claim.""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import types +sys.dont_write_bytecode = True +ROOT = Path(__file__).resolve().parent +pins = json.loads((ROOT / "CODE-SOURCES.json").read_text())["files"] +for name in ("verify_full.py", "archive_support.py"): + if sha256((ROOT / name).read_bytes()).hexdigest() != pins[name]: + raise ValueError("Publication bootstrap source pin: " + name) +S = types.ModuleType("_h25_full_support") +S.__file__ = str(ROOT / "archive_support.py") +exec(compile((ROOT / "archive_support.py").read_bytes(), S.__file__, "exec"), S.__dict__) + + +def main(): + S.need(len(sys.argv) == 1 and sys.flags.optimize == 0, "Fixed combined full caller with original assertions") + S.authenticate() + temporary = S.temporary_parent() + try: + result = S.run("full-all", temporary / "replay") + S.cleanup_owned(temporary) + except BaseException as error: + error.add_note("Failed full publication evidence retained at " + str(temporary)) + raise + print(json.dumps({"status": "PASS_H25_COMBINED_FULL_CORRECTNESS", "publication": result["publication"], + "scientific": result["scientific"], "hosted_performance_factor_claim": False, + "fixed_benchmark_sample": False}, sort_keys=True)) + + +if __name__ == "__main__": + main()