diff --git a/research/verification-key-headroom/CODE-SOURCES.json b/research/verification-key-headroom/CODE-SOURCES.json new file mode 100644 index 0000000000..f4aaacc686 --- /dev/null +++ b/research/verification-key-headroom/CODE-SOURCES.json @@ -0,0 +1,1274 @@ +{ + "authentication_scope": "All new wrappers, unchanged scientific context, DATA/FORMAT/MEASURED metadata, complete committed data and all currently attached historical evidence are hashed before registered execution.", + "excluded_self_and_dynamic_receipts": [ + "CODE-SOURCES.json", + "VALIDATION.json" + ], + "files": { + "FORMAT.json": { + "bytes": 776, + "git_mode": 420, + "sha256": "baf52afe2d0446706cd3c415ad59b603fb1f4f42b7b7d5c518dfe5d9693fda33" + }, + "MEASURED-CONTEXT.json": { + "bytes": 64012, + "git_mode": 420, + "sha256": "c0586ccf6b21ee92015ea7d6a3d88a672f21d556b09332cd6d4502730b074789" + }, + "NOTICE": { + "bytes": 982, + "git_mode": 420, + "sha256": "5745bd98e57fa8bed84dc589cabbe34a23541c88aa6c9877633ee37bc923ad0d" + }, + "README.md": { + "bytes": 10401, + "git_mode": 420, + "sha256": "910241eb8d4968a97f168f4b54832b1dc66e8fa3fb230a5020a823e5455b81b3" + }, + "SOURCES.json": { + "bytes": 3952, + "git_mode": 420, + "sha256": "2806dd664a5af54719fc41f648025e231de5cf917f464393dffe276fdb40e559" + }, + "TASK.json": { + "bytes": 4094, + "git_mode": 420, + "sha256": "29a16369f5762f07e98df4ea91816232545744751610e262453f6528d417eab7" + }, + "VERIFY.json": { + "bytes": 1878, + "git_mode": 420, + "sha256": "1ffed66e98ce509f3b06e07aa6ab5f437ca9a3fea17f29870cf2fbce7b58596f" + }, + "archive_support.py": { + "bytes": 11388, + "git_mode": 420, + "sha256": "5d9db9496e040adac339bcbfdaf97e3561592a6f814b11a455bf700e64406fec" + }, + "context/JOINT-COST-DIAGNOSTIC-RESULT.json": { + "bytes": 70546, + "git_mode": 420, + "sha256": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f" + }, + "context/PLAN.json": { + "bytes": 2692, + "git_mode": 420, + "sha256": "b5bb314d531d91a4cd1e51bad3eafb12bc5b6cb386bb5949b77a2428bc25475f" + }, + "context/baseline-public/.gitignore": { + "bytes": 24, + "git_mode": 420, + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78" + }, + "context/baseline-public/.research-export.json": { + "bytes": 37933, + "git_mode": 420, + "sha256": "bd8d548de371bfce83238f51c8c5487d1e7d57ade1b77a82dd84e2e648ede0b0" + }, + "context/baseline-public/GETTER-SHAPES.json": { + "bytes": 171, + "git_mode": 420, + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4" + }, + "context/baseline-public/NATIVE-SOURCE.json": { + "bytes": 83, + "git_mode": 420, + "sha256": "2bc3043374685ece68f0091238ab038f6cfcd13be80610b5e348d61984cb11f3" + }, + "context/baseline-public/NOTICE": { + "bytes": 1864, + "git_mode": 420, + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83" + }, + "context/baseline-public/PROOF.md": { + "bytes": 7262, + "git_mode": 420, + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b" + }, + "context/baseline-public/README.md": { + "bytes": 8035, + "git_mode": 420, + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95" + }, + "context/baseline-public/RESULT.json": { + "bytes": 5100, + "git_mode": 420, + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188" + }, + "context/baseline-public/SOURCES.json": { + "bytes": 5864, + "git_mode": 420, + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc" + }, + "context/baseline-public/TASK.json": { + "bytes": 3484, + "git_mode": 420, + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c" + }, + "context/baseline-public/VALIDATION.json": { + "bytes": 3832, + "git_mode": 420, + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4" + }, + "context/baseline-public/VERIFY.json": { + "bytes": 1300, + "git_mode": 420, + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53" + }, + "context/baseline-public/actual_audit.py": { + "bytes": 2691, + "git_mode": 420, + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a" + }, + "context/baseline-public/benchmark.py": { + "bytes": 2818, + "git_mode": 420, + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5" + }, + "context/baseline-public/compact_finite.py": { + "bytes": 4892, + "git_mode": 420, + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1" + }, + "context/baseline-public/compact_parent.py": { + "bytes": 5285, + "git_mode": 420, + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a" + }, + "context/baseline-public/custody.py": { + "bytes": 757, + "git_mode": 420, + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f" + }, + "context/baseline-public/entry_finite.py": { + "bytes": 7667, + "git_mode": 420, + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9" + }, + "context/baseline-public/entry_parent.py": { + "bytes": 4334, + "git_mode": 420, + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe" + }, + "context/baseline-public/evidence/FINITE-INERT-GC-FIXTURE.py.txt": { + "bytes": 597, + "git_mode": 420, + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4" + }, + "context/baseline-public/evidence/HARNESS-CORRECTION.json": { + "bytes": 1137, + "git_mode": 420, + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b" + }, + "context/baseline-public/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md": { + "bytes": 11022, + "git_mode": 420, + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767" + }, + "context/baseline-public/evidence/NATIVE-CACHE-REVIEW-SOURCES.json": { + "bytes": 1417, + "git_mode": 420, + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9" + }, + "context/baseline-public/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md": { + "bytes": 6046, + "git_mode": 420, + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448" + }, + "context/baseline-public/evidence/NATIVE-REVIEW-FINAL-STATE.json": { + "bytes": 1241, + "git_mode": 420, + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243" + }, + "context/baseline-public/evidence/PLAN.json": { + "bytes": 1226, + "git_mode": 420, + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434" + }, + "context/baseline-public/evidence/SCREEN.json": { + "bytes": 1234, + "git_mode": 420, + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c" + }, + "context/baseline-public/evidence/SEALED-RESULT.json": { + "bytes": 1241, + "git_mode": 420, + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/SCREEN.json": { + "bytes": 1606, + "git_mode": 420, + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/STATE.json": { + "bytes": 1956, + "git_mode": 420, + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json": { + "bytes": 1010, + "git_mode": 420, + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt": { + "bytes": 1082, + "git_mode": 420, + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26" + }, + "context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json": { + "bytes": 467, + "git_mode": 420, + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/SCREEN.json": { + "bytes": 554, + "git_mode": 420, + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/STATE.json": { + "bytes": 266, + "git_mode": 420, + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json": { + "bytes": 1008, + "git_mode": 420, + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt": { + "bytes": 485, + "git_mode": 420, + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2" + }, + "context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json": { + "bytes": 657, + "git_mode": 420, + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/STATE.json": { + "bytes": 98, + "git_mode": 420, + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json": { + "bytes": 1007, + "git_mode": 420, + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt": { + "bytes": 1092, + "git_mode": 420, + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c" + }, + "context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5" + }, + "context/baseline-public/evidence/portable/runs/complete-native/receipt.json": { + "bytes": 1019, + "git_mode": 420, + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0" + }, + "context/baseline-public/evidence/portable/runs/complete-native/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/portable/runs/complete-native/stdout.txt": { + "bytes": 14301, + "git_mode": 420, + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b" + }, + "context/baseline-public/evidence/portable/runs/complete-native/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10" + }, + "context/baseline-public/evidence/runtime/GATE-2.json": { + "bytes": 363, + "git_mode": 420, + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7" + }, + "context/baseline-public/evidence/runtime/GATE-6.json": { + "bytes": 391, + "git_mode": 420, + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de" + }, + "context/baseline-public/evidence/runtime/benchmark.py": { + "bytes": 2488, + "git_mode": 420, + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa" + }, + "context/baseline-public/evidence/runtime/dispatch.py": { + "bytes": 790, + "git_mode": 420, + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8" + }, + "context/baseline-public/evidence/runtime/guard.py": { + "bytes": 5090, + "git_mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "context/baseline-public/evidence/runtime/runs/B1/receipt.json": { + "bytes": 998, + "git_mode": 420, + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5" + }, + "context/baseline-public/evidence/runtime/runs/B1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/B1/stdout.txt": { + "bytes": 1086, + "git_mode": 420, + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9" + }, + "context/baseline-public/evidence/runtime/runs/B1/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342" + }, + "context/baseline-public/evidence/runtime/runs/B2/receipt.json": { + "bytes": 999, + "git_mode": 420, + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9" + }, + "context/baseline-public/evidence/runtime/runs/B2/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/B2/stdout.txt": { + "bytes": 1086, + "git_mode": 420, + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0" + }, + "context/baseline-public/evidence/runtime/runs/B2/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35" + }, + "context/baseline-public/evidence/runtime/runs/B3/receipt.json": { + "bytes": 997, + "git_mode": 420, + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8" + }, + "context/baseline-public/evidence/runtime/runs/B3/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/B3/stdout.txt": { + "bytes": 1086, + "git_mode": 420, + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2" + }, + "context/baseline-public/evidence/runtime/runs/B3/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c" + }, + "context/baseline-public/evidence/runtime/runs/C1/receipt.json": { + "bytes": 999, + "git_mode": 420, + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba" + }, + "context/baseline-public/evidence/runtime/runs/C1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/C1/stdout.txt": { + "bytes": 14103, + "git_mode": 420, + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f" + }, + "context/baseline-public/evidence/runtime/runs/C1/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0" + }, + "context/baseline-public/evidence/runtime/runs/C2/receipt.json": { + "bytes": 998, + "git_mode": 420, + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579" + }, + "context/baseline-public/evidence/runtime/runs/C2/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/C2/stdout.txt": { + "bytes": 14105, + "git_mode": 420, + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c" + }, + "context/baseline-public/evidence/runtime/runs/C2/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5" + }, + "context/baseline-public/evidence/runtime/runs/C3/receipt.json": { + "bytes": 999, + "git_mode": 420, + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9" + }, + "context/baseline-public/evidence/runtime/runs/C3/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/C3/stdout.txt": { + "bytes": 14101, + "git_mode": 420, + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193" + }, + "context/baseline-public/evidence/runtime/runs/C3/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af" + }, + "context/baseline-public/evidence/runtime/runs/actual-native-apply/receipt.json": { + "bytes": 1021, + "git_mode": 420, + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3" + }, + "context/baseline-public/evidence/runtime/runs/actual-native-apply/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/actual-native-apply/stdout.txt": { + "bytes": 1831, + "git_mode": 420, + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5" + }, + "context/baseline-public/evidence/runtime/runs/actual-native-apply/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746" + }, + "context/baseline-public/evidence/runtime/runs/apply-micro-native/receipt.json": { + "bytes": 1016, + "git_mode": 420, + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a" + }, + "context/baseline-public/evidence/runtime/runs/apply-micro-native/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/apply-micro-native/stdout.txt": { + "bytes": 7524, + "git_mode": 420, + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c" + }, + "context/baseline-public/evidence/runtime/runs/apply-micro-native/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-O/receipt.json": { + "bytes": 1006, + "git_mode": 420, + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-O/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-O/stdout.txt": { + "bytes": 11770, + "git_mode": 420, + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-O/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/receipt.json": { + "bytes": 1020, + "git_mode": 420, + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stdout.txt": { + "bytes": 11834, + "git_mode": 420, + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json": { + "bytes": 1021, + "git_mode": 420, + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt": { + "bytes": 11770, + "git_mode": 420, + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json": { + "bytes": 1021, + "git_mode": 420, + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt": { + "bytes": 11769, + "git_mode": 420, + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug/receipt.json": { + "bytes": 1016, + "git_mode": 420, + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug/stderr.txt": { + "bytes": 185, + "git_mode": 420, + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug/stdout.txt": { + "bytes": 11769, + "git_mode": 420, + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-debug/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-final-debug/receipt.json": { + "bytes": 1020, + "git_mode": 420, + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stdout.txt": { + "bytes": 11835, + "git_mode": 420, + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-final-debug/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-initial/receipt.json": { + "bytes": 1015, + "git_mode": 420, + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-initial/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-initial/stdout.txt": { + "bytes": 11769, + "git_mode": 420, + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-initial/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-packet-O/receipt.json": { + "bytes": 1057, + "git_mode": 420, + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stderr.txt": { + "bytes": 625, + "git_mode": 420, + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stdout.txt": { + "bytes": 7318, + "git_mode": 420, + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-packet-O/usage.json": { + "bytes": 118, + "git_mode": 420, + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/receipt.json": { + "bytes": 1016, + "git_mode": 420, + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt": { + "bytes": 11835, + "git_mode": 420, + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/receipt.json": { + "bytes": 1017, + "git_mode": 420, + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt": { + "bytes": 11948, + "git_mode": 420, + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519" + }, + "context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b" + }, + "context/baseline-public/evidence/runtime/runs/full-native-O/receipt.json": { + "bytes": 1010, + "git_mode": 420, + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448" + }, + "context/baseline-public/evidence/runtime/runs/full-native-O/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/full-native-O/stdout.txt": { + "bytes": 14103, + "git_mode": 420, + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54" + }, + "context/baseline-public/evidence/runtime/runs/full-native-O/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1" + }, + "context/baseline-public/evidence/runtime/runs/micro-native/receipt.json": { + "bytes": 1005, + "git_mode": 420, + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4" + }, + "context/baseline-public/evidence/runtime/runs/micro-native/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/micro-native/stdout.txt": { + "bytes": 1708, + "git_mode": 420, + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9" + }, + "context/baseline-public/evidence/runtime/runs/micro-native/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/receipt.json": { + "bytes": 1018, + "git_mode": 420, + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stdout.txt": { + "bytes": 12183, + "git_mode": 420, + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite/receipt.json": { + "bytes": 1016, + "git_mode": 420, + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite/stdout.txt": { + "bytes": 12183, + "git_mode": 420, + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab" + }, + "context/baseline-public/evidence/runtime/runs/packaged-native-finite/usage.json": { + "bytes": 80, + "git_mode": 420, + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3" + }, + "context/baseline-public/finite.py": { + "bytes": 9441, + "git_mode": 420, + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359" + }, + "context/baseline-public/fraction_table.py": { + "bytes": 6483, + "git_mode": 420, + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4" + }, + "context/baseline-public/frozen.py": { + "bytes": 3197, + "git_mode": 420, + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547" + }, + "context/baseline-public/full.py": { + "bytes": 3061, + "git_mode": 420, + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0" + }, + "context/baseline-public/full_B.py": { + "bytes": 34, + "git_mode": 420, + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a" + }, + "context/baseline-public/full_C.py": { + "bytes": 33, + "git_mode": 420, + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394" + }, + "context/baseline-public/guard.py": { + "bytes": 5090, + "git_mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "context/baseline-public/inputs/PR5848.tar": { + "bytes": 614400, + "git_mode": 420, + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6" + }, + "context/baseline-public/micro.py": { + "bytes": 1205, + "git_mode": 420, + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53" + }, + "context/baseline-public/micro_apply.py": { + "bytes": 1748, + "git_mode": 420, + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e" + }, + "context/baseline-public/native_backend.py": { + "bytes": 2992, + "git_mode": 420, + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d" + }, + "context/baseline-public/native_cache.c": { + "bytes": 13895, + "git_mode": 420, + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" + }, + "context/baseline-public/parent_finite.py": { + "bytes": 10693, + "git_mode": 420, + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f" + }, + "context/baseline-public/replay.py": { + "bytes": 801, + "git_mode": 420, + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9" + }, + "context/baseline-public/replay_driver.py": { + "bytes": 267, + "git_mode": 420, + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528" + }, + "context/baseline-public/slot_binding.py": { + "bytes": 2718, + "git_mode": 420, + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593" + }, + "context/baseline-public/slot_finite.py": { + "bytes": 4804, + "git_mode": 420, + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390" + }, + "context/baseline-public/slot_parent.py": { + "bytes": 4366, + "git_mode": 420, + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24" + }, + "context/baseline-public/table_parent.py": { + "bytes": 5205, + "git_mode": 420, + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4" + }, + "context/baseline-public/verify.py": { + "bytes": 692, + "git_mode": 420, + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82" + }, + "context/cache-key-pilot/keypilot.c": { + "bytes": 10312, + "git_mode": 420, + "sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6" + }, + "context/cache-key-pilot/load_pilot.py": { + "bytes": 3758, + "git_mode": 420, + "sha256": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968" + }, + "context/cache-key-pilot/run_pilot.py": { + "bytes": 17410, + "git_mode": 420, + "sha256": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e" + }, + "context/guard.py": { + "bytes": 5090, + "git_mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "context/run_guarded.py": { + "bytes": 1470, + "git_mode": 420, + "sha256": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "context/stages/actual-key-pilot-v1/FROZEN-SOURCE.json": { + "bytes": 2674, + "git_mode": 420, + "sha256": "04ee8ee199bfddc692232ac97adf457d41c33f22d66c0caddd0afced26b3656a" + }, + "context/stages/actual-key-pilot-v1/PARENT-PLAN.json": { + "bytes": 947, + "git_mode": 420, + "sha256": "1591b634bd6a61271dd9f227d661566d8674e5b4fac567e6e177539926e6b2c0" + }, + "context/stages/actual-key-pilot-v1/PLAN.md": { + "bytes": 5940, + "git_mode": 420, + "sha256": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458" + }, + "context/stages/actual-key-pilot-v1/REPRODUCE.md": { + "bytes": 3332, + "git_mode": 420, + "sha256": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851" + }, + "context/stages/actual-key-pilot-v1/SOURCE-EDITS.json": { + "bytes": 29693, + "git_mode": 420, + "sha256": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a" + }, + "context/stages/actual-key-pilot-v1/actual_driver.py": { + "bytes": 6963, + "git_mode": 420, + "sha256": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2" + }, + "context/stages/actual-key-pilot-v1/baseline-public/NATIVE-SOURCE.json": { + "bytes": 83, + "git_mode": 420, + "sha256": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26" + }, + "context/stages/actual-key-pilot-v1/baseline-public/native_cache.c": { + "bytes": 15892, + "git_mode": 420, + "sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" + }, + "context/stages/actual-key-pilot-v1/capture.inc": { + "bytes": 1911, + "git_mode": 420, + "sha256": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8" + }, + "context/stages/actual-key-pilot-v1/capture_actual.py": { + "bytes": 7577, + "git_mode": 420, + "sha256": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56" + }, + "context/stages/actual-key-pilot-v1/keypilot.c": { + "bytes": 10312, + "git_mode": 420, + "sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6" + }, + "context/stages/actual-key-pilot-v1/load_pilot.py": { + "bytes": 3758, + "git_mode": 420, + "sha256": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968" + }, + "context/stages/actual-key-pilot-v1/prepare_source.py": { + "bytes": 3822, + "git_mode": 420, + "sha256": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c" + }, + "context/stages/actual-key-pilot-v1/run_pilot.py": { + "bytes": 17410, + "git_mode": 420, + "sha256": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e" + }, + "context/stages/actual-key-pilot-v1/stage_entry.py": { + "bytes": 383, + "git_mode": 420, + "sha256": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + }, + "data/DATA.json": { + "bytes": 4441, + "git_mode": 420, + "sha256": "38e64373293c9d2b2feb315353e305e5f657499ce1d2b0b4ce09d357e62fab9f" + }, + "data/actual-keys-v1.pickle.gz": { + "bytes": 7945691, + "git_mode": 420, + "sha256": "660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699" + }, + "data/canonical-flags.u8.gz": { + "bytes": 142123, + "git_mode": 420, + "sha256": "8acb6dd4d577dcb964ee1ef027eab9f0c91b811ad445bd93f8e1804a8d447001" + }, + "data/canonical-ids.u64.gz": { + "bytes": 2980010, + "git_mode": 420, + "sha256": "51753090e6ae4b02651590963341dc30e2424a00b49adb88ba65b05e03901fc5" + }, + "data/canonical-prefixes.json.gz": { + "bytes": 315973, + "git_mode": 420, + "sha256": "0960e36d7c43f9b37dc1550778ff60a55de02d7ab8a83c1f4c7cdd691ffec3b8" + }, + "evidence/ACTUAL-KEY-PARENT-SOURCE-CHECK.json": { + "bytes": 564, + "git_mode": 420, + "sha256": "ba0a8faa3869e3905d02b64fc0d7a1fa0a2f830d5c4862447a8cc3d9a81a00f0" + }, + "evidence/ACTUAL-KEY-PILOT-REVIEW.md": { + "bytes": 17267, + "git_mode": 420, + "sha256": "d07e34bc2e6ef34b269233dbde911a436030e0e9e7138addb328ef1c598b019a" + }, + "evidence/ADJACENT-PRECEDENTS.json": { + "bytes": 778, + "git_mode": 420, + "sha256": "1ff123dc87e147352c7e78e425205ae0e40d40e594d37a24b2a78f57b7178ace" + }, + "evidence/ARCHIVE-MAP.json": { + "bytes": 12308, + "git_mode": 420, + "sha256": "191841073899372bbd05fc29cfb3d6f503fa53734e512f4e31a680aefd26f06e" + }, + "evidence/CACHE-KEY-PILOT-REVIEW.md": { + "bytes": 14874, + "git_mode": 420, + "sha256": "61e672e788a2bec260c64e7d1427f653b150b49e3ce2c02300336562bdde28f1" + }, + "evidence/HEADROOM-CONTEXT-EARLY-REVIEW.json": { + "bytes": 279, + "git_mode": 420, + "sha256": "720979ea677c38e41edf7ceb76b2d653ca57c07dbb0c1454ce1d9de720b6af98" + }, + "evidence/HEADROOM-INPUT-COMMIT.json": { + "bytes": 712, + "git_mode": 420, + "sha256": "d0354398ca9dd5d5c0d5e93c8e13c1dc2522a2cf41fae333a30bac63783949c0" + }, + "evidence/JOINT-CACHE-INTEGER-PLAN.md": { + "bytes": 17237, + "git_mode": 420, + "sha256": "2ab423b3b2afc628d6505d71d777febd8160eda72327b7f2e080afa2947092e0" + }, + "evidence/JOINT-DIAGNOSTIC-REVIEW.md": { + "bytes": 8059, + "git_mode": 420, + "sha256": "6374ac5865a7fc12000a264e632181a49a0f70d1ab20e222537aa77322d77bab" + }, + "evidence/JOINT-PARENT-SOURCE-CHECK.json": { + "bytes": 681, + "git_mode": 420, + "sha256": "f4f802bb2ff778760db77b8715b5fba4349517830ba58acabb1e0f08af4131e0" + }, + "evidence/ORIGINAL-OUTPUTS.json": { + "bytes": 3110, + "git_mode": 420, + "sha256": "87c796cd716301c57d20c1736d22bae56f9cfda01ebfc50005ce39f6e2c093d2" + }, + "evidence/POST-ASSESSMENT-GC-RESULT.json": { + "bytes": 1266, + "git_mode": 420, + "sha256": "caace396f7de2379905500e2da1696de5b08970214e3418708037070cb0434bf" + }, + "evidence/REMAINING-ROUTE-REASSESSMENT.md": { + "bytes": 18968, + "git_mode": 420, + "sha256": "caddd8fb6c8128ac907a668b491c9aab981362d9f1b66377084271e10f8f1289" + }, + "evidence/actual/CAPTURE-RECEIPT.json": { + "bytes": 2452, + "git_mode": 420, + "sha256": "065d0088fbbc633f19e7881171123fae30b4495e2f6bc5eedcfb1c722bc48c29" + }, + "evidence/actual/FULL-QUALIFIER.stdout.txt": { + "bytes": 14102, + "git_mode": 420, + "sha256": "0f94a000fa740ec7095b98383c8d954dc4a6ebeb66c3991f5bab9989a43bd703" + }, + "evidence/actual/RESULT.json": { + "bytes": 16149, + "git_mode": 420, + "sha256": "3e7768a75f7eee36a10303fd8fdfa26b7b1c03a2777cf19ded1e70c456a454a7" + }, + "evidence/actual/RESULTS.md": { + "bytes": 5608, + "git_mode": 420, + "sha256": "e9884794d7fe0887ab13fc85861f333cab9414ce4367ffe60002a0bee5529e1b" + }, + "evidence/actual/key-build/BUILD.json": { + "bytes": 3935, + "git_mode": 420, + "sha256": "c797ce0f665e17120a80b0835df43093e82dd973edf803bd19de1daca092a3e4" + }, + "evidence/actual/key-build/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/actual/key-build/stdout.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/actual-key-pilot-v1/receipt.json": { + "bytes": 1047, + "git_mode": 420, + "sha256": "d23967e470c1522cb4e6877eca91c1a9441cec83c33c48f1d6b67d4278b96398" + }, + "evidence/runs/actual-key-pilot-v1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/actual-key-pilot-v1/stdout.txt": { + "bytes": 295, + "git_mode": 420, + "sha256": "308ffe27bf48a493ab1f50a35f34961230b773a2c31fa859578dcf23b9b489d3" + }, + "evidence/runs/actual-key-pilot-v1/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "86ce16ddc6a814f3bfb5e78f1fcab5219c29da1d1bbc27bc63eab390b18fa6a0" + }, + "evidence/runs/cache-key-pilot-v1/receipt.json": { + "bytes": 1041, + "git_mode": 420, + "sha256": "77db0c4b14458e42d07c0a2e804708a0c7485d667a7a52807513bb4d8bb6824e" + }, + "evidence/runs/cache-key-pilot-v1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/cache-key-pilot-v1/stdout.txt": { + "bytes": 282, + "git_mode": 420, + "sha256": "df207bff8a8705ebfcffb38e29cb75f92723fd3513872430721555a8a8a5a541" + }, + "evidence/runs/cache-key-pilot-v1/usage.json": { + "bytes": 81, + "git_mode": 420, + "sha256": "628bc46e484b2a7298826e9e1b53a58a06f6af3f71dffb0e5fadd6050dcd338a" + }, + "evidence/runs/gc-attribution-v1/receipt.json": { + "bytes": 1044, + "git_mode": 420, + "sha256": "6f0353fd85ba9e6fcc46cf42bf681cb865a8738efff18dfa858dde32648ed74e" + }, + "evidence/runs/gc-attribution-v1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/gc-attribution-v1/stdout.txt": { + "bytes": 16524, + "git_mode": 420, + "sha256": "c9b2b773719e034fb6cf08b4e02045765ea884e0d83683a3ce1e05d03882d9e1" + }, + "evidence/runs/gc-attribution-v1/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "a2aa4df97d4df37bcb2f2c0482918a8569dd6a25f260e2e499a16192791fee3f" + }, + "evidence/runs/joint-cost-screen-v1/receipt.json": { + "bytes": 1048, + "git_mode": 420, + "sha256": "db20985314263b71b5909fc33debedad9f22352292522a964ba6fb35708b5e6b" + }, + "evidence/runs/joint-cost-screen-v1/stderr.txt": { + "bytes": 0, + "git_mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runs/joint-cost-screen-v1/stdout.txt": { + "bytes": 63282, + "git_mode": 420, + "sha256": "e369ccaf1f73fc1842b752d9caf57d871b5e2553f11115ba252dff1d5ffebcd6" + }, + "evidence/runs/joint-cost-screen-v1/usage.json": { + "bytes": 82, + "git_mode": 420, + "sha256": "0c52220df26c509401b4b659e93537935ce613e92378eae0554609be8a418051" + }, + "evidence/source/cache-key-pilot-v1/FROZEN-SOURCE.json": { + "bytes": 1783, + "git_mode": 420, + "sha256": "b8f843524f62ed239927db894c4699b3d945900cd9681b78f6d32dfa06e1f3de" + }, + "evidence/source/cache-key-pilot-v1/PARENT-PLAN.json": { + "bytes": 1005, + "git_mode": 420, + "sha256": "7d7af10fea01ddf6e9fe9fba9b91991d65537e2dd9a2f0eb1a36b6660b66efcb" + }, + "evidence/source/cache-key-pilot-v1/PLAN.md": { + "bytes": 5227, + "git_mode": 420, + "sha256": "18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5" + }, + "evidence/source/cache-key-pilot-v1/REPRODUCE.md": { + "bytes": 3288, + "git_mode": 420, + "sha256": "167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941" + }, + "evidence/source/cache-key-pilot-v1/stage_entry.py": { + "bytes": 403, + "git_mode": 420, + "sha256": "3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9" + }, + "evidence/source/gc-attribution-v1/PLAN.json": { + "bytes": 1629, + "git_mode": 420, + "sha256": "d4a81fb820ea7cc6d363da651afd389e0570161eecce0982f97cc2672a15ad65" + }, + "evidence/source/gc-attribution-v1/diagnostic.py": { + "bytes": 5829, + "git_mode": 420, + "sha256": "fb4aa2c876e25119017c31507dd373bb0ba857e3d2de81a090d24b1440086383" + }, + "evidence/source/joint-cost-screen-v1/PLAN.json": { + "bytes": 2416, + "git_mode": 420, + "sha256": "e72e95207e1f191f0e83bcbe1cac665d45c353737c08624fdcaca7c9a8b8c548" + }, + "evidence/source/joint-cost-screen-v1/SOURCE-EDITS.json": { + "bytes": 39843, + "git_mode": 420, + "sha256": "91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8" + }, + "evidence/source/joint-cost-screen-v1/contribution_diagnostic.c": { + "bytes": 3211, + "git_mode": 420, + "sha256": "2e62c74ae8121d806caa7f3d79ab29b8b9390ba2c06896a539ce1213932e38cd" + }, + "evidence/source/joint-cost-screen-v1/diagnostic.py": { + "bytes": 15103, + "git_mode": 420, + "sha256": "fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee" + }, + "evidence/source/joint-cost-screen-v1/joint_diag.inc": { + "bytes": 6172, + "git_mode": 420, + "sha256": "91e0e716c7ea9ca532991277ddf2535dfb34d00d4a25212ffe192927f6f6ae35" + }, + "evidence/source/joint-cost-screen-v1/prepare_source.py": { + "bytes": 5329, + "git_mode": 420, + "sha256": "92e8ae1370f47c2cf2659a738f3bd561299755c3347be5aa9256fd17a994dd13" + }, + "evidence/synthetic/RESULT.json": { + "bytes": 11178, + "git_mode": 420, + "sha256": "17d20360c792a6917f77f1d5c50ffa773b9f290200dd540ce5c79d6178521078" + }, + "evidence/synthetic/RESULTS.md": { + "bytes": 4473, + "git_mode": 420, + "sha256": "cdfc77cd7ccc623549f23c1ca887bc897fff45c4a859c995e3b9b127f4b33088" + }, + "replay_capture.py": { + "bytes": 3901, + "git_mode": 420, + "sha256": "226aa76079545339cdc72ac65483628db8e7a42a071bbae21bf17baad5fc9126" + }, + "verify.py": { + "bytes": 6116, + "git_mode": 420, + "sha256": "e6218ee4d0dc1154c5d6cc90a20405dbbf0d753ba39ddffeeb29b4f9fda0b39e" + } + }, + "historical_source_modes": "MEASURED-CONTEXT.json", + "mode_scope": "Git executable-bit semantics for published inputs; exact original 164/177 file modes restored and checked only in external reconstruction.", + "mutable_validation_receipt": "VALIDATION.json", + "no_scientific_execution_by_package_author": true, + "schema_version": 1 +} diff --git a/research/verification-key-headroom/FORMAT.json b/research/verification-key-headroom/FORMAT.json new file mode 100644 index 0000000000..9805f818cb --- /dev/null +++ b/research/verification-key-headroom/FORMAT.json @@ -0,0 +1,35 @@ +{ + "corpus": { + "block_keys": 4096, + "cross_block_identity_preserved": false, + "format": "actual-keys-v1", + "key_fields": 7, + "pickle_protocol": 5 + }, + "flags": { + "item_bytes": 1, + "values": { + "0": "hit", + "1": "miss", + "3": "miss plus FIFO eviction" + } + }, + "ids": { + "byteorder": "little", + "item_bytes": 8, + "type": "unsigned 64-bit integer" + }, + "mathematical_equality": "all decompressed key values/order and every canonical output item; regenerated compression bytes are not a mathematical identity gate", + "prefixes": { + "every_calls": 80, + "fields": [ + "calls", + "hits", + "misses", + "evictions", + "resident" + ], + "final_partial_included": true + }, + "schema_version": 1 +} diff --git a/research/verification-key-headroom/MEASURED-CONTEXT.json b/research/verification-key-headroom/MEASURED-CONTEXT.json new file mode 100644 index 0000000000..94b9093f41 --- /dev/null +++ b/research/verification-key-headroom/MEASURED-CONTEXT.json @@ -0,0 +1,1720 @@ +{ + "baseline_count": 164, + "baseline_overlay": [ + "native_cache.c", + "NATIVE-SOURCE.json" + ], + "measured_stage_files": { + "FROZEN-SOURCE.json": { + "bytes": 2674, + "mode": 436, + "sha256": "04ee8ee199bfddc692232ac97adf457d41c33f22d66c0caddd0afced26b3656a" + }, + "PARENT-PLAN.json": { + "bytes": 947, + "mode": 436, + "sha256": "1591b634bd6a61271dd9f227d661566d8674e5b4fac567e6e177539926e6b2c0" + }, + "PLAN.md": { + "bytes": 5940, + "mode": 436, + "sha256": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458" + }, + "REPRODUCE.md": { + "bytes": 3332, + "mode": 436, + "sha256": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851" + }, + "SOURCE-EDITS.json": { + "bytes": 29693, + "mode": 436, + "sha256": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a" + }, + "actual_driver.py": { + "bytes": 6963, + "mode": 436, + "sha256": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2" + }, + "baseline-public/.gitignore": { + "bytes": 24, + "mode": 420, + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78" + }, + "baseline-public/.research-export.json": { + "bytes": 37933, + "mode": 420, + "sha256": "bd8d548de371bfce83238f51c8c5487d1e7d57ade1b77a82dd84e2e648ede0b0" + }, + "baseline-public/GETTER-SHAPES.json": { + "bytes": 171, + "mode": 420, + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4" + }, + "baseline-public/NATIVE-SOURCE.json": { + "bytes": 83, + "mode": 420, + "sha256": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26" + }, + "baseline-public/NOTICE": { + "bytes": 1864, + "mode": 420, + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83" + }, + "baseline-public/PROOF.md": { + "bytes": 7262, + "mode": 420, + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b" + }, + "baseline-public/README.md": { + "bytes": 8035, + "mode": 420, + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95" + }, + "baseline-public/RESULT.json": { + "bytes": 5100, + "mode": 420, + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188" + }, + "baseline-public/SOURCES.json": { + "bytes": 5864, + "mode": 420, + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc" + }, + "baseline-public/TASK.json": { + "bytes": 3484, + "mode": 420, + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c" + }, + "baseline-public/VALIDATION.json": { + "bytes": 3832, + "mode": 420, + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4" + }, + "baseline-public/VERIFY.json": { + "bytes": 1300, + "mode": 420, + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53" + }, + "baseline-public/actual_audit.py": { + "bytes": 2691, + "mode": 420, + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a" + }, + "baseline-public/benchmark.py": { + "bytes": 2818, + "mode": 420, + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5" + }, + "baseline-public/compact_finite.py": { + "bytes": 4892, + "mode": 420, + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1" + }, + "baseline-public/compact_parent.py": { + "bytes": 5285, + "mode": 420, + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a" + }, + "baseline-public/custody.py": { + "bytes": 757, + "mode": 420, + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f" + }, + "baseline-public/entry_finite.py": { + "bytes": 7667, + "mode": 420, + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9" + }, + "baseline-public/entry_parent.py": { + "bytes": 4334, + "mode": 420, + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe" + }, + "baseline-public/evidence/FINITE-INERT-GC-FIXTURE.py.txt": { + "bytes": 597, + "mode": 420, + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4" + }, + "baseline-public/evidence/HARNESS-CORRECTION.json": { + "bytes": 1137, + "mode": 420, + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b" + }, + "baseline-public/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md": { + "bytes": 11022, + "mode": 420, + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767" + }, + "baseline-public/evidence/NATIVE-CACHE-REVIEW-SOURCES.json": { + "bytes": 1417, + "mode": 420, + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9" + }, + "baseline-public/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md": { + "bytes": 6046, + "mode": 420, + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448" + }, + "baseline-public/evidence/NATIVE-REVIEW-FINAL-STATE.json": { + "bytes": 1241, + "mode": 420, + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243" + }, + "baseline-public/evidence/PLAN.json": { + "bytes": 1226, + "mode": 420, + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434" + }, + "baseline-public/evidence/SCREEN.json": { + "bytes": 1234, + "mode": 420, + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c" + }, + "baseline-public/evidence/SEALED-RESULT.json": { + "bytes": 1241, + "mode": 420, + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f" + }, + "baseline-public/evidence/fraction-compact-key-20261027/SCREEN.json": { + "bytes": 1606, + "mode": 420, + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83" + }, + "baseline-public/evidence/fraction-compact-key-20261027/STATE.json": { + "bytes": 1956, + "mode": 420, + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a" + }, + "baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json": { + "bytes": 1010, + "mode": 420, + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a" + }, + "baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt": { + "bytes": 1082, + "mode": 420, + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26" + }, + "baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe" + }, + "baseline-public/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json": { + "bytes": 467, + "mode": 420, + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93" + }, + "baseline-public/evidence/fraction-direct-add-20261027/SCREEN.json": { + "bytes": 554, + "mode": 420, + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834" + }, + "baseline-public/evidence/fraction-direct-add-20261027/STATE.json": { + "bytes": 266, + "mode": 420, + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17" + }, + "baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json": { + "bytes": 1008, + "mode": 420, + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5" + }, + "baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt": { + "bytes": 485, + "mode": 420, + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2" + }, + "baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e" + }, + "baseline-public/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json": { + "bytes": 657, + "mode": 420, + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d" + }, + "baseline-public/evidence/fraction-slot-key-20261027/STATE.json": { + "bytes": 98, + "mode": 420, + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20" + }, + "baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json": { + "bytes": 1007, + "mode": 420, + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875" + }, + "baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt": { + "bytes": 1092, + "mode": 420, + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c" + }, + "baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5" + }, + "baseline-public/evidence/portable/runs/complete-native/receipt.json": { + "bytes": 1019, + "mode": 420, + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0" + }, + "baseline-public/evidence/portable/runs/complete-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/portable/runs/complete-native/stdout.txt": { + "bytes": 14301, + "mode": 420, + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b" + }, + "baseline-public/evidence/portable/runs/complete-native/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10" + }, + "baseline-public/evidence/runtime/GATE-2.json": { + "bytes": 363, + "mode": 420, + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7" + }, + "baseline-public/evidence/runtime/GATE-6.json": { + "bytes": 391, + "mode": 420, + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de" + }, + "baseline-public/evidence/runtime/benchmark.py": { + "bytes": 2488, + "mode": 420, + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa" + }, + "baseline-public/evidence/runtime/dispatch.py": { + "bytes": 790, + "mode": 420, + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8" + }, + "baseline-public/evidence/runtime/guard.py": { + "bytes": 5090, + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline-public/evidence/runtime/runs/B1/receipt.json": { + "bytes": 998, + "mode": 420, + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5" + }, + "baseline-public/evidence/runtime/runs/B1/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/B1/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9" + }, + "baseline-public/evidence/runtime/runs/B1/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342" + }, + "baseline-public/evidence/runtime/runs/B2/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9" + }, + "baseline-public/evidence/runtime/runs/B2/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/B2/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0" + }, + "baseline-public/evidence/runtime/runs/B2/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35" + }, + "baseline-public/evidence/runtime/runs/B3/receipt.json": { + "bytes": 997, + "mode": 420, + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8" + }, + "baseline-public/evidence/runtime/runs/B3/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/B3/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2" + }, + "baseline-public/evidence/runtime/runs/B3/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c" + }, + "baseline-public/evidence/runtime/runs/C1/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba" + }, + "baseline-public/evidence/runtime/runs/C1/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/C1/stdout.txt": { + "bytes": 14103, + "mode": 420, + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f" + }, + "baseline-public/evidence/runtime/runs/C1/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0" + }, + "baseline-public/evidence/runtime/runs/C2/receipt.json": { + "bytes": 998, + "mode": 420, + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579" + }, + "baseline-public/evidence/runtime/runs/C2/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/C2/stdout.txt": { + "bytes": 14105, + "mode": 420, + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c" + }, + "baseline-public/evidence/runtime/runs/C2/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5" + }, + "baseline-public/evidence/runtime/runs/C3/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9" + }, + "baseline-public/evidence/runtime/runs/C3/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/C3/stdout.txt": { + "bytes": 14101, + "mode": 420, + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193" + }, + "baseline-public/evidence/runtime/runs/C3/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af" + }, + "baseline-public/evidence/runtime/runs/actual-native-apply/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3" + }, + "baseline-public/evidence/runtime/runs/actual-native-apply/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/actual-native-apply/stdout.txt": { + "bytes": 1831, + "mode": 420, + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5" + }, + "baseline-public/evidence/runtime/runs/actual-native-apply/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746" + }, + "baseline-public/evidence/runtime/runs/apply-micro-native/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a" + }, + "baseline-public/evidence/runtime/runs/apply-micro-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/apply-micro-native/stdout.txt": { + "bytes": 7524, + "mode": 420, + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c" + }, + "baseline-public/evidence/runtime/runs/apply-micro-native/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea" + }, + "baseline-public/evidence/runtime/runs/finite-native-O/receipt.json": { + "bytes": 1006, + "mode": 420, + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410" + }, + "baseline-public/evidence/runtime/runs/finite-native-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-O/stdout.txt": { + "bytes": 11770, + "mode": 420, + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18" + }, + "baseline-public/evidence/runtime/runs/finite-native-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5" + }, + "baseline-public/evidence/runtime/runs/finite-native-bound-debug/receipt.json": { + "bytes": 1020, + "mode": 420, + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432" + }, + "baseline-public/evidence/runtime/runs/finite-native-bound-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-bound-debug/stdout.txt": { + "bytes": 11834, + "mode": 420, + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87" + }, + "baseline-public/evidence/runtime/runs/finite-native-bound-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6" + }, + "baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c" + }, + "baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt": { + "bytes": 11770, + "mode": 420, + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1" + }, + "baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug/stderr.txt": { + "bytes": 185, + "mode": 420, + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1" + }, + "baseline-public/evidence/runtime/runs/finite-native-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407" + }, + "baseline-public/evidence/runtime/runs/finite-native-final-debug/receipt.json": { + "bytes": 1020, + "mode": 420, + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a" + }, + "baseline-public/evidence/runtime/runs/finite-native-final-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-final-debug/stdout.txt": { + "bytes": 11835, + "mode": 420, + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6" + }, + "baseline-public/evidence/runtime/runs/finite-native-final-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32" + }, + "baseline-public/evidence/runtime/runs/finite-native-initial/receipt.json": { + "bytes": 1015, + "mode": 420, + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972" + }, + "baseline-public/evidence/runtime/runs/finite-native-initial/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-initial/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b" + }, + "baseline-public/evidence/runtime/runs/finite-native-initial/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3" + }, + "baseline-public/evidence/runtime/runs/finite-native-packet-O/receipt.json": { + "bytes": 1057, + "mode": 420, + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e" + }, + "baseline-public/evidence/runtime/runs/finite-native-packet-O/stderr.txt": { + "bytes": 625, + "mode": 420, + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8" + }, + "baseline-public/evidence/runtime/runs/finite-native-packet-O/stdout.txt": { + "bytes": 7318, + "mode": 420, + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb" + }, + "baseline-public/evidence/runtime/runs/finite-native-packet-O/usage.json": { + "bytes": 118, + "mode": 420, + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675" + }, + "baseline-public/evidence/runtime/runs/finite-native-reviewed-O/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a" + }, + "baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt": { + "bytes": 11835, + "mode": 420, + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36" + }, + "baseline-public/evidence/runtime/runs/finite-native-reviewed-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998" + }, + "baseline-public/evidence/runtime/runs/finite-native-snapshot-O/receipt.json": { + "bytes": 1017, + "mode": 420, + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de" + }, + "baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt": { + "bytes": 11948, + "mode": 420, + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519" + }, + "baseline-public/evidence/runtime/runs/finite-native-snapshot-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b" + }, + "baseline-public/evidence/runtime/runs/full-native-O/receipt.json": { + "bytes": 1010, + "mode": 420, + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448" + }, + "baseline-public/evidence/runtime/runs/full-native-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/full-native-O/stdout.txt": { + "bytes": 14103, + "mode": 420, + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54" + }, + "baseline-public/evidence/runtime/runs/full-native-O/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1" + }, + "baseline-public/evidence/runtime/runs/micro-native/receipt.json": { + "bytes": 1005, + "mode": 420, + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4" + }, + "baseline-public/evidence/runtime/runs/micro-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/micro-native/stdout.txt": { + "bytes": 1708, + "mode": 420, + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9" + }, + "baseline-public/evidence/runtime/runs/micro-native/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite-O/receipt.json": { + "bytes": 1018, + "mode": 420, + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite-O/stdout.txt": { + "bytes": 12183, + "mode": 420, + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite/stdout.txt": { + "bytes": 12183, + "mode": 420, + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab" + }, + "baseline-public/evidence/runtime/runs/packaged-native-finite/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3" + }, + "baseline-public/finite.py": { + "bytes": 9441, + "mode": 420, + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359" + }, + "baseline-public/fraction_table.py": { + "bytes": 6483, + "mode": 420, + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4" + }, + "baseline-public/frozen.py": { + "bytes": 3197, + "mode": 420, + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547" + }, + "baseline-public/full.py": { + "bytes": 3061, + "mode": 420, + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0" + }, + "baseline-public/full_B.py": { + "bytes": 34, + "mode": 420, + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a" + }, + "baseline-public/full_C.py": { + "bytes": 33, + "mode": 420, + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394" + }, + "baseline-public/guard.py": { + "bytes": 5090, + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "baseline-public/inputs/PR5848.tar": { + "bytes": 614400, + "mode": 420, + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6" + }, + "baseline-public/micro.py": { + "bytes": 1205, + "mode": 420, + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53" + }, + "baseline-public/micro_apply.py": { + "bytes": 1748, + "mode": 420, + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e" + }, + "baseline-public/native_backend.py": { + "bytes": 2992, + "mode": 420, + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d" + }, + "baseline-public/native_cache.c": { + "bytes": 15892, + "mode": 420, + "sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" + }, + "baseline-public/parent_finite.py": { + "bytes": 10693, + "mode": 420, + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f" + }, + "baseline-public/replay.py": { + "bytes": 801, + "mode": 420, + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9" + }, + "baseline-public/replay_driver.py": { + "bytes": 267, + "mode": 420, + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528" + }, + "baseline-public/slot_binding.py": { + "bytes": 2718, + "mode": 420, + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593" + }, + "baseline-public/slot_finite.py": { + "bytes": 4804, + "mode": 420, + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390" + }, + "baseline-public/slot_parent.py": { + "bytes": 4366, + "mode": 420, + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24" + }, + "baseline-public/table_parent.py": { + "bytes": 5205, + "mode": 420, + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4" + }, + "baseline-public/verify.py": { + "bytes": 692, + "mode": 420, + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82" + }, + "capture.inc": { + "bytes": 1911, + "mode": 436, + "sha256": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8" + }, + "capture_actual.py": { + "bytes": 7577, + "mode": 436, + "sha256": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56" + }, + "keypilot.c": { + "bytes": 10312, + "mode": 436, + "sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6" + }, + "load_pilot.py": { + "bytes": 3758, + "mode": 436, + "sha256": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968" + }, + "prepare_source.py": { + "bytes": 3822, + "mode": 436, + "sha256": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c" + }, + "run_pilot.py": { + "bytes": 17410, + "mode": 436, + "sha256": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e" + }, + "stage_entry.py": { + "bytes": 383, + "mode": 436, + "sha256": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + } + }, + "original_baseline_files": { + ".gitignore": { + "bytes": 24, + "mode": 420, + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78" + }, + ".research-export.json": { + "bytes": 37933, + "mode": 420, + "sha256": "bd8d548de371bfce83238f51c8c5487d1e7d57ade1b77a82dd84e2e648ede0b0" + }, + "GETTER-SHAPES.json": { + "bytes": 171, + "mode": 420, + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4" + }, + "NATIVE-SOURCE.json": { + "bytes": 83, + "mode": 420, + "sha256": "2bc3043374685ece68f0091238ab038f6cfcd13be80610b5e348d61984cb11f3" + }, + "NOTICE": { + "bytes": 1864, + "mode": 420, + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83" + }, + "PROOF.md": { + "bytes": 7262, + "mode": 420, + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b" + }, + "README.md": { + "bytes": 8035, + "mode": 420, + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95" + }, + "RESULT.json": { + "bytes": 5100, + "mode": 420, + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188" + }, + "SOURCES.json": { + "bytes": 5864, + "mode": 420, + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc" + }, + "TASK.json": { + "bytes": 3484, + "mode": 420, + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c" + }, + "VALIDATION.json": { + "bytes": 3832, + "mode": 420, + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4" + }, + "VERIFY.json": { + "bytes": 1300, + "mode": 420, + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53" + }, + "actual_audit.py": { + "bytes": 2691, + "mode": 420, + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a" + }, + "benchmark.py": { + "bytes": 2818, + "mode": 420, + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5" + }, + "compact_finite.py": { + "bytes": 4892, + "mode": 420, + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1" + }, + "compact_parent.py": { + "bytes": 5285, + "mode": 420, + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a" + }, + "custody.py": { + "bytes": 757, + "mode": 420, + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f" + }, + "entry_finite.py": { + "bytes": 7667, + "mode": 420, + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9" + }, + "entry_parent.py": { + "bytes": 4334, + "mode": 420, + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe" + }, + "evidence/FINITE-INERT-GC-FIXTURE.py.txt": { + "bytes": 597, + "mode": 420, + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4" + }, + "evidence/HARNESS-CORRECTION.json": { + "bytes": 1137, + "mode": 420, + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b" + }, + "evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md": { + "bytes": 11022, + "mode": 420, + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767" + }, + "evidence/NATIVE-CACHE-REVIEW-SOURCES.json": { + "bytes": 1417, + "mode": 420, + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9" + }, + "evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md": { + "bytes": 6046, + "mode": 420, + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448" + }, + "evidence/NATIVE-REVIEW-FINAL-STATE.json": { + "bytes": 1241, + "mode": 420, + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243" + }, + "evidence/PLAN.json": { + "bytes": 1226, + "mode": 420, + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434" + }, + "evidence/SCREEN.json": { + "bytes": 1234, + "mode": 420, + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c" + }, + "evidence/SEALED-RESULT.json": { + "bytes": 1241, + "mode": 420, + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f" + }, + "evidence/fraction-compact-key-20261027/SCREEN.json": { + "bytes": 1606, + "mode": 420, + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83" + }, + "evidence/fraction-compact-key-20261027/STATE.json": { + "bytes": 1956, + "mode": 420, + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json": { + "bytes": 1010, + "mode": 420, + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt": { + "bytes": 1082, + "mode": 420, + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe" + }, + "evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json": { + "bytes": 467, + "mode": 420, + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93" + }, + "evidence/fraction-direct-add-20261027/SCREEN.json": { + "bytes": 554, + "mode": 420, + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834" + }, + "evidence/fraction-direct-add-20261027/STATE.json": { + "bytes": 266, + "mode": 420, + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json": { + "bytes": 1008, + "mode": 420, + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt": { + "bytes": 485, + "mode": 420, + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e" + }, + "evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json": { + "bytes": 657, + "mode": 420, + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d" + }, + "evidence/fraction-slot-key-20261027/STATE.json": { + "bytes": 98, + "mode": 420, + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json": { + "bytes": 1007, + "mode": 420, + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt": { + "bytes": 1092, + "mode": 420, + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5" + }, + "evidence/portable/runs/complete-native/receipt.json": { + "bytes": 1019, + "mode": 420, + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0" + }, + "evidence/portable/runs/complete-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/portable/runs/complete-native/stdout.txt": { + "bytes": 14301, + "mode": 420, + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b" + }, + "evidence/portable/runs/complete-native/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10" + }, + "evidence/runtime/GATE-2.json": { + "bytes": 363, + "mode": 420, + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7" + }, + "evidence/runtime/GATE-6.json": { + "bytes": 391, + "mode": 420, + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de" + }, + "evidence/runtime/benchmark.py": { + "bytes": 2488, + "mode": 420, + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa" + }, + "evidence/runtime/dispatch.py": { + "bytes": 790, + "mode": 420, + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8" + }, + "evidence/runtime/guard.py": { + "bytes": 5090, + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "evidence/runtime/runs/B1/receipt.json": { + "bytes": 998, + "mode": 420, + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5" + }, + "evidence/runtime/runs/B1/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B1/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9" + }, + "evidence/runtime/runs/B1/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342" + }, + "evidence/runtime/runs/B2/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9" + }, + "evidence/runtime/runs/B2/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B2/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0" + }, + "evidence/runtime/runs/B2/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35" + }, + "evidence/runtime/runs/B3/receipt.json": { + "bytes": 997, + "mode": 420, + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8" + }, + "evidence/runtime/runs/B3/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B3/stdout.txt": { + "bytes": 1086, + "mode": 420, + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2" + }, + "evidence/runtime/runs/B3/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c" + }, + "evidence/runtime/runs/C1/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba" + }, + "evidence/runtime/runs/C1/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C1/stdout.txt": { + "bytes": 14103, + "mode": 420, + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f" + }, + "evidence/runtime/runs/C1/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0" + }, + "evidence/runtime/runs/C2/receipt.json": { + "bytes": 998, + "mode": 420, + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579" + }, + "evidence/runtime/runs/C2/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C2/stdout.txt": { + "bytes": 14105, + "mode": 420, + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c" + }, + "evidence/runtime/runs/C2/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5" + }, + "evidence/runtime/runs/C3/receipt.json": { + "bytes": 999, + "mode": 420, + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9" + }, + "evidence/runtime/runs/C3/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C3/stdout.txt": { + "bytes": 14101, + "mode": 420, + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193" + }, + "evidence/runtime/runs/C3/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af" + }, + "evidence/runtime/runs/actual-native-apply/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3" + }, + "evidence/runtime/runs/actual-native-apply/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/actual-native-apply/stdout.txt": { + "bytes": 1831, + "mode": 420, + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5" + }, + "evidence/runtime/runs/actual-native-apply/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746" + }, + "evidence/runtime/runs/apply-micro-native/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a" + }, + "evidence/runtime/runs/apply-micro-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/apply-micro-native/stdout.txt": { + "bytes": 7524, + "mode": 420, + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c" + }, + "evidence/runtime/runs/apply-micro-native/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea" + }, + "evidence/runtime/runs/finite-native-O/receipt.json": { + "bytes": 1006, + "mode": 420, + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410" + }, + "evidence/runtime/runs/finite-native-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-O/stdout.txt": { + "bytes": 11770, + "mode": 420, + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18" + }, + "evidence/runtime/runs/finite-native-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5" + }, + "evidence/runtime/runs/finite-native-bound-debug/receipt.json": { + "bytes": 1020, + "mode": 420, + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432" + }, + "evidence/runtime/runs/finite-native-bound-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-bound-debug/stdout.txt": { + "bytes": 11834, + "mode": 420, + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87" + }, + "evidence/runtime/runs/finite-native-bound-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt": { + "bytes": 11770, + "mode": 420, + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/receipt.json": { + "bytes": 1021, + "mode": 420, + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad" + }, + "evidence/runtime/runs/finite-native-debug/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581" + }, + "evidence/runtime/runs/finite-native-debug/stderr.txt": { + "bytes": 185, + "mode": 420, + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877" + }, + "evidence/runtime/runs/finite-native-debug/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1" + }, + "evidence/runtime/runs/finite-native-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407" + }, + "evidence/runtime/runs/finite-native-final-debug/receipt.json": { + "bytes": 1020, + "mode": 420, + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a" + }, + "evidence/runtime/runs/finite-native-final-debug/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-final-debug/stdout.txt": { + "bytes": 11835, + "mode": 420, + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6" + }, + "evidence/runtime/runs/finite-native-final-debug/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32" + }, + "evidence/runtime/runs/finite-native-initial/receipt.json": { + "bytes": 1015, + "mode": 420, + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972" + }, + "evidence/runtime/runs/finite-native-initial/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-initial/stdout.txt": { + "bytes": 11769, + "mode": 420, + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b" + }, + "evidence/runtime/runs/finite-native-initial/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3" + }, + "evidence/runtime/runs/finite-native-packet-O/receipt.json": { + "bytes": 1057, + "mode": 420, + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e" + }, + "evidence/runtime/runs/finite-native-packet-O/stderr.txt": { + "bytes": 625, + "mode": 420, + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8" + }, + "evidence/runtime/runs/finite-native-packet-O/stdout.txt": { + "bytes": 7318, + "mode": 420, + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb" + }, + "evidence/runtime/runs/finite-native-packet-O/usage.json": { + "bytes": 118, + "mode": 420, + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675" + }, + "evidence/runtime/runs/finite-native-reviewed-O/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stdout.txt": { + "bytes": 11835, + "mode": 420, + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36" + }, + "evidence/runtime/runs/finite-native-reviewed-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998" + }, + "evidence/runtime/runs/finite-native-snapshot-O/receipt.json": { + "bytes": 1017, + "mode": 420, + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stdout.txt": { + "bytes": 11948, + "mode": 420, + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519" + }, + "evidence/runtime/runs/finite-native-snapshot-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b" + }, + "evidence/runtime/runs/full-native-O/receipt.json": { + "bytes": 1010, + "mode": 420, + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448" + }, + "evidence/runtime/runs/full-native-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/full-native-O/stdout.txt": { + "bytes": 14103, + "mode": 420, + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54" + }, + "evidence/runtime/runs/full-native-O/usage.json": { + "bytes": 82, + "mode": 420, + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1" + }, + "evidence/runtime/runs/micro-native/receipt.json": { + "bytes": 1005, + "mode": 420, + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4" + }, + "evidence/runtime/runs/micro-native/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/micro-native/stdout.txt": { + "bytes": 1708, + "mode": 420, + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9" + }, + "evidence/runtime/runs/micro-native/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143" + }, + "evidence/runtime/runs/packaged-native-finite-O/receipt.json": { + "bytes": 1018, + "mode": 420, + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d" + }, + "evidence/runtime/runs/packaged-native-finite-O/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite-O/stdout.txt": { + "bytes": 12183, + "mode": 420, + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b" + }, + "evidence/runtime/runs/packaged-native-finite-O/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041" + }, + "evidence/runtime/runs/packaged-native-finite/receipt.json": { + "bytes": 1016, + "mode": 420, + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d" + }, + "evidence/runtime/runs/packaged-native-finite/stderr.txt": { + "bytes": 0, + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite/stdout.txt": { + "bytes": 12183, + "mode": 420, + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab" + }, + "evidence/runtime/runs/packaged-native-finite/usage.json": { + "bytes": 80, + "mode": 420, + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3" + }, + "finite.py": { + "bytes": 9441, + "mode": 420, + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359" + }, + "fraction_table.py": { + "bytes": 6483, + "mode": 420, + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4" + }, + "frozen.py": { + "bytes": 3197, + "mode": 420, + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547" + }, + "full.py": { + "bytes": 3061, + "mode": 420, + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0" + }, + "full_B.py": { + "bytes": 34, + "mode": 420, + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a" + }, + "full_C.py": { + "bytes": 33, + "mode": 420, + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394" + }, + "guard.py": { + "bytes": 5090, + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "inputs/PR5848.tar": { + "bytes": 614400, + "mode": 420, + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6" + }, + "micro.py": { + "bytes": 1205, + "mode": 420, + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53" + }, + "micro_apply.py": { + "bytes": 1748, + "mode": 420, + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e" + }, + "native_backend.py": { + "bytes": 2992, + "mode": 420, + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d" + }, + "native_cache.c": { + "bytes": 13895, + "mode": 420, + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" + }, + "parent_finite.py": { + "bytes": 10693, + "mode": 420, + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f" + }, + "replay.py": { + "bytes": 801, + "mode": 420, + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9" + }, + "replay_driver.py": { + "bytes": 267, + "mode": 420, + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528" + }, + "slot_binding.py": { + "bytes": 2718, + "mode": 420, + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593" + }, + "slot_finite.py": { + "bytes": 4804, + "mode": 420, + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390" + }, + "slot_parent.py": { + "bytes": 4366, + "mode": 420, + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24" + }, + "table_parent.py": { + "bytes": 5205, + "mode": 420, + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4" + }, + "verify.py": { + "bytes": 692, + "mode": 420, + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82" + } + }, + "original_guard_source_inventory_sha256": "225ae409b5400b746690d271a90ddd2aab7d042134434f52007e951c26f2f5d1", + "reconstruction_scope": "Exact 164-file baseline and 177-file measured stage; historical original whole-round guard closure is not duplicated.", + "stage_count": 177, + "status": "MEASURED_SOURCE_CENSUS_ONLY" +} diff --git a/research/verification-key-headroom/NOTICE b/research/verification-key-headroom/NOTICE new file mode 100644 index 0000000000..68114607ba --- /dev/null +++ b/research/verification-key-headroom/NOTICE @@ -0,0 +1,6 @@ +Verification key headroom archive +Chris R / Clear1nsight, with substantial OpenAI Codex and user-requested GPT-6-astra xhigh design and separate source-review assistance. Apache-2.0. + +Original Fraction/precision arithmetic: Ali Romman and all inherited P104/native/compiler/precision contributors. The complete original source notice is retained unchanged at context/baseline-public/NOTICE. Preserve its Adam Gall/ywz65, Mason Hale, upstream/source-archive and tooling credits, plus PR5848/5864/5875/5908 lineage. + +The prototype author and independent Astra source reviewer are separate roles; parent-only serial execution is not independent human or proof-kernel acceptance. Memoization and open-address hash tables are standard algorithms. Adjacent immutable-key cache work includes JoyboyBrian/PR4947 and ywz65/PR2506, retaining Chafik Boukhalfa, Ali Romman and Rohan Arun's attribution. No code was copied from those adjacent PRs and their timing claims were not replayed here. diff --git a/research/verification-key-headroom/README.md b/research/verification-key-headroom/README.md new file mode 100644 index 0000000000..63eaeee045 --- /dev/null +++ b/research/verification-key-headroom/README.md @@ -0,0 +1,72 @@ +# Actual verification keys and a negative conditional cost screen + +This package preserves the complete PR5864 contribution-key corpus, exact ordered replay outputs, measured source context, and negative cost evidence. The requested **further 15% reduction in both complete frozen-qualifier wall time and CPU remains unmet**. The scoped audit is complete; that is not completion of the broader performance goal. No private integer owner, GMP integration, production cache replacement or GC-policy optimization is admitted. + +The useful result is reproducible evidence about an actual workload, including an unsuccessful engineering nomination. It does not change a selected result, certify a κ, prove a multiplication theorem, establish a universal performance barrier, or supply an upper bound on actual complete-runtime savings. + +## What was measured + +The original complete qualifier ran with its original cache and a reversible diagnostic hook that retained every existing seven-PyLong key before lookup. Capture was enabled only during the source-bound actual invocation. Original Fraction arithmetic, miss callbacks, F(0), ordered score additions, source iteration, Observation, exact counters and full signed-witness comparisons remained intact. The qualifier retained 25,984 events, 799 coordinates, 120 finite fixtures and the frozen source result. Its actual output digest remained `954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9`. + +All **2,579,750 keys** were captured, with 3,587 weight tokens. The resulting corpus was replayed separately through the unchanged finite key comparator: PyDict plus fresh seven-tuple/FIFO storage versus a private open-address table with full numeric equality, collision handling, tombstones, rehashing and owned references. Both timed loops used opaque miss IDs and omitted descriptors, Fraction arithmetic and callbacks. This isolates key handling; it does not establish literal Fraction-cache API or general GC compatibility. + +One predeclared B,C,C,B sequence used fresh cache state in every arm, with no warmup or retry. Every ordered ID, hit/miss/eviction flag and 80-operation/final-partial prefix matched a separate literal Python dict/deque oracle. Each arm reproduced 2,252,966 hits, 326,784 misses, 310,400 evictions and 16,384 residents. Both custom runs paid for 23 natural rehashes. + +| Actual-key sample | Wall seconds | CPU seconds | +|---|---:|---:| +| B1 | 0.477255588 | 0.477131657 | +| C1 | 0.307855024 | 0.307762678 | +| C2 | 0.313469836 | 0.313226221 | +| B2 | 0.474210388 | 0.474076689 | + +The smaller paired difference was **0.160740552 wall / 0.160850468 CPU seconds**. It is measured on actual keys, without synthetic extrapolation, but is not a complete-verification gain. Adding that difference to the earlier diagnostic integer gross region gives **4.845453128 / 4.844279183 seconds**, even with zero retained integer runtime and zero new bill. Both values fall below the necessary **5.199267809 / 5.170500000-second** thresholds. The declared provisional 0.5-second reserve makes the failure larger. + +That integer anchor comes from a different diagnostic run and includes clock overhead. The sum is a conditional screening calculation, not a same-run removable-cost bound or achieved saving. Real retained integer work and future construction/build/validation costs remain nonzero and unpriced. The result rejects this nomination without proving global impossibility. + +The complete cold capture/replay command cost **42.639824143 seconds wall / 42.54 seconds CPU**, including both compilers, original qualification, capture, checks, serialization/readback and output persistence. Sampled peak process-group RSS was **437,825,536 bytes**. Source bytes/modes remained unchanged and stderr was empty. One post-qualifier cleanup collection was charged outside replay timings and changed no GC policy. Capture changes allocation and object lifetime; its whole-command timing is diagnostic, not a replacement baseline sample. + +## Retained evidence and earlier boundaries + +[data/DATA.json](data/DATA.json) describes the complete 7,945,691-byte corpus and canonical output streams. The corpus SHA-256 is `660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699`. It preserves arbitrary-width signed integer values and order. The measured replay used original live objects; the archive does not promise cross-block identity. + +All five original oracle/B/C output sets were byte-identical. One complete canonical set is committed; [ORIGINAL-OUTPUTS.json](evidence/ORIGINAL-OUTPUTS.json) records every original payload hash and size. The full 135,724,869-byte original runtime tree remains retained locally. No failed or unfavorable sample was substituted. Decompressed payloads are authoritative; regenerated compression bytes are not mathematical identity. + +[Actual results](evidence/actual/RESULT.json), [guard receipts](evidence/runs/), source reviews and [ARCHIVE-MAP.json](evidence/ARCHIVE-MAP.json) retain provenance. Historical attachments keep their original paths and publication-state wording; those are historical records, not assertions about current PR status. The unchanged scientific source lives in [context/](context/); [MEASURED-CONTEXT.json](MEASURED-CONTEXT.json) records its complete census. + +All four original C opportunities were assessed before this follow-up: + +| Opportunity | Retained conclusion | +|---|---| +| Rational arithmetic | Restoring the required independent literal Fraction oracle defeated the proposed cost screen. | +| Integer loops | The combined integer/formatting experiment's descriptive 6.47% wall / 6.21% CPU reductions failed the target and declared noise gates. | +| Canonical formatting | Tested with integer loops; no separate complete formatting speed claim. | +| Matrix kernels | The historical 29.27% H25 side result belongs to [PR5929](https://github.com/CrocSwap/integer-mult-bounds/pull/5929), a separate workload; it cannot count toward this target. | + +[PR5908](https://github.com/CrocSwap/integer-mult-bounds/pull/5908) retains the earlier negative feasibility work. The attached passive GC diagnostic found about 1.54 seconds and did not fund its nomination. A subsequent same-run disjoint integer/key diagnostic found about 7.30 wall seconds of gross regions, including retained work and clock overhead, opening only cost design. The synthetic key pilot then failed; the distinct actual-key pilot also failed. These are scoped observations, not additive universal bounds. No further scientific action is funded by this archive. + +## Bounded verification + +Use Linux 64-bit CPython 3.12 with an existing C compiler and Python headers. No Python dependencies or installation are requested. The registered commands are: + +```sh +python3.12 -B research/verification-key-headroom/verify.py finite +python3.12 -B -O research/verification-key-headroom/verify.py finite +python3.12 -B research/verification-key-headroom/verify.py data +python3.12 -B research/verification-key-headroom/verify.py context +``` + +`finite` compiles fresh unchanged comparator code outside the package and runs all 82 controls, including equality, collision, FIFO, rejection and ownership/failure cases. Failed build/control evidence is retained at the reported external path. `data` authenticates immutable inputs before decoding, uses bounded plain protocol-5 objects with fresh memos, and streams every key through an independent literal oracle while comparing all canonical outputs. Pickle is accepted only from pinned own data; unsafe object-construction opcodes and trailing bytes are rejected. `context` reconstructs and checks all 164 baseline files and 177 measured stage files, exact C reversal and official PR5864 export equality, without scientific execution. + +Code/data manifests are checked before execution. Direct source loading avoids stale bytecode, and deliberate `-O` propagates into loaded controls. Read-only Git-free exports are supported by restoring historical modes only in a fresh external reconstruction. The official PR5864 tar is the existing declared repository input, not another provenance copy. These commands do not rerun historical timings or capture. + +An explicitly requested future reproduction may use `replay_capture.py --evidence NEW_EXTERNAL_DIRECTORY`. It invokes the reconstructed original guard once under 180 seconds and 1 GiB, retains failures, and compares every regenerated key value/order to the committed corpus. It is **not registered for publication or CI**. Its new timings cannot replace archived samples or reopen the failed gate. The original runtime/source constraints still apply. See [VERIFY.json](VERIFY.json) and [VALIDATION.json](VALIDATION.json) for registered scope and execution status. + +## Open next questions + +[TASK.json](TASK.json) records the blocked questions. Reopening engineering would require a materially different source-specific mechanism with a credible complete paid cost case, preserving the independent Fraction oracle and all outputs. The first step is a bounded source/cost proposal, not another timing reroll. No such funded proposal exists here; remaining shared budget is not authorization to invent one. + +## Credit and scope + +Chris R / Clear1nsight prepared this work with substantial OpenAI Codex and user-requested Astra xhigh assistance. Separate Astra agents performed design and independent source review; the prototype author’s own checks are not independent review. One parent owned all serial compiler/scientific execution. There is no independent human or proof-kernel acceptance. + +Preserve Ali Romman’s arithmetic and all inherited P104 authors/notices, including PR5848, PR5864 and PR5875; the original [NOTICE](context/baseline-public/NOTICE) is unchanged. Standard hash-table and memoization algorithms are not claimed as novel. Adjacent credit includes JoyboyBrian’s [PR4947](https://github.com/CrocSwap/integer-mult-bounds/pull/4947) immutable-matrix inverse cache and ywz65’s [PR2506](https://github.com/CrocSwap/integer-mult-bounds/pull/2506) immutable P104 matrix/address cache, retaining Chafik Boukhalfa, Ali Romman and Rohan Arun’s credit. Their workloads and author timings were not replayed here. A bounded parent Chrome phrase search was not an exhaustive novelty audit. Apache-2.0; no abi3, free-threaded, subinterpreter, general C memory-safety, theorem or selected-frontier claim. diff --git a/research/verification-key-headroom/SOURCES.json b/research/verification-key-headroom/SOURCES.json new file mode 100644 index 0000000000..de7795f079 --- /dev/null +++ b/research/verification-key-headroom/SOURCES.json @@ -0,0 +1,93 @@ +{ + "adjacent_precedents": [ + { + "author": "JoyboyBrian", + "pr": 4947, + "scope": "immutable exact-matrix inverse cache; different workload and unreplayed author timings" + }, + { + "additional_credit": [ + "Chafik Boukhalfa", + "Ali Romman", + "Rohan Arun" + ], + "author": "ywz65", + "pr": 2506, + "scope": "complete immutable P104 binary-matrix/address cache; different workload and unreplayed author timings" + } + ], + "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "external_origin": { + "complete_files": 163, + "head": "3f15c943e4ad6479f03e674c80fff1269a16ccfe", + "official_export_sha256": "7b142567acacac5182045bf8daa8780e916661c2cf343dbf81b13c88ead85d64", + "pr": 5864, + "repository": "CrocSwap/integer-mult-bounds" + }, + "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": "bb9fc302168df0bf66cf43d08bce70544eeffc4e", + "path": "research/c-verification-feasibility/inputs/PR5864.tar", + "pin": "head:ccb92b752ab31df4220780a580cc14d9e86ffeca:research/c-verification-feasibility/inputs/PR5864.tar", + "sha256": "7b142567acacac5182045bf8daa8780e916661c2cf343dbf81b13c88ead85d64", + "usage": "input" + }, + { + "git_blob": "ba0924f46f37cbbadcee0922dd980302fd95e758", + "path": "research/verification-key-headroom/data/DATA.json", + "pin": "head:f901e992a3846ff0351bfb0caf75b6167788cd74:research/verification-key-headroom/data/DATA.json", + "sha256": "38e64373293c9d2b2feb315353e305e5f657499ce1d2b0b4ce09d357e62fab9f", + "usage": "input" + }, + { + "git_blob": "31af3a69fa4f04482b1a831960ac419a555c3ffb", + "path": "research/verification-key-headroom/data/actual-keys-v1.pickle.gz", + "pin": "head:f901e992a3846ff0351bfb0caf75b6167788cd74:research/verification-key-headroom/data/actual-keys-v1.pickle.gz", + "sha256": "660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699", + "usage": "input" + }, + { + "git_blob": "f85b666764d5689d1229683139c8674e6e51c4e4", + "path": "research/verification-key-headroom/data/canonical-flags.u8.gz", + "pin": "head:f901e992a3846ff0351bfb0caf75b6167788cd74:research/verification-key-headroom/data/canonical-flags.u8.gz", + "sha256": "8acb6dd4d577dcb964ee1ef027eab9f0c91b811ad445bd93f8e1804a8d447001", + "usage": "input" + }, + { + "git_blob": "ded74d9970fa3cbf3c3e05629c9a8fe4786297ff", + "path": "research/verification-key-headroom/data/canonical-ids.u64.gz", + "pin": "head:f901e992a3846ff0351bfb0caf75b6167788cd74:research/verification-key-headroom/data/canonical-ids.u64.gz", + "sha256": "51753090e6ae4b02651590963341dc30e2424a00b49adb88ba65b05e03901fc5", + "usage": "input" + }, + { + "git_blob": "da04301c10f7a448bec9a574dd4397dc00b20b33", + "path": "research/verification-key-headroom/data/canonical-prefixes.json.gz", + "pin": "head:f901e992a3846ff0351bfb0caf75b6167788cd74:research/verification-key-headroom/data/canonical-prefixes.json.gz", + "sha256": "0960e36d7c43f9b37dc1550778ff60a55de02d7ab8a83c1f4c7cdd691ffec3b8", + "usage": "input" + } + ], + "immutable_data_input_commit": "f901e992a3846ff0351bfb0caf75b6167788cd74", + "predecessors": [ + 5848, + 5864, + 5875, + 5908 + ], + "schema_version": 1, + "scope": "Scoped actual-key archive and negative conditional screen; no complete performance, universal bound, kappa or selected-frontier claim.", + "separate_workload_reference": 5929 +} diff --git a/research/verification-key-headroom/TASK.json b/research/verification-key-headroom/TASK.json new file mode 100644 index 0000000000..7117b0384b --- /dev/null +++ b/research/verification-key-headroom/TASK.json @@ -0,0 +1,63 @@ +{ + "actual_scope": "source-pinned-actual-key-headroom-audit", + "ai_assistance": "Substantial OpenAI Codex and user-requested GPT-6-astra xhigh design plus separate source review; parent-only serial compiler/scientific execution. Author self-checks are not independent review; 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.", + "broader_performance_target": "UNMET", + "evidence": "README.md, data/DATA.json, evidence/actual/RESULT.json, evidence/runs, exact source context and independent static review reports", + "open_questions": [ + { + "blocked_by": "The assessed rational, integer/format, GC and key nominations do not fund the target; no further scientific action is presently funded.", + "first_step": "Provide a bounded source/ownership/cost proposal with nonzero retained runtime and the entire new build/validation bill before seeking any fresh scientific run.", + "question": "Is there a materially different source-specific mechanism with a credible complete paid cost case while preserving the required independent Fraction oracle?", + "why_it_matters": "The further15% complete frozen PR5864 target remains unmet after all four opportunities and the actual-key conditional screen." + } + ], + "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 archive/cost audit only; broader complete PR5864 >=15% wall/CPU goal remains unmet.", + "schema_version": 1, + "scope_change_reason": "The user requested all four C opportunities and a further15% complete PR5864 gain. Those assessments and the distinct actual-key nomination yielded retained negative cost evidence; this package archives the complete actual corpus and bounded checks without new optimization or benchmark rerolls.", + "scope_status": "refined", + "stop_rule": "Archive the completed scoped audit; no further funded scientific action, timing reroll, owner/GMP construction or full-cache integration follows from remaining budget.", + "task_id": "replay-runtime", + "time_budget_minutes": 60, + "time_budget_scope": "Historical bounded research proposal, not a fresh automatic research allocation." +} diff --git a/research/verification-key-headroom/VALIDATION.json b/research/verification-key-headroom/VALIDATION.json new file mode 100644 index 0000000000..fce3e00367 --- /dev/null +++ b/research/verification-key-headroom/VALIDATION.json @@ -0,0 +1,132 @@ +{ + "historical_scientific_evidence": { + "actual": "evidence/actual/RESULT.json", + "actual_capture_and_key_comparison": "PASS_ACTUAL_KEY_COMPARISON_ONLY", + "broader_performance_target": "UNMET", + "conditional_nomination": "REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION", + "outer_receipt": "evidence/runs/actual-key-pilot-v1/receipt.json" + }, + "independent_source_review": { + "file": "publication/HEADROOM-PUBLICATION-REVIEW.md", + "scope": "Source-only, not independent scientific replay or C memory-safety certification", + "sha256": "0e1100ddf40d21c9cf053d3e563920ddabcab481033c91bc2053c2ac725c62ec", + "status": "PASS_PUBLICATION_SOURCE_REVIEW_ONLY" + }, + "local_registered_checks": [ + { + "label": "headroom-publication-finite-v1", + "optimized": false, + "receipt": "publication/headroom-publication-finite-v1/receipt.json", + "result": { + "natural_rehashes": 50, + "no_capture_or_benchmark": true, + "optimized": 0, + "receipts": 82, + "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "status": "PASS_ARCHIVED_FINITE_CONTROLS" + }, + "sampled_group_rss_bytes": 75530240, + "source_unchanged": true, + "status": "PASS", + "wall_seconds": 0.785633888997836 + }, + { + "label": "headroom-publication-finite-O-v1", + "optimized": true, + "receipt": "publication/headroom-publication-finite-O-v1/receipt.json", + "result": { + "natural_rehashes": 50, + "no_capture_or_benchmark": true, + "optimized": 1, + "receipts": 82, + "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "status": "PASS_ARCHIVED_FINITE_CONTROLS" + }, + "sampled_group_rss_bytes": 75513856, + "source_unchanged": true, + "status": "PASS", + "wall_seconds": 0.7695385620172601 + }, + { + "label": "headroom-publication-data-v1", + "optimized": false, + "receipt": "publication/headroom-publication-data-v1/receipt.json", + "result": { + "all_ordered_items_checked": true, + "no_C_capture_or_timing": true, + "prefixes": 32247, + "regenerated_compression_is_not_mathematical_identity": true, + "statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "status": "PASS_COMPLETE_ACTUAL_KEY_DATA", + "streaming": true + }, + "sampled_group_rss_bytes": 41033728, + "source_unchanged": true, + "status": "PASS", + "wall_seconds": 43.02619857201353 + }, + { + "label": "headroom-publication-context-v1", + "optimized": false, + "receipt": "publication/headroom-publication-context-v1/receipt.json", + "result": { + "context": { + "all_bytes_and_modes_equal": true, + "exact_C_inverse": true, + "measured_stage_files": 177, + "original_baseline_files": 164 + }, + "no_scientific_import_or_execution": true, + "official_input": { + "head": "3f15c943e4ad6479f03e674c80fff1269a16ccfe", + "official_export_files": 163, + "retained_export_receipt": true, + "sha256": "7b142567acacac5182045bf8daa8780e916661c2cf343dbf81b13c88ead85d64" + }, + "status": "PASS_EXACT_MEASURED_CONTEXT" + }, + "sampled_group_rss_bytes": 27918336, + "source_unchanged": true, + "status": "PASS", + "wall_seconds": 0.5080786359903868 + } + ], + "new_measurement_or_research_authorized": false, + "new_scientific_capture_or_timing_reroll": false, + "optional_capture_rerun_for_publication": false, + "pending_parent_checks": [ + "committed bytes/source history", + "committed export integrity", + "exact-head hosted CI" + ], + "performance_target_met": false, + "readonly_gitfree": { + "all_four_commands_pass": true, + "directory_mode": "0555", + "files_mode": "0444", + "runtime": "fresh external directories only" + }, + "schema_version": 1, + "source_manifest_sha256": "9b3c05b97f926c2c767ad394a399554cd4034a86526dead247251e0921c697d5", + "source_preparation": { + "author_checks": [ + "file-byte hashes", + "complete source-context censuses", + "C patch inversion", + "Python AST parsing" + ], + "compilation": false, + "registered_commands_executed_by_package_author": false, + "scientific_imports": false + }, + "status": "PASS_LOCAL_ARCHIVE_CHECKS_HOSTED_PENDING", + "updated_utc": "2026-10-27T16:29:32.093230+00:00" +} diff --git a/research/verification-key-headroom/VERIFY.json b/research/verification-key-headroom/VERIFY.json new file mode 100644 index 0000000000..a55032c7f5 --- /dev/null +++ b/research/verification-key-headroom/VERIFY.json @@ -0,0 +1,57 @@ +{ + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "finite" + ], + "checks": "Fresh unchanged key comparator plus all82 finite/reference/ownership/collision/FIFO checks; Linux64 CPython3.12 and existing cc/headers; no benchmark or full capture.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-B", + "-O", + "{package}/verify.py", + "finite" + ], + "checks": "Same fresh finite controls under deliberate optimization; explicit guards remain active and source compile inherits -O.", + "timeout_seconds": 60 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "data" + ], + "checks": "Authenticate committed data then stream all2579750 exact keys through literal dict/deque and compare every canonical ID, flag, prefix and payload hash; strict plain pickle/EOF; no C or timing.", + "timeout_seconds": 180 + }, + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "context" + ], + "checks": "Source-only external reconstruction: exact164baseline/177stage bytes and modes, complete C inverse, reference pins and officialPR5864 archive equality; no scientific imports or execution.", + "timeout_seconds": 60 + } + ], + "inputs": [ + "research/c-verification-feasibility/inputs/PR5864.tar", + "research/verification-key-headroom/data/DATA.json", + "research/verification-key-headroom/data/actual-keys-v1.pickle.gz", + "research/verification-key-headroom/data/canonical-flags.u8.gz", + "research/verification-key-headroom/data/canonical-ids.u64.gz", + "research/verification-key-headroom/data/canonical-prefixes.json.gz" + ], + "python": "3.12", + "requirements": [], + "schema_version": 1, + "status": "ready" +} diff --git a/research/verification-key-headroom/archive_support.py b/research/verification-key-headroom/archive_support.py new file mode 100644 index 0000000000..def6766d66 --- /dev/null +++ b/research/verification-key-headroom/archive_support.py @@ -0,0 +1,216 @@ +"""Archive integrity and bounded value transport; no scientific module imports. + +Chris R / Clear1nsight with substantial OpenAI Codex/Astra assistance. +Apache-2.0. Hash tables and source-bound replay are standard techniques. +""" +from hashlib import sha256 +import gzip +import io +import pickletools +import json +from pathlib import Path, PurePosixPath +import pickle +import shutil +import sys +import tarfile +import types + +ROOT=Path(__file__).resolve().parent +REPO=ROOT.parent.parent +CONTEXT=ROOT/'context' +STAGE='stages/actual-key-pilot-v1' +OFFICIAL_PATH='research/c-verification-feasibility/inputs/PR5864.tar' +OFFICIAL_SHA='7b142567acacac5182045bf8daa8780e916661c2cf343dbf81b13c88ead85d64' +OFFICIAL_HEAD='3f15c943e4ad6479f03e674c80fff1269a16ccfe' +CALLS=2579750 +BLOCK=4096 + + +def need(ok,reason): + if not ok:raise ValueError(reason) + + +def digest_file(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 regular(root,relative): + part=PurePosixPath(relative) + need(not part.is_absolute() and part.parts and all(x not in ('.','..') for x in part.parts),'canonical archive path') + path=root + for component in part.parts: + path=path/component + need(not path.is_symlink(),'no symlink: '+relative) + need(path.is_file(),'regular file: '+relative) + return path + + +def authenticate(): + manifest=json.loads((ROOT/'CODE-SOURCES.json').read_text()) + need(manifest['schema_version']==1,'code manifest version') + for relative,pin in manifest['files'].items(): + path=regular(ROOT,relative) + need(path.stat().st_size==pin['bytes'] and digest_file(path)==pin['sha256'],'exact protected bytes: '+relative) + need(bool(path.stat().st_mode&0o111)==bool(pin['git_mode']&0o111),'Git executable mode: '+relative) + expected_code={p for p in manifest['files'] if Path(p).suffix in ('.py','.c','.inc')} + live_code={str(p.relative_to(ROOT)) for p in ROOT.rglob('*') if p.is_file() and p.suffix in ('.py','.c','.inc')} + need(live_code==expected_code,'complete protected source-code census') + official=regular(REPO,OFFICIAL_PATH) + need(digest_file(official)==OFFICIAL_SHA,'official PR5864 immutable input') + return manifest + + +def inventory(root): + need(not any(p.is_symlink() for p in root.rglob('*')),'no context symlinks') + return {str(p.relative_to(root)):dict(sha256=digest_file(p),mode=p.stat().st_mode&0o777,bytes=p.stat().st_size) + for p in sorted(root.rglob('*')) if p.is_file()} + + +def reconstruct(destination): + destination=destination.resolve() + need(not destination.is_relative_to(REPO),'external reconstruction directory') + need(not destination.exists(),'fresh reconstruction directory') + shutil.copytree(CONTEXT,destination) + # Read-only Git-free exports may have 0555 directories and 0444 files. + # Change only this fresh external copy, never the published source tree. + for directory in (destination,*destination.rglob('*')): + if directory.is_dir():directory.chmod(0o755) + measured=json.loads((ROOT/'MEASURED-CONTEXT.json').read_text()) + for relative,pin in measured['original_baseline_files'].items(): + (destination/'baseline-public'/relative).chmod(pin['mode']) + target=destination/STAGE + for relative,pin in measured['original_baseline_files'].items(): + out=target/'baseline-public'/relative + if relative not in measured['baseline_overlay']: + out.parent.mkdir(parents=True,exist_ok=True) + shutil.copy2(destination/'baseline-public'/relative,out) + # Git only preserves executable mode. Restore the measured 0664 stage modes + # from the retained census, in this fresh external tree only. + for relative,pin in measured['measured_stage_files'].items(): + (target/relative).chmod(pin['mode']) + return destination + + +def validate_context(context): + measured=json.loads((ROOT/'MEASURED-CONTEXT.json').read_text()) + need(inventory(context/'baseline-public')==measured['original_baseline_files'],'all 164 original baseline bytes/modes') + need(inventory(context/STAGE)==measured['measured_stage_files'],'all 177 measured stage bytes/modes') + stage=context/STAGE + receipt=json.loads((stage/'SOURCE-EDITS.json').read_text()) + need(receipt['changed_baseline_files']==['native_cache.c','NATIVE-SOURCE.json'],'two declared capture overlays') + for relative,pin in receipt['original_inventory'].items(): + original=regular(context/'baseline-public',relative);copied=regular(stage/'baseline-public',relative) + need(digest_file(original)==pin['sha256'] and original.stat().st_mode&0o777==pin['mode'],'original baseline source receipt') + need(copied.stat().st_mode&0o777==pin['mode'],'copied baseline mode') + if relative not in receipt['changed_baseline_files']:need(digest_file(copied)==pin['sha256'],'unchanged copied baseline bytes') + raw=(stage/'baseline-public/native_cache.c').read_bytes() + need(sha256(raw).hexdigest()==receipt['diagnostic_native_sha256'],'capture C exact pin') + need(json.loads((stage/'baseline-public/NATIVE-SOURCE.json').read_text())==dict(sha256=receipt['diagnostic_native_sha256']),'capture cold-loader pin') + restored=raw.decode() + for edit in reversed(receipt['edits']): + need(restored.count(edit['after'])==1,'unique inverse diagnostic seam') + restored=restored.replace(edit['after'],edit['before']) + need(sha256(restored.encode()).hexdigest()==receipt['original_native_sha256'],'capture C reverses to entire original C') + # Resolve every old path convention and pin without importing old code. + frozen=json.loads((stage/'FROZEN-SOURCE.json').read_text()) + for directory,key in ((stage,'files_sha256'),(context,'reference_files_sha256')): + for relative,pin in frozen[key].items():need(digest_file(regular(directory,relative))==pin,'frozen source/reference: '+relative) + return dict(original_baseline_files=164,measured_stage_files=177,all_bytes_and_modes_equal=True,exact_C_inverse=True) + + +def official_baseline(context): + prefix='research/fraction-native-qualification/' + archive=regular(REPO,OFFICIAL_PATH) + need(digest_file(archive)==OFFICIAL_SHA,'official input before tar read') + with tarfile.open(archive,'r:') as stream: + members=stream.getmembers();names={m.name for m in members} + need(len(members)==len(names)==164 and all(m.isfile() for m in members),'complete regular official export') + exported=stream.extractfile('.research-export.json').read() + receipt=json.loads(exported) + need(receipt['commit']==OFFICIAL_HEAD and receipt['package']=='research/fraction-native-qualification','official export lineage') + rows=receipt['files'];need(len(rows)==163,'official source file count') + need(names=={r['path'] for r in rows}|{'.research-export.json'},'official export exact census') + need((context/'baseline-public/.research-export.json').read_bytes()==exported,'original complete export receipt') + for row in rows: + name=row['path'];need(name.startswith(prefix),'official package prefix') + member=stream.getmember(name) + need(member.size==row['size'] and member.mode&0o777==row['mode'],'official member size/mode') + raw=stream.extractfile(member).read() + need(len(raw)==row['size'] and sha256(raw).hexdigest()==row['sha256'],'official payload pin') + path=regular(context/'baseline-public',name[len(prefix):]) + need(path.read_bytes()==raw and path.stat().st_mode&0o777==row['mode'],'retained baseline equals official export') + return dict(official_export_files=163,retained_export_receipt=True,head=OFFICIAL_HEAD,sha256=OFFICIAL_SHA) + + +class PlainUnpickler(pickle.Unpickler): + def find_class(self,module,name): + raise ValueError('class/global objects are outside the pinned plain corpus format') + + +# Only plain protocol-5 structure is needed. Scan each bounded object before +# deserializing; no GLOBAL/STACK_GLOBAL/REDUCE/BUILD/OBJ/INST/NEWOBJ/EXT forms. +PLAIN_OPS={'PROTO','FRAME','EMPTY_DICT','MEMOIZE','MARK','SHORT_BINUNICODE', + 'BINUNICODE','BINUNICODE8','BININT','BININT1','BININT2','LONG1','LONG4', + 'NEWFALSE','NEWTRUE','SETITEMS','SETITEM','EMPTY_TUPLE','TUPLE','TUPLE1', + 'TUPLE2','TUPLE3','BINGET','LONG_BINGET','STOP'} + + +class BoundedObjectReader: + def __init__(self,stream):self.stream=stream;self.raw=io.BytesIO();self.size=0 + def tell(self):return self.size + def save(self,value): + self.size+=len(value);need(self.size<=64*1024*1024,'bounded single pickle object') + self.raw.write(value);return value + def read(self,count): + need(type(count) is int and 0<=count<=64*1024*1024-self.size,'bounded pickle operand') + return self.save(self.stream.read(count)) + def readline(self):return self.save(self.stream.readline(64*1024*1024-self.size+1)) + + +def plain_object(stream): + reader=BoundedObjectReader(stream);first=True + for opcode,argument,position in pickletools.genops(reader): + need(opcode.name in PLAIN_OPS,'plain-only pickle opcode: '+opcode.name) + if first: + need(opcode.name=='PROTO' and argument==5,'explicit protocol 5') + first=False + need(not first,'one complete pickle object') + # genops consumes exactly through STOP without unpickler read-ahead. + # A fresh unpickler gives each bounded object a fresh memo. + return PlainUnpickler(io.BytesIO(reader.raw.getvalue())).load() + + +def corpus_blocks(path,transport_pin): + # Only committed pinned data or a fresh source-pinned replay's own output. + need(digest_file(path)==transport_pin,'authenticate corpus container before unpickling') + expected=json.loads((ROOT/'data/DATA.json').read_text())['actual_corpus']['format'] + with gzip.open(path,'rb') as stream: + need(plain_object(stream)==expected,'complete corpus format/header') + for start in range(0,CALLS,BLOCK): + block=plain_object(stream) + need(type(block) is tuple and len(block)==min(BLOCK,CALLS-start),'complete bounded corpus block') + for key in block: + need(type(key) is tuple and len(key)==7 and all(type(x) is int for x in key),'seven exact signed integer fields') + yield block + need(stream.read(1)==b'','strict decompressed EOF after final object') + + +def read_plain_gzip(path,pin): + need(digest_file(path)==pin['transport_sha256'],'committed transport SHA') + with gzip.open(path,'rb') as stream:raw=stream.read(pin['uncompressed_bytes']+1) + need(len(raw)==pin['uncompressed_bytes'] and sha256(raw).hexdigest()==pin['uncompressed_sha256'],'authoritative complete decompressed payload') + return raw + + +def source_module(name,path): + need(name not in sys.modules,'fresh owned module namespace: '+name) + relative=str(path.relative_to(ROOT));pins=json.loads((ROOT/'CODE-SOURCES.json').read_text())['files'] + raw=path.read_bytes();need(sha256(raw).hexdigest()==pins[relative]['sha256'],'authenticate module bytes before execution') + module=types.ModuleType(name);module.__file__=str(path);module.__package__='' + sys.modules[name]=module + try:exec(compile(raw,str(path),'exec'),module.__dict__) + except BaseException:sys.modules.pop(name,None);raise + return module diff --git a/research/verification-key-headroom/context/JOINT-COST-DIAGNOSTIC-RESULT.json b/research/verification-key-headroom/context/JOINT-COST-DIAGNOSTIC-RESULT.json new file mode 100644 index 0000000000..e625486a0b --- /dev/null +++ b/research/verification-key-headroom/context/JOINT-COST-DIAGNOSTIC-RESULT.json @@ -0,0 +1,2344 @@ +{ + "arithmetic_changed": false, + "calibration_subtracted": false, + "callbacks_and_score_arithmetic_excluded_from_key_regions": true, + "clock_overhead_calibration": { + "clock_gettime_calls_per_interval": 4, + "cpu_seconds": 0.000512329, + "empty_intervals": 512, + "subtracted_from_envelope": false, + "wall_seconds": 0.00051351 + }, + "complete_new_validation_and_build_bill": "UNPRICED_NONZERO", + "construction_admitted": false, + "expected_actual_fraction_output_checked_by_original_full": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "expected_actual_native_counters_checked_by_original_full": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "fixed_baseline_medians": { + "cpu": 34.47, + "wall": 34.66178539200337 + }, + "fixed_noise_spreads": { + "cpu": 2.3500000000000014, + "wall": 2.713637237990042 + }, + "full_source_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "gc_added_separately": false, + "instrumented_driver_sha256": "89525456cc6130419ec97e35348156bf25ddc1db691d6752590fa351f98cf256", + "integer": { + "counts": { + "error_trace": 121, + "ideal": 4, + "reverse_all": 121 + }, + "disjoint_union_seconds": { + "cpu": 4.683428714999984, + "wall": 4.684712576272432 + }, + "expected_actual_program_length": 25984, + "records": [ + { + "classification": "actual_word", + "cpu_seconds": 0.466810433, + "exception": null, + "family": "ideal", + "outermost": true, + "program_length": 25984, + "wall_seconds": 0.46696532200439833 + }, + { + "classification": "actual_word", + "cpu_seconds": 2.81241495, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 25984, + "wall_seconds": 2.8127848140138667 + }, + { + "classification": "actual_word", + "cpu_seconds": 0.9579453329999996, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 25984, + "wall_seconds": 0.9580617039755452 + }, + { + "classification": "modified_word_control", + "cpu_seconds": 0.28259738600000084, + "exception": "ValueError", + "family": "ideal", + "outermost": true, + "program_length": 25985, + "wall_seconds": 0.2826643980224617 + }, + { + "classification": "modified_word_control", + "cpu_seconds": 0.03382899800000061, + "exception": "ValueError", + "family": "ideal", + "outermost": true, + "program_length": 25984, + "wall_seconds": 0.033892175008077174 + }, + { + "classification": "modified_word_control", + "cpu_seconds": 0.03272733100000025, + "exception": "ValueError", + "family": "ideal", + "outermost": true, + "program_length": 25984, + "wall_seconds": 0.032770830002846196 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00014333500000418553, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 5, + "wall_seconds": 0.00014666098286397755 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 7.521100000218439e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 5, + "wall_seconds": 7.6786003774032e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013484299999788618, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 6, + "wall_seconds": 0.00013654999202117324 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 7.442399999746385e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 6, + "wall_seconds": 7.573998300358653e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00015547299999951747, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 7, + "wall_seconds": 0.00015692700981162488 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 9.245599999729848e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 7, + "wall_seconds": 9.409800986759365e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00014759500000138814, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 8, + "wall_seconds": 0.00014910101890563965 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 8.850300000062816e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 8, + "wall_seconds": 8.982999133877456e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001872420000026409, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 9, + "wall_seconds": 0.00019355700351297855 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00010550600000414079, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 9, + "wall_seconds": 0.0001068450219463557 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002670599999987644, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 10, + "wall_seconds": 0.000269146024947986 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002538740000019857, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 10, + "wall_seconds": 0.0002565199974924326 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002382879999984766, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 11, + "wall_seconds": 0.00024023899459280074 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001540379999980246, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 11, + "wall_seconds": 0.00015580898616462946 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022328400000048987, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 12, + "wall_seconds": 0.00022500299382954836 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00012888500000229897, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 12, + "wall_seconds": 0.0001302769815083593 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022304400000194846, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 13, + "wall_seconds": 0.00022472100681625307 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001284590000025787, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 13, + "wall_seconds": 0.00012978099402971566 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002524999999948818, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 14, + "wall_seconds": 0.00025414401898160577 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00014358800000024985, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 14, + "wall_seconds": 0.00014494001516140997 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002859749999970518, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 15, + "wall_seconds": 0.0002875810023397207 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00018371299999841995, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 15, + "wall_seconds": 0.00018518301658332348 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00025831099999606977, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 16, + "wall_seconds": 0.00026007098495028913 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00017818599999941398, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 16, + "wall_seconds": 0.00018336100038141012 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002676890000046228, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 17, + "wall_seconds": 0.0002691960253287107 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00017271099999760509, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 17, + "wall_seconds": 0.00017434201436117291 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002922219999987874, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 18, + "wall_seconds": 0.00029381999047473073 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001688069999943309, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 18, + "wall_seconds": 0.000170087005244568 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00029680000000098516, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 19, + "wall_seconds": 0.0002984059974551201 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00016654800000281966, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 19, + "wall_seconds": 0.0001681669964455068 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00032493799999855355, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 20, + "wall_seconds": 0.00033070798963308334 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000175624999997126, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 20, + "wall_seconds": 0.00017700600437819958 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00031795700000003535, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 21, + "wall_seconds": 0.00031974600278772414 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00018624200000516566, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 21, + "wall_seconds": 0.00018757698126137257 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00032234399999708785, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 22, + "wall_seconds": 0.00032402199576608837 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00019960499999882586, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 22, + "wall_seconds": 0.00020128700998611748 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003766159999969432, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 23, + "wall_seconds": 0.00038322099135257304 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002059429999974327, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 23, + "wall_seconds": 0.0002074289950542152 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003429729999950837, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 24, + "wall_seconds": 0.00034464302007108927 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00021414800000485457, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 24, + "wall_seconds": 0.0002156049886252731 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004563769999990086, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 25, + "wall_seconds": 0.0004584520065691322 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000245812000002843, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 25, + "wall_seconds": 0.00024732400197535753 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00039169299999741725, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 26, + "wall_seconds": 0.0003935459826607257 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022258699999611053, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 26, + "wall_seconds": 0.00022420601453632116 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00038179899999590816, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 27, + "wall_seconds": 0.00038345897337421775 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002175920000055953, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 27, + "wall_seconds": 0.00021915198885835707 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004347349999989092, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 28, + "wall_seconds": 0.00044012500438839197 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002322879999994143, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 28, + "wall_seconds": 0.00023370198323391378 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00041895199999686383, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 29, + "wall_seconds": 0.0004207479942124337 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00023903299999972205, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 29, + "wall_seconds": 0.00024045599275268614 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004059759999961443, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 30, + "wall_seconds": 0.0004077500198036432 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022203500000017584, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 30, + "wall_seconds": 0.00022341599105857313 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005100389999981303, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 31, + "wall_seconds": 0.0005118839908391237 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000261691000005726, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 31, + "wall_seconds": 0.00026312400586903095 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005485579999984225, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 32, + "wall_seconds": 0.0005504399887286127 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003075969999954964, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 32, + "wall_seconds": 0.0003090790123678744 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004959830000004217, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 33, + "wall_seconds": 0.0004978899960406125 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002532930000000988, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 33, + "wall_seconds": 0.00025469399406574667 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005474539999994477, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 34, + "wall_seconds": 0.0005493889912031591 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002776729999993677, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 34, + "wall_seconds": 0.0002792289888020605 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005078269999998497, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 35, + "wall_seconds": 0.0005096190143376589 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00027787999999873136, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 35, + "wall_seconds": 0.000279305997537449 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004850939999982984, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 36, + "wall_seconds": 0.0004871870041824877 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00024183000000022048, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 36, + "wall_seconds": 0.00024327999562956393 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006031759999984843, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 37, + "wall_seconds": 0.0006051560048945248 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00033352699999511515, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 37, + "wall_seconds": 0.00033496200921945274 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005333400000040456, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 38, + "wall_seconds": 0.0005351479921955615 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002953500000018039, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 38, + "wall_seconds": 0.00029678401187993586 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005386380000018676, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 39, + "wall_seconds": 0.0005406580166891217 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00030443499999677215, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 39, + "wall_seconds": 0.00030603399500250816 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007210309999976516, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 40, + "wall_seconds": 0.0007231030031107366 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000479905999995367, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 40, + "wall_seconds": 0.0004819000023417175 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006298369999981901, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 41, + "wall_seconds": 0.0006317030056379735 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003358240000039814, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 41, + "wall_seconds": 0.00033726502442732453 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006242360000001668, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 42, + "wall_seconds": 0.0006260699883569032 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003255029999991166, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 42, + "wall_seconds": 0.0003270150045864284 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006341550000001916, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 43, + "wall_seconds": 0.0006360859842970967 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000351638000005039, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 43, + "wall_seconds": 0.0003532049886416644 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005850350000002891, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 44, + "wall_seconds": 0.0005870770255569369 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00029871400000303083, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 44, + "wall_seconds": 0.0003002459998242557 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005904739999991193, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 45, + "wall_seconds": 0.0005924149882048368 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00035894300000194335, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 45, + "wall_seconds": 0.000360539008397609 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007180089999963002, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 46, + "wall_seconds": 0.0007199079846031964 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00036865300000243906, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 46, + "wall_seconds": 0.0003702759859152138 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006785230000048159, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 47, + "wall_seconds": 0.0006810780032537878 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003606820000001676, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 47, + "wall_seconds": 0.00036225400981493294 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005927680000041846, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 48, + "wall_seconds": 0.0005947909958194941 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003320269999989023, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 48, + "wall_seconds": 0.00033353501930832863 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006729699999965533, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 49, + "wall_seconds": 0.0006748079904355109 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00042327199999903087, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 49, + "wall_seconds": 0.00042537899571470916 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007041619999981208, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 50, + "wall_seconds": 0.0007072379812598228 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005358390000012037, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 50, + "wall_seconds": 0.00053795101121068 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007270519999948988, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 51, + "wall_seconds": 0.0007291090150829405 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004175970000019902, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 51, + "wall_seconds": 0.0004193390195723623 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007032029999933798, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 52, + "wall_seconds": 0.0007052169821690768 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000352722999998889, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 52, + "wall_seconds": 0.0003541340120136738 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006563889999995354, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 53, + "wall_seconds": 0.0006583080103155226 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00040455599999944525, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 53, + "wall_seconds": 0.0004061350191477686 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008041829999996253, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 54, + "wall_seconds": 0.0008059109968598932 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004334829999947942, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 54, + "wall_seconds": 0.00043510799878276885 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000748314999995614, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 55, + "wall_seconds": 0.0007503170054405928 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00039218999999945936, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 55, + "wall_seconds": 0.0003937039873562753 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007158480000057921, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 56, + "wall_seconds": 0.0007178939995355904 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00037048600000133547, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 56, + "wall_seconds": 0.0003719509986694902 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007888640000004443, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 57, + "wall_seconds": 0.000790806021541357 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00039068699999944556, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 57, + "wall_seconds": 0.0003924180055037141 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0009870989999996027, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 58, + "wall_seconds": 0.0009893440001178533 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000490261000003045, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 58, + "wall_seconds": 0.0004918829945381731 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007919929999999908, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 59, + "wall_seconds": 0.0007937680056784302 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00041902199999555023, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 59, + "wall_seconds": 0.0004205779987387359 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0009626649999958659, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 60, + "wall_seconds": 0.0009643759985920042 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005500830000002566, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 60, + "wall_seconds": 0.0005518139805644751 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008089869999992061, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 61, + "wall_seconds": 0.0008109210175462067 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004530530000010913, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 61, + "wall_seconds": 0.0004548550059553236 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0009862970000042992, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 62, + "wall_seconds": 0.000988504005363211 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005403040000047099, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 62, + "wall_seconds": 0.0005420820089057088 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0010192639999999642, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 63, + "wall_seconds": 0.0010213720088358968 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005207570000038686, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 63, + "wall_seconds": 0.0005224320048000664 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008628089999973554, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 64, + "wall_seconds": 0.0008648359798826277 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004855410000033089, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 64, + "wall_seconds": 0.0004874130245298147 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0011713899999961086, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 65, + "wall_seconds": 0.0011805260146502405 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005708859999984384, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 65, + "wall_seconds": 0.0005726699891965836 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0011818360000006578, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 66, + "wall_seconds": 0.0011838439968414605 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005968450000040093, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 66, + "wall_seconds": 0.000598366983467713 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0010762960000008093, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 67, + "wall_seconds": 0.001078705012332648 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000536252999999931, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 67, + "wall_seconds": 0.0005382019735407084 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000905258999999603, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 68, + "wall_seconds": 0.0009072610118892044 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004415940000015439, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 68, + "wall_seconds": 0.00044345599599182606 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000903330999996399, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 69, + "wall_seconds": 0.0009102470066864043 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005234230000041862, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 69, + "wall_seconds": 0.0005249939858913422 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008097159999991277, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 70, + "wall_seconds": 0.0008116200042422861 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00046308200000311217, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 70, + "wall_seconds": 0.00046472199028357863 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000883508000001143, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 71, + "wall_seconds": 0.0008853540057316422 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005278459999971119, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 71, + "wall_seconds": 0.0005339839844964445 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008980179999937832, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 72, + "wall_seconds": 0.0008997730037663132 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00046848499999896376, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 72, + "wall_seconds": 0.00047008501132950187 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0009215079999975728, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 73, + "wall_seconds": 0.0009335569920949638 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005218889999980547, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 73, + "wall_seconds": 0.0005234749987721443 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0009699949999983914, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 74, + "wall_seconds": 0.0009719010267872363 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005751719999977922, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 74, + "wall_seconds": 0.0005769220006186515 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00016540600000070071, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 5, + "wall_seconds": 0.0001672340149525553 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 8.077900000103e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 5, + "wall_seconds": 8.215001435019076e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013186300000000983, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 6, + "wall_seconds": 0.00013337700511328876 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 7.410299999577319e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 6, + "wall_seconds": 7.534000906161964e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00014018500000645417, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 7, + "wall_seconds": 0.00014185599866323173 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 7.636299999802532e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 7, + "wall_seconds": 7.76439846958965e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013441000000113945, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 8, + "wall_seconds": 0.00013581098755821586 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 8.42940000040926e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 8, + "wall_seconds": 8.563499432057142e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00015905000000060454, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 9, + "wall_seconds": 0.0001607910089660436 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 9.353099999742653e-05, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 9, + "wall_seconds": 9.483000030741096e-05 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00015107000000114112, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 10, + "wall_seconds": 0.0001524980179965496 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013862100000494593, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 10, + "wall_seconds": 0.0001401000190526247 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00018284100000443004, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 11, + "wall_seconds": 0.00018437899416312575 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00010612700000223185, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 11, + "wall_seconds": 0.00010742200538516045 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00019088799999877892, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 12, + "wall_seconds": 0.0001926789991557598 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00010932100000360379, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 12, + "wall_seconds": 0.00011068000458180904 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00019194000000055667, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 13, + "wall_seconds": 0.0001933479798026383 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00011167400000289263, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 13, + "wall_seconds": 0.00011319699115119874 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022051799999900368, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 14, + "wall_seconds": 0.00022200500825420022 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001299320000001103, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 14, + "wall_seconds": 0.00013141598901711404 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002870530000009808, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 15, + "wall_seconds": 0.00028899998869746923 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013176800000280764, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 15, + "wall_seconds": 0.0001331249950453639 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022680600000057893, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 16, + "wall_seconds": 0.00022838101722300053 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00013158600000195975, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 16, + "wall_seconds": 0.0001329020014964044 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002557899999970914, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 17, + "wall_seconds": 0.0002573060046415776 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00015454100000056314, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 17, + "wall_seconds": 0.00015591800911352038 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002311320000032424, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 18, + "wall_seconds": 0.00023278401931747794 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00014364200000471783, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 18, + "wall_seconds": 0.00014508698950521648 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00028555700000509887, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 19, + "wall_seconds": 0.00028711199411191046 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00016130199999508932, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 19, + "wall_seconds": 0.00016271401545964181 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00028834599999782995, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 20, + "wall_seconds": 0.0002899190003518015 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00016102600000067468, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 20, + "wall_seconds": 0.00016239102114923298 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000323231999999507, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 21, + "wall_seconds": 0.00032486399868503213 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00020316200000536355, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 21, + "wall_seconds": 0.0002080590056721121 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003158209999938322, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 22, + "wall_seconds": 0.00031760698766447604 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0001776340000034793, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 22, + "wall_seconds": 0.00017908602603711188 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003375300000030279, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 23, + "wall_seconds": 0.00033913698280230165 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00018624099999442478, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 23, + "wall_seconds": 0.00018761400133371353 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00033312799999407616, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 24, + "wall_seconds": 0.00033464899752289057 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00019222600000290413, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 24, + "wall_seconds": 0.00019369900110177696 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003622549999988678, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 25, + "wall_seconds": 0.0003639799833763391 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00020208099999763363, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 25, + "wall_seconds": 0.00020334700820967555 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005969140000061657, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 26, + "wall_seconds": 0.0005988780176267028 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00030627699999996594, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 26, + "wall_seconds": 0.00030800202512182295 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00041758899999422283, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 27, + "wall_seconds": 0.00041932601016014814 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00022191600000098788, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 27, + "wall_seconds": 0.00022345100296661258 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004690920000030019, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 28, + "wall_seconds": 0.0004707580083049834 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002628829999977711, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 28, + "wall_seconds": 0.00026455699116922915 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00040088800000148694, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 29, + "wall_seconds": 0.0004026360111311078 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00024790199999813467, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 29, + "wall_seconds": 0.0002493899955879897 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003247639999983676, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 30, + "wall_seconds": 0.0003264860133640468 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00018521500000190372, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 30, + "wall_seconds": 0.00018658197950571775 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005028180000010707, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 31, + "wall_seconds": 0.0005045229918323457 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00027881099999405023, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 31, + "wall_seconds": 0.0002802789967972785 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005080990000010388, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 32, + "wall_seconds": 0.0005097539979033172 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002878680000009126, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 32, + "wall_seconds": 0.00028934498550370336 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0004491369999968242, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 33, + "wall_seconds": 0.00045100602437742054 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00023924799999974766, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 33, + "wall_seconds": 0.00024072499945759773 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005583840000014106, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 34, + "wall_seconds": 0.0005601519951596856 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00030376800000198045, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 34, + "wall_seconds": 0.00030525799957104027 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005313119999996729, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 35, + "wall_seconds": 0.0005365980032365769 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003111549999985641, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 35, + "wall_seconds": 0.00031268701422959566 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005150950000043508, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 36, + "wall_seconds": 0.0005168149946257472 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003032699999963029, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 36, + "wall_seconds": 0.00030487400363199413 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005494279999993523, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 37, + "wall_seconds": 0.000551136996364221 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003177330000028178, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 37, + "wall_seconds": 0.0003190720162820071 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005048499999986689, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 38, + "wall_seconds": 0.000506484997458756 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002674799999979882, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 38, + "wall_seconds": 0.0002690829860512167 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005493470000033085, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 39, + "wall_seconds": 0.0005510629853233695 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00028910400000370373, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 39, + "wall_seconds": 0.00029049100703559816 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006743049999968775, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 40, + "wall_seconds": 0.0006761649856343865 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00033628599999957487, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 40, + "wall_seconds": 0.0003377599932719022 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005429320000018834, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 41, + "wall_seconds": 0.0005445849965326488 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003050529999981677, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 41, + "wall_seconds": 0.00030645300284959376 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005892870000039352, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 42, + "wall_seconds": 0.0005949450132902712 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003266889999977707, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 42, + "wall_seconds": 0.0003285080019850284 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006104029999960403, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 43, + "wall_seconds": 0.0006122740160208195 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003407709999976305, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 43, + "wall_seconds": 0.00034233101177960634 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005100819999981354, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 44, + "wall_seconds": 0.0005118419940117747 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0002899640000038062, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 44, + "wall_seconds": 0.0002914220094680786 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0005679970000045387, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 45, + "wall_seconds": 0.0005695870204363018 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003053579999985345, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 45, + "wall_seconds": 0.0003069849917665124 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006163540000017065, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 46, + "wall_seconds": 0.0006181209755595773 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003390749999994114, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 46, + "wall_seconds": 0.00034045299980789423 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007048080000018331, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 47, + "wall_seconds": 0.000709834013832733 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00039225999999814576, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 47, + "wall_seconds": 0.00039365902193821967 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006885789999984127, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 48, + "wall_seconds": 0.0006901239976286888 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003742540000004624, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 48, + "wall_seconds": 0.00037577300099655986 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007642650000008189, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 49, + "wall_seconds": 0.0007659099937882274 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00042872400000248945, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 49, + "wall_seconds": 0.00043020700104534626 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007181249999987926, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 50, + "wall_seconds": 0.0007201400003395975 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003679320000031794, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 50, + "wall_seconds": 0.000369468005374074 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0008098570000001359, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 51, + "wall_seconds": 0.0008162379963323474 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00042853499999750966, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 51, + "wall_seconds": 0.00043027798528783023 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.000693945999998391, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 52, + "wall_seconds": 0.0006955930148251355 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0003763960000000566, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 52, + "wall_seconds": 0.0003779969993047416 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0006773129999970706, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 53, + "wall_seconds": 0.0006789749895688146 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00036254300000138073, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 53, + "wall_seconds": 0.0003638869966380298 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.0007084790000035923, + "exception": null, + "family": "error_trace", + "outermost": true, + "program_length": 54, + "wall_seconds": 0.0007103410025592893 + }, + { + "classification": "finite_fixture", + "cpu_seconds": 0.00038912099999777183, + "exception": null, + "family": "reverse_all", + "outermost": true, + "program_length": 54, + "wall_seconds": 0.0003906239871867001 + } + ] + }, + "integer_source_sha256": "82a73e4bcf1835bfdd510c7ad5538625c1b380c559b671e6a67be490615a743a", + "key_disjoint_union_seconds": { + "cpu": 2.577710656000054, + "wall": 2.6140917660009224 + }, + "native_key_regions": { + "after_callback": { + "closed": 347439, + "cpu_seconds": 0.4405703460000047, + "entries": 347439, + "errors": 6, + "excluded_callback": 0, + "hits": 0, + "inserted": 347433, + "misses": 0, + "timed": 347439, + "wall_seconds": 0.44372518899999314 + }, + "callback_depth": 0, + "clock_failures": 0, + "integer_depth": 0, + "integer_enters": 246, + "integer_leaves": 246, + "integer_overlap_intervals": 0, + "key_depth": 0, + "lookup": { + "closed": 2600825, + "cpu_seconds": 2.1371403100000492, + "entries": 2600825, + "errors": 3, + "excluded_callback": 0, + "hits": 2253383, + "inserted": 0, + "misses": 347439, + "timed": 2600825, + "wall_seconds": 2.1703665770009293 + }, + "nested_key_intervals": 0, + "protocol_errors": 0 + }, + "necessary_zero_cost_threshold_seconds": { + "cpu": 5.1705, + "wall": 5.199267808800505 + }, + "optimization_constructed": false, + "original_cache_statistics_unchanged": true, + "original_fraction_callback_and_score_order_unchanged": true, + "outer_cpu_must_include_compiler_children": true, + "overlap_rejected": true, + "performance_sample": false, + "prior_run_numbers_added": false, + "provisional_new_control_reserve_seconds": { + "cpu": 0.5, + "wall": 0.5 + }, + "provisional_reserve_is_measured_bill": false, + "reserve_gate": { + "cpu": true, + "wall": true + }, + "retained_integer_runtime": "UNPRICED_NONZERO", + "retained_key_runtime": "UNPRICED_NONZERO", + "same_run_disjoint_union_seconds": { + "cpu": 7.261139371000038, + "wall": 7.298804342273354 + }, + "scope": "same frozen PR5864 full_C qualifier scope; original separately registered custody scope unchanged", + "screen_status": "HEADROOM_FOR_COST_DESIGN_ONLY", + "source_copy": { + "all_other_baseline_bytes_and_modes_equal": true, + "copied_baseline_files": 164, + "current_original_baseline_compared_per_file": true, + "diagnostic_edits_reverse_to_exact_original": true, + "diagnostic_native_sha256": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3", + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" + }, + "status": "PASS_JOINT_COST_DIAGNOSTIC", + "zero_cost_gate": { + "cpu": true, + "wall": true + } +} diff --git a/research/verification-key-headroom/context/PLAN.json b/research/verification-key-headroom/context/PLAN.json new file mode 100644 index 0000000000..076a830b35 --- /dev/null +++ b/research/verification-key-headroom/context/PLAN.json @@ -0,0 +1,51 @@ +{ + "status": "ACTIVE_AUTHORIZED_ALL_FOUR", + "created_utc": "2026-10-27T12:01:43.486342+00:00", + "base_main": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "performance_baseline": "PR5864 3f15c943e4ad6479f03e674c80fff1269a16ccfe", + "target": "At least 15% further complete wall AND CPU reduction over frozen PR5864, with a full assessment of all four opportunities. Positive smaller independent increments may be retained; goal remains unfulfilled until target/all-assessments/publication are complete.", + "opportunities": { + "1": "bulk exact rational batching", + "2": "native arbitrary-width integer sparse/reverse loops", + "3": "exact matrix and finite-field kernels, separate workload", + "4": "canonical dyadic witness formatting" + }, + "coverage": "All original and PR5864 checks retained and charged; independent Python Fraction oracle unchanged, exact output types/witnesses/hash bytes and all inputs preserved.", + "measurement_rule": { + "order": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "baseline": "fresh cold complete PR5864", + "candidate": "same workload plus every new finite/native/binding check and cold compiler/link/load", + "preliminary_pair_gate": "both wall/CPU positive, greater than declared 0.50 sec absolute conservative noise allowance, with optimistic route to 15% cumulative. No dropped samples or automatic retries.", + "final_gate": "both median wall and CPU improvement >=15%, absolute saving >0.50 sec and > observed complete repeat spread, exact scientific receipts all equal", + "platform": "frozen Linux CPython 3.12", + "profiling": "diagnostic only; never convert nested totals to complete speed claims" + }, + "caps": { + "serial_numerical_runner": true, + "command_seconds": 180, + "sampled_process_group_rss_bytes": 1073741824, + "initial_feasibility_seconds": 600, + "shared_round_seconds": 1500, + "automatic_retries": 0 + }, + "roles": { + "parent": "sole numerical runner, integration, matrix assessment, Chrome publication", + "astra_rational_design": "static creative design/source rational/ only", + "astra_integer_format": "static source integer-format/ only" + }, + "publication": "fresh upstream main/overlap checks, isolated scoped worktree, source pins/credit, upstream PR template, normal/O/readonly export/committed-byte checks, exact-head CI and seven-field handoff readback; Chrome for GitHub writes; nonforce SSH fork push", + "paused": [ + "kappa research", + "Work1/Work2 mathematics", + "unrelated feeds", + "automations" + ], + "preservation": "No modification of synced sources/, old checkpoints, old evidence or original thread" +} diff --git a/research/verification-key-headroom/context/baseline-public/.gitignore b/research/verification-key-headroom/context/baseline-public/.gitignore new file mode 100644 index 0000000000..4446e4135a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/.gitignore @@ -0,0 +1,3 @@ +__pycache__/ +work/ +*.so diff --git a/research/verification-key-headroom/context/baseline-public/.research-export.json b/research/verification-key-headroom/context/baseline-public/.research-export.json new file mode 100644 index 0000000000..8317f3ff54 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/.research-export.json @@ -0,0 +1,985 @@ +{ + "commit": "3f15c943e4ad6479f03e674c80fff1269a16ccfe", + "files": [ + { + "mode": 420, + "path": "research/fraction-native-qualification/.gitignore", + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78", + "size": 24 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/GETTER-SHAPES.json", + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4", + "size": 171 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/NATIVE-SOURCE.json", + "sha256": "2bc3043374685ece68f0091238ab038f6cfcd13be80610b5e348d61984cb11f3", + "size": 83 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/NOTICE", + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83", + "size": 1864 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/PROOF.md", + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b", + "size": 7262 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/README.md", + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95", + "size": 8035 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/RESULT.json", + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188", + "size": 5100 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/SOURCES.json", + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc", + "size": 5864 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/TASK.json", + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c", + "size": 3484 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/VALIDATION.json", + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4", + "size": 3832 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/VERIFY.json", + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53", + "size": 1300 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/actual_audit.py", + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a", + "size": 2691 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/benchmark.py", + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5", + "size": 2818 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/compact_finite.py", + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1", + "size": 4892 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/compact_parent.py", + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a", + "size": 5285 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/custody.py", + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f", + "size": 757 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/entry_finite.py", + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9", + "size": 7667 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/entry_parent.py", + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe", + "size": 4334 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/FINITE-INERT-GC-FIXTURE.py.txt", + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4", + "size": 597 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/HARNESS-CORRECTION.json", + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b", + "size": 1137 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md", + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767", + "size": 11022 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/NATIVE-CACHE-REVIEW-SOURCES.json", + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9", + "size": 1417 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md", + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448", + "size": 6046 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/NATIVE-REVIEW-FINAL-STATE.json", + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243", + "size": 1241 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/PLAN.json", + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434", + "size": 1226 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/SCREEN.json", + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c", + "size": 1234 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/SEALED-RESULT.json", + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f", + "size": 1241 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/SCREEN.json", + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83", + "size": 1606 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/STATE.json", + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a", + "size": 1956 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json", + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a", + "size": 1010 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt", + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26", + "size": 1082 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json", + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json", + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93", + "size": 467 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/SCREEN.json", + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834", + "size": 554 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/STATE.json", + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17", + "size": 266 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json", + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5", + "size": 1008 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt", + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2", + "size": 485 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json", + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json", + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d", + "size": 657 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/STATE.json", + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20", + "size": 98 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json", + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875", + "size": 1007 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt", + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c", + "size": 1092 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json", + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/portable/runs/complete-native/receipt.json", + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0", + "size": 1019 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/portable/runs/complete-native/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/portable/runs/complete-native/stdout.txt", + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "size": 14301 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/portable/runs/complete-native/usage.json", + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/GATE-2.json", + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7", + "size": 363 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/GATE-6.json", + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de", + "size": 391 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/benchmark.py", + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa", + "size": 2488 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/dispatch.py", + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8", + "size": 790 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/guard.py", + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "size": 5090 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B1/receipt.json", + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5", + "size": 998 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B1/stdout.txt", + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9", + "size": 1086 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B1/usage.json", + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B2/receipt.json", + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9", + "size": 999 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B2/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B2/stdout.txt", + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0", + "size": 1086 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B2/usage.json", + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B3/receipt.json", + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8", + "size": 997 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B3/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B3/stdout.txt", + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2", + "size": 1086 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/B3/usage.json", + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C1/receipt.json", + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba", + "size": 999 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C1/stdout.txt", + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f", + "size": 14103 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C1/usage.json", + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C2/receipt.json", + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579", + "size": 998 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C2/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C2/stdout.txt", + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c", + "size": 14105 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C2/usage.json", + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C3/receipt.json", + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9", + "size": 999 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C3/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C3/stdout.txt", + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193", + "size": 14101 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/C3/usage.json", + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/receipt.json", + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3", + "size": 1021 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/stdout.txt", + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5", + "size": 1831 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/actual-native-apply/usage.json", + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/receipt.json", + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a", + "size": 1016 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/stdout.txt", + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c", + "size": 7524 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/apply-micro-native/usage.json", + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/receipt.json", + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410", + "size": 1006 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/stdout.txt", + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18", + "size": 11770 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-O/usage.json", + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/receipt.json", + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432", + "size": 1020 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/stdout.txt", + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87", + "size": 11834 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-bound-debug/usage.json", + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json", + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c", + "size": 1021 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt", + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1", + "size": 11770 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-cleanup-debug/usage.json", + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json", + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6", + "size": 1021 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt", + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221", + "size": 11769 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug-cleanup/usage.json", + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/receipt.json", + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581", + "size": 1016 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stderr.txt", + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877", + "size": 185 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/stdout.txt", + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1", + "size": 11769 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-debug/usage.json", + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/receipt.json", + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a", + "size": 1020 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/stdout.txt", + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6", + "size": 11835 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-final-debug/usage.json", + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/receipt.json", + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972", + "size": 1015 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/stdout.txt", + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b", + "size": 11769 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-initial/usage.json", + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/receipt.json", + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e", + "size": 1057 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stderr.txt", + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8", + "size": 625 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/stdout.txt", + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb", + "size": 7318 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-packet-O/usage.json", + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675", + "size": 118 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/receipt.json", + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a", + "size": 1016 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt", + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36", + "size": 11835 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-reviewed-O/usage.json", + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/receipt.json", + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de", + "size": 1017 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt", + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519", + "size": 11948 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/finite-native-snapshot-O/usage.json", + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/full-native-O/receipt.json", + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448", + "size": 1010 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/full-native-O/stdout.txt", + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54", + "size": 14103 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/full-native-O/usage.json", + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1", + "size": 82 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/micro-native/receipt.json", + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4", + "size": 1005 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/micro-native/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/micro-native/stdout.txt", + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9", + "size": 1708 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/micro-native/usage.json", + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/receipt.json", + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d", + "size": 1018 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/stdout.txt", + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b", + "size": 12183 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite-O/usage.json", + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/receipt.json", + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d", + "size": 1016 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/stdout.txt", + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab", + "size": 12183 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/evidence/runtime/runs/packaged-native-finite/usage.json", + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3", + "size": 80 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/finite.py", + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359", + "size": 9441 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/fraction_table.py", + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4", + "size": 6483 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/frozen.py", + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547", + "size": 3197 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/full.py", + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "size": 3061 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/full_B.py", + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a", + "size": 34 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/full_C.py", + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394", + "size": 33 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/guard.py", + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "size": 5090 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/inputs/PR5848.tar", + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6", + "size": 614400 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/micro.py", + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53", + "size": 1205 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/micro_apply.py", + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e", + "size": 1748 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/native_backend.py", + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d", + "size": 2992 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/native_cache.c", + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "size": 13895 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/parent_finite.py", + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f", + "size": 10693 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/replay.py", + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9", + "size": 801 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/replay_driver.py", + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528", + "size": 267 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/slot_binding.py", + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593", + "size": 2718 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/slot_finite.py", + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390", + "size": 4804 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/slot_parent.py", + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24", + "size": 4366 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/table_parent.py", + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4", + "size": 5205 + }, + { + "mode": 420, + "path": "research/fraction-native-qualification/verify.py", + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82", + "size": 692 + } + ], + "format": "research-package-export-v1", + "package": "research/fraction-native-qualification" +} diff --git a/research/verification-key-headroom/context/baseline-public/GETTER-SHAPES.json b/research/verification-key-headroom/context/baseline-public/GETTER-SHAPES.json new file mode 100644 index 0000000000..d3dadac227 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/GETTER-SHAPES.json @@ -0,0 +1,4 @@ +{ + "numerator": "2223091528d16d7797026549874741a186c586604b625862f0c09b4baadafdcf", + "denominator": "dba448f5b021e71de33e6a5b388bac53022b886e7d8cb0ca59577ff038467efd" +} diff --git a/research/verification-key-headroom/context/baseline-public/NATIVE-SOURCE.json b/research/verification-key-headroom/context/baseline-public/NATIVE-SOURCE.json new file mode 100644 index 0000000000..793edb7fd8 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/NATIVE-SOURCE.json @@ -0,0 +1,3 @@ +{ + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" +} diff --git a/research/verification-key-headroom/context/baseline-public/NOTICE b/research/verification-key-headroom/context/baseline-public/NOTICE new file mode 100644 index 0000000000..3cd6a81a60 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/NOTICE @@ -0,0 +1,9 @@ +Fraction arithmetic primitive profile and bounded contribution-table feasibility +============================================================================ +Original Fraction/error arithmetic: Ali Romman, retaining Adam Gall/ywz65/PR2878, PR5826/5819, Mason Hale/PR5811 and all P104/native/compiler/precision notices. Full PR5848, PR5831 and nested source archives are unchanged. Apache-2.0. + +New primitive profiling, exact local table, finite/key/capacity/failure checks and complete-cost screen: Chris R / Clear1nsight, substantial OpenAI Codex assistance; no subagents or independent human/kernel acceptance. Memoization is a standard technique. PR5848/5839 supply the qualifier/Linux baseline; PR5816/5818/5832/5761 retain tooling and test-repair credit with original authorship. The prior zero/unit negative artifact71f22c77b393e5cc14925c771894dc1a92c8443c supplies source-binding and finite-fixture lineage. No complete performance or kappa improvement is claimed. + +Source-bound entry type gate: Chris R / Clear1nsight with substantial OpenAI Codex assistance; no independent human or proof-kernel acceptance. Parent table/finite bytes retained exactly from df9dc4c89b31494f1390d16b9ca2a15e5946e853 (PR5852). Publication agents handled only earlier branches, not this scientific test. + +Native cache/context, source-bound slot/compact-key integration and complete cold-build qualifier: Chris R / Clear1nsight with substantial OpenAI Codex assistance and GPT-6-astra xhigh static review. The original Fraction miss arithmetic and independent exact integer engine are unchanged. C API/reference-counting/memoization are standard techniques. Preserve all inherited authors and Apache-2.0 notices. The C helper is new code; it does not port CPython arithmetic. Local measured timings are not a universal speedup or hosted performance validation. No kappa claim. diff --git a/research/verification-key-headroom/context/baseline-public/PROOF.md b/research/verification-key-headroom/context/baseline-public/PROOF.md new file mode 100644 index 0000000000..98076aaa39 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/PROOF.md @@ -0,0 +1,37 @@ +# Equivalence and complete-cost obligations + +This is a source-bound implementation argument for the frozen PR5848 qualifier, supported by exact finite/actual comparisons and local cold-process measurements. It is not a formal proof of arbitrary Python callbacks, a multiplication theorem or a kappa admission. + +## Entry domain and arithmetic + +Retain the predecessor's conservative identity-only exact-container/type predicate. For that domain, induction through empty rows, INIT/CLEAR resets, F(1) injections, SCALE and ADD/COPY gives exact Fraction row coefficients. Weights are exact Fractions. Stable standard Fraction operations on exact operands return exact Fractions. Unknown/custom domains retain the checked generic behavior. Native selection additionally requires valid distinct source/destination rows, sufficient source-site metadata, and well-formed exact-Fraction scalar slots; other such cases use the literal original trace so error type/message/order are preserved. + +The canonical numerator/denominator property getters are bound to their pure executable shapes, owned member descriptors and ordinary object attribute lookup. Before each trace, identity/code/presence freshness is rechecked. Getter, slot or lookup drift selects the literal original. The miss callback is extracted from raw class MRO dictionaries only after verifying an exact staticmethod descriptor, exact FunctionType, no closure/defaults, the literal original compute code shape and captured builtin abs. A foreign descriptor is not invoked to inspect it. Nonqualifying callbacks select the checked parent path, allowing retained corruption controls to detect altered arithmetic. + +Each successful miss computes exactly `value = old + q*v`, `change = abs(value)-abs(old)`, then returns `(value, change*a, change*c, change)`, with the original Python Fraction operations. The native helper does not implement rational arithmetic. Cached values are immutable exact-Fraction tuples under the predecessor's stable-input/runtime premise. + +## Complete key and FIFO invariant + +The key is `(old_n,old_d,q_n,q_d,v_n,v_d,weight_token)`. Per-trace tokens are assigned injectively to complete `(a_n,a_d,c_n,c_d)` pairs using full Python integer equality after hash comparison, bounded to 16,384 distinct pairs with no recycling. Equal canonical weights share a token; unequal pairs cannot. Metadata is indexed by original source site i, not event position. Event owns q and its canonical key components. Overflow or invalid metadata selects original behavior. + +Initially dictionary and fixed ring are empty. Each dictionary entry has exactly one owned ring-key reference, with `used` resident entries and `head` at the next insertion/oldest eviction slot. Hits return an owned reference to the dictionary result and do not reorder the ring. A miss increments the same counters and performs original computation before eviction. At capacity, delete the oldest dictionary key and clear its ring reference; then insert and advance. Failed computation never evicts or caches. If insertion itself fails after eviction, the ring/dictionary remain consistent with a smaller cache, and the error propagates. Counters are bounded against C signed overflow. Per-trace Cache objects are fresh; only code is reused in a process. + +## Coefficient-loop correspondence and native ownership + +The complete literal source loop is authenticated before replacement. Native apply uses the actual Python dict-items iterator, preserving order and its size/key mutation errors. Each item tuple holds source index/value strongly across callbacks. Each iteration constructs F(0), obtains the destination's old coefficient, gets the exact contribution tuple, performs the three ordered PyNumber_InPlaceAdd updates and updates/removes the destination exactly as the Python loop. Checked score retrieval and strong temporary references remain safe around Python callbacks. Rounded injection, score peaks, witness capture, stream hashing and return structure remain in the unchanged outer source. + +Cache owns dictionary, ring, immutable metadata snapshots, callback, descriptors and Fraction class. Event owns Cache and q context. Constructor tokens use checked owned reads, not unchecked reads from a mutable caller list across allocations. Partial initialization, error exits, GC traversal/clear/deallocation and Event-outliving-Cache cases are covered by source review and finite checks. A busy guard rejects reentrant mutation; errors reset it. Descriptor reads stop at the first failure. These defenses protect the packet API; the wrapper's semantic qualification is still required. + +The loader authenticates C bytes, copies exactly those bytes into an owned read-only build snapshot and compiles that snapshot. Loaded-code reuse requires the same authenticated source digest. Builds occur in a fresh temporary directory per complete candidate process, with explicit cleanup. Every fresh complete process pays compilation, linking, loading and validation. There is no system installation, persistent compiled-answer cache or native arithmetic shared with the independent integer engine. + +## Complete caller and oracle boundary + +The new full entry authenticates the complete readonly PR5848 export and changes exactly the sole actual noisy_precision error_trace immediately before the existing Observation wrapper. The separately loaded reference/integer engine, source contract, all reverse checks, 120 finite fixtures, six controls, final receipt and original Observation finite tests remain unchanged. Capture by program length is scoped to this exact frozen source, which calls error_trace once; it is not a general caller-identification rule. The full native output digest and exact cache counters are required in addition to the original complete scientific comparisons. + +The new native finite stage runs before the original complete entry in every timed C command. All 964 comparisons / 73 inherited +45 native controls are charged. The four inherited custody checks remain separate registered-verification obligations, just as in the predecessor benchmark. Independent backends do not share mutable caches or answers. Complete normal/O and exported-source replays supplement the finite gate. + +## Economics and limits + +The immutable-code build is shared only between the new finite stage and actual trace inside one process. The complete outer process is measured with GNU time, so compiler/linker child CPU is included. In six fresh serial B,C,C,B,B,C processes, wall medians are 40.516156 and 32.771297 seconds, CPU medians 40.33 and 32.74 seconds: 19.1155% and 18.8197% saved, passing both declared 15% gates. All observations, source inventories, stdout/stderr and failed harness attempts are retained. This evidence is specific to the frozen fixture and recorded Linux/CPython/GCC environment; inner trace timings, cost models and hosted finite replay are distinct claims. + +Static/API review by GPT-6-astra xhigh ran no compiler or numerical replay. Chris R / Clear1nsight with substantial OpenAI Codex assistance performed the single serial numerical execution. Original arithmetic/provenance remains Ali Romman and all retained predecessor authors; see NOTICE. No kappa or selected metadata changes. diff --git a/research/verification-key-headroom/context/baseline-public/README.md b/research/verification-key-headroom/context/baseline-public/README.md new file mode 100644 index 0000000000..927cbee16a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/README.md @@ -0,0 +1,62 @@ +# Native bookkeeping for complete PR5848 qualification + +The complete frozen qualifier runs in **32.77 rather than 40.52 seconds median wall time (19.12% less)** and **32.74 rather than 40.33 seconds median CPU (18.82% less)** on this Linux host. Each candidate command includes every new finite/native check and a fresh compile, link and load. Compiler-child CPU is counted. This is a local six-process B,C,C,B,B,C comparison, not a universal speedup or hosted performance result. + +This opt-in package follows [PR #5848](https://github.com/CrocSwap/integer-mult-bounds/pull/5848), [PR #5852](https://github.com/CrocSwap/integer-mult-bounds/pull/5852), [PR #5853](https://github.com/CrocSwap/integer-mult-bounds/pull/5853) and the [entry-domain handoff](https://github.com/CrocSwap/integer-mult-bounds/pull/5852#issuecomment-6436191164). It changes verification implementation; it makes no kappa, construction, physical-cost, compiler or selected-frontier claim. Kappa research remains paused. + +## What changes + +An exact 16,384-entry per-trace contribution table avoids recomputing pure Fraction contributions. Bounded injective tokens represent complete canonical weight pairs, always indexed by the original source site i. A small C extension implements the exact seven-integer key, FIFO bookkeeping and coefficient-loop control. It uses authenticated Fraction descriptors and ordinary Python C APIs, retaining the GIL. The original Python Fraction callback computes every miss; all three score additions still use Python numeric operations in their original order. Per-coefficient F(0) construction is deliberately retained. + +Rows, rounded injections, ideal metadata, full output comparisons, signed witnesses, peaks, hashes, reverse checks and the independent exact integer backend remain active. Mutable caches and answers never cross traces or backends. Only loaded immutable native code is reused within one fresh process; each fresh process pays its build. Unsupported or changed native packets use the inherited checked path or literal original trace under the documented domain rules. A platform without the required compiler/headers fails native qualification explicitly. + +## Frozen sources and coverage + +Canonical main: `de5ec2e7a6074068452f45b1a191b5c72832df4a`, priority 8. Complete PR5848: `66fb6c6b8683b37967e9d7f313b3df99a49d2406`. Its 97-file official export remains byte-for-byte unchanged. The source manifest pins all 12 retained inputs to own ancestor `2ebc3a071c62fc839aaed1291220d78a317395d4`. The separate inherited test-only PR5761 repair retains its exact author/commit credit; no shared test is weakened here. + +- **964** complete finite comparisons on 241 programs at four capacities, with full values, numeric types and input preservation. +- **73** inherited controls and **45** native controls, covering collision equality, FIFO wrap, exceptions, source/runtime drift, fallback, metadata ownership, cyclic GC, re-entry and malformed C API packets. +- **Four** unchanged predecessor source-custody rejection checks in registered verification, separate from both timed candidate.py stages as in PR5848. +- Complete independent qualification on **25,984 events / 799 coordinates**, including all 120 inherited independent finite fixtures, six source controls, full actual ideal/error outputs and witness comparisons. Actual output SHA256: `954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9`. +- Complete optimized qualification also passes. The C native actual path preserves 2,579,750 calls, 2,252,966 hits, 326,784 misses, 310,400 FIFO evictions and 3,587 weight tokens. + +The native API accepts validated packets from the source-bound wrapper. Its error/lifetime checks are memory-safety defenses, not a theorem that arbitrary callbacks or noninjective supplied tokens have Fraction semantics. The proof assumes stable inputs/runtime during a trace, matching the predecessor. Full-C-API support is the tested CPython 3.12 ABI; this is not abi3, subinterpreter or free-threaded support. + +## Reproduction + +Tested on Linux x86_64, CPython 3.12.3 and GCC 13.3. An existing `cc` and Python 3.12 development headers are required; no dependencies are installed and no compiled binary is committed. + +Registered finite/native/source verification, about three seconds here: + +```sh +python3 -B scripts/research_package.py --package research/fraction-native-qualification +``` + +Explicit complete guarded replay, about 33 seconds here. Choose a new evidence directory outside the package; it retains stdout, stderr, timing, source inventory and RSS receipts: + +```sh +python3 -B research/fraction-native-qualification/replay.py /tmp/native-qualification-evidence +``` + +Fresh complete timing round, first pair then the remaining fixed-order repetitions only if the first pair passes both 15% gates: + +```sh +python3 -B research/fraction-native-qualification/benchmark.py pair /tmp/native-qualification-benchmark +python3 -B research/fraction-native-qualification/benchmark.py remaining /tmp/native-qualification-benchmark +``` + +The same default 180-second command / 1 GiB sampled process-group RSS / 600-second initial round and 1,500-second shared-round contract applies. One serial runner, zero automatic retries. Do not infer complete performance from the inner `qualify.seconds`: it excludes the preceding native finite/build stage. The outer GNU-time receipt is authoritative and includes compiler children. The original raw timing driver and every observation are retained under `evidence/runtime`; the portable wrapper changes evidence/source path resolution only. + +## Findings, failures and limits + +The earlier table, entry gate and compact keys were correct within their tested domains but failed their complete-cost screens. Cache-only C lookups were slightly slower than the Python slot-key parent in the fixed micro screen. The full coefficient-loop mechanism subsequently passed a complete actual audit and the complete timing gate. Do not discard those negative results or credit all improvement to C alone: the candidate combines the exact table, source-bound entry/compact/slot mechanisms and native bookkeeping. + +The first debug attempt passed scientific checks but stopped on a temporary-directory cleanup ResourceWarning. Explicit cleanup fixed it without suppressing warnings. A later forced-GC constructor fixture was inert: its callback did not run during construction, so it did not demonstrate the intended interleaving. That failure and draft remain; a deterministic metadata-ownership test replaced it. Checked constructor token reads remain a source-reviewed safety condition. No empirically exercised constructor-GC interleaving is claimed. All attempts are retained; no automated retry or timing sample was dropped. + +The source reviewer is a user-requested GPT-6-astra xhigh agent and performed static review only. All compiler and numerical execution used one parent runner. This is assisted engineering verification, without independent human or proof-kernel acceptance. Registered hosted replay covers finite/native/source checks; it does not itself freshly establish the local complete-performance measurements. See [PROOF.md](PROOF.md), [VALIDATION.json](VALIDATION.json), the [complete timing gate](evidence/runtime/GATE-6.json) and the retained static reviews. + +## Open next questions + +Can a further source-bound reduction in the remaining coefficient/score bookkeeping pay its additional validation bill? First census the new candidate, refresh upstream overlap and name one bounded feasibility test. Keep this measured candidate frozen during publication. A new arithmetic implementation would require a broader independent proof and validation bill; it is outside this contribution. + +Original mathematics/arithmetic: Ali Romman and all retained P104/native/compiler/precision authors; see NOTICE and nested archives. New profiling, table/domain/compact/slot integration, C helper and validation: Chris R / Clear1nsight with substantial OpenAI Codex/Astra assistance. Apache-2.0. diff --git a/research/verification-key-headroom/context/baseline-public/RESULT.json b/research/verification-key-headroom/context/baseline-public/RESULT.json new file mode 100644 index 0000000000..a5ccf66db3 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/RESULT.json @@ -0,0 +1,154 @@ +{ + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_coverage_preserved": true, + "inherited": { + "all_complete_values_and_types_equal": true, + "cases": 241, + "controls": [ + "returned-mutation-isolated", + "source-drift", + "Fraction-type-drift", + "module-byte-drift", + "live-code-drift", + "nested-live-code-drift", + "omitted-witness", + "omitted-rounded-sites", + "wrong-coefficient", + "wrong-weighted-increment", + "bad-role", + "bad-scalar", + "missing-weight", + "restore-success", + "restore-exception", + "fresh-derivation", + "key-field-0", + "key-field-1", + "key-field-2", + "key-field-3", + "key-field-4", + "FIFO-eviction", + "canonical-key", + "hash-collision", + "disabled", + "invalid-capacity--1", + "invalid-capacity-16385", + "invalid-capacity-True", + "invalid-capacity-1.5", + "uncached-exception-0", + "uncached-exception-1", + "fresh-call-table", + "stats-mutation", + "failed-call-clears-stats" + ], + "events": 10164, + "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY" + }, + "new_control_count": 20, + "new_controls": [ + "all-241-fixtures-take-certified-domain", + "subtypes-and-foreign-types-fall-back-without-custom-methods", + "metaclass-container", + "metaclass-scalar", + "original-fallback-dict-subclass", + "original-fallback-program-subclass", + "original-fallback-event-subclass", + "original-fallback-weights-subclass", + "original-fallback-row-subclass", + "original-fallback-rounded-subclass", + "original-fallback-Fraction-subclass", + "original-fallback-integer-weights", + "original-fallback-boolean-public", + "exact-internal-type-preservation-at-certified-updates", + "malformed-outcome-missing-weight", + "malformed-outcome-bad-role", + "malformed-outcome-bad-scalar", + "malformed-outcome-short-event", + "recertification-invalidates-certified-method", + "disabled-capacity-not-certified" + ], + "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY" + }, + "new_control_count": 9, + "new_controls": [ + "canonical-full-pair-tokens", + "weight-token-hash-collision", + "bounded-context-overflow", + "event-q-canonical-equality-and-FIFO-counters", + "six-complete-trace-counter-and-type-comparisons", + "source-site-weight-ownership", + "wrong-token-alias-detected", + "overflow-fallback-preserves-original", + "fresh-token-and-cache-lifetimes" + ], + "status": "PASS_COMPACT_KEY_FINITE_ONLY" + }, + "new_control_count": 10, + "new_controls": [ + "changed-getter-invalidates", + "changed-live-getter-code", + "foreign-slot-probe-is-pure", + "changed-attribute-lookup", + "missing-attribute-handler-presence", + "binding-restored", + "slot-path-selected", + "post-derive-getter-drift-literal-fallback", + "uninitialized-unused-weight-fallback", + "foreign-slot-value-fallback" + ], + "status": "PASS_SLOT_KEY_FINITE_ONLY" + }, + "native_control_count": 45, + "native_controls": [ + "canonical-keys-FIFO-wrap-counters", + "native-hash-collision", + "exact-one-callback-per-miss", + "uncached-native-error-0", + "uncached-native-error-1", + "full-cache-failure-before-eviction", + "cache-survives-callback-exception", + "capacity-0", + "capacity--1", + "capacity-16385", + "capacity-True", + "capacity-1.5", + "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "index--1", + "index-3", + "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "index-True", + "index-0", + "arity", + "keywords", + "exact-operand", + "exact-scalar", + "event-creation", + "descriptor-protocol", + "token-length", + "token-range", + "partial-init-length", + "partial-init-weight", + "callback-result-shape", + "callback-result-type", + "callback-reentry", + "event-owns-parent", + "GC-callback-cycle", + "native-statistics-isolated", + "native-coefficient-loop", + "same-row-lowlevel-rejection", + "dict-iterator-mutation-safe", + "callback-list-mutation-safe", + "native-source-authenticated", + "callback-descriptor-is-pure", + "plain-callback-rejected", + "live-callback-code-drift", + "owned-metadata-snapshot", + "same-row-source-fallback", + "malformed-scalar-literal-fallback" + ], + "status": "PASS_NATIVE_FINITE_ONLY" +} diff --git a/research/verification-key-headroom/context/baseline-public/SOURCES.json b/research/verification-key-headroom/context/baseline-public/SOURCES.json new file mode 100644 index 0000000000..d8cb6e68d3 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/SOURCES.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8", + "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + }, + { + "path": "research/fraction-native-qualification/inputs/PR5848.tar", + "usage": "input", + "git_blob": "307d09d2a968e1bbec8025d9fbd0a884df790d12", + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/inputs/PR5848.tar" + }, + { + "path": "research/fraction-native-qualification/slot_parent.py", + "usage": "input", + "git_blob": "5a77bebfe03d308baf223e517b7bd04e52cb204c", + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_parent.py" + }, + { + "path": "research/fraction-native-qualification/slot_finite.py", + "usage": "input", + "git_blob": "3231246efe9a2d1b975989a1ff9e000ffb0d9976", + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_finite.py" + }, + { + "path": "research/fraction-native-qualification/compact_parent.py", + "usage": "input", + "git_blob": "b3dc1be5c08b32990e456260843f40bc34fde89a", + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/compact_parent.py" + }, + { + "path": "research/fraction-native-qualification/compact_finite.py", + "usage": "input", + "git_blob": "b6cc3d9ddb1a266c8f1933c55e746e14be404d5b", + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/compact_finite.py" + }, + { + "path": "research/fraction-native-qualification/entry_parent.py", + "usage": "input", + "git_blob": "2a631bdc4cda602159a47b5f5b5b1d70972acd56", + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/entry_parent.py" + }, + { + "path": "research/fraction-native-qualification/entry_finite.py", + "usage": "input", + "git_blob": "cafaf408fd4e3ec6cdc42044c8d4187c51f55dde", + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/entry_finite.py" + }, + { + "path": "research/fraction-native-qualification/table_parent.py", + "usage": "input", + "git_blob": "7f44b25859e90d981587a53e9467284961f60a8f", + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/table_parent.py" + }, + { + "path": "research/fraction-native-qualification/parent_finite.py", + "usage": "input", + "git_blob": "e00dd293859b115cad99644e1c614a13c71fc133", + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/parent_finite.py" + }, + { + "path": "research/fraction-native-qualification/frozen.py", + "usage": "input", + "git_blob": "eb26be4a0f2e27e03becd3741da98f65799b8f0a", + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/frozen.py" + }, + { + "path": "research/fraction-native-qualification/slot_binding.py", + "usage": "input", + "git_blob": "e226fd730ed33f6ac769240f6530325c8db470e0", + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/slot_binding.py" + }, + { + "path": "research/fraction-native-qualification/GETTER-SHAPES.json", + "usage": "input", + "git_blob": "d3dadac22725126c3283d99f85073a1b7c8c8c83", + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4", + "pin": "head:2ebc3a071c62fc839aaed1291220d78a317395d4:research/fraction-native-qualification/GETTER-SHAPES.json" + } + ], + "external_origin": { + "pr": 5848, + "head": "66fb6c6b8683b37967e9d7f313b3df99a49d2406", + "archive_sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6", + "files": 97 + }, + "predecessors": { + "table_pr": 5852, + "zero_unit_pr": 5853, + "entry_artifact": "070e377470a0778d466eabb0fcfcba600c707d19", + "slot_and_compact": "Own source-bound feasibility predecessors, retained in this own input ancestor; unpublished earlier local micro/actual evidence is labelled." + }, + "runtime": { + "platform": "Linux x86_64 CPython3.12.3 GCC13.3", + "Fraction_file_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", + "native_source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "full_C_API": "CPython3.12 ABI; not abi3" + } +} diff --git a/research/verification-key-headroom/context/baseline-public/TASK.json b/research/verification-key-headroom/context/baseline-public/TASK.json new file mode 100644 index 0000000000..f7b568ff15 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/TASK.json @@ -0,0 +1,60 @@ +{ + "schema_version": 1, + "task_id": "replay-runtime", + "original_card": { + "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" + ] + }, + "scope_status": "refined", + "scope_change_reason": "Donor requested C and at least15% complete wall AND CPU savings. Finite/native gate, actual audit and complete cold-build BCCBBC gate passed.", + "actual_scope": "PR5848/frozen66fb6c6/native-cache-complete-qualification", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "stop_rule": "Publish verified measured scope, then reassess before further optimization. Preserve coverage, cold build and180s/1GiB/600sinitial1500shared/serial/no-auto-retry contract.", + "time_budget_minutes": 60, + "outcome": "completed", + "evidence": "PROOF.md, RESULT.json and evidence/runtime/GATE-6.json; full normal/O and source custody; publication controls separate.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex implementation and user-requested GPT-6-astra xhigh static API/source review. One parent numerical runner; no independent human or proof-kernel acceptance.", + "open_questions": [ + { + "question": "Can one further source-bound native bookkeeping reduction pay its additional verification bill?", + "why_it_matters": "The minimum15% complete gate passes, but the user requests further justified improvements.", + "first_step": "Profile/census the new candidate, freeze one costed feasibility nomination, refresh overlap and run the smallest discriminating test before construction.", + "blocked_by": "Do not change this measured candidate or its scientific coverage during publication." + } + ], + "base_commit": "de5ec2e7a6074068452f45b1a191b5c72832df4a" +} diff --git a/research/verification-key-headroom/context/baseline-public/VALIDATION.json b/research/verification-key-headroom/context/baseline-public/VALIDATION.json new file mode 100644 index 0000000000..545178cce1 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/VALIDATION.json @@ -0,0 +1,105 @@ +{ + "local_only": true, + "complete_BCCBBC": { + "medians": { + "B": { + "wall": 40.51615557898185, + "cpu": 40.33 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.19115483165428626, + "cpu": 0.18819737168361017 + }, + "order": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true + }, + "complete_optimized": { + "exit": 0, + "label": "full-native-O", + "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116686848, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112500, + "system_seconds": 0.18, + "user_seconds": 32.33 + }, + "wall_seconds": 32.580494505004026 + }, + "finite_comparisons": 964, + "inherited_controls": 73, + "native_controls": 45, + "predecessor_custody_controls": 4, + "all_complete_values_and_types_and_witnesses_preserved": true, + "actual_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "guarded_attempts": 20, + "guarded_wall_seconds": 332.434005899966, + "retained_failed_attempts": [ + "finite-native-debug", + "finite-native-packet-O" + ], + "automatic_retries": 0, + "independent_human_or_kernel_acceptance": false, + "hosted_performance": false, + "scope": "Only frozen PR5848; no kappa, physical/cost/compiler or selected-frontier change. Four predecessor custody controls are separate registered checks, as in PR5848, and excluded from both timed candidate.py stages.", + "packaged_registered_finite_normal_and_optimized": "PASS, including all four unchanged custody controls; receipts in evidence/runtime/runs", + "portable_readonly_full_replay": { + "source_before_after_equal": true, + "files": 159, + "no_symlinks": true, + "run": { + "exit": 0, + "label": "complete-native", + "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": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 + }, + "git_free": true, + "source_commit": "8f04865e903eead8730be622357e3604c6fea179" + } +} diff --git a/research/verification-key-headroom/context/baseline-public/VERIFY.json b/research/verification-key-headroom/context/baseline-public/VERIFY.json new file mode 100644 index 0000000000..b1458cfac7 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/VERIFY.json @@ -0,0 +1,31 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/fraction-native-qualification/inputs/PR5848.tar", + "research/fraction-native-qualification/slot_parent.py", + "research/fraction-native-qualification/slot_finite.py", + "research/fraction-native-qualification/compact_parent.py", + "research/fraction-native-qualification/compact_finite.py", + "research/fraction-native-qualification/entry_parent.py", + "research/fraction-native-qualification/entry_finite.py", + "research/fraction-native-qualification/table_parent.py", + "research/fraction-native-qualification/parent_finite.py", + "research/fraction-native-qualification/frozen.py", + "research/fraction-native-qualification/slot_binding.py", + "research/fraction-native-qualification/GETTER-SHAPES.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 30, + "checks": "Fresh964 complete comparisons,73 inherited+45 native controls and all4 unchanged custody controls. Cold C build requires existing cc/Python3.12 headers; no dependency installation. Finite/source/native coverage only; full replay and performance remain separate opt-in evidence." + } + ] +} diff --git a/research/verification-key-headroom/context/baseline-public/actual_audit.py b/research/verification-key-headroom/context/baseline-public/actual_audit.py new file mode 100644 index 0000000000..1b50e726b0 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/actual_audit.py @@ -0,0 +1,32 @@ +"""One complete frozen original/slot/native audit; compiler work charged.""" +import gzip,importlib.util,json,sys,time,resource +from frozen import baseline,require +from compact_finite import types_of +from fraction_table import derive +import slot_parent,native_backend + +with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_actual_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('native_actual_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (original_path,original,reference): + word=json.loads(gzip.decompress((original_path/'inputs/WORD.json.gz').read_bytes())) + ideal,weights=reference.ideal(word);rounded=set(ideal['counts']) + fingerprint=reference.digest((word,weights,sorted(rounded))) + parent=slot_parent.derive(reference);native=derive(reference) + observed=[];base=None + for label,fn in [('original',reference.error_trace),('slot-parent',parent),('native-apply-cold',native)]: + start_children=resource.getrusage(resource.RUSAGE_CHILDREN) + cpu=time.process_time();wall=time.perf_counter();result=fn(word,weights,rounded);elapsed=time.perf_counter()-wall;used=time.process_time()-cpu + end_children=resource.getrusage(resource.RUSAGE_CHILDREN) + child_cpu=end_children.ru_utime+end_children.ru_stime-start_children.ru_utime-start_children.ru_stime + if base is None:base=result + else:require(result==base and types_of(result)==types_of(base),'all actual values/types/witnesses') + require(reference.digest((word,weights,sorted(rounded)))==fingerprint,'all actual inputs unchanged') + observed.append(dict(label=label,wall_seconds=elapsed,cpu_seconds=used+child_cpu,parent_cpu_seconds=used,compiler_child_cpu_seconds=child_cpu,full_output_sha256=reference.digest(result))) + require(native.compacted_selected() is True,'actual native path used') + require(parent.statistics()==native.statistics(),'all actual cache statistics unchanged') + print(json.dumps(dict(status='PASS_FULL_NATIVE_ACTUAL_AUDIT',events=len(word['program']),coordinates=ideal['n'],observations=observed,all_values_types_witnesses_inputs_equal=True,table_statistics=native.statistics(),weight_tokens=native.token_count(),build=native_backend.receipt(),direct_add=False,not_complete_performance=True),sort_keys=True)) diff --git a/research/verification-key-headroom/context/baseline-public/benchmark.py b/research/verification-key-headroom/context/baseline-public/benchmark.py new file mode 100644 index 0000000000..092f972e3d --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/benchmark.py @@ -0,0 +1,46 @@ +"""Fresh cold BCCBBC; full original and every new finite/native check billed.""" +import json,statistics,sys +from pathlib import Path +import guard +if len(sys.argv)!=3:raise ValueError('pair|remaining and an external evidence directory') +PACKAGE=Path(__file__).resolve().parent +guard.HERE=Path(sys.argv[2]).resolve() +if guard.HERE.is_relative_to(PACKAGE):raise ValueError('Evidence directory must be outside the immutable package') +guard.HERE.mkdir(parents=True,exist_ok=True) +guard.SOURCE=PACKAGE +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +sys.path.insert(0,str(guard.SOURCE)) +from frozen import payload,require +EXPECTED=json.loads(payload()['research/p104-single-pass-qualification/RESULT.json']) +ORDER=[('B1','full_B.py'),('C1','full_C.py'),('C2','full_C.py'),('B2','full_B.py'),('B3','full_B.py'),('C3','full_C.py')] + +def receipt(label): + p=guard.HERE/'runs'/label + r=json.loads((p/'receipt.json').read_text());require(r['status']=='PASS','full bounded command '+label) + out=json.loads((p/'stdout.txt').read_text().splitlines()[-1]);require(out['mode']=='qualify' and out['receipt']==EXPECTED,'unchanged full scientific receipt '+label) + if label.startswith('C'): + rows=[json.loads(x) for x in (p/'stdout.txt').read_text().splitlines() if x.startswith('{')] + require(sum(x.get('status')=='PASS_COMPLETE_NATIVE_COVERAGE' for x in rows)==1,'native and compiler coverage '+label) + return r + +def gate(labels): + groups={arm:[receipt(label) for label in labels if label.startswith(arm)] for arm in 'BC'} + medians={arm:dict(wall=statistics.median(x['wall_seconds'] for x in rows),cpu=statistics.median(x['usage']['user_seconds']+x['usage']['system_seconds'] for x in rows)) for arm,rows in groups.items()} + saving={k:1-medians['C'][k]/medians['B'][k] for k in ('wall','cpu')} + result=dict(medians=medians,saving=saving,order=labels,all_full_receipts_equal=True,cold_compile_included=True) + (guard.HERE/('GATE-'+str(len(labels))+'.json')).write_text(json.dumps(result,indent=2)+'\n') + require(min(saving.values())>=.15,'15% complete wall AND CPU gate') + return result + +require(len(sys.argv)==3 and sys.argv[1] in ('pair','remaining'),'pair or remaining') +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + if sys.argv[1]=='pair': + for label,script in ORDER[:2]:guard.run(label,script);receipt(label) + result=gate(['B1','C1']) + else: + gate(['B1','C1']) + for label,script in ORDER[2:]:guard.run(label,script);receipt(label) + result=gate([x[0] for x in ORDER]) + print(json.dumps(result,sort_keys=True)) diff --git a/research/verification-key-headroom/context/baseline-public/compact_finite.py b/research/verification-key-headroom/context/baseline-public/compact_finite.py new file mode 100644 index 0000000000..b6cc3d9ddb --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/compact_finite.py @@ -0,0 +1,78 @@ +"""All inherited coverage plus token, q-context, collision and FIFO controls.""" +import importlib.util +import json +import sys +from fractions import Fraction as F +import entry_finite +import entry_parent as entry +from entry_finite import fixtures,types_of +from frozen import baseline,require +import fraction_table as table + + +def main(): + inherited=entry_finite.main();controls=[] + weights=[(F(1),F(2)),(F(3),F(5)),(F(2,2),F(4,2))] + tokens=table.weight_tokens(weights) + require(tokens==[0,1,0],'canonical equal pairs share a token') + controls.append('canonical-full-pair-tokens') + modulus=sys.hash_info.modulus + collision=[(F(0),F(1)),(F(modulus),F(1))] + keys=lambda w:(w[0].numerator,w[0].denominator,w[1].numerator,w[1].denominator) + require(hash(keys(collision[0]))==hash(keys(collision[1])) and keys(collision[0])!=keys(collision[1]),'real canonical hash collision') + require(table.weight_tokens(collision)==[0,1],'full equality after hash collision') + controls.append('weight-token-hash-collision') + require(table.weight_tokens(weights,1) is None,'context overflow rejects compression') + require(table.weight_tokens([],0)==[],'empty zero-capacity context') + controls.append('bounded-context-overflow') + # Same exact equality relation and global FIFO sequence at each capacity. + word=dict(public=1,owned_fields=0,program=[]) + for capacity in (1,2,16): + old=entry.Contributions(capacity);old.certify(word,weights,set()) + new=table.CompactContributions(capacity,weights,tokens) + for q in (F(1),F(-1),F(2),F(1,2),F(2,4),F(1)): + step=new.event(q) + for index,i in enumerate((0,1,2,0,2,1,0,1,2)): + a,b=F(index%2),F((index%3)-1) + require(step(a,b,i)==old.step(a,q,b,*weights[i]),'same exact contribution') + require(new.statistics()==old.statistics(),'same complete FIFO/counters') + controls.append('event-q-canonical-equality-and-FIFO-counters') + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('compact_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('compact_finite_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace;fast=table.derive(ref);parent=entry.derive(ref) + for index,c in enumerate(fixtures()): + if index in (0,23,71,142,200,239): + a=parent(*c);b=fast(*c) + require(a==b and types_of(a)==types_of(b),'complete parent/compact trace types') + require(fast.compacted_selected() is True,'compact route actually executed') + require(parent.statistics()==fast.statistics(),'full finite actual counter sequence') + controls.append('six-complete-trace-counter-and-type-comparisons') + fixture=(dict(public=4,owned_fields=0,program=[['INIT',0,0],['INIT',1,0],['ADD',2,0,1,0],['ADD',3,1,1,0]]),[(F(1),F(2)),(F(3),F(5)),(F(7),F(11)),(F(13),F(17))],{'INIT'}) + require(fast(*fixture)==original(*fixture),'source weights vary by i, not event') + controls.append('source-site-weight-ownership') + factory=table.weight_tokens + table.weight_tokens=lambda w:[0]*len(w) + try:require(table.derive(ref)(*fixture)!=original(*fixture),'wrong token merges rejected') + finally:table.weight_tokens=factory + controls.append('wrong-token-alias-detected') + table.weight_tokens=lambda w:factory(w,1) + try: + fallback=table.derive(ref) + require(fallback(*fixture)==original(*fixture) and fallback.compacted_selected() is False,'whole-call overflow fallback') + finally:table.weight_tokens=factory + controls.append('overflow-fallback-preserves-original') + # Reusing token numbers in a later trace cannot reuse an answer. + a=fast(*fixture);counts=fast.statistics();changed=(fixture[0],list(reversed(fixture[1])),fixture[2]) + require(fast(*changed)==original(*changed),'new trace tokens independent') + require(fast(*fixture)==a and fast.statistics()==counts,'fresh table on each call') + controls.append('fresh-token-and-cache-lifetimes') + result=dict(status='PASS_COMPACT_KEY_FINITE_ONLY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/compact_parent.py b/research/verification-key-headroom/context/baseline-public/compact_parent.py new file mode 100644 index 0000000000..b3dc1be5c0 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/compact_parent.py @@ -0,0 +1,106 @@ +"""Compact exact table keys; original Fraction arithmetic on every miss.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import entry_parent as entry + +F=entry.F +CAPACITY=entry.CAPACITY +CONTEXT_CAPACITY=16384 +Contributions=entry.Contributions +NORMAL_CONTRIBUTIONS=Contributions +certified_domain=entry.certified_domain +transformed=entry.transformed + + +def weight_tokens(weights,limit=CONTEXT_CAPACITY): + entry.parent.need(type(limit) is int and 0<=limit<=CONTEXT_CAPACITY,'bounded context token capacity') + mapping={};tokens=[] + for row in weights: + a,c=row[0],row[1] + key=(a.numerator,a.denominator,c.numerator,c.denominator) + token=mapping.get(key) + if token is None: + if len(mapping)>=limit:return None + token=len(mapping);mapping[key]=token + tokens.append(token) + return tokens + + +class CompactContributions(NORMAL_CONTRIBUTIONS): + def __init__(self,capacity,weights,tokens): + super().__init__(capacity) + self.weights=weights;self.tokens=tokens + + def event(self,q): + qn,qd=q.numerator,q.denominator + table=self.table;weights=self.weights;tokens=self.tokens;capacity=self.capacity + compute=self.compute + def step(old,v,i): + self.calls+=1 + key=(old.numerator,old.denominator,qn,qd,v.numerator,v.denominator,tokens[i]) + result=table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=compute(old,q,v,weights[i][0],weights[i][1]) + if len(table)>=capacity: + table.popitem(last=False);self.evictions+=1 + table[key]=result + return result + return step + + +def compact_text(raw): + text=transformed(raw) + before='def error_trace(word, weights, rounded):\n' + entry.parent.need(text.count(before)==1,'one compact function signature') + text=text.replace(before,'def error_trace(word, weights, rounded, tokens):\n') + before=' contributions = _contribution_factory()\n contributions.certify(word,weights,rounded)\n' + entry.parent.need(text.count(before)==1,'one compact factory seam') + text=text.replace(before,' contributions = _compact_factory(weights,tokens)\n') + before=" elif op in ('ADD', 'COPY'):\n q = F(event[-2])\n for i, v in rows[event[2]].items():\n" + entry.parent.need(text.count(before)==1,'one source ADD/COPY event seam') + text=text.replace(before," elif op in ('ADD', 'COPY'):\n q = F(event[-2])\n step_contribution = contributions.event(q)\n for i, v in rows[event[2]].items():\n") + before=''' value, increment_a, increment_c, change = contributions.step( + old, q, v, weights[i][0], weights[i][1]) +''' + entry.parent.need(text.count(before)==1,'one compact call seam') + return text.replace(before,' value, increment_a, increment_c, change = step_contribution(old,v,i)\n') + + +def derive(reference,capacity=CAPACITY): + parent=entry.parent + parent.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + parent.need(reference.F is F,'exact standard Fraction type') + parent.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==parent.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace;raw=inspect.getsource(original) + safe=transformed(raw);compact=compact_text(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + parent.need(parent.code_shape(original.__code__)==parent.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + parent.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None,None,None] + factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + tokens=weight_tokens(weights) if capacity and factory is NORMAL_CONTRIBUTIONS and certified_domain(word,weights,rounded) else None + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/verification-key-headroom/context/baseline-public/custody.py b/research/verification-key-headroom/context/baseline-public/custody.py new file mode 100644 index 0000000000..4bd2b4592c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/custody.py @@ -0,0 +1,19 @@ +"""Retain all four unchanged predecessor custody checks, with scoped imports.""" +import importlib.util,sys +from frozen import baseline + +def main(): + prior={name:sys.modules.pop(name,None) for name in ('source','observe')} + paths=list(sys.path) + try: + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_predecessor_custody',package/'custody.py') + module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);module.main() + finally: + sys.path[:]=paths + for name,value in prior.items(): + sys.modules.pop(name,None) + if value is not None:sys.modules[name]=value + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/entry_finite.py b/research/verification-key-headroom/context/baseline-public/entry_finite.py new file mode 100644 index 0000000000..cafaf408fd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/entry_finite.py @@ -0,0 +1,128 @@ +"""All unchanged predecessor finite coverage plus entry/fallback controls.""" +from copy import deepcopy +import importlib.util +import json +import sys +from fractions import Fraction as F +import fraction_table as table +import parent_finite +from parent_finite import types_of,fixtures +from frozen import baseline,require + + +def main(): + inherited=parent_finite.main() + controls=[] + cases=list(fixtures()) + base=cases[0] + require(table.certified_domain(*base),'ordinary fixture certified') + require(all(table.certified_domain(*c) for c in cases),'all inherited fixtures certified') + controls.append('all-241-fixtures-take-certified-domain') + class DictSubclass(dict): + def __getitem__(self,key): + log.append(('word-get',key));return super().__getitem__(key) + class ListSubclass(list): + def __iter__(self): + log.append('list-iter');return super().__iter__() + def __getitem__(self,key): + log.append(('list-get',key));return super().__getitem__(key) + class TupleSubclass(tuple): + def __iter__(self): + log.append('tuple-iter');return super().__iter__() + def __getitem__(self,key): + log.append(('tuple-get',key));return super().__getitem__(key) + class SetSubclass(set): + def __contains__(self,key): + log.append(('set-contains',key));return super().__contains__(key) + class FractionSubclass(F): + pass + log=[] + bad_domains=[] + def changed_word(key,value): + w=deepcopy(base[0]);w[key]=value;return w,deepcopy(base[1]),set(base[2]) + bad_domains.append(('dict-subclass',(DictSubclass(base[0]),deepcopy(base[1]),set(base[2])))) + bad_domains.append(('program-subclass',changed_word('program',ListSubclass(base[0]['program'])))) + bad_domains.append(('event-subclass',changed_word('program',[TupleSubclass(e) for e in base[0]['program']])) ) + bad_domains.append(('weights-subclass',(deepcopy(base[0]),ListSubclass(base[1]),set(base[2])))) + bad_domains.append(('row-subclass',(deepcopy(base[0]),[TupleSubclass(r) for r in base[1]],set(base[2])))) + bad_domains.append(('rounded-subclass',(deepcopy(base[0]),deepcopy(base[1]),SetSubclass(base[2])))) + bad_domains.append(('Fraction-subclass',(deepcopy(base[0]),[(FractionSubclass(a),c) for a,c in base[1]],set(base[2])))) + bad_domains.append(('integer-weights',(deepcopy(base[0]),[(1,2)]*len(base[1]),set(base[2])))) + bad_domains.append(('boolean-public',changed_word('public',True))) + for label,c in bad_domains: + log.clear();require(not table.certified_domain(*c),'fallback domain '+label) + require(not log,'gate invokes no custom methods '+label) + controls.append('subtypes-and-foreign-types-fall-back-without-custom-methods') + class HostileMeta(type): + def __eq__(cls,other): + log.append('metaclass-equality');return False + class Foreign(metaclass=HostileMeta):pass + for label,c in [('metaclass-container',(deepcopy(base[0]),Foreign(),set(base[2]))),('metaclass-scalar',changed_word('program',[['ADD',0,1,Foreign(),0]]))]: + log.clear();require(not table.certified_domain(*c),'foreign metaclass falls back') + require(not log,'no foreign metaclass equality methods') + controls.append(label) + with baseline() as package: + sys.path.insert(0,str(package)) + source_spec=importlib.util.spec_from_file_location('type_gate_additional_bundle',package/'source.py') + source=importlib.util.module_from_spec(source_spec);source_spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('type_gate_finite_source',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + old=ref.error_trace;fast=table.derive(ref) + for label,c in bad_domains: + outcomes=[] + for fn in (old,fast): + log.clear() + try: + value=fn(*c);outcome=('value',value,types_of(value)) + except (IndexError,ValueError,TypeError,KeyError) as e: + outcome=('error',type(e).__name__,str(e)) + outcomes.append((outcome,list(log))) + require(outcomes[0]==outcomes[1],'original outcome and custom-method order '+label) + controls.append('original-fallback-'+label) + # Audit the invariant on a representative complete mixed-operation + # trace and dyadic cancellation/large-rational fixtures. This extra + # checking exists only in this finite control, never in timing runs. + normal=table.Contributions + checked_calls=[0] + class Checked(normal): + def _certified_step(self,*operands): + require(all(type(x) is F for x in operands),'certified operands exact Fraction') + checked_calls[0]+=1 + out=super()._certified_step(*operands) + require(all(type(x) is F for x in out),'certified results exact Fraction') + return out + table.Contributions=Checked + try: + checked=table.derive(ref) + for c in [base,cases[71],cases[142],cases[239]]: + require(checked(*c)==old(*c),'inductive type instrumentation preserves values') + finally:table.Contributions=normal + require(checked_calls[0]>0,'certified path actually executed') + controls.append('exact-internal-type-preservation-at-certified-updates') + for label,c in [ + ('missing-weight',(dict(public=2,owned_fields=0,program=[['ADD',0,1,1,0]]),[],{'ADD'})), + ('bad-role',(dict(public=2,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))],{'ADD'})), + ('bad-scalar',(dict(public=2,owned_fields=0,program=[['ADD',0,1,'bad',0]]),[(F(1),F(1))],{'ADD'})), + ('short-event',(dict(public=2,owned_fields=0,program=[['ADD']]),[(F(1),F(1))],{'ADD'}))]: + outcomes=[] + for fn in (old,fast): + try:fn(*c) + except (IndexError,ValueError,TypeError) as e:outcomes.append((type(e).__name__,str(e))) + else:outcomes.append(('no-error',None)) + require(outcomes[0]==outcomes[1],'same malformed-input outcome '+label) + controls.append('malformed-outcome-'+label) + # Invalidation if a table is explicitly certified a second time. + c=table.Contributions(2);c.certify(*base) + require(c.certified,'entry selected certified path') + foreign=(deepcopy(base[0]),[(1,2)]*len(base[1]),set(base[2])) + c.certify(*foreign);require(not c.certified,'recertification removes fast path') + require(c.step(F(0),F(1),F(1),1,2)==c.compute(F(0),F(1),F(1),1,2) and c.bypasses==1,'recertified fallback preserves non-Fraction operands') + controls.append('recertification-invalidates-certified-method') + c=table.Contributions(0);c.certify(*base) + require(not c.certified,'disabled table stays checked');controls.append('disabled-capacity-not-certified') + result=dict(status='PASS_TYPE_GATE_FINITE_FEASIBILITY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/entry_parent.py b/research/verification-key-headroom/context/baseline-public/entry_parent.py new file mode 100644 index 0000000000..2a631bdc4c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/entry_parent.py @@ -0,0 +1,99 @@ +"""Source-bound entry type gate for the exact predecessor contribution table. + +Ali Romman: original Fraction arithmetic. Chris R / Clear1nsight with +substantial OpenAI Codex assistance: table and entry-domain proof. Apache-2.0. +The independent integer engine, arithmetic and complete output stay unchanged. +""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import table_parent as parent + +F=parent.F +CAPACITY=parent.CAPACITY + + +def certified_domain(word,weights,rounded): + # Test exact container types before inspecting members. No user-defined + # iteration, conversion, comparison, indexing or numeric methods run here. + if type(word) is not dict or any(type(k) is not str for k in word): + return False + if type(word.get('public')) is not int or type(word.get('owned_fields')) is not int: + return False + program=word.get('program') + if (type(program) is not list and type(program) is not tuple) or (type(weights) is not list and type(weights) is not tuple): + return False + if (type(rounded) is not set and type(rounded) is not frozenset) or any(type(op) is not str for op in rounded): + return False + for event in program: + if (type(event) is not list and type(event) is not tuple) or len(event)<2: + return False + if type(event[0]) is not str: + return False + if any(type(x) is not str and type(x) is not int and type(x) is not bool and type(x) is not F for x in event): + return False + for row in weights: + if (type(row) is not list and type(row) is not tuple) or len(row)<2: + return False + if type(row[0]) is not F or type(row[1]) is not F: + return False + return True + + +class Contributions(parent.Contributions): + def certify(self,word,weights,rounded): + self.certified=bool(self.capacity and certified_domain(word,weights,rounded)) + self.step=self._certified_step if self.certified else super().step + + def _certified_step(self,old,q,v,a,c): + self.calls+=1 + key=(old.numerator,old.denominator,q.numerator,q.denominator, + v.numerator,v.denominator,a.numerator,a.denominator,c.numerator,c.denominator) + result=self.table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=self.compute(old,q,v,a,c) + if len(self.table)>=self.capacity: + self.table.popitem(last=False) + self.evictions+=1 + self.table[key]=result + return result + + +def transformed(raw): + text=parent.transformed(raw) + seam=' contributions = _contribution_factory()\n' + parent.need(text.count(seam)==1,'one entry type certification seam') + return text.replace(seam,seam+' contributions.certify(word,weights,rounded)\n') + + +def derive(reference,capacity=CAPACITY): + parent.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + parent.need(reference.F is F,'exact standard Fraction type') + parent.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==parent.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace + raw=inspect.getsource(original) + text=transformed(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + parent.need(parent.code_shape(original.__code__)==parent.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + parent.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None] + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:Contributions(capacity),_contribution_report=report) + exec(compile(text,'','exec'),namespace) + result=namespace['error_trace'] + result.statistics=lambda:None if last[0] is None else dict(last[0]) + return result + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace + derived=derive(reference,capacity) + reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/verification-key-headroom/context/baseline-public/evidence/FINITE-INERT-GC-FIXTURE.py.txt b/research/verification-key-headroom/context/baseline-public/evidence/FINITE-INERT-GC-FIXTURE.py.txt new file mode 100644 index 0000000000..e91610348f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/FINITE-INERT-GC-FIXTURE.py.txt @@ -0,0 +1,13 @@ + ws=[(F(1),F(1))]*256;ts=list(range(256));fired=[];thresholds=gc.get_threshold();gc.collect() + def on_gc(phase,info): + if phase=='start' and ts:ts.clear();fired.append(True) + gc.callbacks.append(on_gc) + try: + gc.set_threshold(1,1,1) + try:make(ws=ws,ts=ts) + except (IndexError,ValueError):pass + else:raise ValueError('constructor mutation was not rejected') + finally: + gc.callbacks.remove(on_gc);gc.set_threshold(*thresholds) + require(fired,'constructor GC mutation fixture exercised') + controls.append('GC-mutated-token-packet-safe') diff --git a/research/verification-key-headroom/context/baseline-public/evidence/HARNESS-CORRECTION.json b/research/verification-key-headroom/context/baseline-public/evidence/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..8179a6f905 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/HARNESS-CORRECTION.json @@ -0,0 +1,13 @@ +{ + "preserved_attempt": "runtime/runs/finite-native-debug", + "outcome": "All scientific/native checks and exit 0; runner correctly STOPPED for ResourceWarning on implicit TemporaryDirectory cleanup.", + "manual_correction": "Register explicit owned compilation-directory cleanup with atexit; do not suppress warnings or change coverage. Native API and C source unchanged.", + "source_refinement": "Before actual audit, native entry additionally sends malformed exact-Fraction scalar slots to literal-original fallback.", + "automatic_retries": 0, + "inert_GC_fixture": { + "attempt": "runtime/runs/finite-native-packet-O", + "preserved_draft": "FINITE-INERT-GC-FIXTURE.py.txt", + "failure": "The forced-threshold GC callback did not run inside the constructor, so the demanded rejection did not occur. Not a demonstrated native bug.", + "manual_correction": "Retain the failed attempt. Replace the timing-dependent fixture with deterministic owned metadata mutation/lifetime coverage. Checked token reads remain a source-reviewed safety requirement; do not claim a constructor-GC interleaving was empirically exercised." + } +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md new file mode 100644 index 0000000000..5cc8c57baf --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md @@ -0,0 +1,65 @@ +# Native cache/context helper: preconstruction review + +**Recommendation: proceed to a bounded native-helper feasibility gate, with Fraction arithmetic and the Python trace unchanged.** Prefer a vectorcall Event and authenticated member-descriptor reads over repeated `PyObject_GetAttrString`. The target is Python key/context/cache bookkeeping, not a second rational engine. This review approves neither an unseen implementation nor a performance claim. No compiler, arithmetic experiment, native module or replay was run by this reviewer. Only local headers and primary CPython documentation/source were inspected. + +The user explicitly requested C. Parent owns implementation and the only scientific runner. Keep kappa work, other feeds and publication paused. The supported environment is the actual CPython 3.12 ABI and compiler used for the cold build; do not describe a full-C-API extension as `abi3` merely because some individual calls belong to the Stable ABI. + +## Recommended API boundary + +- Cache is fresh for each trace and owns the exact Python miss callback, immutable snapshots of the weight/token metadata, authenticated Fraction descriptors/type, dictionary and fixed-capacity FIFO ring. Snapshotting means copying the metadata structure into owned tuples, not merely retaining the original mutable list. Standard Fraction objects remain under the predecessor's stable/immutable-value premise. +- Event owns a strong Cache reference and captures q plus its two canonical key components. Its three positional inputs are old, v and source-site i. Cache should not retain every Event; avoid a reverse Event ownership cycle or an event-history list. Direct score addition stays disabled for the first native nomination. +- Enable vectorcall on the Event type, store its function pointer at the declared offset, extract positional count with `PyVectorcall_NARGS`, reject unsupported keywords/arity, and give `tp_call` identical behavior through `PyVectorcall_Call`. Do not misuse the arguments-offset flag. Call the Python miss callback with `PyObject_Vectorcall` and five arguments. Keep the GIL throughout. [Python 3.12 call protocol](https://docs.python.org/3.12/c-api/call.html). +- A certified exact member descriptor may be read through `Py_TYPE(descriptor)->tp_descr_get(descriptor, operand, (PyObject *)fraction_type)`. Retain descriptor ownership and check a non-null function pointer. This uses the descriptor protocol rather than a Fraction-layout cast. Preserve the preceding property/slot/getattribute binding and per-trace freshness checks, because bypassing a changed public getter would change semantics. The documented slot has the three-object descriptor-get signature. [Type slot reference](https://docs.python.org/3.12/c-api/typeobj.html#c.PyTypeObject.tp_descr_get). + +The CPython 3.12 member-descriptor implementation performs its owner/type check and delegates to `PyMember_GetOne`; its object-valued member path returns a strong reference. Accordingly, each successful integer slot read must either transfer its reference into the new key tuple or be decremented on every exit path. These source links explain the API behavior; they are reference material, not substitutes for the installed-runtime/ABI binding. [Descriptor implementation](https://github.com/python/cpython/blob/3.12/Objects/descrobject.c), [member implementation](https://github.com/python/cpython/blob/3.12/Python/structmember.c). + +## Ownership rules that must be explicit in the C review + +| Item | Required ownership | +| --- | --- | +| Cache metadata, callback, descriptor and type fields | Owned references, released on clear/deallocation | +| Event Cache/q/q-numerator/q-denominator | Owned references; an Event remains safe if the caller drops its Cache variable | +| Fresh seven-element key | One local owned reference until insertion/return cleanup | +| Each FIFO ring entry | Its own owned key reference, independently of dictionary ownership | +| Dictionary hit | Borrowed from `PyDict_GetItemWithError`; return a new reference | +| Successful Python miss result | New reference; dictionary insertion retains its own reference, and the caller receives an owned reference | + +Use `PyDict_GetItemWithError`, distinguishing a missing key from a pending exception. Ordinary `PyDict_GetItem` can suppress hash/equality errors. `PyDict_SetItem` does not steal its value reference. Check every dictionary API return value. [Dictionary API](https://docs.python.org/3.12/c-api/dict.html). + +Fill only newly allocated tuples with `PyTuple_SET_ITEM`, whose reference transfer must be accounted for. Never use unchecked tuple item/size macros before establishing exact container shape and index bounds. Any borrowed metadata object remains valid only while its owning container is retained. [Tuple API](https://docs.python.org/3.12/c-api/tuple.html). + +Decrementing a reference can run Python finalization. Restore internal invariants before releasing old objects, clear pointers before decref, and make partial-construction cleanup safe. Do not infer ownership from apparent reference counts or immortal integers. [Reference-counting API](https://docs.python.org/3.12/c-api/refcounting.html). + +## FIFO and exception contract + +Preserve the exact seven-component key order and Python integer objects. Do not narrow numerators/denominators to C integers, use raw hashes as identities, or change collision resolution. Hits return the existing result and do not move the FIFO position. A miss first invokes the unchanged Python computation; a computation failure must not evict or cache anything. Successful full-cache misses evict the oldest entry before inserting the new one, matching the parent order. + +Maintain explicit `head`, resident `count` and fixed ring capacity. On successful eviction, remove the corresponding dictionary key and ring reference together and update the head/count consistently. If the later insertion fails, leave a consistent smaller cache and propagate the exception; do not leave a ring entry for a dictionary insertion that never succeeded. Do not temporarily exceed the capacity to simplify rollback. Counters should follow the parent's successful and exceptional transitions, and C counters must not invoke signed-overflow undefined behavior. + +Calling Python on a miss creates a reentrancy boundary. The known compute function is pure in the supported runtime, but native objects should not become memory-unsafe if an injected callback reenters them. Prefer a small busy/closed guard and reject reentrant mutation; alternatively document and enforce a callback restriction sufficient to prove non-reentrancy. Preserve the original callback exception and return `NULL`; do not convert it to a miss, cache a failure, retry, or continue with a pending error. Cover recursive callback handling and reset the guard on every failure path. + +The optimization domain must establish valid internal i/metadata bounds before unchecked access. Inherited malformed-word/missing-weight cases must select original behavior or preserve its exception type/message/order. A stronger pure entry condition such as sufficient metadata length may safely select original fallback; it must not reject an input the original accepts. Separately, direct calls to the exposed C API with invalid types, huge/negative indices or malformed descriptors must raise Python exceptions, never read invalid memory. + +## Native object lifecycle + +Cache and Event contain references to Python containers/callables. Support cyclic GC with complete traversal of owned references and an appropriate clear/deallocation path, unless a strictly enforced acyclic graph is actually proved. Callback closures can otherwise create cycles even if Cache does not own Events. Initialize all owned pointers before tracking; untrack before clearing/deallocation, and pair the allocation/free APIs correctly. [Cyclic-GC requirements](https://docs.python.org/3.12/c-api/gcsupport.html). + +Prefer non-subclassable types with no writable native fields. Prevent public creation or reinitialization of uninitialized Event/Cache instances, or require an initialized-state check on every entry. A cleared or partially constructed instance must not dereference null fields. Heap-type deallocation must also handle its type reference correctly. Keep mutable cache data out of module globals; only authenticated loaded code/types may be reused in a process. Do not claim subinterpreter or free-threaded support without a separate design. + +## Smallest meaningful coverage gate + +Retain all prior finite comparisons and controls, including the compact-key/slot binding gates actually used by this candidate. Add focused native checks for: + +1. Capacities 0/1/2/full, FIFO wraparound, equal-value keys, deliberate integer-hash collision, unchanged token identity and fresh traces/Events. +2. Identical outputs/counters and Python callback invocation count: exactly one call per successful miss, none on a hit, and no cached exception. +3. Invalid arity/keywords/type/index/descriptor and partial-construction rejection, Event surviving deletion of the caller's Cache reference, and bounded create/drop/GC lifetime behavior. +4. Callback failure/reentrancy, cleanup after failure, full-cache failure ordering, output/statistics isolation, and unsupported/stale binding selecting original execution. +5. One bounded finite subprocess with CPython's debug allocator/development checks, plus source review of every allocation/error/deallocation branch. This is memory-safety validation for new native ownership; it is not a replacement for scientific comparisons. + +Only then perform the parent's fixed native/Python cache micro screen. A promising result permits one original/parent/native actual audit with unchanged complete output/type/witness digests and exact calls/hits/misses/evictions/tokens. No complete qualifier is justified by micro timings alone. + +## Cold-build and acceptance accounting + +Compile and load inside every fresh complete candidate process, in a fresh owned temporary directory, without installing anything system-wide. Record C source hash, compiler/version/flags, interpreter version/SOABI/extension suffix and build/load outcome. Preserve build failures and unsupported environments; do not silently claim native coverage through fallback. A loaded immutable module may be reused within that one complete process, but every trace still gets fresh mutable Cache/Event state. + +The complete wall and CPU bill includes compilation, linking, loading, binding, all finite/native controls, metadata preparation and the scientific trace. `time.process_time()` alone excludes compiler/linker child CPU; use the existing process-group/resource accounting that includes children. Ensure a feasibility model does not either omit the build or double-count the same within-process build. A fresh complete B/C comparison remains the authority for the user's at-least-15% wall **and** CPU threshold. The C design creates a new plausible cost target, not an admitted saving. diff --git a/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-REVIEW-SOURCES.json b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-REVIEW-SOURCES.json new file mode 100644 index 0000000000..81b07807b0 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-CACHE-REVIEW-SOURCES.json @@ -0,0 +1,28 @@ +{ + "scope": "Static native-helper API/refcount/FIFO feasibility review only; no compiler, native import, arithmetic or replay run", + "target": "CPython 3.12 full C API; exact ABI and build to be recorded by parent", + "preferred": "Vectorcall Event plus authenticated member-descriptor tp_descr_get; Python Fraction callback on misses", + "performance_admission": false, + "numerical_runs": 0, + "compiler_runs": 0, + "local_headers_read": [ + "/usr/include/python3.12/abstract.h", + "/usr/include/python3.12/cpython/abstract.h", + "/usr/include/python3.12/cpython/object.h", + "/usr/include/python3.12/dictobject.h", + "/usr/include/python3.12/objimpl.h", + "/usr/include/python3.12/object.h" + ], + "primary_references": [ + "https://docs.python.org/3.12/c-api/call.html", + "https://docs.python.org/3.12/c-api/dict.html", + "https://docs.python.org/3.12/c-api/typeobj.html", + "https://docs.python.org/3.12/c-api/structures.html", + "https://docs.python.org/3.12/c-api/gcsupport.html", + "https://docs.python.org/3.12/c-api/refcounting.html", + "https://docs.python.org/3.12/c-api/tuple.html", + "https://github.com/python/cpython/blob/3.12/Objects/descrobject.c", + "https://github.com/python/cpython/blob/3.12/Python/structmember.c" + ], + "source_limit": "Documentation and 3.12 branch source explain API contracts; they are not a source pin for the installed CPython binary." +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md new file mode 100644 index 0000000000..c57106eccd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md @@ -0,0 +1,51 @@ +# Native full-qualification seam: final static review + +**No remaining concrete blocker was found in the requested static scope after the boundary repairs below.** The repaired native implementation may proceed to the parent's fresh complete cold B/C gate. This is a source review, not an independent execution, memory-safety proof for arbitrary Python callbacks, or performance admission. + +Reviewed C source: `78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb`. +Reviewed `full.py`: `ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0`. +Reviewed `fraction_table.py`: `d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4`. + +## Boundary repairs confirmed + +- Cache construction now fetches each token with checked `PySequence_GetItem`, owns that result, releases it on rejected type/range, and transfers it into the immutable snapshot tuple on success. The earlier unchecked caller-list access is gone. +- Contribution member reads now check each result immediately; scalar Event initialization stops immediately if the numerator getter fails before reading the denominator. +- `checked_compute` resolves raw Contributions MRO dictionaries through `type.__getattribute__`, requires an exact staticmethod and exact FunctionType, then checks code shape, defaults/closure and effective captured builtin abs. Qualification no longer invokes an arbitrary compute descriptor or treats a plain method as equivalent. +- The native loader compiles a read-only snapshot of authenticated bytes and rejects cached-module/source-digest disagreement. + +Parent reports a failed attempt to force constructor GC interleaving: its callback did not run inside the constructor. That attempt and draft remain preserved. The replacement deterministic ownership test supports metadata lifetime behavior; it does **not** empirically exercise the previously hypothesized GC interleaving. The checked item-read source fix removes the unchecked access without that empirical claim. + +## Complete seam inspection + +The outer authenticated PR5848 export supplies `candidate.py`. `full.py` requires exactly one literal Observation seam and adds the native error-trace wrapper only for the original `noisy_precision` module at that seam. The existing Observation wrapper still surrounds it. + +The following remain in the frozen candidate code and are not replaced: + +- The separately loaded integer Engine and its Observation. +- The independently loaded reference module used by the original 120-program differential and integer guards. +- Full expected contract-result equality, six source semantic controls, reverse-all/cut and literal checks performed by the original contract. +- Complete ideal/weight and actual trace/witness comparisons between the retained observations. +- Original observation lifecycle/error/alias controls in `candidate.main` and the exact frozen final receipt comparison. + +The C branch first executes the full native finite entry, including its inherited gates and cold build, then invokes the original candidate main with that single seam changed. The native actual wrapper checks route selection, exact table counters and the complete output digest. Its capture predicate uses program length; that identifies the sole call only because this exact frozen `calculate` invokes that module's `error_trace` once. Do not generalize the predicate into a general-purpose actual-word classifier. A direct complete word equality assertion would be clearer if this wrapper is later generalized. + +The stale-module cleanup is limited to `source` and `observe` modules whose files belong to expired owned temporary exports. The fresh package is then placed first on the import path. No accepted numeric result is reused; only already loaded native code is reused within the one C process. Cache/Event state remains per trace. + +## Measurement and claim boundary + +The complete benchmark must use **outer command wall and total user/system CPU including children**. The returned/printed `qualify` seconds exclude the preceding native finite suite and its build, so they cannot decide the threshold. Each fresh C process must pay its own compile/link/load cost. + +The predecessor's four custody controls are a separate registered-verification obligation outside its declared qualification benchmark. They must remain in the final registered verification; this seam review does not silently count them as executed by `full.py`. + +Parent subsequently reports the completed fresh-process B,C,C,B,B,C measurements: + +| Complete qualification median | Baseline | Native candidate | Saving | +| --- | ---: | ---: | ---: | +| Wall seconds | 40.516155579 | 32.771296680 | 19.1155% | +| Total CPU seconds | 40.33 | 32.74 | 18.8197% | + +All complete scientific receipts, native counters and full output digests reportedly agree. Parent also reports a complete optimized run passing at 32.5805 wall / 32.51 CPU seconds. These are parent-run local measurements, not executions independently repeated by this static reviewer. They supersede the earlier feasibility model as the parent's evidence for clearing the mandatory 15% threshold in both metrics. They are not a hosted-CI performance claim or a guarantee for another interpreter, compiler or machine. + +The final package should retain registered finite/native checks, the cold compilation path and four inherited custody controls, with the expensive full replay explicitly opt-in as planned. Preserve exact sources, complete timing receipts, earlier failures and negative micro findings. All implementation blockers identified in this review are resolved in the reviewed source. Further optimization, including any C arithmetic port, requires a separate bounded round after publication; no such round was started here. + +No compiler, native import, numerical test, replay or external publication was performed by this reviewer. This addendum supersedes the three outstanding implementation items in `NATIVE-CACHE-CODE-REVIEW.md`; its raw-packet/stable-runtime and coverage boundaries remain applicable. diff --git a/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-REVIEW-FINAL-STATE.json b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-REVIEW-FINAL-STATE.json new file mode 100644 index 0000000000..aaa43f4292 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/NATIVE-REVIEW-FINAL-STATE.json @@ -0,0 +1,33 @@ +{ + "status": "STATIC_REVIEW_COMPLETE_NO_REMAINING_CONCRETE_BLOCKER_IN_REVIEWED_SCOPE", + "c_source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "full_source_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "runtime_boundary": "Frozen source, qualified callback/packet and stable supported CPython runtime; not arbitrary raw callback semantics", + "actual_capture_boundary": "Program length identifies the sole actual error_trace call only in this frozen calculate source", + "parent_reported_complete_medians": { + "order": [ + "B", + "C", + "C", + "B", + "B", + "C" + ], + "baseline_wall": 40.516155579, + "baseline_cpu": 40.33, + "candidate_wall": 32.77129668, + "candidate_cpu": 32.74, + "wall_saving_percent": 19.1155, + "cpu_saving_percent": 18.8197 + }, + "parent_reported_complete_optimized": { + "wall": 32.5805, + "cpu": 32.51, + "status": "PASS" + }, + "scientific_runs_by_reviewer": 0, + "compiler_runs_by_reviewer": 0, + "external_posts_by_reviewer": 0, + "hosted_performance_claim": false, + "next": "Parent publication packaging only; any further optimization requires a separate bounded round after publication." +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/PLAN.json b/research/verification-key-headroom/context/baseline-public/evidence/PLAN.json new file mode 100644 index 0000000000..0f5d3eb42d --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/PLAN.json @@ -0,0 +1,22 @@ +{ + "mechanism": "C cache/context and optional coefficient-loop apply using existing Fraction miss callback and PyNumber_InPlaceAdd; unchanged outer scientifictrace", + "source_PR5848": "66fb6c6b8683b37967e9d7f313b3df99a49d2406", + "canonical_main": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "scope": "One bounded C prototype; no newrational arithmetic, fixed16kcache/tokens, vectorcall+actual memberdescriptors, sameFIFO/counters. Genericoriginalfallback outsidevalidnativepacket.", + "gates": [ + "All964/54+9+10 inheritedchecks plusnativeprotocol/exception/GC/ownership/FIFO/buildsourcecontrols normalO beforeoneactualaudit.", + "Ccompilation andloading arepaidinsideeachfreshcompleteCcommand; externalcompilerCPUcountedby/usr/bin/time, notjustprocess_time.", + "No fullqualifier untilcrediblecomplete15%wallANDCPU afterallchecks/buildbill; firstpairthenBCCBBCmedians." + ], + "caps": { + "initial_seconds": 600, + "shared_seconds": 1500, + "command_seconds": 180, + "rss_bytes": 1073741824, + "serial": true, + "automatic_retries": 0 + }, + "goal_active": true, + "kappa_research": "PAUSED", + "reviewer": "Astra staticCAPI/refcount/ownership review; parentownsallimplementationandserialexecution" +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/SCREEN.json b/research/verification-key-headroom/context/baseline-public/evidence/SCREEN.json new file mode 100644 index 0000000000..2854ee67f9 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/SCREEN.json @@ -0,0 +1,29 @@ +{ + "decision": "CREDIBLE_COMPLETE_PAIR_AFTER_REVIEW_BINDING_CHECKS", + "not_complete_measurement": true, + "modeled_wall": 32.93958982103504, + "modeled_cpu": 32.758142364000015, + "modeled_wall_saving": 0.15571803213498303, + "modeled_cpu_saving": 0.15745518611111076, + "all_actual_values_types_witnesses_inputs": true, + "compile_paid_once": true, + "finite_bill": "entire observed debug finite command conservatively charged; remove only duplicated immutable compile", + "original_actual": { + "compiler_child_cpu_seconds": 0.0, + "cpu_seconds": 20.523067174, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "parent_cpu_seconds": 20.523067174, + "wall_seconds": 20.534678025986068 + }, + "native_actual": { + "compiler_child_cpu_seconds": 0.31187299999999996, + "cpu_seconds": 11.883082538000005, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "native-apply-cold", + "parent_cpu_seconds": 11.571209538000005, + "wall_seconds": 11.886980237992248 + }, + "coverage": "964 finite comparisons;73 inherited+41 native controls; normal/O/debug", + "new_bindings_require_recheck": true +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/SEALED-RESULT.json b/research/verification-key-headroom/context/baseline-public/evidence/SEALED-RESULT.json new file mode 100644 index 0000000000..0a3724b924 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/SEALED-RESULT.json @@ -0,0 +1,33 @@ +{ + "source_before_after_equal": true, + "files": 159, + "no_symlinks": true, + "run": { + "exit": 0, + "label": "complete-native", + "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": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 + }, + "git_free": true, + "source_commit": "8f04865e903eead8730be622357e3604c6fea179" +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/SCREEN.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/SCREEN.json new file mode 100644 index 0000000000..74ad222d9b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/SCREEN.json @@ -0,0 +1,50 @@ +{ + "decision": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "modeled_complete_wall": 33.52121791499667, + "modeled_complete_cpu": 33.35370983800001, + "modeled_wall_saving": 0.14081019283268814, + "modeled_cpu_saving": 0.14213709264403274, + "next_required_net_wall": 0.3585395521251513, + "next_required_net_cpu": 0.3057098380000056, + "not_complete_measurement": true, + "actual": { + "all_values_types_witnesses_inputs_equal": true, + "coordinates": 799, + "direct_add": false, + "events": 25984, + "not_complete_performance": true, + "observations": [ + { + "cpu_seconds": 20.388246467, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "wall_seconds": 20.39976386600756 + }, + { + "cpu_seconds": 13.453441415, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "entry-parent", + "wall_seconds": 13.468788220983697 + }, + { + "cpu_seconds": 12.921956305000002, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "compact-key", + "wall_seconds": 12.928807335993042 + } + ], + "status": "PASS_FULL_COMPACT_KEY_ACTUAL_AUDIT", + "table_statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "weight_tokens": 3587 + }, + "finite_wall": 1.9772587239858694, + "finite_cpu": 1.94 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/STATE.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/STATE.json new file mode 100644 index 0000000000..0f3eff4f43 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/STATE.json @@ -0,0 +1,57 @@ +{ + "stage": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "goal_active": true, + "kappa_research": "PAUSED", + "runs": 0, + "screen": { + "decision": "STOP_KEY_ONLY_BEFORE_COMPLETE_CONSTRUCTION", + "modeled_complete_wall": 33.52121791499667, + "modeled_complete_cpu": 33.35370983800001, + "modeled_wall_saving": 0.14081019283268814, + "modeled_cpu_saving": 0.14213709264403274, + "next_required_net_wall": 0.3585395521251513, + "next_required_net_cpu": 0.3057098380000056, + "not_complete_measurement": true, + "actual": { + "all_values_types_witnesses_inputs_equal": true, + "coordinates": 799, + "direct_add": false, + "events": 25984, + "not_complete_performance": true, + "observations": [ + { + "cpu_seconds": 20.388246467, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "original", + "wall_seconds": 20.39976386600756 + }, + { + "cpu_seconds": 13.453441415, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "entry-parent", + "wall_seconds": 13.468788220983697 + }, + { + "cpu_seconds": 12.921956305000002, + "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "label": "compact-key", + "wall_seconds": 12.928807335993042 + } + ], + "status": "PASS_FULL_COMPACT_KEY_ACTUAL_AUDIT", + "table_statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "weight_tokens": 3587 + }, + "finite_wall": 1.9772587239858694, + "finite_cpu": 1.94 + }, + "next": "Separate source-bound property-to-slot key read feasibility before any construction or combination." +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json new file mode 100644 index 0000000000..4b7e0b5b86 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-compact-key", + "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": "022300c8970e9a8475735206f20dcf965d3dd26f03ccbfd3000716d03992e084", + "sampled_process_group_rss_bytes": 26951680, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "244b7982939faaa425f991062b547f901607661209c1714bb151249cde8db533", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1082, + "stdout_sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26180, + "system_seconds": 0.01, + "user_seconds": 1.08 + }, + "wall_seconds": 1.1367301769787446 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt new file mode 100644 index 0000000000..b63e50d55d --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt @@ -0,0 +1 @@ +{"not_full_performance": true, "order": "BCCB", "records": [{"cpu": 0.22844539799999997, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.22845600498840213}, {"cpu": 0.17601116500000008, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.1760264449985698}, {"cpu": 0.175548217, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.17556217897799797}, {"cpu": 0.23951183600000003, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.23956723097944632}], "status": "PASS_COMPACT_KEY_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json new file mode 100644 index 0000000000..0e47962dce --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-compact-key-20261027/micro-compact-key/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.08,"system_seconds":0.01,"kernel_max_rss_kib":26180,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..dea1d82ebd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json @@ -0,0 +1,6 @@ +{ + "failed_label": "finite-direct-add-freshness", + "cause": "New hostile-callable fixture was armed during classmethod construction and before its log existed; setup failed after inherited54controls, before freshness probe.", + "repair": "Construct classmethod with ordinary attribute reads first, initialize log, then arm hostile attribute behavior before the pure freshness check. No arithmetic or production implementation change.", + "automatic_retry": false +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/SCREEN.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/SCREEN.json new file mode 100644 index 0000000000..3b14fdb76b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/SCREEN.json @@ -0,0 +1,9 @@ +{ + "status": "STOP_DIRECT_ONLY_BEFORE_ACTUAL_OR_COMPLETE_CONSTRUCTION", + "micro_wall_difference": 0.013148339494364336, + "micro_cpu_difference": 0.013159579999999976, + "micro_steps": 131072, + "target_sites": 7739250, + "not_a_full_trace_or_accepted_projection": true, + "reason": "Illustrative micro scaling is only about0.78s before addedbinding/controlbill, not convincing headroom for the required0.794wall/.738CPU net beyond parent. Preserve semantics result and reassess a separate compact-key mechanism with direct addition disabled first." +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/STATE.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/STATE.json new file mode 100644 index 0000000000..a477d16e6a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/STATE.json @@ -0,0 +1,7 @@ +{ + "stage": "STOP_DIRECT_ONLY_BEFORE_ACTUAL_OR_COMPLETE_CONSTRUCTION", + "goal_active": true, + "kappa_research": "PAUSED", + "numerical_runs": 0, + "next": "Separate bounded compact-key assessment, then reassess before any combination or complete construction." +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json new file mode 100644 index 0000000000..d3bced2c3f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-direct-add", + "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": "97f5d5e29dca3428fcb48d12113bef05d701410cac35fe3b4bb130f4b0985a7f", + "sampled_process_group_rss_bytes": 28286976, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "2ffd9a5fb7c4d8c02d78561bedc490e29ac1dbba61b9c1a0b1471ead50e1c94a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 485, + "stdout_sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26172, + "system_seconds": 0.01, + "user_seconds": 0.63 + }, + "wall_seconds": 0.6582466270192526 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt new file mode 100644 index 0000000000..b11393fdc8 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt @@ -0,0 +1 @@ +{"not_a_full_trace_or_performance_claim": true, "order": "BCCB", "records": [{"cpu": 0.104671191, "label": "B", "result": "6144", "wall": 0.10466263099806383}, {"cpu": 0.092273824, "label": "C", "result": "6144", "wall": 0.09234263902180828}, {"cpu": 0.09426316400000001, "label": "C", "result": "6144", "wall": 0.09425690298667178}, {"cpu": 0.10818495699999997, "label": "B", "result": "6144", "wall": 0.1082335899991449}], "status": "PASS_FIXED_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json new file mode 100644 index 0000000000..0ae542e1cd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-direct-add-20261027/micro-direct-add/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.63,"system_seconds":0.01,"kernel_max_rss_kib":26172,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json new file mode 100644 index 0000000000..32e5072db2 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json @@ -0,0 +1,8 @@ +{ + "failed_label": "finite-slot-key", + "inherited": "All964/54+9 checks passed", + "cause": "The post-derive drift fixture changed Fraction.numerator values, poisoning Fraction equality itself; comparing two otherwise identical original outputs with == therefore fails.", + "repair": "Use an observable value-preserving getter replacement, compare getter-call counts before output equality, require original literal fallback. Preserve draft/receipt.", + "production_tightening": "Unsafe or overflowed weight-token metadata now uses literal original rather than cached generic; add unused corrupt-slot data fallback control.", + "automatic_retry": false +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/STATE.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/STATE.json new file mode 100644 index 0000000000..315d85263c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/STATE.json @@ -0,0 +1,5 @@ +{ + "stage": "SLOT_KEY_FINITE_FEASIBILITY", + "goal_active": true, + "kappa_research": "PAUSED" +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json new file mode 100644 index 0000000000..5f6e634b65 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-slot-key", + "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": "6981c68888c25ab48b527bcbb07ad156cf15113e8c304d458527eb3578e8e8f8", + "sampled_process_group_rss_bytes": 27860992, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "c0002580773c054149013e3f76cbd668a9a7e9e9087d4433226fa058fecc811f", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1092, + "stdout_sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 26124, + "system_seconds": 0.01, + "user_seconds": 0.47 + }, + "wall_seconds": 0.5072708880179562 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt new file mode 100644 index 0000000000..8810e0b1a8 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt @@ -0,0 +1 @@ +{"not_complete_performance": true, "order": "BCCB", "records": [{"cpu": 0.05924658599999999, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.05927750901901163}, {"cpu": 0.04855816399999996, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.04856140600168146}, {"cpu": 0.04629298700000001, "final_value": ["1", "0", "0", "0"], "label": "C", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.0463139720086474}, {"cpu": 0.058482900000000004, "final_value": ["1", "0", "0", "0"], "label": "B", "statistics": {"bypasses": 0, "calls": 131072, "capacity": 16384, "evictions": 0, "hits": 130832, "misses": 240, "resident": 240}, "wall": 0.05851913499645889}], "status": "PASS_SLOT_KEY_MICRO_ONLY", "steps_per_arm": 131072} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json new file mode 100644 index 0000000000..9ef53ceb2f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/fraction-slot-key-20261027/micro-slot-key/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.47,"system_seconds":0.01,"kernel_max_rss_kib":26124,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/receipt.json new file mode 100644 index 0000000000..590be8e622 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "complete-native", + "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": "7d7c27fb5be89dfb6679036aa8c76a2d907465aa4bd21e242b2a0a70e5be7b3c", + "sampled_process_group_rss_bytes": 115798016, + "script": "replay_driver.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "67d631ee4df8aa3057fd6b61fa0c0575858524b752f4689d01fe4132b0b9a7c2", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14301, + "stdout_sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111632, + "system_seconds": 0.2, + "user_seconds": 32.74 + }, + "wall_seconds": 33.032243947003735 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/stdout.txt new file mode 100644 index 0000000000..9be7f66daf --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/stdout.txt @@ -0,0 +1,10 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "396549b0d3ce74ef0cc931adf70be92fe18a34d509ac6dfc6ab692622a04c9d8", "cold_build_load_wall_seconds": 0.30989734499598853, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "396549b0d3ce74ef0cc931adf70be92fe18a34d509ac6dfc6ab692622a04c9d8", "cold_build_load_wall_seconds": 0.30989734499598853, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.282628} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/usage.json new file mode 100644 index 0000000000..877681e80d --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/portable/runs/complete-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.74,"system_seconds":0.20,"kernel_max_rss_kib":111632,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-2.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-2.json new file mode 100644 index 0000000000..27a25d91cc --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-2.json @@ -0,0 +1,22 @@ +{ + "medians": { + "B": { + "wall": 40.19379291200312, + "cpu": 40.129999999999995 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.1846677234032279, + "cpu": 0.18415150760029886 + }, + "order": [ + "B1", + "C1" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-6.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-6.json new file mode 100644 index 0000000000..24b9b04190 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/GATE-6.json @@ -0,0 +1,26 @@ +{ + "medians": { + "B": { + "wall": 40.51615557898185, + "cpu": 40.33 + }, + "C": { + "wall": 32.771296680002706, + "cpu": 32.74 + } + }, + "saving": { + "wall": 0.19115483165428626, + "cpu": 0.18819737168361017 + }, + "order": [ + "B1", + "C1", + "C2", + "B2", + "B3", + "C3" + ], + "all_full_receipts_equal": true, + "cold_compile_included": true +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/benchmark.py b/research/verification-key-headroom/context/baseline-public/evidence/runtime/benchmark.py new file mode 100644 index 0000000000..9914ac8386 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/benchmark.py @@ -0,0 +1,40 @@ +"""Fresh cold BCCBBC; full original and every new finite/native check billed.""" +import json,statistics,sys +import guard +guard.SOURCE=guard.HERE.parent/'feasibility' +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +sys.path.insert(0,str(guard.SOURCE)) +from frozen import payload,require +EXPECTED=json.loads(payload()['research/p104-single-pass-qualification/RESULT.json']) +ORDER=[('B1','full_B.py'),('C1','full_C.py'),('C2','full_C.py'),('B2','full_B.py'),('B3','full_B.py'),('C3','full_C.py')] + +def receipt(label): + p=guard.HERE/'runs'/label + r=json.loads((p/'receipt.json').read_text());require(r['status']=='PASS','full bounded command '+label) + out=json.loads((p/'stdout.txt').read_text().splitlines()[-1]);require(out['mode']=='qualify' and out['receipt']==EXPECTED,'unchanged full scientific receipt '+label) + if label.startswith('C'): + rows=[json.loads(x) for x in (p/'stdout.txt').read_text().splitlines() if x.startswith('{')] + require(sum(x.get('status')=='PASS_COMPLETE_NATIVE_COVERAGE' for x in rows)==1,'native and compiler coverage '+label) + return r + +def gate(labels): + groups={arm:[receipt(label) for label in labels if label.startswith(arm)] for arm in 'BC'} + medians={arm:dict(wall=statistics.median(x['wall_seconds'] for x in rows),cpu=statistics.median(x['usage']['user_seconds']+x['usage']['system_seconds'] for x in rows)) for arm,rows in groups.items()} + saving={k:1-medians['C'][k]/medians['B'][k] for k in ('wall','cpu')} + result=dict(medians=medians,saving=saving,order=labels,all_full_receipts_equal=True,cold_compile_included=True) + (guard.HERE/('GATE-'+str(len(labels))+'.json')).write_text(json.dumps(result,indent=2)+'\n') + require(min(saving.values())>=.15,'15% complete wall AND CPU gate') + return result + +require(len(sys.argv)==2 and sys.argv[1] in ('pair','remaining'),'pair or remaining') +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + if sys.argv[1]=='pair': + for label,script in ORDER[:2]:guard.run(label,script);receipt(label) + result=gate(['B1','C1']) + else: + gate(['B1','C1']) + for label,script in ORDER[2:]:guard.run(label,script);receipt(label) + result=gate([x[0] for x in ORDER]) + print(json.dumps(result,sort_keys=True)) diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/dispatch.py b/research/verification-key-headroom/context/baseline-public/evidence/runtime/dispatch.py new file mode 100644 index 0000000000..3b504562ef --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/dispatch.py @@ -0,0 +1,14 @@ +import sys +import guard +guard.SOURCE=guard.HERE.parent/'feasibility' +guard.CLOSURE=tuple(sorted(str(p.relative_to(guard.SOURCE)) for p in guard.SOURCE.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +guard.AGGREGATE=600 +label=sys.argv[1] +if label.endswith('-debug'): + guard.os.environ.update(PYTHONMALLOC='debug',PYTHONDEVMODE='1') +script='finite.py' if label.startswith('finite') else 'micro.py' if label.startswith('micro') else 'actual_audit.py' +if label.startswith('apply-micro'):script='micro_apply.py' +if label.startswith('full-'):script='full_C.py' +with (guard.HERE/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + guard.run(label,script,optimized=label.endswith('-O')) diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/guard.py b/research/verification-key-headroom/context/baseline-public/evidence/runtime/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/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/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/receipt.json new file mode 100644 index 0000000000..ec341c0150 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123207680, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 118872, + "system_seconds": 0.08, + "user_seconds": 40.05 + }, + "wall_seconds": 40.19379291200312 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/stdout.txt new file mode 100644 index 0000000000..1d9d2a70a1 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 39.767559} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/usage.json new file mode 100644 index 0000000000..14e15408ed --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B1/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.05,"system_seconds":0.08,"kernel_max_rss_kib":118872,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/receipt.json new file mode 100644 index 0000000000..deccaf5a8e --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123224064, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 118884, + "system_seconds": 0.11, + "user_seconds": 40.46 + }, + "wall_seconds": 41.037053946987726 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/stdout.txt new file mode 100644 index 0000000000..fe5b7cc302 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 40.630028} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/usage.json new file mode 100644 index 0000000000..52abd76a09 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B2/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.46,"system_seconds":0.11,"kernel_max_rss_kib":118884,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/receipt.json new file mode 100644 index 0000000000..d5652ef3e8 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 123383808, + "script": "full_B.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1086, + "stdout_sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 119040, + "system_seconds": 0.1, + "user_seconds": 40.23 + }, + "wall_seconds": 40.51615557898185 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/stdout.txt new file mode 100644 index 0000000000..e2ca989c67 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/stdout.txt @@ -0,0 +1,3 @@ +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 40.142608} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/usage.json new file mode 100644 index 0000000000..16bba0c29e --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/B3/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.23,"system_seconds":0.10,"kernel_max_rss_kib":119040,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/receipt.json new file mode 100644 index 0000000000..d61dc4261f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 115896320, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111728, + "system_seconds": 0.2, + "user_seconds": 32.54 + }, + "wall_seconds": 32.771296680002706 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/stdout.txt new file mode 100644 index 0000000000..483a20d08a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0bb3ea54973df7923cabfa1aaab440e1ee5847e244fdcea126de8dbda7a1d73a", "cold_build_load_wall_seconds": 0.3246453919855412, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0bb3ea54973df7923cabfa1aaab440e1ee5847e244fdcea126de8dbda7a1d73a", "cold_build_load_wall_seconds": 0.3246453919855412, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.019237} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/usage.json new file mode 100644 index 0000000000..d3aecad589 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C1/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.54,"system_seconds":0.20,"kernel_max_rss_kib":111728,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/receipt.json new file mode 100644 index 0000000000..f8e6215401 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116826112, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14105, + "stdout_sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112636, + "system_seconds": 0.2, + "user_seconds": 32.75 + }, + "wall_seconds": 33.03183611499844 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/stdout.txt new file mode 100644 index 0000000000..bde4ca7336 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "edfe5dc3887f683e221224b2612c0f6196f2c8fc917b7e73a01f488b3e0bb818", "cold_build_load_wall_seconds": 0.32343554199906066, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "edfe5dc3887f683e221224b2612c0f6196f2c8fc917b7e73a01f488b3e0bb818", "cold_build_load_wall_seconds": 0.32343554199906066, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.223509} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/usage.json new file mode 100644 index 0000000000..645ef2cf8a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C2/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.75,"system_seconds":0.20,"kernel_max_rss_kib":112636,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/receipt.json new file mode 100644 index 0000000000..8225ad0284 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 115761152, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14101, + "stdout_sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 111596, + "system_seconds": 0.19, + "user_seconds": 32.31 + }, + "wall_seconds": 32.57126763599808 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/stdout.txt new file mode 100644 index 0000000000..cf5431ba46 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8a99dc259d7d897391ba3c0386ed8aed3a6f1e6566be48f792ab275cc3d65cce", "cold_build_load_wall_seconds": 0.323765334993368, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8a99dc259d7d897391ba3c0386ed8aed3a6f1e6566be48f792ab275cc3d65cce", "cold_build_load_wall_seconds": 0.323765334993368, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 29.924985} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/usage.json new file mode 100644 index 0000000000..685c9c0d2a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/C3/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.31,"system_seconds":0.19,"kernel_max_rss_kib":111596,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/receipt.json new file mode 100644 index 0000000000..f0deab72ff --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "actual-native-apply", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 147218432, + "script": "actual_audit.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e1f20ff8b51286e1fc8bd7e9af7f46432ff8453ef7a02bcccdd878697de62b7e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1831, + "stdout_sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 108184, + "system_seconds": 0.11, + "user_seconds": 47.81 + }, + "wall_seconds": 48.00038802300696 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/stdout.txt new file mode 100644 index 0000000000..fdadbf7244 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/stdout.txt @@ -0,0 +1 @@ +{"all_values_types_witnesses_inputs_equal": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3164052689971868, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "coordinates": 799, "direct_add": false, "events": 25984, "not_complete_performance": true, "observations": [{"compiler_child_cpu_seconds": 0.0, "cpu_seconds": 20.523067174, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "original", "parent_cpu_seconds": 20.523067174, "wall_seconds": 20.534678025986068}, {"compiler_child_cpu_seconds": 0.0, "cpu_seconds": 12.547595455, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "slot-parent", "parent_cpu_seconds": 12.547595455, "wall_seconds": 12.551854210993042}, {"compiler_child_cpu_seconds": 0.31187299999999996, "cpu_seconds": 11.883082538000005, "full_output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "label": "native-apply-cold", "parent_cpu_seconds": 11.571209538000005, "wall_seconds": 11.886980237992248}], "status": "PASS_FULL_NATIVE_ACTUAL_AUDIT", "table_statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "weight_tokens": 3587} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/usage.json new file mode 100644 index 0000000000..5b74447409 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/actual-native-apply/usage.json @@ -0,0 +1 @@ +{"user_seconds":47.81,"system_seconds":0.11,"kernel_max_rss_kib":108184,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/receipt.json new file mode 100644 index 0000000000..3aef239968 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "apply-micro-native", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 75952128, + "script": "micro_apply.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 7524, + "stdout_sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43952, + "system_seconds": 0.05, + "user_seconds": 1.57 + }, + "wall_seconds": 1.682075733988313 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/stdout.txt new file mode 100644 index 0000000000..01c5f4261a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/stdout.txt @@ -0,0 +1 @@ +{"build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3147972009901423, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "fixed_order": "BCCB", "results": [{"checksum": "20080", "cpu_seconds": 0.222510198, "label": "B", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.22254838500521146}, {"checksum": "20080", "cpu_seconds": 0.22580282900000004, "label": "C", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.22616888402262703}, {"checksum": "20080", "cpu_seconds": 0.18162575299999995, "label": "C", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.1816379169758875}, {"checksum": "20080", "cpu_seconds": 0.22555638100000008, "label": "B", "last_row": {"0": "-3/4", "1": "-1/4", "10": "-1/2", "100": "-1/2", "102": "-1/4", "103": "1/4", "104": "3/4", "105": "-3/4", "106": "-1/4", "107": "1/4", "109": "1/2", "110": "-1/4", "111": "-1/2", "113": "1/2", "114": "1/4", "115": "-1/2", "117": "-1/4", "118": "1/4", "119": "3/4", "12": "-1/4", "120": "-3/4", "121": "-1/4", "122": "1/4", "124": "1/2", "125": "-1/4", "126": "-1/2", "13": "1/4", "14": "3/4", "15": "-3/4", "16": "-1/4", "17": "1/4", "19": "1/2", "2": "1/4", "20": "-1/4", "21": "-1/2", "23": "1/2", "24": "1/4", "25": "-1/2", "27": "-1/4", "28": "1/4", "29": "3/4", "30": "-3/4", "31": "-1/4", "32": "1/4", "34": "1/2", "35": "-1/4", "36": "-1/2", "38": "1/2", "39": "1/4", "4": "1/2", "40": "-1/2", "42": "-1/4", "43": "1/4", "44": "3/4", "45": "-3/4", "46": "-1/4", "47": "1/4", "49": "1/2", "5": "-1/4", "50": "-1/4", "51": "-1/2", "53": "1/2", "54": "1/4", "55": "-1/2", "57": "-1/4", "58": "1/4", "59": "3/4", "6": "-1/2", "60": "-3/4", "61": "-1/4", "62": "1/4", "64": "1/2", "65": "-1/4", "66": "-1/2", "68": "1/2", "69": "1/4", "70": "-1/2", "72": "-1/4", "73": "1/4", "74": "3/4", "75": "-3/4", "76": "-1/4", "77": "1/4", "79": "1/2", "8": "1/2", "80": "-1/4", "81": "-1/2", "83": "1/2", "84": "1/4", "85": "-1/2", "87": "-1/4", "88": "1/4", "89": "3/4", "9": "1/4", "90": "-3/4", "91": "-1/4", "92": "1/4", "94": "1/2", "95": "-1/4", "96": "-1/2", "98": "1/2", "99": "1/4"}, "last_scores": ["167/16", "241/32", "85/4"], "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65431, "misses": 105, "resident": 105}, "wall_seconds": 0.2255811319919303}], "status": "PASS_NATIVE_APPLY_MICRO_ONLY", "updates_per_arm": 65536} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/usage.json new file mode 100644 index 0000000000..4057a5cd3b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/apply-micro-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.57,"system_seconds":0.05,"kernel_max_rss_kib":43952,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/receipt.json new file mode 100644 index 0000000000..faef8eba4f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-O", + "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": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 78721024, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e3d67435d792a554af13bd465a842da56b70aaeffde49bd4590266adcfdfd00f", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11770, + "stdout_sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43888, + "system_seconds": 0.1, + "user_seconds": 2.41 + }, + "wall_seconds": 2.53013645199826 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/stdout.txt new file mode 100644 index 0000000000..a120e5728f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.32082126100431196, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/usage.json new file mode 100644 index 0000000000..2577953a5b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.41,"system_seconds":0.10,"kernel_max_rss_kib":43888,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/receipt.json new file mode 100644 index 0000000000..03d370a5d2 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-bound-debug", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 81235968, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd17c6f6bfa6d484c93ac000f78186a42ef87669a2ce0ccfb7ca97a41afb96f8", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11834, + "stdout_sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43752, + "system_seconds": 0.14, + "user_seconds": 2.95 + }, + "wall_seconds": 3.1384479379921686 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stdout.txt new file mode 100644 index 0000000000..dd71642695 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "fac2e410b80373947310853f08c7ed231b9f70320d78f1203b42f72f664d223c", "cold_build_load_wall_seconds": 0.3231552589859348, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/usage.json new file mode 100644 index 0000000000..3b8428a71e --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-bound-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.95,"system_seconds":0.14,"kernel_max_rss_kib":43752,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json new file mode 100644 index 0000000000..77fac21517 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-cleanup-debug", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 81371136, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11770, + "stdout_sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43780, + "system_seconds": 0.13, + "user_seconds": 2.7 + }, + "wall_seconds": 2.8887771570007317 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt new file mode 100644 index 0000000000..5e87740383 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.31362746001104824, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/usage.json new file mode 100644 index 0000000000..664eaf4904 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-cleanup-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.70,"system_seconds":0.13,"kernel_max_rss_kib":43780,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json new file mode 100644 index 0000000000..d30e36ba55 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-debug-cleanup", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 77979648, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "73551d162dde470d0e3ad0f472beb39e786c9df2cd434e0c0db0081dd1fceabd", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11769, + "stdout_sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 44000, + "system_seconds": 0.12, + "user_seconds": 2.41 + }, + "wall_seconds": 2.586756376986159 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt new file mode 100644 index 0000000000..e41069639c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3298818950133864, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/usage.json new file mode 100644 index 0000000000..ba8acb9713 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug-cleanup/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.41,"system_seconds":0.12,"kernel_max_rss_kib":44000,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/receipt.json new file mode 100644 index 0000000000..3b95662ddc --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-debug", + "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": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 80912384, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e3d67435d792a554af13bd465a842da56b70aaeffde49bd4590266adcfdfd00f", + "status": "STOP", + "stderr_bytes": 185, + "stderr_sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877", + "stdout_bytes": 11769, + "stdout_sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43952, + "system_seconds": 0.11, + "user_seconds": 2.72 + }, + "wall_seconds": 2.8839498269953765 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stderr.txt new file mode 100644 index 0000000000..7275b618d7 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stderr.txt @@ -0,0 +1,2 @@ +/usr/lib/python3.12/tempfile.py:1075: ResourceWarning: Implicitly cleaning up + _warnings.warn(warn_message, ResourceWarning) diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stdout.txt new file mode 100644 index 0000000000..f8a8d0869d --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.3027255790075287, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/usage.json new file mode 100644 index 0000000000..267e4d9b05 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.72,"system_seconds":0.11,"kernel_max_rss_kib":43952,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/receipt.json new file mode 100644 index 0000000000..05299d286c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-final-debug", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 80936960, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "64231ec17a585015124a8ebfb0ff8f1e18176ca3c6e2a8125333cbbf6040ff1d", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11835, + "stdout_sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43736, + "system_seconds": 0.13, + "user_seconds": 3.05 + }, + "wall_seconds": 3.2485531510028522 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stdout.txt new file mode 100644 index 0000000000..07800f5480 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "576df287369ec83fbed9a22dbae9de171d4dd3d08767ef3de252fc5dae708531", "cold_build_load_wall_seconds": 0.32178150399704464, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/usage.json new file mode 100644 index 0000000000..169c410243 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-final-debug/usage.json @@ -0,0 +1 @@ +{"user_seconds":3.05,"system_seconds":0.13,"kernel_max_rss_kib":43736,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/receipt.json new file mode 100644 index 0000000000..449069b1c7 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-initial", + "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": "787d19d195e2a2fdfb91f1a2798e96d7291c1c63431bd8c0ad4830ac0070d19e", + "sampled_process_group_rss_bytes": 77836288, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "1fe97ee94c9617e6d9ed7fb1297ec7a1042cb874155a4dd91973975322e19942", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11769, + "stdout_sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43268, + "system_seconds": 0.12, + "user_seconds": 2.39 + }, + "wall_seconds": 2.682428517990047 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/stdout.txt new file mode 100644 index 0000000000..718b715088 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.5364224890072364, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 39, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/usage.json new file mode 100644 index 0000000000..4304aa4876 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-initial/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.39,"system_seconds":0.12,"kernel_max_rss_kib":43268,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/receipt.json new file mode 100644 index 0000000000..c73b3693bc --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/receipt.json @@ -0,0 +1,23 @@ +{ + "exit": 1, + "label": "finite-native-packet-O", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78438400, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "eb4d294b159acd91e48a11348e321e41c3b1093f62d19ab3bc50ace7b433c7b5", + "status": "STOP", + "stderr_bytes": 625, + "stderr_sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8", + "stdout_bytes": 7318, + "stdout_sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb", + "termination": null, + "usage": { + "raw": "Command exited with non-zero status 1\n{\"user_seconds\":3.17,\"system_seconds\":0.12,\"kernel_max_rss_kib\":43456,\"exit\":1}\n" + }, + "wall_seconds": 3.376391716010403 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stderr.txt new file mode 100644 index 0000000000..62ac60af11 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stderr.txt @@ -0,0 +1,8 @@ +Traceback (most recent call last): + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/fraction-native-cache-20261027/feasibility/finite.py", line 155, in + if __name__=='__main__':main() + ^^^^^^ + File "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/fraction-native-cache-20261027/feasibility/finite.py", line 128, in main + else:raise ValueError('constructor mutation was not rejected') + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +ValueError: constructor mutation was not rejected diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stdout.txt new file mode 100644 index 0000000000..0991e5508f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/stdout.txt @@ -0,0 +1,4 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/usage.json new file mode 100644 index 0000000000..8c2bc0490a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-packet-O/usage.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"user_seconds":3.17,"system_seconds":0.12,"kernel_max_rss_kib":43456,"exit":1} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/receipt.json new file mode 100644 index 0000000000..0a12987700 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-reviewed-O", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78131200, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "e1f20ff8b51286e1fc8bd7e9af7f46432ff8453ef7a02bcccdd878697de62b7e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11835, + "stdout_sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43712, + "system_seconds": 0.1, + "user_seconds": 2.56 + }, + "wall_seconds": 2.686613911006134 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt new file mode 100644 index 0000000000..0d93e94552 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.32369362501776777, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 41, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/usage.json new file mode 100644 index 0000000000..16ebf521bd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-reviewed-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.56,"system_seconds":0.10,"kernel_max_rss_kib":43712,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/receipt.json new file mode 100644 index 0000000000..aa53b9aac9 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "finite-native-snapshot-O", + "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": "b8184e42951e063c237e3cd5ee7e39c3bf614d22e8159a7c17c07532f8e0bd92", + "sampled_process_group_rss_bytes": 78516224, + "script": "finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "a1a837e3b495b14c37389deecba442c44ef17f07b45dfeb2aa46f93aca98331d", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 11948, + "stdout_sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43800, + "system_seconds": 0.13, + "user_seconds": 2.55 + }, + "wall_seconds": 2.735172514017904 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt new file mode 100644 index 0000000000..ca62de4dab --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/stdout.txt @@ -0,0 +1,5 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "58bdc232837c7be4adb4c9ea3c26b921c55e0ae71886e1d8fd37409716e8600d", "cold_build_load_wall_seconds": 0.33438298499095254, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/usage.json new file mode 100644 index 0000000000..f7b5b7b02e --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/finite-native-snapshot-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.55,"system_seconds":0.13,"kernel_max_rss_kib":43800,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/receipt.json new file mode 100644 index 0000000000..a57be41a5b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "full-native-O", + "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": "f2fb57d260620346ad1100e4afb6e15e754460e3a086a54802c976fab2fc1552", + "sampled_process_group_rss_bytes": 116686848, + "script": "full_C.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "94948995f7ffb81a2215df2828296156bd0e579a5d15fe2e998f72ca1ab94674", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 14103, + "stdout_sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112500, + "system_seconds": 0.18, + "user_seconds": 32.33 + }, + "wall_seconds": 32.580494505004026 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/stdout.txt new file mode 100644 index 0000000000..c26b54d68b --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0f12f0ce53dc87222465784fc58dcc852c209ab3c71d3f183c85db08c74d3826", "cold_build_load_wall_seconds": 0.3294046340161003, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "0f12f0ce53dc87222465784fc58dcc852c209ab3c71d3f183c85db08c74d3826", "cold_build_load_wall_seconds": 0.3294046340161003, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 29.794405} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/usage.json new file mode 100644 index 0000000000..cf159e98e6 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/full-native-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":32.33,"system_seconds":0.18,"kernel_max_rss_kib":112500,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/receipt.json new file mode 100644 index 0000000000..9432927459 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "micro-native", + "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": "2787c5b5a49190f9181726808dd1bc8fb9110329451df0a650598f2a10e84fe2", + "sampled_process_group_rss_bytes": 74960896, + "script": "micro.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "d618febc8e0d593a3a459bf56cf622fe4e7bcd13f72b77341332797d3c0f516a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 1708, + "stdout_sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43672, + "system_seconds": 0.04, + "user_seconds": 1.18 + }, + "wall_seconds": 1.2924172079947311 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/stdout.txt new file mode 100644 index 0000000000..b878a1cc00 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/stdout.txt @@ -0,0 +1 @@ +{"build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "8724f5ede848e49533b0a004cf3c74b7c9bd4b831e68a271721268d634c26048", "cold_build_load_wall_seconds": 0.31328881898662075, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "aaad7b84c71f273e0eba005c4e45ea10490983c5446a584cd3b504f05ee2e1de"}, "fixed_order": "BCCB", "results": [{"cpu_seconds": 0.11537545099999996, "label": "B", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.11537122199661098}, {"cpu_seconds": 0.12363816999999999, "label": "C", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.12369171800673939}, {"cpu_seconds": 0.13746958999999992, "label": "C", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.13854740900569595}, {"cpu_seconds": 0.11428460200000001, "label": "B", "statistics": {"bypasses": 0, "calls": 65536, "capacity": 16384, "evictions": 0, "hits": 65532, "misses": 4, "resident": 4}, "total": "393216", "wall_seconds": 0.11428235299536027}], "status": "PASS_NATIVE_MICRO_SCREEN_ONLY", "updates_per_arm": 65536} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/usage.json new file mode 100644 index 0000000000..a6e059160a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/micro-native/usage.json @@ -0,0 +1 @@ +{"user_seconds":1.18,"system_seconds":0.04,"kernel_max_rss_kib":43672,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/receipt.json new file mode 100644 index 0000000000..816d6ec8fd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "packaged-native-finite-O", + "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": "915a89f16cff26648e9fa7387bba5b60edaa585ad520cf6026bfe1d575bbc237", + "sampled_process_group_rss_bytes": 78098432, + "script": "verify.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd668ce315f27bd03758656461f80f600d7f510ed251751fd8cc167b51fa99b5", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 12183, + "stdout_sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 43628, + "system_seconds": 0.14, + "user_seconds": 2.47 + }, + "wall_seconds": 2.6385492559929844 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stdout.txt new file mode 100644 index 0000000000..002652f850 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/stdout.txt @@ -0,0 +1,7 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "ec97f6ab576e23680c1fa6e0b3d6d9533a10ca0d7728aa7b21b7393ca0635360", "cold_build_load_wall_seconds": 0.3090584030142054, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/usage.json new file mode 100644 index 0000000000..81ad6268c0 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite-O/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.47,"system_seconds":0.14,"kernel_max_rss_kib":43628,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/receipt.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/receipt.json new file mode 100644 index 0000000000..d32188ccb7 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "packaged-native-finite", + "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": "915a89f16cff26648e9fa7387bba5b60edaa585ad520cf6026bfe1d575bbc237", + "sampled_process_group_rss_bytes": 78401536, + "script": "verify.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "dd668ce315f27bd03758656461f80f600d7f510ed251751fd8cc167b51fa99b5", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 12183, + "stdout_sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 44092, + "system_seconds": 0.13, + "user_seconds": 2.5 + }, + "wall_seconds": 2.6823815919924527 +} diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/stderr.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/stdout.txt b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/stdout.txt new file mode 100644 index 0000000000..c04cc0b9ce --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/stdout.txt @@ -0,0 +1,7 @@ +PASS_PRECISION_LINUX_SOURCE_CONTROLS {"contract": "declared contract edits", "declared_edit": "unique backend seam", "inner_archive": "source hash", "official_export_byte": "Exact PR5831 bundle"} +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "14e39fdbdd9a3d15962a1e5aa387b8dc0a06d193f2f73d953f13d039b2f7587e", "cold_build_load_wall_seconds": 0.3222606969939079, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY diff --git a/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/usage.json b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/usage.json new file mode 100644 index 0000000000..e0924173bd --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/evidence/runtime/runs/packaged-native-finite/usage.json @@ -0,0 +1 @@ +{"user_seconds":2.50,"system_seconds":0.13,"kernel_max_rss_kib":44092,"exit":0} diff --git a/research/verification-key-headroom/context/baseline-public/finite.py b/research/verification-key-headroom/context/baseline-public/finite.py new file mode 100644 index 0000000000..628b3a6e34 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/finite.py @@ -0,0 +1,146 @@ +"""Full inherited scientific gate and bounded native ownership/API controls.""" +import gc,json,sys,weakref,importlib.util +from fractions import Fraction as F +import native_backend +import fraction_table as table +import slot_finite +from frozen import require,baseline +from compact_finite import types_of + +def main(): + inherited=slot_finite.main();controls=[];native=native_backend.load() + weights=[(F(2),F(3)),(F(5),F(7)),(F(4,2),F(6,2))];tokens=[0,1,0] + compute=table.Contributions.compute + def make(cap=2,fn=compute,ws=None,ts=None):return native.Cache(cap,weights if ws is None else ws,tokens if ts is None else ts,fn,F.__dict__['_numerator'],F.__dict__['_denominator'],F) + def rejects(action,kind,label): + try:action() + except kind:controls.append(label) + else:raise ValueError('accepted '+label) + for cap in (1,2,16): + old=table.Contributions(cap);old.certify(dict(public=1,owned_fields=0,program=[]),weights,set());new=make(cap) + for q in (F(1),F(-1),F(1,2),F(2,4),F(2)): + event=new.event(q) + for k,i in enumerate((0,1,2,0,1,0,2,2,1)): + a,v=F(k%2),F(k%3-1) + require(event(a,v,i)==old.step(a,q,v,*weights[i]),'native value/FIFO') + require(new.statistics()==old.statistics(),'native full counters') + controls.append('canonical-keys-FIFO-wrap-counters') + c=make();event=c.event(F(1));modulus=sys.hash_info.modulus + a=event(F(0),F(1),0);b=event(F(modulus),F(1),0) + require(a!=b and c.statistics()['misses']==2,'native full equality on integer hash collision') + controls.append('native-hash-collision') + log=[] + def observed(*args):log.append(args);return compute(*args) + c=make(fn=observed);e=c.event(F(1));a=e(F(0),F(1),0);b=e(F(0),F(1),0) + require(a is b and len(log)==1,'hit returns owned existing tuple; no arithmetic') + controls.append('exact-one-callback-per-miss') + def fails(*args):raise ArithmeticError('original callback failure') + c=make(fn=fails);e=c.event(F(1)) + for k in range(2):rejects(lambda:e(F(0),F(1),0),ArithmeticError,'uncached-native-error-'+str(k)) + require(c.statistics()['resident']==0 and c.statistics()['misses']==2,'failed callback never cached') + gate=[False] + def intermittent(*args): + if gate[0]:raise ArithmeticError('full miss') + return compute(*args) + c=make(1,intermittent);e=c.event(F(1));e(F(0),F(1),0);gate[0]=True + rejects(lambda:e(F(2),F(1),0),ArithmeticError,'full-cache-failure-before-eviction') + require(c.statistics()['resident']==1 and c.statistics()['evictions']==0,'failed miss retains FIFO') + require(e(F(0),F(1),0)==compute(F(0),F(1),F(1),*weights[0]),'existing cache hit after failure') + controls.append('cache-survives-callback-exception') + c=make();e=c.event(F(1)) + for cap in (0,-1,16385,True,1.5,10**100):rejects(lambda cap=cap:make(cap),(ValueError,OverflowError),'capacity-'+str(cap)) + for i in (-1,3,10**100,True,'0'):rejects(lambda i=i:e(F(0),F(1),i),(TypeError,IndexError,OverflowError),'index-'+str(i)) + rejects(lambda:e(F(0),F(1)),TypeError,'arity') + rejects(lambda:e(F(0),F(1),0,extra=1),TypeError,'keywords') + rejects(lambda:e(0,F(1),0),TypeError,'exact-operand') + rejects(lambda:c.event(1),TypeError,'exact-scalar') + rejects(lambda:type(e)(),TypeError,'event-creation') + rejects(lambda:native.Cache(2,weights,tokens,compute,object(),F.__dict__['_denominator'],F),TypeError,'descriptor-protocol') + rejects(lambda:make(ts=[0]),ValueError,'token-length') + rejects(lambda:make(ts=[0,-1,1]),ValueError,'token-range') + rejects(lambda:make(ws=[(F(1),)]),ValueError,'partial-init-length') + rejects(lambda:make(ws=[(1,F(1))]*3),TypeError,'partial-init-weight') + def malformed(*args):return (F(1),)*3 + e=make(fn=malformed).event(F(1));rejects(lambda:e(F(0),F(1),0),TypeError,'callback-result-shape') + def malformed(*args):return (F(1),F(1),F(1),1) + e=make(fn=malformed).event(F(1));rejects(lambda:e(F(0),F(1),0),TypeError,'callback-result-type') + holder=[] + def recursive(*args):return holder[0](F(0),F(1),0) + c=make(fn=recursive);holder.append(c.event(F(1))) + rejects(lambda:holder[0](F(0),F(1),0),RuntimeError,'callback-reentry') + require(c.statistics()['calls']==1 and c.statistics()['resident']==0,'reentry cannot mutate cache') + del holder[:] + c=make();e=c.event(F(1));del c;gc.collect() + require(e(F(0),F(1),0)==compute(F(0),F(1),F(1),*weights[0]),'Event owns parent/context') + controls.append('event-owns-parent') + def cycle(): + context=[] + def callback(*args):return compute(*args) if context else None + c=make(fn=callback);context.append(c);return weakref.ref(callback) + ref=cycle();gc.collect();require(ref() is None,'callback/cache cycle collected') + controls.append('GC-callback-cycle') + c=make();s=c.statistics();s['calls']=-1;require(c.statistics()['calls']==0,'statistics isolated');controls.append('native-statistics-isolated') + src={0:F(1),1:F(-1),2:F(2)};dst={0:F(1)};scores=[F(3),F(4),F(5)] + expected=dict(dst);expected_scores=list(scores);parent=table.parent.CompactContributions(2,weights,tokens);step=parent.event(F(-1)) + for i,v in src.items(): + value,a,b,change=step(expected.get(i,F(0)),v,i) + expected_scores[0]+=a;expected_scores[1]+=b;expected_scores[2]+=change + if value:expected[i]=value + else:expected.pop(i,None) + c=make();c.event(F(-1)).apply(dst,src,scores) + require((dst,scores)==(expected,expected_scores) and types_of((dst,scores))==types_of((expected,expected_scores)) and c.statistics()==parent.statistics(),'complete native apply values/types/counters') + controls.append('native-coefficient-loop') + rejects(lambda:c.event(F(1)).apply(dst,dst,scores),TypeError,'same-row-lowlevel-rejection') + def mutate(*args):src.clear();return compute(*args) + src={0:F(1)};e=make(fn=mutate).event(F(1)) + rejects(lambda:e.apply({},src,[F(0)]*3),RuntimeError,'dict-iterator-mutation-safe') + scores=[F(0)]*3 + def mutate_score(*args):scores.clear();return compute(*args) + e=make(fn=mutate_score).event(F(1)) + rejects(lambda:e.apply({}, {0:F(1)},scores),IndexError,'callback-list-mutation-safe') + require(native_backend.source_hash()==native_backend.receipt()['source_sha256'],'compiled source remains bound') + controls.append('native-source-authenticated') + normal=table.Contributions.__dict__.get('compute');had='compute' in table.Contributions.__dict__;log=[] + class ForeignCompute: + def __get__(self,*args):log.append(True);raise RuntimeError('foreign compute must not be invoked') + try: + table.Contributions.compute=ForeignCompute() + require(table.checked_compute() is None and not log,'foreign callback descriptor rejected purely') + controls.append('callback-descriptor-is-pure') + table.Contributions.compute=compute + require(table.checked_compute() is None,'plain function would bind self; not staticmethod') + controls.append('plain-callback-rejected') + finally: + if had:table.Contributions.compute=normal + else:del table.Contributions.compute + code=compute.__code__;compute.__code__=code.replace(co_consts=code.co_consts+('drift',)) + try:require(table.checked_compute() is None,'live callback executable bound') + finally:compute.__code__=code + controls.append('live-callback-code-drift') + ws=[(F(2),F(3))];ts=[0] + owned=make(ws=ws,ts=ts);event=owned.event(F(1));ws.clear();ts.clear();gc.collect() + require(event(F(0),F(1),0)==compute(F(0),F(1),F(1),F(2),F(3)),'owned immutable packet survives caller metadata mutation') + controls.append('owned-metadata-snapshot') + with baseline() as package: + sys.path.insert(0,str(package));spec=importlib.util.spec_from_file_location('native_fallback_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('native_fallback_source',p/'verify.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace;fast=table.derive(ref) + word=dict(public=1,owned_fields=0,program=[['INIT',0,0],['ADD',0,0,1,0]]) + ws=[(F(1),F(1))]*2 + require(fast(word,ws,set())==original(word,ws,set()) and not fast.compacted_selected(),'same-row literal fallback') + controls.append('same-row-source-fallback') + bad=object.__new__(F) + word=dict(public=2,owned_fields=0,program=[['ADD',0,1,bad,0]]) + outcomes=[] + for fn in (original,fast): + try:outcomes.append(('value',fn(word,ws,set()))) + except Exception as error:outcomes.append((type(error).__name__,str(error))) + require(outcomes[0]==outcomes[1] and not fast.compacted_selected(),'malformed Fraction scalar has literal source outcome') + controls.append('malformed-scalar-literal-fallback') + result=dict(status='PASS_NATIVE_FINITE_ONLY',inherited=inherited,native_controls=controls,native_control_count=len(controls),build=native_backend.receipt(),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/fraction_table.py b/research/verification-key-headroom/context/baseline-public/fraction_table.py new file mode 100644 index 0000000000..d1688f4049 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/fraction_table.py @@ -0,0 +1,118 @@ +"""Native bookkeeping with original Fraction miss/score arithmetic.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +import builtins +from types import FunctionType +from pathlib import Path +import slot_parent as parent +import native_backend +from slot_binding import bind,fresh + +F=parent.F;CAPACITY=parent.CAPACITY +Contributions=parent.Contributions;NORMAL_CONTRIBUTIONS=Contributions +certified_domain=parent.certified_domain +transformed=parent.transformed +weight_tokens=parent.weight_tokens +_known={} +_ABS=builtins.abs +exec('def compute(old,q,v,a,c):\n value=old+q*v\n change=abs(value)-abs(old)\n return value,change*a,change*c,change\n',_known) + +def checked_compute(): + if type(Contributions) is not type:return None + descriptor=None + for cls in type.__getattribute__(Contributions,'__mro__'): + namespace=type.__getattribute__(cls,'__dict__') + if 'compute' in namespace: + descriptor=namespace['compute'];break + if type(descriptor) is not staticmethod:return None + fn=descriptor.__func__ + if type(fn) is not FunctionType:return None + if fn.__defaults__ is not None or fn.__kwdefaults__ is not None or fn.__closure__ is not None:return None + source=parent.parent.entry.parent + if source.code_shape(fn.__code__)!=source.code_shape(_known['compute'].__code__):return None + if type(fn.__builtins__) is not dict:return None + effective=fn.__globals__.get('abs',fn.__builtins__.get('abs')) + return fn if effective is _ABS else None + +class CompactContributions: + def __init__(self,capacity,weights,tokens): + callback=checked_compute() + if callback is None:raise ValueError('qualified original Fraction miss callback') + self.native=native_backend.load().Cache(capacity,weights,tokens,callback,F.__dict__['_numerator'],F.__dict__['_denominator'],F) + def event(self,q):return self.native.event(q) + def statistics(self):return self.native.statistics() + +def native_domain(word,weights): + n=word['public']+word['owned_fields'] + if n<0 or word['public']<0 or word['owned_fields']<0 or len(weights)','exec'),namespace) + source.need(source.code_shape(original.__code__)==source.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + source.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + token=bind();last=[None,None,None];factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + last[:]=[None,False,None] + if token is None or not fresh(token):return original(word,weights,rounded) + eligible=bool(capacity and factory is NORMAL_CONTRIBUTIONS and checked_compute() is not None and certified_domain(word,weights,rounded)) + if eligible and not native_domain(word,weights):return original(word,weights,rounded) + tokens=weight_tokens(weights) if eligible else None + if eligible and tokens is None:return original(word,weights,rounded) + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/verification-key-headroom/context/baseline-public/frozen.py b/research/verification-key-headroom/context/baseline-public/frozen.py new file mode 100644 index 0000000000..eb26be4a0f --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/frozen.py @@ -0,0 +1,67 @@ +"""Authenticate the unchanged complete PR5848 export before importing it.""" +from contextlib import contextmanager +from hashlib import sha256 +import json +from pathlib import Path +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +BUNDLE_SHA256 = 'f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6' +SOURCE_HEAD = '66fb6c6b8683b37967e9d7f313b3df99a49d2406' + + +def require(ok, why): + if not ok: + raise ValueError(why) + + +def payload(archive=None): + archive = HERE / 'inputs/PR5848.tar' if archive is None else archive + require(sha256(archive.read_bytes()).hexdigest() == BUNDLE_SHA256, 'Exact PR5848 bundle') + with tarfile.open(archive, 'r:') as stream: + members = stream.getmembers() + require(len(members) == 98 and len({m.name for m in members}) == 98, 'Complete unique baseline bundle') + require(all(m.isfile() and 0 <= m.size <= 8 * 1024**2 for m in members), 'Regular bounded baseline members') + receipt = json.loads(stream.extractfile('.research-export.json').read()) + require(receipt['commit'] == SOURCE_HEAD, 'Exact baseline export head') + rows = {r['path']: r for r in receipt['files']} + require(len(rows) == len(receipt['files']) == 97, 'Complete baseline file census') + require({m.name for m in members} == set(rows) | {'.research-export.json'}, 'Exact baseline member set') + contents = {} + for member in members: + path = Path(member.name) + require(not path.is_absolute() and '..' not in path.parts and path.parts, 'Safe baseline path') + raw = stream.extractfile(member).read() + if member.name in rows: + row = rows[member.name] + require(len(raw) == row['size'] and sha256(raw).hexdigest() == row['sha256'], 'Exact baseline file bytes') + require(row['mode'] in (0o644, 0o755), 'Regular baseline file mode') + contents[member.name] = raw + return contents + + +@contextmanager +def baseline(): + contents = payload() + with tempfile.TemporaryDirectory(prefix='precision-linux-source-') as temporary: + root = Path(temporary) + try: + for name, raw in contents.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + path.chmod(0o444) + for path in root.rglob('*'): + if path.is_dir(): + path.chmod(0o555) + before = {str(p.relative_to(root)): [sha256(p.read_bytes()).hexdigest(), p.stat().st_mode & 0o777] + for p in root.rglob('*') if p.is_file()} + yield root / 'research/p104-single-pass-qualification' + after = {str(p.relative_to(root)): [sha256(p.read_bytes()).hexdigest(), p.stat().st_mode & 0o777] + for p in root.rglob('*') if p.is_file() and not p.is_symlink()} + require(after == before and not any(p.is_symlink() for p in root.rglob('*')), 'Baseline export unchanged') + finally: + for path in [root, *root.rglob('*')]: + if path.is_dir(): + path.chmod(0o755) diff --git a/research/verification-key-headroom/context/baseline-public/full.py b/research/verification-key-headroom/context/baseline-public/full.py new file mode 100644 index 0000000000..93196e8d63 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/full.py @@ -0,0 +1,54 @@ +"""Complete frozen qualifier with one source-bound Fraction seam changed.""" +import importlib.util,inspect,json,sys +from pathlib import Path +from frozen import baseline,require + +ACTUAL_STATS=dict(calls=2579750,hits=2252966,misses=326784,evictions=310400,bypasses=0,resident=16384,capacity=16384) +OUTPUT='954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9' + +def main(native=False): + if native: + import finite + finite.main() + # The inherited finite harness imports its own sealed temporary source. + # Remove only expired, owned temporary modules before the fresh qualifier. + for name in ('source','observe'): + value=sys.modules.get(name);file=getattr(value,'__file__','') + if file.startswith('/tmp/precision-linux-source-') and not Path(file).exists():del sys.modules[name] + with baseline() as package: + sys.path.insert(0,str(package)) + spec=importlib.util.spec_from_file_location('native_complete_frozen_entry',package/'candidate.py') + entry=importlib.util.module_from_spec(spec);spec.loader.exec_module(entry) + if not native: + entry.main();return + import fraction_table,native_backend + captures=[] + def native_trace(reference,expected_word): + trace=fraction_table.derive(reference) + def call(word,weights,rounded): + result=trace(word,weights,rounded) + if len(word['program'])==len(expected_word['program']): + require(trace.compacted_selected() is True,'actual native route selected') + require(trace.statistics()==ACTUAL_STATS,'all actual native counters') + require(reference.digest(result)==OUTPUT,'complete actual native output digest') + captures.append(dict(statistics=trace.statistics(),output_sha256=OUTPUT,tokens=trace.token_count())) + return result + return call + raw=(package/'candidate.py').read_text() + seam=' value = Observation(value, reference.digest, word)\n' + require(raw.count(seam)==1,'one authenticated actual Fraction seam') + changed=raw.replace(seam,' value.error_trace = _native_trace(value, word)\n'+seam) + namespace=dict(entry.__dict__);namespace['_native_trace']=native_trace + exec(compile(changed,str(package/'candidate.py'),'exec'),namespace) + qualify=namespace['qualify'] + def qualified(): + result=qualify() + require(len(captures)==1,'one complete actual native observation') + print(json.dumps(dict(status='PASS_COMPLETE_NATIVE_COVERAGE',actual=captures[0],build=native_backend.receipt(),native_finite_included=True,compiler_children_charged=True,integer_oracle_unchanged=True),sort_keys=True)) + return result + namespace['qualify']=qualified + namespace['main']() + +if __name__=='__main__': + require(len(sys.argv)==2 and sys.argv[1] in ('B','C'),'complete B or C') + main(sys.argv[1]=='C') diff --git a/research/verification-key-headroom/context/baseline-public/full_B.py b/research/verification-key-headroom/context/baseline-public/full_B.py new file mode 100644 index 0000000000..f22596d078 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/full_B.py @@ -0,0 +1,2 @@ +from full import main +main(False) diff --git a/research/verification-key-headroom/context/baseline-public/full_C.py b/research/verification-key-headroom/context/baseline-public/full_C.py new file mode 100644 index 0000000000..c6dc7a2dc5 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/full_C.py @@ -0,0 +1,2 @@ +from full import main +main(True) diff --git a/research/verification-key-headroom/context/baseline-public/guard.py b/research/verification-key-headroom/context/baseline-public/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/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/verification-key-headroom/context/baseline-public/inputs/PR5848.tar b/research/verification-key-headroom/context/baseline-public/inputs/PR5848.tar new file mode 100644 index 0000000000..307d09d2a9 Binary files /dev/null and b/research/verification-key-headroom/context/baseline-public/inputs/PR5848.tar differ diff --git a/research/verification-key-headroom/context/baseline-public/micro.py b/research/verification-key-headroom/context/baseline-public/micro.py new file mode 100644 index 0000000000..b5a33e039a --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/micro.py @@ -0,0 +1,20 @@ +"""Fixed BCCB cache/loop screen, not a complete performance benchmark.""" +import json,time +from fractions import Fraction as F +import slot_parent +import fraction_table as table +import native_backend +from frozen import require + +def main(): + native_backend.load();weights=[(F(2),F(3)),(F(5),F(7))];tokens=[0,1] + results=[];count=65536 + for label,cls in [('B',slot_parent.CompactContributions),('C',table.CompactContributions),('C',table.CompactContributions),('B',slot_parent.CompactContributions)]: + c=cls(16384,weights,tokens);step=c.event(F(1));total=F(0) + cpu=time.process_time();wall=time.perf_counter() + for i in range(count):total+=step(F(0),F(i%4),i%2)[1] + results.append(dict(label=label,wall_seconds=time.perf_counter()-wall,cpu_seconds=time.process_time()-cpu,total=str(total),statistics=c.statistics())) + require(all(r['total']==results[0]['total'] and r['statistics']==results[0]['statistics'] for r in results),'all complete micro outputs/counters') + print(json.dumps(dict(status='PASS_NATIVE_MICRO_SCREEN_ONLY',fixed_order='BCCB',updates_per_arm=count,results=results,build=native_backend.receipt()),sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/micro_apply.py b/research/verification-key-headroom/context/baseline-public/micro_apply.py new file mode 100644 index 0000000000..e1b06d8262 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/micro_apply.py @@ -0,0 +1,29 @@ +"""Fixed complete coefficient-loop comparison, separate from cache-only screen.""" +import json,time +from fractions import Fraction as F +import slot_parent +import fraction_table as table +import native_backend +from frozen import require + +native_backend.load();n=128;repetitions=512 +weights=[(F(i%5,4),F(i%7,8)) for i in range(n)];tokens=table.weight_tokens(weights) +src={i:F(i%5-2,2) for i in range(n)};old={i:F(i%3-1,4) for i in range(n)} +results=[] +for label in 'BCCB': + cls=slot_parent.CompactContributions if label=='B' else table.CompactContributions + c=cls(16384,weights,tokens);step=c.event(F(1,2));checksum=F(0) + cpu=time.process_time();wall=time.perf_counter() + for k in range(repetitions): + dst=dict(old);scores=[F(0),F(0),F(0)] + if label=='C':step.apply(dst,src,scores) + else: + for i,v in src.items(): + value,a,b,change=step(dst.get(i,F(0)),v,i) + scores[0]+=a;scores[1]+=b;scores[2]+=change + if value:dst[i]=value + else:dst.pop(i,None) + checksum+=scores[0]+scores[1]+scores[2] + results.append(dict(label=label,wall_seconds=time.perf_counter()-wall,cpu_seconds=time.process_time()-cpu,checksum=str(checksum),last_row={str(i):str(v) for i,v in dst.items()},last_scores=list(map(str,scores)),statistics=c.statistics())) +require(all({k:v for k,v in r.items() if k not in ('label','wall_seconds','cpu_seconds')}=={k:v for k,v in results[0].items() if k not in ('label','wall_seconds','cpu_seconds')} for r in results),'full apply micro equality/counters') +print(json.dumps(dict(status='PASS_NATIVE_APPLY_MICRO_ONLY',fixed_order='BCCB',updates_per_arm=n*repetitions,results=results,build=native_backend.receipt()),sort_keys=True)) diff --git a/research/verification-key-headroom/context/baseline-public/native_backend.py b/research/verification-key-headroom/context/baseline-public/native_backend.py new file mode 100644 index 0000000000..4ce062118c --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/native_backend.py @@ -0,0 +1,61 @@ +"""Cold-build the owned C source; reuse code only within this process.""" +from hashlib import sha256 +import atexit +import importlib.util +import json +from pathlib import Path +import platform +import shutil +import subprocess +import sys +import sysconfig +import tempfile +import time + +HERE=Path(__file__).resolve().parent +_loaded=None +_temporary=None +_receipt=None + +def source_hash(): + path=HERE/'native_cache.c' + digest=sha256(path.read_bytes()).hexdigest() + expected=json.loads((HERE/'NATIVE-SOURCE.json').read_text())['sha256'] + if path.is_symlink() or digest!=expected:raise ValueError('exact owned C source') + return digest + +def load(): + global _loaded,_temporary,_receipt + digest=source_hash() + if _loaded is not None: + if _receipt['source_sha256']!=digest:raise ValueError('loaded native code has this exact source') + return _loaded + if platform.python_implementation()!='CPython' or sys.version_info[:2]!=(3,12) or sys.platform!='linux': + raise RuntimeError('native feasibility requires Linux CPython 3.12') + compiler=shutil.which('cc') + if not compiler:raise RuntimeError('native feasibility requires an existing C compiler') + start=time.perf_counter() + _temporary=tempfile.TemporaryDirectory(prefix='fraction-native-owned-') + atexit.register(_temporary.cleanup) + root=Path(_temporary.name) + raw=(HERE/'native_cache.c').read_bytes() + if sha256(raw).hexdigest()!=digest:raise ValueError('C source remained authenticated at snapshot') + snapshot=root/'native_cache.c';snapshot.write_bytes(raw);snapshot.chmod(0o444) + destination=root/('_fraction_native'+sysconfig.get_config_var('EXT_SUFFIX')) + flags=['-O2','-shared','-fPIC','-std=c11','-Wall','-Werror','-I'+sysconfig.get_path('include')] + command=[compiler,*flags,str(snapshot),'-o',str(destination)] + build=subprocess.run(command,capture_output=True,text=True,check=False) + if build.returncode or build.stderr or build.stdout: + raise RuntimeError('native build rejected: '+json.dumps(dict(command=command,returncode=build.returncode,stdout=build.stdout,stderr=build.stderr))) + destination.chmod(0o444) + spec=importlib.util.spec_from_file_location('_fraction_native',destination) + value=importlib.util.module_from_spec(spec);spec.loader.exec_module(value) + _receipt=dict(source_sha256=digest,compiler=compiler,flags=flags,SOABI=sysconfig.get_config_var('SOABI'), + extension_suffix=sysconfig.get_config_var('EXT_SUFFIX'),python=sys.version, + binary_sha256=sha256(destination.read_bytes()).hexdigest(),cold_build_load_wall_seconds=time.perf_counter()-start, + compiler_cpu_accounting='outer GNU time user+system includes compiler children', + compiler_version=subprocess.run([compiler,'--version'],capture_output=True,text=True,check=True).stdout.splitlines()[0]) + _loaded=value + return value + +def receipt():return None if _receipt is None else dict(_receipt) diff --git a/research/verification-key-headroom/context/baseline-public/native_cache.c b/research/verification-key-headroom/context/baseline-public/native_cache.c new file mode 100644 index 0000000000..ada7b0d0bf --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/native_cache.c @@ -0,0 +1,227 @@ +/* Exact bounded cache/control only. All Fraction arithmetic stays in Python. + * Chris R / Clear1nsight, substantial OpenAI Codex/Astra assistance. Apache-2.0. + */ +#define PY_SSIZE_T_CLEAN +#include +#include + +typedef struct { + PyObject_HEAD + PyObject *dict, *weights, *tokens, *compute, *num, *den, *fraction; + PyObject **ring; + Py_ssize_t capacity, used, head, calls, hits, misses, evictions; + int ready, busy; +} Cache; +typedef struct { + PyObject_HEAD + vectorcallfunc vectorcall; + Cache *cache; + PyObject *q, *qn, *qd; +} Event; +static PyTypeObject CacheType, EventType; + +static int cache_traverse(Cache *s, visitproc visit, void *arg) { + Py_VISIT(s->dict); Py_VISIT(s->weights); Py_VISIT(s->tokens); + Py_VISIT(s->compute); Py_VISIT(s->num); Py_VISIT(s->den); Py_VISIT(s->fraction); + if (s->ring) for (Py_ssize_t i=0;icapacity;i++) Py_VISIT(s->ring[i]); + return 0; +} +static int cache_clear(Cache *s) { + s->ready=0; s->busy=1; + if (s->ring) { + for (Py_ssize_t i=0;icapacity;i++) Py_CLEAR(s->ring[i]); + PyMem_Free(s->ring); s->ring=NULL; + } + Py_CLEAR(s->dict); Py_CLEAR(s->weights); Py_CLEAR(s->tokens); + Py_CLEAR(s->compute); Py_CLEAR(s->num); Py_CLEAR(s->den); Py_CLEAR(s->fraction); + return 0; +} +static void cache_dealloc(Cache *s) { + PyObject_GC_UnTrack(s); cache_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static int event_traverse(Event *s, visitproc visit, void *arg) { + Py_VISIT(s->cache); Py_VISIT(s->q); Py_VISIT(s->qn); Py_VISIT(s->qd); return 0; +} +static int event_clear(Event *s) { + Py_CLEAR(s->cache); Py_CLEAR(s->q); Py_CLEAR(s->qn); Py_CLEAR(s->qd); return 0; +} +static void event_dealloc(Event *s) { + PyObject_GC_UnTrack(s); event_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static PyObject *event_disabled(PyTypeObject *type, PyObject *args, PyObject *kw) { + (void)type; (void)args; (void)kw; + PyErr_SetString(PyExc_TypeError,"events are created only by Cache.event"); return NULL; +} +static int is_pair(PyObject *p) { + return (PyList_CheckExact(p)||PyTuple_CheckExact(p)) && PySequence_Size(p)>=2; +} +static PyObject *cache_new(PyTypeObject *type, PyObject *args, PyObject *kw) { + if (kw && PyDict_Size(kw)) { PyErr_SetString(PyExc_TypeError,"positional cache arguments only");return NULL; } + PyObject *cap,*weights,*tokens,*compute,*num,*den,*fraction; + if (!PyArg_UnpackTuple(args,"Cache",7,7,&cap,&weights,&tokens,&compute,&num,&den,&fraction)) return NULL; + if (!PyLong_CheckExact(cap)) { PyErr_SetString(PyExc_ValueError,"integer capacity");return NULL; } + Py_ssize_t ncap=PyLong_AsSsize_t(cap); + if (ncap<1 || ncap>16384 || PyErr_Occurred()) { if(!PyErr_Occurred()) PyErr_SetString(PyExc_ValueError,"capacity 1..16384");return NULL; } + if (!(PyList_CheckExact(weights)||PyTuple_CheckExact(weights)) || !PyList_CheckExact(tokens) || !PyFunction_Check(compute) || !PyType_Check(fraction) || Py_TYPE(num)!=&PyMemberDescr_Type || Py_TYPE(den)!=&PyMemberDescr_Type || !Py_TYPE(num)->tp_descr_get || !Py_TYPE(den)->tp_descr_get) { + PyErr_SetString(PyExc_TypeError,"exact native packet types");return NULL; + } + Py_ssize_t n=PySequence_Size(weights); + if (PyList_GET_SIZE(tokens)!=n) { PyErr_SetString(PyExc_ValueError,"weight/token size");return NULL; } + Cache *s=(Cache *)type->tp_alloc(type,0); + if (!s) return NULL; + s->capacity=ncap; + s->dict=PyDict_New();s->weights=PyTuple_New(n);s->tokens=PyTuple_New(n); + s->ring=PyMem_Calloc((size_t)ncap,sizeof(PyObject *)); + if (!s->dict || !s->weights || !s->tokens || !s->ring) { if(!PyErr_Occurred())PyErr_NoMemory();Py_DECREF(s);return NULL; } + s->compute=Py_NewRef(compute);s->num=Py_NewRef(num);s->den=Py_NewRef(den);s->fraction=Py_NewRef(fraction); + for (Py_ssize_t i=0;iweights,i,pair); + PyObject *token=PySequence_GetItem(tokens,i); + if (!token) { Py_DECREF(s);return NULL; } + if (!PyLong_CheckExact(token)) { Py_DECREF(token);Py_DECREF(s);PyErr_SetString(PyExc_TypeError,"integer token");return NULL; } + Py_ssize_t t=PyLong_AsSsize_t(token); + if (t<0 || t>=16384 || PyErr_Occurred()) { Py_DECREF(token);Py_DECREF(s);if(!PyErr_Occurred())PyErr_SetString(PyExc_ValueError,"bounded token");return NULL; } + PyTuple_SET_ITEM(s->tokens,i,token); + } + s->ready=1;return (PyObject *)s; +} +static PyObject *member(PyObject *descriptor, PyObject *object, PyObject *type) { + return Py_TYPE(descriptor)->tp_descr_get(descriptor,object,type); +} +static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) { + Cache *s=e->cache; + if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,"native site index");return NULL; } + if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,"exact Fraction coefficients");return NULL; } + PyObject *parts[4]={NULL,NULL,NULL,NULL}; + for (int k=0;k<4;k++) { + parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction); + if (!parts[k] || !PyLong_CheckExact(parts[k])) { + for(int j=0;j<4;j++)Py_XDECREF(parts[j]); + if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,"integer Fraction slots"); + return NULL; + } + } + PyObject *key=PyTuple_New(7); + if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);return NULL;} + PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]); + PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd)); + PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i))); + if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,"native counter overflow");return NULL;} + s->calls++; + PyObject *result=PyDict_GetItemWithError(s->dict,key); + if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);return result;} + if(PyErr_Occurred()){Py_DECREF(key);return NULL;} + s->misses++; + PyObject *pair=PyTuple_GET_ITEM(s->weights,i); + PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)}; + result=PyObject_Vectorcall(s->compute,argv,5,NULL); + if(!result){Py_DECREF(key);return NULL;} + if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"four exact contributions");return NULL;} + for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"Fraction contributions");return NULL;} + if(s->used==s->capacity){ + PyObject *oldkey=s->ring[s->head]; + if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++; + } + if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++; + return result; +} +static int begin_event(Event *e) { + if(!e->cache||!e->cache->ready){PyErr_SetString(PyExc_RuntimeError,"cleared native event");return -1;} + if(e->cache->busy){PyErr_SetString(PyExc_RuntimeError,"reentrant native event");return -1;} + e->cache->busy=1;return 0; +} +static PyObject *event_call(PyObject *obj, PyObject *const *args, size_t nargsf, PyObject *kw) { + Event *e=(Event *)obj; + if(PyVectorcall_NARGS(nargsf)!=3 || (kw&&PyTuple_GET_SIZE(kw))){PyErr_SetString(PyExc_TypeError,"event(old,v,index)");return NULL;} + if(!PyLong_CheckExact(args[2])){PyErr_SetString(PyExc_TypeError,"integer site index");return NULL;} + Py_ssize_t i=PyLong_AsSsize_t(args[2]);if(PyErr_Occurred())return NULL; + if(begin_event(e)<0)return NULL; + PyObject *result=contribution(e,args[0],args[1],i);e->cache->busy=0;return result; +} +static PyObject *cache_event(Cache *s, PyObject *q) { + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + if(!Py_IS_TYPE(q,(PyTypeObject *)s->fraction)){PyErr_SetString(PyExc_TypeError,"exact Fraction scalar");return NULL;} + Event *e=(Event *)EventType.tp_alloc(&EventType,0);if(!e)return NULL; + e->vectorcall=event_call;e->cache=(Cache *)Py_NewRef((PyObject *)s);e->q=Py_NewRef(q); + e->qn=member(s->num,q,s->fraction); + if(!e->qn){Py_DECREF(e);return NULL;} + e->qd=member(s->den,q,s->fraction); + if(!e->qd){Py_DECREF(e);return NULL;} + if(!PyLong_CheckExact(e->qn)||!PyLong_CheckExact(e->qd)){Py_DECREF(e);PyErr_SetString(PyExc_TypeError,"integer scalar slots");return NULL;} + return (PyObject *)e; +} +static PyObject *cache_statistics(Cache *s, PyObject *unused) { + (void)unused; + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + return Py_BuildValue("{s:n,s:n,s:n,s:n,s:n,s:n,s:n}","calls",s->calls,"hits",s->hits,"misses",s->misses,"evictions",s->evictions,"bypasses",(Py_ssize_t)0,"resident",PyDict_Size(s->dict),"capacity",s->capacity); +} +static PyObject *event_apply(Event *e, PyObject *args) { + PyObject *dst,*src,*scores; + if(!PyArg_UnpackTuple(args,"apply",3,3,&dst,&src,&scores))return NULL; + if(!PyDict_CheckExact(dst)||!PyDict_CheckExact(src)||dst==src||!PyList_CheckExact(scores)||PyList_GET_SIZE(scores)!=3){PyErr_SetString(PyExc_TypeError,"distinct exact rows and three scores");return NULL;} + if(begin_event(e)<0)return NULL; + Cache *s=e->cache; + PyObject *pair=NULL,*result=NULL; + PyObject *view=PyObject_CallMethod(src,"items",NULL); + PyObject *iterator=view?PyObject_GetIter(view):NULL; + Py_XDECREF(view); + if(!iterator)goto fail; + while((pair=PyIter_Next(iterator))){ + if(!PyTuple_CheckExact(pair)||PyTuple_GET_SIZE(pair)!=2){PyErr_SetString(PyExc_TypeError,"dict item pair");goto fail;} + PyObject *index=PyTuple_GET_ITEM(pair,0),*value=PyTuple_GET_ITEM(pair,1); + if(!PyLong_CheckExact(index)){PyErr_SetString(PyExc_TypeError,"integer source site");goto fail;} + Py_ssize_t i=PyLong_AsSsize_t(index);if(PyErr_Occurred())goto fail; + PyObject *zeroarg=PyLong_FromLong(0);if(!zeroarg)goto fail; + PyObject *zero=PyObject_CallOneArg(s->fraction,zeroarg);Py_DECREF(zeroarg);if(!zero)goto fail; + PyObject *old=PyDict_GetItemWithError(dst,index); + if(old){Py_INCREF(old);Py_DECREF(zero);}else if(PyErr_Occurred()){Py_DECREF(zero);goto fail;}else old=zero; + result=contribution(e,old,value,i);Py_DECREF(old);if(!result)goto fail; + for(int k=0;k<3;k++){ + PyObject *score=PyList_GetItem(scores,k); + if(!score)goto fail; + Py_INCREF(score); + PyObject *next=PyNumber_InPlaceAdd(score,PyTuple_GET_ITEM(result,k+1)); + Py_DECREF(score); + if(!next)goto fail; + if(PyList_SetItem(scores,k,next)<0)goto fail; + } + int truth=PyObject_IsTrue(PyTuple_GET_ITEM(result,0)); + if(truth<0)goto fail; + if(truth){if(PyDict_SetItem(dst,index,PyTuple_GET_ITEM(result,0))<0)goto fail;} + else{ + PyObject *present=PyDict_GetItemWithError(dst,index); + if(present){if(PyDict_DelItem(dst,index)<0)goto fail;} + else if(PyErr_Occurred())goto fail; + } + Py_CLEAR(result);Py_CLEAR(pair); + } + if(PyErr_Occurred())goto fail; + Py_DECREF(iterator);s->busy=0;Py_RETURN_NONE; +fail:Py_XDECREF(result);Py_XDECREF(pair);Py_XDECREF(iterator);s->busy=0;return NULL; +} +static PyMethodDef cache_methods[]={{"event",(PyCFunction)cache_event,METH_O,"Fresh scalar context."},{"statistics",(PyCFunction)cache_statistics,METH_NOARGS,"Full counters."},{NULL,NULL,0,NULL}}; +static PyMethodDef event_methods[]={{"apply",(PyCFunction)event_apply,METH_VARARGS,"Same coefficient loop and Python numeric operations."},{NULL,NULL,0,NULL}}; +static PyTypeObject CacheType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Cache",.tp_basicsize=sizeof(Cache),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC, + .tp_new=cache_new,.tp_dealloc=(destructor)cache_dealloc,.tp_traverse=(traverseproc)cache_traverse,.tp_clear=(inquiry)cache_clear,.tp_methods=cache_methods}; +static PyTypeObject EventType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Event",.tp_basicsize=sizeof(Event),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_VECTORCALL, + .tp_new=event_disabled,.tp_dealloc=(destructor)event_dealloc,.tp_traverse=(traverseproc)event_traverse,.tp_clear=(inquiry)event_clear, + .tp_call=PyVectorcall_Call,.tp_vectorcall_offset=offsetof(Event,vectorcall),.tp_methods=event_methods}; +static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_fraction_native","Bounded cache; exact Python arithmetic.",-1,NULL}; +PyMODINIT_FUNC PyInit__fraction_native(void){ + if(PyType_Ready(&CacheType)<0||PyType_Ready(&EventType)<0)return NULL; + PyObject *m=PyModule_Create(&module);if(!m)return NULL; + if(PyModule_AddObjectRef(m,"Cache",(PyObject *)&CacheType)<0){Py_DECREF(m);return NULL;} + return m; +} diff --git a/research/verification-key-headroom/context/baseline-public/parent_finite.py b/research/verification-key-headroom/context/baseline-public/parent_finite.py new file mode 100644 index 0000000000..e00dd29385 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/parent_finite.py @@ -0,0 +1,164 @@ +"""Finite gate before construction, using the actual frozen Fraction source.""" +from copy import deepcopy +from fractions import Fraction as F +import importlib.util +import inspect +import json +from pathlib import Path +import random +import sys +import tempfile +import types +from frozen import baseline, require +from fraction_table import derive, installed, transformed, Contributions, CAPACITY + + +def types_of(value): + if isinstance(value, dict): + return ('dict', {k:types_of(v) for k,v in value.items()}) + if isinstance(value, (list, tuple)): + return (type(value).__name__, [types_of(v) for v in value]) + return type(value).__name__ + + +def fixtures(): + rng = random.Random(5848) + special = [['ADD',0,1,1,0],['ADD',1,0,1,0],['ADD',1,0,-2,0], + ['ADD',1,0,1,0],['COPY',2,1,-1,0],['SCALE',1,'1/2',0], + ['MOVE',2,0,0,False],['INIT',2,0],['CLEAR',2,0]] + yield dict(public=2,owned_fields=1,program=special), [(F(1),F(1))]*len(special), {'ADD','COPY','SCALE','INIT','CLEAR','MOVE'} + scalars = ['1','-1','1/2','-3/8','2','-4','5/16'] + for case in range(240): + n = 3+case%6 + program = [] + for i in range(case%95): + op = rng.choice(['INIT','CLEAR','MOVE','ADD','COPY','SCALE']) + r = rng.randrange(n) + if op in ('INIT','CLEAR'):event=[op,r,0] + elif op=='MOVE':event=[op,r,0,0,False] + elif op=='SCALE':event=[op,r,rng.choice(scalars),0] + else:event=[op,r,rng.choice([s for s in range(n) if s!=r]),rng.choice(scalars),0] + program.append(event) + weights=[(F(rng.randrange(6),2**rng.randrange(7)),F(rng.randrange(5),2**rng.randrange(6))) for e in program] + rounded={op for op in ('INIT','CLEAR','MOVE','ADD','COPY','SCALE') if rng.randrange(2)} + yield dict(public=n-1,owned_fields=1,program=program),weights,rounded + + +def main(): + results=[] + def rejects(label, action, exception=ValueError): + try:action() + except exception:results.append(label) + else:raise ValueError('accepted '+label) + with baseline() as package: + sys.path.insert(0,str(package)) + import source + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('finite_precision_entry',p/'verify.py') + v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,original,ref): + old=ref.error_trace + fast=derive(ref) + cases=list(fixtures());events=0 + engines={capacity:derive(ref,capacity) for capacity in (0,1,2,CAPACITY)} + for word,weights,rounded in cases: + before=deepcopy((word,weights,rounded)) + a=old(word,weights,rounded) + for capacity in (0,1,2,CAPACITY): + f=engines[capacity];b=f(word,weights,rounded) + require(a==b and types_of(a)==types_of(b),'complete finite output and numeric types') + require(f.statistics()['resident']<=capacity,'bounded per-trace table') + require((word,weights,rounded)==before,'inputs remain unchanged') + events+=len(word['program']) + word,weights,rounded=cases[0] + value=fast(word,weights,rounded);value[0]['final_scores'][0][0]=F(999) + require(fast(word,weights,rounded)==old(word,weights,rounded),'fresh mutable output') + results.append('returned-mutation-isolated') + raw=inspect.getsource(old) + rejects('source-drift',lambda:transformed(raw+'\n# drift\n')) + saved_F=ref.F;ref.F=int + try:rejects('Fraction-type-drift',lambda:derive(ref)) + finally:ref.F=saved_F + with tempfile.TemporaryDirectory() as td: + file=Path(td)/'precision.py';file.write_bytes(Path(ref.__file__).read_bytes()+b'\n# drift\n') + saved_file=ref.__file__;ref.__file__=str(file) + try:rejects('module-byte-drift',lambda:derive(ref)) + finally:ref.__file__=saved_file + code=old.__code__.replace(co_consts=('live-code-drift',)+old.__code__.co_consts[1:]) + ref.error_trace=types.FunctionType(code,old.__globals__) + try:rejects('live-code-drift',lambda:derive(ref)) + finally:ref.error_trace=old + constants=list(old.__code__.co_consts) + index=next(i for i,c in enumerate(constants) if isinstance(c,types.CodeType)) + constants[index]=constants[index].replace(co_consts=constants[index].co_consts+('nested-code-drift',)) + ref.error_trace=types.FunctionType(old.__code__.replace(co_consts=tuple(constants)),old.__globals__) + try:rejects('nested-live-code-drift',lambda:derive(ref)) + finally:ref.error_trace=old + for label,change in [ + ('omitted-witness',('witness[k] = dict(rows[r])','witness[k] = {}')), + ('omitted-rounded-sites',('if op in rounded:','if False:'))]: + text=transformed(raw);require(change[0] in text,'mutant site');text=text.replace(*change) + ns=dict(ref.__dict__);ns.update(_contribution_factory=Contributions,_contribution_report=lambda value:None) + exec(compile(text,'','exec'),ns) + require(any(ns['error_trace'](*c)!=old(*c) for c in cases),'mutant rejected '+label) + results.append(label) + correct_compute=Contributions.compute + for label,index in [('wrong-coefficient',0),('wrong-weighted-increment',1)]: + def corrupted(*args,**kwargs): + out=list(correct_compute(*args,**kwargs));out[index]+=F(1);return tuple(out) + Contributions.compute=staticmethod(corrupted) + try:require(any(fast(*c)!=old(*c) for c in cases),'arithmetic mutant rejected '+label) + finally:Contributions.compute=staticmethod(correct_compute) + results.append(label) + for label,bad_word,bad_weights in [('bad-role',dict(public=2,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))]),('bad-scalar',dict(public=2,owned_fields=0,program=[['ADD',0,1,'bad',0]]),[(F(1),F(1))]),('missing-weight',word,[])]: + errors=[] + for fn in (old,fast): + try:fn(bad_word,bad_weights,rounded) + except (IndexError,ValueError) as e:errors.append((type(e).__name__,str(e))) + else:raise ValueError('missing original exception '+label) + require(errors[0]==errors[1],'same original exception '+label);results.append(label) + with installed(ref) as f: + require(ref.error_trace is f and f(*cases[0])==old(*cases[0]),'scoped install') + require(ref.error_trace is old,'restore on success');results.append('restore-success') + try: + with installed(ref):raise RuntimeError('caller-failure') + except RuntimeError:pass + require(ref.error_trace is old,'restore on exception');results.append('restore-exception') + require(derive(ref)(*cases[0])==old(*cases[0]),'fresh derivation');results.append('fresh-derivation') + # Complete exact keys, collision safety, FIFO, exceptions and fresh lifetimes. + base=(F(0),F(1),F(1),F(2),F(3)) + for field in range(5): + c=Contributions(4);c.step(*base);c.step(*base) + changed=list(base);changed[field]+=F(1,2) + require(c.step(*changed)==correct_compute(*changed),'complete key value') + require(c.hits==1 and c.misses==2,'every key field bound') + results.append('key-field-'+str(field)) + c=Contributions(2);a=base;b=(F(1),*base[1:]);d=(F(2),*base[1:]) + c.step(*a);c.step(*b);c.step(*a);c.step(*d) + require(c.evictions==1 and len(c.table)==2,'capacity eviction') + prior=c.misses;c.step(*a);require(c.misses==prior+1,'FIFO eviction recomputes');results.append('FIFO-eviction') + c=Contributions(2);c.step(*base) + same=(F(0,2),F(2,2),F(3,3),F(4,2),F(9,3));c.step(*same) + require(c.hits==1,'canonical equal-value key');results.append('canonical-key') + modulus=sys.hash_info.modulus + one=base;two=(F(modulus),*base[1:]);keys=lambda values:tuple(t for x in values for t in (x.numerator,x.denominator)) + require(hash(keys(one))==hash(keys(two)) and keys(one)!=keys(two),'actual hash-collision fixture') + c=Contributions(2);require(c.step(*one)!=c.step(*two) and c.misses==2,'full equality after hash collision');results.append('hash-collision') + c=Contributions(0);c.step(*base);c.step(*base);require(not c.table and c.bypasses==2,'disabled table');results.append('disabled') + for cap in (-1,CAPACITY+1,True,1.5):rejects('invalid-capacity-'+str(cap),lambda cap=cap:Contributions(cap)) + class Explodes: + def __mul__(self,value):raise ArithmeticError('uncached failure') + c=Contributions(2) + for attempt in range(2):rejects('uncached-exception-'+str(attempt),lambda:c.step(F(0),Explodes(),F(1),F(1),F(1)),ArithmeticError) + require(not c.table,'exceptions not cached') + fast(*cases[0]);first=fast.statistics();fast(*cases[0]);require(first==fast.statistics(),'fresh per-call table counters');results.append('fresh-call-table') + first['hits']=-1;require(fast.statistics()['hits']>=0,'stats mutation isolated');results.append('stats-mutation') + try:fast(dict(public=1,owned_fields=0,program=[['ADD',99,0,1,0]]),[(F(1),F(1))],{'ADD'}) + except IndexError:pass + else:raise ValueError('missing original failed-call exception') + require(fast.statistics() is None,'failed call has no old accepted stats');results.append('failed-call-clears-stats') + require(len(results)==34,'finite control census') + result={'status':'PASS_FINITE_FRACTION_TABLE_FEASIBILITY','cases':len(cases),'events':events,'controls':results,'all_complete_values_and_types_equal':True} + print(json.dumps(result,sort_keys=True)) + return result +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/replay.py b/research/verification-key-headroom/context/baseline-public/replay.py new file mode 100644 index 0000000000..e7a41b6f40 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/replay.py @@ -0,0 +1,13 @@ +"""Guarded explicit complete replay, with retained external evidence.""" +import json,sys +from pathlib import Path +import guard +if len(sys.argv)!=2:raise ValueError('Supply one external evidence directory') +package=Path(__file__).resolve().parent;output=Path(sys.argv[1]).resolve() +if output.is_relative_to(package):raise ValueError('Evidence stays outside the immutable package') +output.mkdir(parents=True,exist_ok=True) +guard.SOURCE=package;guard.HERE=output +guard.CLOSURE=tuple(sorted(str(p.relative_to(package)) for p in package.rglob('*') if p.is_file() and '__pycache__' not in p.parts))+('/usr/lib/python3.12/fractions.py',) +with (output/'execution.lock').open('a') as lock: + guard.fcntl.flock(lock,guard.fcntl.LOCK_EX|guard.fcntl.LOCK_NB) + guard.run('complete-native','replay_driver.py') diff --git a/research/verification-key-headroom/context/baseline-public/replay_driver.py b/research/verification-key-headroom/context/baseline-public/replay_driver.py new file mode 100644 index 0000000000..9a1f086f01 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/replay_driver.py @@ -0,0 +1,9 @@ +"""Explicit complete replay; includes all new checks and a cold native build.""" +import sys +from frozen import require +import custody +from full import main +if __name__=='__main__': + require(len(sys.argv)==1,'No replay arguments') + custody.main() + main(True) diff --git a/research/verification-key-headroom/context/baseline-public/slot_binding.py b/research/verification-key-headroom/context/baseline-public/slot_binding.py new file mode 100644 index 0000000000..e226fd730e --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/slot_binding.py @@ -0,0 +1,53 @@ +"""Bind only pure Fraction key getters and exact owned slots; never arithmetic.""" +from fractions import Fraction as F +from hashlib import sha256 +import json +from pathlib import Path +from types import FunctionType,MemberDescriptorType +from table_parent import code_shape + +EXPECTED=json.loads(Path(__file__).with_name('GETTER-SHAPES.json').read_text()) + + +def snapshot(): + try: + result=[] + for name in ('numerator','denominator'): + prop=F.__dict__.get(name);slot=F.__dict__.get('_'+name) + if type(prop) is not property or type(prop.fget) is not FunctionType or type(slot) is not MemberDescriptorType: + return None + fn=prop.fget + result.extend((prop,fn,fn.__code__,fn.__defaults__,fn.__kwdefaults__,fn.__closure__,slot)) + for cls in F.__mro__: + result.extend((cls,'__getattribute__' in cls.__dict__,cls.__dict__.get('__getattribute__'),'__getattr__' in cls.__dict__,cls.__dict__.get('__getattr__'))) + return tuple(result) + except (AttributeError,TypeError,ValueError):return None + + +def fresh(token): + now=snapshot() + return token is not None and now is not None and len(token)==len(now) and all(a is b for a,b in zip(token,now)) + + +def bind(strict=False): + try: + if any('__getattr__' in cls.__dict__ for cls in F.__mro__): + raise ValueError('no foreign missing-attribute fallback') + for name,expected in EXPECTED.items(): + prop=F.__dict__.get(name);slot=F.__dict__.get('_'+name) + if type(prop) is not property or type(prop.fget) is not FunctionType or type(slot) is not MemberDescriptorType: + raise ValueError('standard getter and owned slot '+name) + fn=prop.fget + if fn.__defaults__ is not None or fn.__kwdefaults__ is not None or fn.__closure__ is not None: + raise ValueError('pure getter has no defaults or closure') + if fn.__code__.co_names!=('_'+name,) or sha256(repr(code_shape(fn.__code__)).encode()).hexdigest()!=expected: + raise ValueError('exact getter executable '+name) + if slot.__objclass__ is not F or slot.__name__!='_'+name: + raise ValueError('slot belongs to this exact Fraction class') + accessor=next((c.__dict__['__getattribute__'] for c in F.__mro__ if '__getattribute__' in c.__dict__),None) + if accessor is not object.__dict__['__getattribute__']: + raise ValueError('ordinary object attribute lookup') + return snapshot() + except (ValueError,AttributeError,TypeError,KeyError) as error: + if strict:raise ValueError('unsupported Fraction key getters: '+str(error)) from error + return None diff --git a/research/verification-key-headroom/context/baseline-public/slot_finite.py b/research/verification-key-headroom/context/baseline-public/slot_finite.py new file mode 100644 index 0000000000..3231246efe --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/slot_finite.py @@ -0,0 +1,75 @@ +"""Inherited complete key/table/entry tests plus getter/fallback controls.""" +import importlib.util,json,sys +from fractions import Fraction as F +import compact_finite +from frozen import baseline,require +from compact_finite import types_of +import fraction_table as table +import slot_binding as binding + + +def main(): + inherited=compact_finite.main();controls=[] + token=binding.bind(strict=True);require(binding.fresh(token),'known getter binding') + numerator=F.__dict__['numerator'];slot=F.__dict__['_numerator'] + F.numerator=property(lambda self:self._numerator+1) + try:require(binding.bind() is None and not binding.fresh(token),'getter replacement invalidates') + finally:F.numerator=numerator + controls.append('changed-getter-invalidates') + code=numerator.fget.__code__;numerator.fget.__code__=code.replace(co_consts=code.co_consts+('drift',)) + try:require(binding.bind() is None and not binding.fresh(token),'live getter code invalidates') + finally:numerator.fget.__code__=code + controls.append('changed-live-getter-code') + calls=[] + class Foreign: + def __get__(self,*args):calls.append(True);raise RuntimeError('foreign descriptor must not run') + F._numerator=Foreign() + try:require(binding.bind() is None and not binding.fresh(token) and not calls,'foreign slot rejected without invocation') + finally:F._numerator=slot + controls.append('foreign-slot-probe-is-pure') + F.__getattribute__=lambda self,name:object.__getattribute__(self,name) + try:require(binding.bind() is None and not binding.fresh(token),'custom attribute lookup rejected') + finally:del F.__getattribute__ + controls.append('changed-attribute-lookup') + F.__getattr__=None + try:require(binding.bind() is None and not binding.fresh(token),'present None getattr rejected') + finally:del F.__getattr__ + controls.append('missing-attribute-handler-presence') + require(binding.fresh(token),'runtime fully restored') + controls.append('binding-restored') + with baseline() as package: + sys.path.insert(0,str(package));spec=importlib.util.spec_from_file_location('slot_bundle',package/'source.py') + source=importlib.util.module_from_spec(spec);spec.loader.exec_module(source) + with source.baseline() as p: + spec=importlib.util.spec_from_file_location('slot_finite_source',p/'verify.py');v=importlib.util.module_from_spec(spec);spec.loader.exec_module(v) + with v.source() as (_,_,ref): + original=ref.error_trace + fixture=(dict(public=4,owned_fields=0,program=[['INIT',0,0],['INIT',1,0],['ADD',2,0,1,0],['ADD',3,1,1,0]]),[(F(1),F(2)),(F(3),F(5)),(F(7),F(11)),(F(13),F(17))],{'INIT'}) + fast=table.derive(ref);a=fast(*fixture);b=original(*fixture) + require(a==b and types_of(a)==types_of(b) and fast.compacted_selected() is True,'slot path used with all outputs preserved') + controls.append('slot-path-selected') + getter_calls=[] + def observed_getter(self): + getter_calls.append(True);return self._numerator + F.numerator=property(observed_getter) + try: + a=fast(*fixture);count_a=len(getter_calls);getter_calls.clear() + b=original(*fixture);count_b=len(getter_calls) + require(a==b and count_a==count_b and fast.compacted_selected() is False,'post-derive getter drift uses literal source and same calls') + finally:F.numerator=numerator + controls.append('post-derive-getter-drift-literal-fallback') + uninitialized=object.__new__(F) + word=dict(public=1,owned_fields=0,program=[]);weights=[(uninitialized,F(1))] + fast=table.derive(ref) + require(fast(word,weights,set())==original(word,weights,set()) and fast.compacted_selected() is False,'unused malformed Fraction does not introduce an exception') + controls.append('uninitialized-unused-weight-fallback') + class ForeignInteger: + def __hash__(self):raise RuntimeError('foreign key hash must not run') + corrupt=object.__new__(F);corrupt._numerator=ForeignInteger();corrupt._denominator=1 + weights=[(corrupt,F(1))] + require(fast(word,weights,set())==original(word,weights,set()) and fast.compacted_selected() is False,'corrupt unused slot values do not run custom hash') + controls.append('foreign-slot-value-fallback') + result=dict(status='PASS_SLOT_KEY_FINITE_ONLY',inherited=inherited,new_controls=controls,new_control_count=len(controls),all_coverage_preserved=True) + print(json.dumps(result,sort_keys=True));return result + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/context/baseline-public/slot_parent.py b/research/verification-key-headroom/context/baseline-public/slot_parent.py new file mode 100644 index 0000000000..5a77bebfe0 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/slot_parent.py @@ -0,0 +1,85 @@ +"""Same compact keys with verified pure property-to-slot equivalence.""" +from contextlib import contextmanager +from hashlib import sha256 +import inspect +from pathlib import Path +import compact_parent as parent +from slot_binding import bind,fresh + +F=parent.F;CAPACITY=parent.CAPACITY +Contributions=parent.Contributions +NORMAL_CONTRIBUTIONS=Contributions +certified_domain=parent.certified_domain +transformed=parent.transformed +def weight_tokens(weights,limit=parent.CONTEXT_CAPACITY): + parent.entry.parent.need(type(limit) is int and 0<=limit<=parent.CONTEXT_CAPACITY,'bounded context token capacity') + mapping={};tokens=[] + for row in weights: + a,c=row[0],row[1] + if type(a) is not F or type(c) is not F:return None + try:key=(a._numerator,a._denominator,c._numerator,c._denominator) + except AttributeError:return None + if any(type(x) is not int for x in key) or key[1]<=0 or key[3]<=0:return None + token=mapping.get(key) + if token is None: + if len(mapping)>=limit:return None + token=len(mapping);mapping[key]=token + tokens.append(token) + return tokens + + +class CompactContributions(parent.CompactContributions): + def event(self,q): + qn,qd=q.numerator,q.denominator + table=self.table;weights=self.weights;tokens=self.tokens;capacity=self.capacity;compute=self.compute + def step(old,v,i): + self.calls+=1 + key=(old._numerator,old._denominator,qn,qd,v._numerator,v._denominator,tokens[i]) + result=table.get(key) + if result is not None:self.hits+=1;return result + self.misses+=1 + result=compute(old,q,v,weights[i][0],weights[i][1]) + if len(table)>=capacity:table.popitem(last=False);self.evictions+=1 + table[key]=result + return result + return step + + +def derive(reference,capacity=CAPACITY): + entry=parent.entry;source=entry.parent + source.need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + source.need(reference.F is F,'exact standard Fraction type') + source.need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==source.MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace;raw=inspect.getsource(original) + safe=transformed(raw);compact=parent.compact_text(raw) + namespace=dict(reference.__dict__);exec(compile(raw,'','exec'),namespace) + source.need(source.code_shape(original.__code__)==source.code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + source.need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + token=bind();last=[None,None,None];factory=Contributions + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:factory(capacity),_contribution_report=report, + _compact_factory=lambda weights,tokens:CompactContributions(capacity,weights,tokens)) + exec(compile(safe,'','exec'),namespace);generic=namespace['error_trace'] + exec(compile(compact,'','exec'),namespace);specialized=namespace['error_trace'] + def call(word,weights,rounded): + if token is None or not fresh(token): + last[:]=[None,False,None] + return original(word,weights,rounded) + eligible=bool(capacity and factory is NORMAL_CONTRIBUTIONS and certified_domain(word,weights,rounded)) + tokens=weight_tokens(weights) if eligible else None + if eligible and tokens is None: + last[:]=[None,False,None] + return original(word,weights,rounded) + last[1]=tokens is not None;last[2]=None if tokens is None else (max(tokens)+1 if tokens else 0) + return specialized(word,weights,rounded,tokens) if tokens is not None else generic(word,weights,rounded) + call.statistics=lambda:None if last[0] is None else dict(last[0]) + call.compacted_selected=lambda:last[1] + call.token_count=lambda:last[2] + return call + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace;derived=derive(reference,capacity);reference.error_trace=derived + try:yield derived + finally:reference.error_trace=original diff --git a/research/verification-key-headroom/context/baseline-public/table_parent.py b/research/verification-key-headroom/context/baseline-public/table_parent.py new file mode 100644 index 0000000000..7f44b25859 --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/table_parent.py @@ -0,0 +1,123 @@ +"""Per-trace bounded tabulation of pure exact Fraction contributions. + +Original arithmetic: Ali Romman and retained completed-error lineage. +New table/derivation: Chris R / Clear1nsight, substantial OpenAI Codex assistance. +Apache-2.0. No approximate or shared integer-backend arithmetic. +""" +from contextlib import contextmanager +from collections import OrderedDict +from fractions import Fraction as F +from hashlib import sha256 +import inspect +from pathlib import Path +from types import CodeType + +MODULE_SHA256='a4c743e79c55e9c2ac26deb6d87cb948b1b0fbe942e4f7912ccbfba55db4b32a' +FUNCTION_SHA256='379c0e7c1c5ab7433ab5ad2669c1bda1234dbf0530fc61b21bfbe83528f37f53' +CAPACITY=16384 +BEFORE=''' value = old + q*v + change = abs(value)-abs(old) + scores[r][0] += change*weights[i][0] + scores[r][1] += change*weights[i][1] + scores[r][2] += change +''' +AFTER=''' value, increment_a, increment_c, change = contributions.step( + old, q, v, weights[i][0], weights[i][1]) + scores[r][0] += increment_a + scores[r][1] += increment_c + scores[r][2] += change +''' + + +def need(ok,message): + if not ok: + raise ValueError(message) + + +class Contributions: + def __init__(self,capacity=CAPACITY): + need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + self.capacity=capacity + self.table=OrderedDict() + self.calls=self.hits=self.misses=self.evictions=self.bypasses=0 + + @staticmethod + def compute(old,q,v,a,c): + value=old+q*v + change=abs(value)-abs(old) + return value,change*a,change*c,change + + def step(self,old,q,v,a,c): + self.calls+=1 + if not self.capacity or not all(type(x) is F for x in (old,q,v,a,c)): + self.bypasses+=1 + return self.compute(old,q,v,a,c) + key=(old.numerator,old.denominator,q.numerator,q.denominator, + v.numerator,v.denominator,a.numerator,a.denominator,c.numerator,c.denominator) + result=self.table.get(key) + if result is not None: + self.hits+=1 + return result + self.misses+=1 + result=self.compute(old,q,v,a,c) + if len(self.table)>=self.capacity: + self.table.popitem(last=False) + self.evictions+=1 + self.table[key]=result + return result + + def statistics(self): + return dict(calls=self.calls,hits=self.hits,misses=self.misses, + evictions=self.evictions,bypasses=self.bypasses, + resident=len(self.table),capacity=self.capacity) + + +def code_shape(code): + constants=tuple(code_shape(c) if isinstance(c,CodeType) else c for c in code.co_consts) + return (code.co_code,constants,code.co_names,code.co_varnames,code.co_argcount, + code.co_posonlyargcount,code.co_kwonlyargcount,code.co_flags, + code.co_freevars,code.co_cellvars,code.co_name,code.co_stacksize, + code.co_nlocals,code.co_exceptiontable) + + +def transformed(raw): + need(sha256(raw.encode()).hexdigest()==FUNCTION_SHA256,'exact Fraction function source') + need(raw.count(BEFORE)==1,'one exact Fraction contribution block') + value=raw.replace(BEFORE,AFTER) + seam=" n = word['public'] + word['owned_fields']\n" + need(value.count(seam)==1,'one exact Fraction setup seam') + value=value.replace(seam,seam+' _contribution_report(None)\n contributions = _contribution_factory()\n') + seam=' return dict(rounded=sorted(rounded), sites=sites, peaks=peaks, pareto=pareto,\n' + need(value.count(seam)==1,'one exact Fraction return seam') + return value.replace(seam,' _contribution_report(contributions.statistics())\n'+seam) + + +def derive(reference,capacity=CAPACITY): + need(type(capacity) is int and 0<=capacity<=CAPACITY,'bounded integer table capacity') + need(reference.F is F,'exact standard Fraction type') + need(sha256(Path(reference.__file__).read_bytes()).hexdigest()==MODULE_SHA256,'exact Fraction module bytes') + original=reference.error_trace + raw=inspect.getsource(original) + text=transformed(raw) + namespace=dict(reference.__dict__) + exec(compile(raw,'','exec'),namespace) + need(code_shape(original.__code__)==code_shape(namespace['error_trace'].__code__),'live Fraction code agrees with source') + need(original.__defaults__ is None and original.__kwdefaults__ is None and original.__closure__ is None,'ordinary Fraction function') + last=[None] + def report(value):last[0]=None if value is None else dict(value) + namespace.update(_contribution_factory=lambda:Contributions(capacity),_contribution_report=report) + exec(compile(text,'','exec'),namespace) + result=namespace['error_trace'] + result.statistics=lambda:None if last[0] is None else dict(last[0]) + return result + + +@contextmanager +def installed(reference,capacity=CAPACITY): + original=reference.error_trace + derived=derive(reference,capacity) + reference.error_trace=derived + try: + yield derived + finally: + reference.error_trace=original diff --git a/research/verification-key-headroom/context/baseline-public/verify.py b/research/verification-key-headroom/context/baseline-public/verify.py new file mode 100644 index 0000000000..35930ff9ea --- /dev/null +++ b/research/verification-key-headroom/context/baseline-public/verify.py @@ -0,0 +1,14 @@ +"""Fresh registered finite/native/source-custody verification, not timing admission.""" +import json,sys +from pathlib import Path +from frozen import require +import custody +from finite import main + +if __name__=='__main__': + require(len(sys.argv)==1,'No registered verifier arguments') + custody.main() + result=main();build=result.pop('build') + require(result==json.loads(Path(__file__).with_name('RESULT.json').read_text()),'all inherited/native finite outputs and controls') + require(build['source_sha256']==json.loads(Path(__file__).with_name('NATIVE-SOURCE.json').read_text())['sha256'],'native build source authenticated') + print('PASS_FRACTION_NATIVE_FINITE_AND_CUSTODY') diff --git a/research/verification-key-headroom/context/cache-key-pilot/keypilot.c b/research/verification-key-headroom/context/cache-key-pilot/keypilot.c new file mode 100644 index 0000000000..772e101868 --- /dev/null +++ b/research/verification-key-headroom/context/cache-key-pilot/keypilot.c @@ -0,0 +1,230 @@ +/* Finite key-only comparator, not Cache/Event API replacement. + * Baseline provenance: native_cache.c contribution(), Chris R / Clear1nsight, + * substantial OpenAI Codex/Astra assistance. Apache-2.0. + * All keys are exact seven-PyLong tuples; no arbitrary callbacks or cyclic values. + */ +#define PY_SSIZE_T_CLEAN +#include +#include +#include + +#define WIDTH 7 +#define EMPTY ((Py_ssize_t)-1) +#define TOMB ((Py_ssize_t)-2) +#define MAX_ROWS 3000000 +#define PREFIX_EVERY 80 + +typedef struct { + PyObject *part[WIDTH], *value; + uint64_t hash; + Py_ssize_t slot; +} Entry; +typedef struct { + Entry *entry; + Py_ssize_t *table, size, capacity, used, head, tombs, rehashes; +} Custom; + +static int fault(Py_ssize_t at, int phase, Py_ssize_t wanted, int wanted_phase) { + if (at == wanted && phase == wanted_phase) { + PyErr_SetString(PyExc_MemoryError, "declared finite cleanup fault"); + return -1; + } + return 0; +} +static void entry_clear(Entry *e) { + for (int j=0;jpart[j]); + Py_CLEAR(e->value); +} +static void custom_clear(Custom *s) { + if (s->entry) { + for (Py_ssize_t j=0;jcapacity;j++) entry_clear(&s->entry[j]); + PyMem_Free(s->entry); + } + PyMem_Free(s->table); +} +static Py_ssize_t *new_table(Py_ssize_t size) { + Py_ssize_t *p=PyMem_Malloc((size_t)size * sizeof(*p)); + if (!p) { PyErr_NoMemory(); return NULL; } + for (Py_ssize_t j=0;j> 2); + h *= UINT64_C(0xbf58476d1ce4e5b9); + } + *answer=h; + return 0; +} +static int equal_parts(Entry *e, PyObject *const part[WIDTH]) { + for (int j=0;jpart[j], part[j], Py_EQ); + if (eq <= 0) return eq; + } + return 1; +} +/* Return 1 for found, 0 for absent, -1 for error; never treat a tomb as empty. */ +static int lookup(Custom *s, PyObject *const part[WIDTH], uint64_t hash, + Py_ssize_t *entry_index) { + Py_ssize_t slot=(Py_ssize_t)(hash & (uint64_t)(s->size-1)); + for (Py_ssize_t steps=0;stepssize;steps++) { + Py_ssize_t ix=s->table[slot]; + if (ix == EMPTY) return 0; + if (ix >= 0 && s->entry[ix].hash == hash) { + int eq=equal_parts(&s->entry[ix],part); + if (eq < 0) return -1; + if (eq) { *entry_index=ix; return 1; } + } + slot=(slot+1)&(s->size-1); + } + PyErr_SetString(PyExc_RuntimeError,"table unexpectedly has no empty slot"); + return -1; +} +static Py_ssize_t vacant_slot(Py_ssize_t *table, Py_ssize_t size, uint64_t hash) { + Py_ssize_t slot=(Py_ssize_t)(hash & (uint64_t)(size-1)); + for (Py_ssize_t steps=0;stepssize); + if (!next) return -1; + for (Py_ssize_t j=0;jcapacity;j++) if (s->entry[j].value) { + Py_ssize_t slot=vacant_slot(next,s->size,s->entry[j].hash); + if (slot < 0) { PyMem_Free(next); return -1; } + next[slot]=j; + } + /* Publish only after the new table is complete. */ + PyMem_Free(s->table); s->table=next; + for (Py_ssize_t j=0;jsize;j++) if (next[j]>=0) s->entry[next[j]].slot=j; + s->tombs=0; s->rehashes++; + return 0; +} +static int exact_int(PyObject *o, Py_ssize_t *v, const char *name) { + if (!PyLong_CheckExact(o)) { PyErr_Format(PyExc_TypeError,"exact int required: %s",name); return -1; } + *v=PyLong_AsSsize_t(o); + return PyErr_Occurred() ? -1 : 0; +} +static PyObject *run(PyObject *module, PyObject *args) { + (void)module; + PyObject *kind_o,*rows,*cap_o,*fail_o=NULL,*phase_o=NULL; + Py_ssize_t kind,cap,fail_at=-1,phase_n=0; + if (!PyArg_UnpackTuple(args,"run",3,5,&kind_o,&rows,&cap_o,&fail_o,&phase_o)) return NULL; + if (exact_int(kind_o,&kind,"kind")<0 || exact_int(cap_o,&cap,"capacity")<0) return NULL; + if (fail_o && exact_int(fail_o,&fail_at,"fail_at")<0) return NULL; + if (phase_o && exact_int(phase_o,&phase_n,"fail_phase")<0) return NULL; + if ((kind!=0 && kind!=1) || cap<1 || cap>16384 || fail_at < -1 || phase_n<0 || phase_n>6) { + PyErr_SetString(PyExc_ValueError,"kind 0/1, capacity 1..16384, fail_at >= -1, phase 0..6"); return NULL; + } + if (!PyTuple_CheckExact(rows)) { PyErr_SetString(PyExc_TypeError,"exact tuple of keys"); return NULL; } + Py_ssize_t n=PyTuple_GET_SIZE(rows); + if (n>MAX_ROWS || fail_at>=n) { PyErr_SetString(PyExc_ValueError,"bounded corpus/failure index"); return NULL; } + if ((fail_at==-1)!=(phase_n==0) || (kind==0 && phase_n==6)) { + PyErr_SetString(PyExc_ValueError,"consistent failure specification; rehash fault is custom only"); return NULL; + } + for (Py_ssize_t i=0;i=s.size*3/4 || (i==fail_at && phase_n==6))) { + /* Phase 6 simulates allocation failure before publishing a new table. */ + if (rehash(&s,i==fail_at && phase_n==6)<0) goto done; + } + if (used==cap) { + if (kind==0) { + if (PyDict_DelItem(dict,ring[head])<0) goto done; + Py_CLEAR(ring[head]); + } else { + Entry *old=&s.entry[head]; + s.table[old->slot]=TOMB; s.tombs++; + entry_clear(old); s.used--; + } + used--; evictions++; flag|=2; + } + if (fault(i,3,fail_at,(int)phase_n)<0) goto done; + if (kind==0) { + if (PyDict_SetItem(dict,key,result)<0) goto done; + ring[head]=key; key=NULL; + } else { + Py_ssize_t slot=vacant_slot(s.table,s.size,hash); if (slot<0) goto done; + Entry *e=&s.entry[head]; + for (int j=0;jpart[j]=Py_NewRef(part[j]); + e->value=Py_NewRef(result); e->hash=hash; e->slot=slot; + if (s.table[slot]==TOMB) s.tombs--; + s.table[slot]=head; s.used++; + } + head=(head+1)%cap; used++; + if (fault(i,4,fail_at,(int)phase_n)<0) goto done; + } + Py_CLEAR(key); + PyTuple_SET_ITEM(ids,i,result); result=NULL; + PyBytes_AS_STRING(flags)[i]=(char)flag; + if (fault(i,5,fail_at,(int)phase_n)<0) goto done; + if ((i+1)%PREFIX_EVERY==0 || i+1==n) { + PyObject *p=Py_BuildValue("(nnnnn)",i+1,hits,misses,evictions,used); + if (!p) goto done; + PyTuple_SET_ITEM(prefix,prefix_index++,p); + } + } + stats=Py_BuildValue("{s:n,s:n,s:n,s:n,s:n,s:n,s:n}","calls",n,"hits",hits,"misses",misses,"evictions",evictions,"resident",used,"capacity",cap,"rehashes",s.rehashes); + if (!stats) goto done; + answer=PyTuple_Pack(4,ids,flags,prefix,stats); +done: + Py_XDECREF(key); Py_XDECREF(result); Py_XDECREF(dict); + if (ring) { for (Py_ssize_t j=0;j dict: + manifest = json.loads((ROOT / "FROZEN-SOURCE.json").read_text()) + base = ROOT.parent.parent if ROOT.parent.name == "stages" else ROOT.parent + groups = ((ROOT, manifest["files_sha256"]), + (base, manifest["reference_files_sha256"])) + for directory, pins in groups: + for relative, expected in pins.items(): + path = directory / relative + if path.is_symlink() or not path.is_file(): + raise RuntimeError(f"source is absent or symlink: {relative}") + actual = hashlib.sha256(path.read_bytes()).hexdigest() + if actual != expected: + raise RuntimeError(f"source pin mismatch: {relative}") + return manifest + + +def compile_and_load(destination: Path): + manifest = verify_sources() + build = destination / "build" + build.mkdir() # Existing directory is an error; never reuse a built answer. + source = ROOT / "keypilot.c" + copied = build / "keypilot.c" + copied.write_bytes(source.read_bytes()) + copied_sha256 = hashlib.sha256(copied.read_bytes()).hexdigest() + if copied_sha256 != manifest["files_sha256"]["keypilot.c"]: + raise RuntimeError("compiler snapshot differs from the declared C source pin") + suffix = sysconfig.get_config_var("EXT_SUFFIX") + if not isinstance(suffix, str) or not suffix: + raise RuntimeError("missing extension suffix") + extension = build / ("_keypilot" + suffix) + compiler = shlex.split(sysconfig.get_config_var("CC") or "cc") + command = compiler + ["-O3", "-std=c11", "-fPIC", "-shared", "-Wall", "-Wextra", "-Werror"] + for directory in sorted({sysconfig.get_path("include"), sysconfig.get_path("platinclude")}): + if directory: + command.extend(["-I", directory]) + command.extend([str(copied), "-o", str(extension)]) + receipt = {"command": command, "cwd": str(ROOT), "python": sys.version, + "executable": sys.executable, "platform": sys.platform, + "source_sha256": copied_sha256, + "source_manifest": manifest} + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + completed = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, + check=False, timeout=60) + (build / "stdout.txt").write_text(completed.stdout) + (build / "stderr.txt").write_text(completed.stderr) + receipt["returncode"] = completed.returncode + receipt["stdout_bytes"] = len(completed.stdout.encode()) + receipt["stderr_bytes"] = len(completed.stderr.encode()) + if completed.returncode or completed.stdout or completed.stderr: + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + raise RuntimeError("single compiler attempt failed or emitted output; see retained BUILD.json and compiler logs") + if hashlib.sha256(copied.read_bytes()).hexdigest() != copied_sha256: + raise RuntimeError("compiler snapshot changed during the single build") + receipt["extension_sha256"] = hashlib.sha256(extension.read_bytes()).hexdigest() + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + verify_sources() + spec = importlib.util.spec_from_file_location("_keypilot", extension) + if spec is None or spec.loader is None: + raise RuntimeError("extension has no loader") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module, receipt diff --git a/research/verification-key-headroom/context/cache-key-pilot/run_pilot.py b/research/verification-key-headroom/context/cache-key-pilot/run_pilot.py new file mode 100644 index 0000000000..b8c416b6b2 --- /dev/null +++ b/research/verification-key-headroom/context/cache-key-pilot/run_pilot.py @@ -0,0 +1,383 @@ +"""One frozen finite pilot. No warmups, searches, automatic retries or science imports.""" +from __future__ import annotations +import time +_COLD_WALL_START = time.perf_counter() +import resource + +def process_and_child_cpu(): + own = resource.getrusage(resource.RUSAGE_SELF) + child = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + child.ru_utime + child.ru_stime + +_COLD_CPU_START = process_and_child_cpu() +import argparse +from array import array +from collections import deque +import hashlib +import json +from pathlib import Path +import struct +import sys +import traceback +from load_pilot import ROOT, compile_and_load, verify_sources + +EVENTS = 32768 +LOOKUPS_PER_EVENT = 80 +KEYS_PER_EVENT = 10 +REPETITIONS = 8 +CALLS = EVENTS * LOOKUPS_PER_EVENT +CAPACITY = 16384 +ACTUAL_CALLS = 2579750 +ORDER = (("B1", 0), ("C1", 1), ("C2", 1), ("B2", 0)) +BASELINE = {"wall": 34.66178539200337, "cpu": 34.47} +INTEGER_GROSS = {"wall": 4.684712576272432, "cpu": 4.683428714999984} +RESERVE = {"wall": 0.5, "cpu": 0.5} + + +def write_json(path, data): + path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n") + + +def literal_oracle(rows, capacity): + """Independent ordinary dict + deque, no C/custom hash or shared lookup code.""" + cache = {} + fifo = deque() + ids = [] + flags = bytearray() + prefixes = [] + hits = misses = evictions = 0 + for i, key in enumerate(rows, 1): + value = cache.get(key) + flag = 0 + if value is not None: + hits += 1 + else: + misses += 1 + value = misses + flag = 1 + if len(fifo) == capacity: + del cache[fifo.popleft()] + evictions += 1 + flag |= 2 + cache[key] = value + fifo.append(key) + ids.append(value) + flags.append(flag) + if i % LOOKUPS_PER_EVENT == 0 or i == len(rows): + prefixes.append((i, hits, misses, evictions, len(cache))) + stats = dict(calls=len(rows), hits=hits, misses=misses, evictions=evictions, + resident=len(cache), capacity=capacity) + return tuple(ids), bytes(flags), tuple(prefixes), stats + + +def assert_equal(actual, expected, mode): + if type(actual) is not tuple or len(actual) != 4: + raise AssertionError("malformed output packet") + # Full sequence comparisons; hashes never substitute for equality. + for index, name in ((0, "ordered IDs"), (1, "ordered hit/miss/eviction flags"), + (2, "all 80-operation prefixes")): + if actual[index] != expected[index]: + raise AssertionError(f"mismatched {name}") + actual_stats = dict(actual[3]) + rehashes = actual_stats.pop("rehashes", None) + if type(rehashes) is not int or rehashes < 0 or actual_stats != expected[3]: + raise AssertionError("mismatched counters or rehash metadata") + if mode == 0 and rehashes != 0: + raise AssertionError("baseline must report zero custom rehashes") + + +def retain_full(destination, name, result): + ids = array("Q", result[0]) + if ids.itemsize != 8: + raise RuntimeError("Q output format is not 64 bits on this interpreter") + id_path = destination / (name + "-ids.u64") + with id_path.open("wb") as stream: + ids.tofile(stream) + flag_path = destination / (name + "-flags.u8") + flag_path.write_bytes(result[1]) + prefix_path = destination / (name + "-prefixes.json") + write_json(prefix_path, result[2]) + return {"ids": id_path.name, "flags": flag_path.name, + "prefixes": prefix_path.name, "id_byteorder": sys.byteorder, + "id_itemsize": ids.itemsize, "calls": len(result[0]), + "stats": result[3], + "ids_sha256": hashlib.sha256(ids.tobytes()).hexdigest(), + "flags_sha256": hashlib.sha256(result[1]).hexdigest()} + + +def clone_key(key): + # int(existing_int) may preserve object identity; decimal construction avoids + # that for non-interned values. Small immortal/cached ints may still be shared. + return tuple(int(str(field)) for field in key) + + +def finite_key(i): + return (i * 2 + 10001, 2, -3, 4, -i * 2 - 10001, 8, i % 3587) + + +def tracked_objects(rows): + unique = {id(rows): rows} + for row in rows: + unique[id(row)] = row + for field in row: + # Small cached integers can acquire legitimate references from the + # retained counter/ID receipts, so they cannot diagnose key leaks. + if not -5 <= field <= 256: + unique[id(field)] = field + return list(unique.values()) + + +def refs(objects): + return tuple(sys.getrefcount(obj) for obj in objects) + + +def finite_controls(module): + receipts = [] + p = sys.hash_info.modulus + collision_keys = tuple((p*i, -p*i, p*(i+1), 1, 0, 1, p*(i+2)) for i in range(1, 21)) + if len({hash(key) for key in collision_keys}) != 1: + raise AssertionError("declared exact-PyLong and tuple hash collision construction failed") + a = finite_key(1) + a_equal = clone_key(a) + if a_equal != a or a_equal[0] is a[0]: + raise AssertionError("distinct numerically equal key control failed") + big = (1 << 8191) + 73 + broad = ((0, 0, 0, 0, 0, 0, 0), + (-1, 1, -2, 2, -3, 3, -4), + (big, -big, big-1, 1, -big+1, 2, 3586)) + cases = [ + ("empty", (), 1), + ("numeric-equality-and-no-FIFO-refresh", (a, finite_key(2), a_equal, + finite_key(3), a_equal, finite_key(2)), 2), + ("signed-zero-8192-bit", broad + tuple(clone_key(k) for k in broad), 3), + ("full-hash-and-table-collisions", collision_keys + collision_keys[5:] + + tuple(clone_key(k) for k in collision_keys), 16), + ("capacity-one", tuple(finite_key(i) for i in range(40)), 1), + ("tombstone-rehash-turnover", tuple(finite_key(i) for i in range(512)) + + tuple(finite_key(i) for i in range(480, 512)), 16), + ("full-capacity-turnover", tuple(finite_key(i) for i in range(16416)) + + tuple(finite_key(i) for i in range(16390, 16416)), 16384), + ] + natural_rehashes = 0 + for name, rows, cap in cases: + expected = literal_oracle(rows, cap) + tracked = tracked_objects(rows) + before = refs(tracked) + for mode in (0, 1): + actual = module.run(mode, rows, cap) + assert_equal(actual, expected, mode) + if mode == 1: + natural_rehashes += actual[3]["rehashes"] + receipts.append({"control": name, "mode": mode, "stats": actual[3], + "ordered_ids": actual[0], "ordered_flags": list(actual[1]), + "prefixes": actual[2], "full_equality": True}) + del actual + if refs(tracked) != before: + raise AssertionError(f"reference leak on success: {name}/{mode}") + if natural_rehashes < 1: + raise AssertionError("finite controls never exercised natural rehash") + + class IntSubclass(int): + def __hash__(self): + raise AssertionError("subclass hash must never run") + def __eq__(self, other): + raise AssertionError("subclass comparison must never run") + class TupleSubclass(tuple): + pass + bad_calls = [ + (False, (a,), 2), (2, (a,), 2), (0, (a,), True), + (0, (a,), IntSubclass(2)), (0, (a,), 0), (0, (a,), -1), + (0, (a,), 16385), (0, (a,), 1 << 100), + (0, [a], 2), (0, TupleSubclass((a,)), 2), + (0, (a[:-1],), 2), (0, (a + (1,),), 2), + (0, (list(a),), 2), (0, (TupleSubclass(a),), 2), + (0, ((True,) + a[1:],), 2), + (0, ((IntSubclass(a[0]),) + a[1:],), 2), + (0, ((object(),) + a[1:],), 2), (0, ((1.5,) + a[1:],), 2), + (0, (("1",) + a[1:],), 2), (0, ((None,) + a[1:],), 2), + (0, (a,), 2, True, 1), (0, (a,), 2, 0, True), + (0, (a,), 2, -2, 1), (0, (a,), 2, 0, 7), + (0, (a,), 2, -1, 1), (0, (a,), 2, 0, 0), + (0, (a,), 2, 1, 1), (0, (a,), 2, 0, 6), + ] + for index, args in enumerate(bad_calls): + # Type/capacity/row rejection is shared prevalidation, but check both arms + # whenever the explicit test does not itself target the mode selector. + modes = (None,) if index < 2 else (0, 1) + for mode in modes: + packet = args if mode is None else (mode,) + args[1:] + if index == len(bad_calls)-1 and mode == 1: + continue # phase 6 is a supported custom-only cleanup hook. + try: + module.run(*packet) + except (TypeError, ValueError, OverflowError): + receipts.append({"rejection": index, "mode": mode, "rejected": True}) + else: + raise AssertionError(f"malformed packet accepted: {index}/{mode}") + fault_rows = tuple(finite_key(i) for i in range(8)) + tracked = tracked_objects(fault_rows) + before = refs(tracked) + for mode in (0, 1): + for phase in range(1, 7 if mode else 6): + try: + module.run(mode, fault_rows, 2, 4, phase) + except MemoryError: + pass + else: + raise AssertionError(f"declared fault did not fire: {mode}/{phase}") + if refs(tracked) != before: + raise AssertionError(f"reference leak after failure: {mode}/{phase}") + receipts.append({"cleanup_fault_mode": mode, "phase": phase, + "raised_MemoryError": True, "reference_counts_equal": True}) + hit_rows = (a, a_equal, a, a_equal) + tracked = tracked_objects(hit_rows) + before = refs(tracked) + for mode in (0, 1): + for phase in (1, 5): + try: + module.run(mode, hit_rows, 2, 2, phase) + except MemoryError: + pass + else: + raise AssertionError(f"declared hit fault did not fire: {mode}/{phase}") + if refs(tracked) != before: + raise AssertionError(f"reference leak after hit failure: {mode}/{phase}") + receipts.append({"cleanup_hit_fault_mode": mode, "phase": phase, + "raised_MemoryError": True, "reference_counts_equal": True}) + return {"status": "PASS_FINITE_KEY_ONLY", "receipts": receipts, + "natural_rehashes": natural_rehashes, + "allocator_failures_exhaustive": False} + + +def timed_corpus(): + rows = [] + qs = ((-3, 1), (-1, 2), (0, 1), (1, 1), (3, 2), (1, 4), (5, 8)) + for event in range(EVENTS): + qn, qd = qs[event % len(qs)] + first = [] + second = [] + for offset in range(KEYS_PER_EVENT): + serial = event * KEYS_PER_EVENT + offset + old_num = (serial * 2 + 1) * (-1 if serial % 2 else 1) + old_den = 1 << (serial % 13) + v_num = 0 if serial % 19 == 0 else (2*(serial % 511)+1) * (-1 if serial % 3 == 0 else 1) + v_den = 1 if v_num == 0 else 1 << ((serial // 13) % 9) + key = (old_num, old_den, qn, qd, v_num, v_den, serial % 3587) + first.append(key) + second.append(clone_key(key)) + for repeat in range(REPETITIONS): + rows.extend(first if repeat % 2 == 0 else second) + if len(rows) != CALLS: + raise AssertionError("frozen work-unit count mismatch") + return tuple(rows) + + +def optimistic_screen(samples): + indexed = {sample["name"]: sample for sample in samples} + result = {"interpretation": "ILLUSTRATIVE_OPTIMISTIC_SCREEN_ONLY", + "measured_complete_saving": False, "construction_admitted": False, + "integer_residual_assumed_seconds": 0, + "new_bill_reserve_measured": False, "actual_calls_for_illustration": ACTUAL_CALLS, + "real_integer_residual": "UNPRICED_NONZERO", + "complete_new_validation_build_bill": "UNPRICED_NONZERO", + "diagnostic_integer_regions_include_clock_overhead": True} + gates = [] + for metric in ("wall", "cpu"): + deltas = [indexed["B1"][metric] - indexed["C1"][metric], + indexed["B2"][metric] - indexed["C2"][metric]] + smaller = min(deltas) + per_call = smaller / CALLS + illustrative = per_call * ACTUAL_CALLS + optimistic = INTEGER_GROSS[metric] + illustrative - RESERVE[metric] + threshold = BASELINE[metric] * 0.15 + gate = optimistic >= threshold + gates.append(gate) + result[metric] = {"paired_gross_seconds": deltas, + "smaller_paired_gross_seconds": smaller, + "synthetic_gross_seconds_per_call": per_call, + "illustrative_key_saving_at_actual_calls": illustrative, + "diagnostic_integer_gross_region": INTEGER_GROSS[metric], + "provisional_new_bill_reserve": RESERVE[metric], + "optimistic_budget_seconds": optimistic, + "necessary_15pct_threshold_seconds": threshold, + "necessary_threshold_met": gate} + result["status"] = ("HEADROOM_FOR_SOURCE_SPECIFIC_COST_DESIGN_ONLY" if all(gates) + else "REJECT_THIS_OPTIMISTIC_NOMINATION") + return result + + +def main(destination): + if destination.exists(): + raise RuntimeError("fresh output directory required; no answer/build reuse") + destination.mkdir(parents=True) + report = {"status": "STARTED", "scope": "finite synthetic key-only comparator", + "source_only_preparation_precedes_parent_run": True, + "performance_publication": False, "construction_admitted": False, + "frozen_order": [name for name, _ in ORDER], "calls_per_sample": CALLS, + "events": EVENTS, "lookups_per_event": LOOKUPS_PER_EVENT, + "capacity": CAPACITY, "samples": [], "automatic_retries": 0} + write_json(destination / "RESULT.json", report) + try: + report["source_manifest"] = verify_sources() + module, report["build"] = compile_and_load(destination) + controls = finite_controls(module) + write_json(destination / "FINITE-CONTROLS.json", controls) + report["finite_controls"] = controls["status"] + rows = timed_corpus() + corpus_hash = hashlib.sha256() + for row in rows: + corpus_hash.update(struct.pack("<7q", *row)) + report["corpus_sha256_little_endian_i64_fields"] = corpus_hash.hexdigest() + expected = literal_oracle(rows, CAPACITY) + expected_counts = dict(calls=CALLS, hits=EVENTS*KEYS_PER_EVENT*7, + misses=EVENTS*KEYS_PER_EVENT, + evictions=EVENTS*KEYS_PER_EVENT-CAPACITY, + resident=CAPACITY, capacity=CAPACITY) + if expected[3] != expected_counts: + raise AssertionError("synthetic trace does not have its frozen hit/miss/FIFO counts") + report["oracle_output"] = retain_full(destination, "oracle", expected) + write_json(destination / "RESULT.json", report) + for name, mode in ORDER: + wall_start = time.perf_counter_ns() + cpu_start = time.process_time_ns() + actual = module.run(mode, rows, CAPACITY) + cpu_elapsed = time.process_time_ns() - cpu_start + wall_elapsed = time.perf_counter_ns() - wall_start + sample = {"name": name, "mode": mode, "calls": CALLS, + "wall": wall_elapsed/1e9, "cpu": cpu_elapsed/1e9} + report["samples"].append(sample) + # Retain a failed output as well; no failing sample is discarded. + sample["output"] = retain_full(destination, name, actual) + write_json(destination / "RESULT.json", report) + assert_equal(actual, expected, mode) + if mode == 1 and actual[3]["rehashes"] < 1: + raise AssertionError("timed candidate never exercised natural rehash") + sample["full_output_equality"] = True + del actual + write_json(destination / "RESULT.json", report) + verify_sources() + report["optimistic_screen"] = optimistic_screen(report["samples"]) + report["status"] = "PASS_FINITE_KEY_COMPARISON_ONLY" + except BaseException as exc: + report["status"] = "FAIL_RETAINED_NO_RETRY" + report["failure"] = {"type": type(exc).__name__, "message": str(exc)} + (destination / "traceback.txt").write_text(traceback.format_exc()) + raise + finally: + # Parent's guard receipt remains authoritative for process startup, exit, + # this final write, group RSS and whole-command compiler-child CPU. + report["child_cold_through_final_receipt_boundary"] = { + "wall": time.perf_counter() - _COLD_WALL_START, + "cpu_including_compiler_children": process_and_child_cpu() - _COLD_CPU_START, + "excludes_process_startup_exit_and_this_final_write": True} + report["parent_outer_guard_receipt_required"] = True + write_json(destination / "RESULT.json", report) + print(json.dumps({"status": report["status"], "screen": report["optimistic_screen"]["status"], + "result": str(destination / "RESULT.json")})) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + arguments = parser.parse_args() + main(arguments.output.resolve()) diff --git a/research/verification-key-headroom/context/guard.py b/research/verification-key-headroom/context/guard.py new file mode 100644 index 0000000000..bf4265b129 --- /dev/null +++ b/research/verification-key-headroom/context/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/verification-key-headroom/context/run_guarded.py b/research/verification-key-headroom/context/run_guarded.py new file mode 100644 index 0000000000..d8898fdba0 --- /dev/null +++ b/research/verification-key-headroom/context/run_guarded.py @@ -0,0 +1,19 @@ +"""One parent-owned guarded command; no retries, immutable stage inputs.""" +import argparse,fcntl,json,sys +from pathlib import Path +import guard +ROOT=Path(__file__).resolve().parent +p=argparse.ArgumentParser();p.add_argument('label');p.add_argument('script');p.add_argument('--optimized',action='store_true');p.add_argument('--initial',action='store_true');a=p.parse_args() +script=(ROOT/a.script).resolve() +if not script.is_relative_to(ROOT/'stages') or not script.is_file():raise ValueError('Frozen stage script required') +stage=next(x for x in script.parents if x.parent==ROOT/'stages') +guard.HERE=ROOT/'runtime';guard.HERE.mkdir(exist_ok=True);guard.SOURCE=ROOT +# Static source closure includes every stage byte and unchanged baseline. Reports/evidence are excluded. +guard.CLOSURE=tuple(sorted(str(x.relative_to(ROOT)) for d in (stage,ROOT/'baseline',ROOT/'baseline-public',ROOT/'inputs') for x in d.rglob('*') if x.is_file() and '__pycache__' not in x.parts))+('guard.py','run_guarded.py','PLAN.json','/usr/lib/python3.12/fractions.py') +guard.AGGREGATE=1500 +spent=sum(json.loads(x.read_text())['wall_seconds'] for x in (guard.HERE/'runs').glob('*/receipt.json')) +if a.initial and spent>=600:raise ValueError('Initial aggregate feasibility budget consumed') +if a.initial:guard.TIMEOUT=min(180,600-spent) +with (guard.HERE/'execution.lock').open('a') as lock: + fcntl.flock(lock,fcntl.LOCK_EX|fcntl.LOCK_NB) + guard.run(a.label,str(script.relative_to(ROOT)),a.optimized) diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/FROZEN-SOURCE.json b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/FROZEN-SOURCE.json new file mode 100644 index 0000000000..9b7e37dac7 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/FROZEN-SOURCE.json @@ -0,0 +1,51 @@ +{ + "files_sha256": { + "PLAN.md": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458", + "REPRODUCE.md": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851", + "SOURCE-EDITS.json": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a", + "actual_driver.py": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2", + "baseline-public/NATIVE-SOURCE.json": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26", + "baseline-public/native_cache.c": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "capture.inc": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8", + "capture_actual.py": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "prepare_source.py": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + }, + "frozen_plan": { + "automatic_retries": 0, + "block_keys": 4096, + "calls_per_sample": 2579750, + "capacity": 16384, + "complete_original_qualifier_required": true, + "construction_admitted": false, + "evictions": 310400, + "hits": 2252966, + "integer_anchor_from_different_run": true, + "misses": 326784, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "per_command_seconds": 180, + "process_group_rss_bytes": 1073741824, + "samples": 4, + "tokens": 3587, + "whole_actual_corpus_retained": true + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "baseline-public/full.py": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "cache-key-pilot/keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "cache-key-pilot/load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "cache-key-pilot/run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_ACTUAL_KEY_NOMINATION_UNEXECUTED" +} diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PARENT-PLAN.json b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PARENT-PLAN.json new file mode 100644 index 0000000000..16e4396dc7 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PARENT-PLAN.json @@ -0,0 +1,24 @@ +{ + "status": "FROZEN_SOURCE_CLEARED_ONE_MONITORED_ACTUAL_CAPTURE_ATTEMPT", + "created_utc": "2026-10-27T15:35:57.457898+00:00", + "manifest_sha256": "04ee8ee199bfddc692232ac97adf457d41c33f22d66c0caddd0afced26b3656a", + "one_command": true, + "automatic_retries": 0, + "capture_all_keys": 2579750, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "full_original_qualifier_receipt_required": true, + "shared_spent_before_seconds": 702.8753873150854, + "shared_cap_seconds": 1500, + "command_seconds": 180, + "groupRSS_bytes": 1073741824, + "resource_fit": "UNPROVEN; guard cap failure ends nomination; no sampling or cap increase", + "source_reviews": "ParentcompleteC/Python/inventory/AST+inverse; independentAstrafinalpinreviewclearance", + "no_optimization_constructed": true, + "scope": "actualvaluekey-onlycost information, notcompleteperformanceorFractionAPIclaim", + "output": "runtime/actual-key-pilot-v1-artifacts/RESULT.json" +} diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PLAN.md b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PLAN.md new file mode 100644 index 0000000000..3e58217c5c --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/PLAN.md @@ -0,0 +1,17 @@ +# Source-specific actual-key nomination + +Status: SOURCE PREPARATION ONLY. The earlier synthetic screen is failed and closed. This separate nomination asks whether the complete source-pinned actual key sequence materially changes the key-only cost premise. It has no favorable reroll, synthetic regeneration, new cache algorithm, private integer owner, GMP procurement, or GC-policy change. + +One prospective cold guarded child will execute the exact original full_C qualifier with a reversible diagnostic C capture hook. The hook retains the existing freshly constructed exact seven-PyLong tuple immediately before its original lookup; it does not recompute fields. Capture is off for inherited finite/control calls. A source-bound Python wrapper activates capture only for the one original actual-word invocation, requires the complete original native counters/output/tokens checks, takes all 2,579,750 keys, and always aborts capture in a finally block. Overflow, missing keys, wrong types, duplicate actual invocation or any qualifier failure stop the child. The C patch adds only begin/take/abort methods and the one capture hook; removing the three declared edits restores the exact original C hash. + +The baseline copy must contain exactly the original 164 files, with every byte/mode unchanged except native_cache.c and its NATIVE-SOURCE.json pin. The original full.py remains byte-identical. Its one authenticated namespace assignment is transformed only in memory to wrap native_trace; original Fraction arithmetic, miss callbacks, F(0), ordered score additions, source iteration, Observation, complete signed-witness comparisons, 120 finite fixtures, 25,984 events, 799 coordinates and the frozen source result remain mandatory. The full qualifier's printed receipts are retained and checked. Capture changes allocation/GC/liveness costs, so this phase is diagnostic, not a complete performance sample. + +Only after the complete qualifier passes, retain the whole captured corpus as a versioned gzip/pickle stream in fixed-size blocks with clear_memo after each block. Exact PyLong values and signs survive serialization. The replay uses the original in-memory captured objects, preserving separately allocated equal integer identities. The archive preserves values/order; cross-block object identity is not a claim. Retain the corpus SHA-256, counts and serialization version. + +Reuse the previously approved comparator, loader, finite controls, independent literal dict/deque oracle and full-output writer unchanged. The copied helper module contains its historical synthetic entrypoint, but the new driver never invokes that entrypoint or generator. The new fixed replay is B,C,C,B, once per arm, fresh state, all 2,579,750 actual keys, capacity 16,384, no warmup or retry. Every result ID, hit/miss/eviction flag and every 80-operation/final-partial prefix must equal the oracle; expected counts are 2,252,966 hits, 326,784 misses and 310,400 evictions. Both timed loops omit Fraction arithmetic, callbacks and descriptor extraction exactly as before. Four samples, oracle, corpus and all receipts are retained. + +The smaller paired B−C difference is measured for actual keys, but it is not a complete-verification saving. The conditional engineering screen uses the previous diagnostic integer gross region as an explicitly different-run anchor (4.684712576272432 wall / 4.683428714999984 CPU seconds, including diagnostic clock overhead), zero integer residual solely for rejection, and a provisional unmeasured 0.5-second reserve. It compares against fixed complete-B thresholds 5.199267808800505 wall / 5.1705 CPU seconds. A negative result stops this nomination; a positive result cannot admit construction or a complete saving. No per-lookup clock is added to either timed replay loop. + +Memory is the principal unresolved execution risk. On 64-bit CPython, 2,579,750 seven-item tuples at 96 bytes account for about 248 MB; their capture-list pointer array may add about 23 MB, with another 21 MB temporarily while taking the immutable outer tuple. Captured integers are referenced, not copied, but references extend their lifetimes. Four old/v fields per call at an assumed 40-byte distinct integer allocation would add about 413 MB; q/token references mostly share event/token objects. Adding the prior roughly 117 MB baseline working set and a deliberately generous 150 MB allowance for oracle/comparator outputs, serialization and allocator overhead gives roughly 972 MB, below but close to the 1-GiB guard. This is a planning estimate, not a proven bound: 64-byte independently retained integers could exceed the cap. Actual widths, sharing and allocator retention remain unknown until capture. There is no fallback, sampling or cap increase: the existing process-group RSS guard must terminate and retain failure if the full trace cannot fit. Successful qualifier frames and the owned wrapper namespace are released before oracle/replay. One explicit gc.collect() after all original qualifier checks clears unreachable temporary qualifier objects; it keeps the complete corpus, changes no GC policy, runs outside all replay timings, and is charged to the outer command. No duplicate materialized corpus or unbounded pickle memo is permitted. An explicit per-field size census is not added because it would require a large extra identity set/workload. + +The parent alone may freeze and execute, after independent source review. Shared cap remains 1500 seconds, approximately 702.875387315 already spent, with 180 seconds per command and 1 GiB group RSS; zero automatic retries, initial 600-second phase closed. The full qualifier previously took tens of seconds; source capture, serialization, two cold compilers and four key replays remain unpriced and could breach the guard. No time-limit assurance is claimed. All costs are charged in the one cold outer receipt, including compiler-child CPU and output persistence. diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/REPRODUCE.md b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/REPRODUCE.md new file mode 100644 index 0000000000..f4de9adddd --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/REPRODUCE.md @@ -0,0 +1,35 @@ +# Parent-only actual-key freeze and single guarded attempt + +This directory is source preparation only. No compiler, scientific import, captured corpus or replay was executed by its author. Independent source review and the parent's resource/ledger decision precede any execution. The earlier synthetic pilot remains closed. + +From `/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453`, the parent can freeze this distinct source-only stage with file operations: + +```bash +python3 - <<'PY' +from pathlib import Path +import hashlib, json, shutil +base=Path('outputs/c-verification-all-opportunities-20261027') +source=base/'actual-key-pilot' +stage=base/'stages/actual-key-pilot-v1' +manifest=json.loads((source/'FROZEN-SOURCE.json').read_text()) +for name,digest in manifest['files_sha256'].items(): + assert hashlib.sha256((source/name).read_bytes()).hexdigest()==digest,name +for name,digest in manifest['reference_files_sha256'].items(): + assert hashlib.sha256((base/name).read_bytes()).hexdigest()==digest,name +assert not any(p.is_symlink() for p in source.rglob('*')) +shutil.copytree(source,stage) # Must be new; preserves all 164 baseline file modes. +print('Frozen stage:',stage.resolve()) +PY +``` + +Then, only if admitted by the parent, one execution: + +```bash +/usr/bin/python3.12 outputs/c-verification-all-opportunities-20261027/run_guarded.py actual-key-pilot-v1 stages/actual-key-pilot-v1/stage_entry.py +``` + +No `--initial`, `--optimized`, alternate corpus, warmup or retry. The existing guard serializes execution, fixes PYTHONHASHSEED=0, retains the outer `/usr/bin/time` bill including compiler children, enforces 180 seconds / sampled 1-GiB process-group RSS, and charges the shared 1500-second ledger. It freezes every stage file plus the unchanged baseline/input closure. The wrapper writes only to a fresh `runtime/actual-key-pilot-v1-artifacts/` directory. A cap failure is a retained final failure of this nomination; no keys are sampled or deduplicated and the caps are not raised. + +Retain the entire artifact directory and `runtime/runs/actual-key-pilot-v1/receipt.json`. Artifacts include original full-qualifier stdout, a capture receipt, native/key build receipts, finite controls, the complete `actual-keys-v1.pickle.gz` corpus, the oracle and all four full ID/flag/prefix outputs, and the final result or failure traceback. Successful corpus readback compares every value/order in bounded blocks. Performance replay uses the original live captured objects, not deserialized replacements; the persisted archive does not promise cross-block object identity. This report's file format is versioned explicitly: gzip with mtime 0, compression level 1, pickle protocol 5, one header, then outer tuple blocks of up to 4096 keys with pickler/unpickler memo cleared at block boundaries. All arbitrary-width signed exact integers remain values in each seven-field key. + +The parent outer receipt is the authoritative cold cost. Capture and complete qualification are diagnostic and cannot be treated as a new baseline timing. The unchanged key-only comparator excludes descriptors/Fraction arithmetic/callbacks from both inner arms. A positive conditional budget still leaves actual complete integration, retained integer costs and all new bills unpriced; a negative budget stops this nomination. diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/SOURCE-EDITS.json b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/SOURCE-EDITS.json new file mode 100644 index 0000000000..85849c359e --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/SOURCE-EDITS.json @@ -0,0 +1,688 @@ +{ + "baseline_file_count": 164, + "changed_baseline_files": [ + "native_cache.c", + "NATIVE-SOURCE.json" + ], + "compilation": false, + "diagnostic_native_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "edits": [ + { + "after": "#define PY_SSIZE_T_CLEAN\n#include \n#include \n\n/* Diagnostic capture only: off by default; exact existing contribution keys. */\n#define ACTUAL_CAPTURE_CALLS ((Py_ssize_t)2579750)\nstatic PyObject *capture_keys=NULL;\nstatic int capture_active=0;\n\nstatic int capture_key(PyObject *key) {\n if (!capture_active || !capture_keys) {\n PyErr_SetString(PyExc_RuntimeError,\"capture protocol inactive\"); return -1;\n }\n if (PyList_GET_SIZE(capture_keys)>=ACTUAL_CAPTURE_CALLS) {\n PyErr_SetString(PyExc_OverflowError,\"actual capture exceeds fixed complete call count\"); return -1;\n }\n return PyList_Append(capture_keys,key);\n}\nstatic PyObject *capture_begin(PyObject *module, PyObject *unused) {\n (void)module; (void)unused;\n if (capture_active || capture_keys) {\n PyErr_SetString(PyExc_RuntimeError,\"one active actual capture only\"); return NULL;\n }\n capture_keys=PyList_New(0);\n if (!capture_keys) return NULL;\n capture_active=1; Py_RETURN_NONE;\n}\nstatic PyObject *capture_take(PyObject *module, PyObject *unused) {\n (void)module; (void)unused;\n if (!capture_active || !capture_keys || PyList_GET_SIZE(capture_keys)!=ACTUAL_CAPTURE_CALLS) {\n PyErr_SetString(PyExc_RuntimeError,\"complete active actual key capture required\"); return NULL;\n }\n PyObject *answer=PyList_AsTuple(capture_keys);\n if (!answer) return NULL;\n capture_active=0; Py_CLEAR(capture_keys);\n return answer;\n}\nstatic PyObject *capture_abort(PyObject *module, PyObject *unused) {\n (void)module; (void)unused;\n capture_active=0; Py_CLEAR(capture_keys); Py_RETURN_NONE;\n}\nstatic PyMethodDef capture_methods[]={\n {\"_capture_begin\",capture_begin,METH_NOARGS,\"Begin one complete actual key capture.\"},\n {\"_capture_take\",capture_take,METH_NOARGS,\"Take every captured original key, then clear.\"},\n {\"_capture_abort\",capture_abort,METH_NOARGS,\"Idempotently clear capture on every path.\"},\n {NULL,NULL,0,NULL}\n};\n", + "before": "#define PY_SSIZE_T_CLEAN\n#include \n#include \n", + "label": "capture-state-and-separate-methods" + }, + { + "after": " PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i)));\n if(capture_active && capture_key(key)<0){Py_DECREF(key);return NULL;}\n", + "before": " PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i)));\n", + "label": "retain-original-key-before-original-lookup" + }, + { + "after": "static struct PyModuleDef module={PyModuleDef_HEAD_INIT,\"_fraction_native\",\"Bounded cache; exact Python arithmetic.\",-1,capture_methods};", + "before": "static struct PyModuleDef module={PyModuleDef_HEAD_INIT,\"_fraction_native\",\"Bounded cache; exact Python arithmetic.\",-1,NULL};", + "label": "expose-separate-capture-methods" + } + ], + "exact_original_complete_c_source_restored": true, + "numerical_execution": false, + "original_inventory": { + ".gitignore": { + "mode": 420, + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78" + }, + ".research-export.json": { + "mode": 420, + "sha256": "bd8d548de371bfce83238f51c8c5487d1e7d57ade1b77a82dd84e2e648ede0b0" + }, + "GETTER-SHAPES.json": { + "mode": 420, + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4" + }, + "NATIVE-SOURCE.json": { + "mode": 420, + "sha256": "2bc3043374685ece68f0091238ab038f6cfcd13be80610b5e348d61984cb11f3" + }, + "NOTICE": { + "mode": 420, + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83" + }, + "PROOF.md": { + "mode": 420, + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b" + }, + "README.md": { + "mode": 420, + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95" + }, + "RESULT.json": { + "mode": 420, + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188" + }, + "SOURCES.json": { + "mode": 420, + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc" + }, + "TASK.json": { + "mode": 420, + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c" + }, + "VALIDATION.json": { + "mode": 420, + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4" + }, + "VERIFY.json": { + "mode": 420, + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53" + }, + "actual_audit.py": { + "mode": 420, + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a" + }, + "benchmark.py": { + "mode": 420, + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5" + }, + "compact_finite.py": { + "mode": 420, + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1" + }, + "compact_parent.py": { + "mode": 420, + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a" + }, + "custody.py": { + "mode": 420, + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f" + }, + "entry_finite.py": { + "mode": 420, + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9" + }, + "entry_parent.py": { + "mode": 420, + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe" + }, + "evidence/FINITE-INERT-GC-FIXTURE.py.txt": { + "mode": 420, + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4" + }, + "evidence/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b" + }, + "evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md": { + "mode": 420, + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767" + }, + "evidence/NATIVE-CACHE-REVIEW-SOURCES.json": { + "mode": 420, + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9" + }, + "evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md": { + "mode": 420, + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448" + }, + "evidence/NATIVE-REVIEW-FINAL-STATE.json": { + "mode": 420, + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243" + }, + "evidence/PLAN.json": { + "mode": 420, + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434" + }, + "evidence/SCREEN.json": { + "mode": 420, + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c" + }, + "evidence/SEALED-RESULT.json": { + "mode": 420, + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f" + }, + "evidence/fraction-compact-key-20261027/SCREEN.json": { + "mode": 420, + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83" + }, + "evidence/fraction-compact-key-20261027/STATE.json": { + "mode": 420, + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json": { + "mode": 420, + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt": { + "mode": 420, + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/usage.json": { + "mode": 420, + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe" + }, + "evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93" + }, + "evidence/fraction-direct-add-20261027/SCREEN.json": { + "mode": 420, + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834" + }, + "evidence/fraction-direct-add-20261027/STATE.json": { + "mode": 420, + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json": { + "mode": 420, + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt": { + "mode": 420, + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/usage.json": { + "mode": 420, + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e" + }, + "evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d" + }, + "evidence/fraction-slot-key-20261027/STATE.json": { + "mode": 420, + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json": { + "mode": 420, + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt": { + "mode": 420, + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/usage.json": { + "mode": 420, + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5" + }, + "evidence/portable/runs/complete-native/receipt.json": { + "mode": 420, + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0" + }, + "evidence/portable/runs/complete-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/portable/runs/complete-native/stdout.txt": { + "mode": 420, + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b" + }, + "evidence/portable/runs/complete-native/usage.json": { + "mode": 420, + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10" + }, + "evidence/runtime/GATE-2.json": { + "mode": 420, + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7" + }, + "evidence/runtime/GATE-6.json": { + "mode": 420, + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de" + }, + "evidence/runtime/benchmark.py": { + "mode": 420, + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa" + }, + "evidence/runtime/dispatch.py": { + "mode": 420, + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8" + }, + "evidence/runtime/guard.py": { + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "evidence/runtime/runs/B1/receipt.json": { + "mode": 420, + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5" + }, + "evidence/runtime/runs/B1/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B1/stdout.txt": { + "mode": 420, + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9" + }, + "evidence/runtime/runs/B1/usage.json": { + "mode": 420, + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342" + }, + "evidence/runtime/runs/B2/receipt.json": { + "mode": 420, + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9" + }, + "evidence/runtime/runs/B2/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B2/stdout.txt": { + "mode": 420, + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0" + }, + "evidence/runtime/runs/B2/usage.json": { + "mode": 420, + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35" + }, + "evidence/runtime/runs/B3/receipt.json": { + "mode": 420, + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8" + }, + "evidence/runtime/runs/B3/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B3/stdout.txt": { + "mode": 420, + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2" + }, + "evidence/runtime/runs/B3/usage.json": { + "mode": 420, + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c" + }, + "evidence/runtime/runs/C1/receipt.json": { + "mode": 420, + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba" + }, + "evidence/runtime/runs/C1/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C1/stdout.txt": { + "mode": 420, + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f" + }, + "evidence/runtime/runs/C1/usage.json": { + "mode": 420, + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0" + }, + "evidence/runtime/runs/C2/receipt.json": { + "mode": 420, + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579" + }, + "evidence/runtime/runs/C2/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C2/stdout.txt": { + "mode": 420, + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c" + }, + "evidence/runtime/runs/C2/usage.json": { + "mode": 420, + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5" + }, + "evidence/runtime/runs/C3/receipt.json": { + "mode": 420, + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9" + }, + "evidence/runtime/runs/C3/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C3/stdout.txt": { + "mode": 420, + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193" + }, + "evidence/runtime/runs/C3/usage.json": { + "mode": 420, + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af" + }, + "evidence/runtime/runs/actual-native-apply/receipt.json": { + "mode": 420, + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3" + }, + "evidence/runtime/runs/actual-native-apply/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/actual-native-apply/stdout.txt": { + "mode": 420, + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5" + }, + "evidence/runtime/runs/actual-native-apply/usage.json": { + "mode": 420, + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746" + }, + "evidence/runtime/runs/apply-micro-native/receipt.json": { + "mode": 420, + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a" + }, + "evidence/runtime/runs/apply-micro-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/apply-micro-native/stdout.txt": { + "mode": 420, + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c" + }, + "evidence/runtime/runs/apply-micro-native/usage.json": { + "mode": 420, + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea" + }, + "evidence/runtime/runs/finite-native-O/receipt.json": { + "mode": 420, + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410" + }, + "evidence/runtime/runs/finite-native-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-O/stdout.txt": { + "mode": 420, + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18" + }, + "evidence/runtime/runs/finite-native-O/usage.json": { + "mode": 420, + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5" + }, + "evidence/runtime/runs/finite-native-bound-debug/receipt.json": { + "mode": 420, + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432" + }, + "evidence/runtime/runs/finite-native-bound-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-bound-debug/stdout.txt": { + "mode": 420, + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87" + }, + "evidence/runtime/runs/finite-native-bound-debug/usage.json": { + "mode": 420, + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/receipt.json": { + "mode": 420, + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt": { + "mode": 420, + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/usage.json": { + "mode": 420, + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/receipt.json": { + "mode": 420, + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt": { + "mode": 420, + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/usage.json": { + "mode": 420, + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad" + }, + "evidence/runtime/runs/finite-native-debug/receipt.json": { + "mode": 420, + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581" + }, + "evidence/runtime/runs/finite-native-debug/stderr.txt": { + "mode": 420, + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877" + }, + "evidence/runtime/runs/finite-native-debug/stdout.txt": { + "mode": 420, + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1" + }, + "evidence/runtime/runs/finite-native-debug/usage.json": { + "mode": 420, + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407" + }, + "evidence/runtime/runs/finite-native-final-debug/receipt.json": { + "mode": 420, + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a" + }, + "evidence/runtime/runs/finite-native-final-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-final-debug/stdout.txt": { + "mode": 420, + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6" + }, + "evidence/runtime/runs/finite-native-final-debug/usage.json": { + "mode": 420, + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32" + }, + "evidence/runtime/runs/finite-native-initial/receipt.json": { + "mode": 420, + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972" + }, + "evidence/runtime/runs/finite-native-initial/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-initial/stdout.txt": { + "mode": 420, + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b" + }, + "evidence/runtime/runs/finite-native-initial/usage.json": { + "mode": 420, + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3" + }, + "evidence/runtime/runs/finite-native-packet-O/receipt.json": { + "mode": 420, + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e" + }, + "evidence/runtime/runs/finite-native-packet-O/stderr.txt": { + "mode": 420, + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8" + }, + "evidence/runtime/runs/finite-native-packet-O/stdout.txt": { + "mode": 420, + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb" + }, + "evidence/runtime/runs/finite-native-packet-O/usage.json": { + "mode": 420, + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675" + }, + "evidence/runtime/runs/finite-native-reviewed-O/receipt.json": { + "mode": 420, + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stdout.txt": { + "mode": 420, + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36" + }, + "evidence/runtime/runs/finite-native-reviewed-O/usage.json": { + "mode": 420, + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998" + }, + "evidence/runtime/runs/finite-native-snapshot-O/receipt.json": { + "mode": 420, + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stdout.txt": { + "mode": 420, + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519" + }, + "evidence/runtime/runs/finite-native-snapshot-O/usage.json": { + "mode": 420, + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b" + }, + "evidence/runtime/runs/full-native-O/receipt.json": { + "mode": 420, + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448" + }, + "evidence/runtime/runs/full-native-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/full-native-O/stdout.txt": { + "mode": 420, + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54" + }, + "evidence/runtime/runs/full-native-O/usage.json": { + "mode": 420, + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1" + }, + "evidence/runtime/runs/micro-native/receipt.json": { + "mode": 420, + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4" + }, + "evidence/runtime/runs/micro-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/micro-native/stdout.txt": { + "mode": 420, + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9" + }, + "evidence/runtime/runs/micro-native/usage.json": { + "mode": 420, + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143" + }, + "evidence/runtime/runs/packaged-native-finite-O/receipt.json": { + "mode": 420, + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d" + }, + "evidence/runtime/runs/packaged-native-finite-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite-O/stdout.txt": { + "mode": 420, + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b" + }, + "evidence/runtime/runs/packaged-native-finite-O/usage.json": { + "mode": 420, + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041" + }, + "evidence/runtime/runs/packaged-native-finite/receipt.json": { + "mode": 420, + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d" + }, + "evidence/runtime/runs/packaged-native-finite/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite/stdout.txt": { + "mode": 420, + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab" + }, + "evidence/runtime/runs/packaged-native-finite/usage.json": { + "mode": 420, + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3" + }, + "finite.py": { + "mode": 420, + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359" + }, + "fraction_table.py": { + "mode": 420, + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4" + }, + "frozen.py": { + "mode": 420, + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547" + }, + "full.py": { + "mode": 420, + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0" + }, + "full_B.py": { + "mode": 420, + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a" + }, + "full_C.py": { + "mode": 420, + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394" + }, + "guard.py": { + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "inputs/PR5848.tar": { + "mode": 420, + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6" + }, + "micro.py": { + "mode": 420, + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53" + }, + "micro_apply.py": { + "mode": 420, + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e" + }, + "native_backend.py": { + "mode": 420, + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d" + }, + "native_cache.c": { + "mode": 420, + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" + }, + "parent_finite.py": { + "mode": 420, + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f" + }, + "replay.py": { + "mode": 420, + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9" + }, + "replay_driver.py": { + "mode": 420, + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528" + }, + "slot_binding.py": { + "mode": 420, + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593" + }, + "slot_finite.py": { + "mode": 420, + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390" + }, + "slot_parent.py": { + "mode": 420, + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24" + }, + "table_parent.py": { + "mode": 420, + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4" + }, + "verify.py": { + "mode": 420, + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82" + } + }, + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "status": "SOURCE_ONLY_CAPTURE_PREPARED" +} diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/actual_driver.py b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/actual_driver.py new file mode 100644 index 0000000000..4c9e05ec7a --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/actual_driver.py @@ -0,0 +1,121 @@ +"""One prospective actual-key capture and fixed BCCB replay; parent guard only.""" +import time +COLD_START=time.perf_counter() +import gzip +import gc +import hashlib +import json +from pathlib import Path +import pickle +import resource +import sys +import traceback +import run_pilot as approved +from load_pilot import compile_and_load,verify_sources +from capture_actual import CALLS,STATS,capture_qualified,verify_copy + +ORDER=(('B1',0),('C1',1),('C2',1),('B2',0)) +BLOCK=4096 +ANCHOR=dict(wall=4.684712576272432,cpu=4.683428714999984) +THRESHOLD=dict(wall=5.199267808800505,cpu=5.1705) + + +def cpu(): + a=resource.getrusage(resource.RUSAGE_SELF);b=resource.getrusage(resource.RUSAGE_CHILDREN) + return a.ru_utime+a.ru_stime+b.ru_utime+b.ru_stime +COLD_CPU=cpu() + + +def archive_corpus(rows,destination): + path=destination/'actual-keys-v1.pickle.gz' + header=dict(format='actual-keys-v1',pickle_protocol=5,block_keys=BLOCK,calls=CALLS,key_fields=7, + values='exact signed Python integers',order='original contribution order',cross_block_identity_preserved=False) + with path.open('wb') as raw,gzip.GzipFile(fileobj=raw,mode='wb',compresslevel=1,mtime=0) as stream: + writer=pickle.Pickler(stream,protocol=5);writer.dump(header);writer.clear_memo() + for start in range(0,CALLS,BLOCK): + writer.dump(rows[start:start+BLOCK]);writer.clear_memo() + # Bounded streaming readback checks every archived key value/order, while + # timed replay retains the original in-memory object identities. + with gzip.open(path,'rb') as stream: + reader=pickle.Unpickler(stream) + if reader.load()!=header:raise ValueError('corpus serialization header') + reader.memo.clear() + for start in range(0,CALLS,BLOCK): + block=reader.load();reader.memo.clear() + if type(block) is not tuple or block!=rows[start:start+BLOCK]:raise ValueError('entire archived corpus equals captured keys') + try:reader.load() + except EOFError:pass + else:raise ValueError('no trailing corpus object') + digest=hashlib.sha256() + with path.open('rb') as stream: + for block in iter(lambda:stream.read(1024*1024),b''):digest.update(block) + return dict(file=path.name,sha256=digest.hexdigest(),compressed_bytes=path.stat().st_size,format=header, + complete_streaming_value_readback=True,replay_uses_original_captured_objects=True) + + +def screen(samples): + by={r['name']:r for r in samples};out={} + for kind in ('wall','cpu'): + pairs=[by['B1'][kind]-by['C1'][kind],by['B2'][kind]-by['C2'][kind]] + saving=min(pairs);budget=ANCHOR[kind]+saving-0.5 + out[kind]=dict(paired_key_only_seconds=pairs,smaller_key_only_seconds=saving, + different_run_integer_gross_anchor=ANCHOR[kind],provisional_reserve_seconds=0.5, + optimistic_budget_seconds=budget,zero_reserve_budget_seconds=budget+0.5, + necessary_15pct_threshold_seconds=THRESHOLD[kind],necessary_threshold_met=budget>=THRESHOLD[kind]) + out.update(status='HEADROOM_FOR_SOURCE_SPECIFIC_COST_DESIGN_ONLY' if all(out[k]['necessary_threshold_met'] for k in ('wall','cpu')) else 'REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION', + measured_actual_key_only=True,measured_complete_saving=False,construction_admitted=False, + integer_anchor_from_different_run=True,integer_anchor_includes_clock_overhead=True, + integer_residual_assumed_seconds=0,real_integer_residual='UNPRICED_NONZERO',reserve_measured=False, + complete_new_validation_build_bill='UNPRICED_NONZERO',synthetic_failed_screen_remains_closed=True) + return out + + +def main(destination): + if len(sys.argv)!=1:raise ValueError('no alternate workload or arguments') + destination.mkdir(parents=True,exist_ok=False) + report=dict(status='STARTED',scope='source-specific full actual-key capture and key-only replay',samples=[], + calls_per_sample=CALLS,frozen_order=[n for n,_ in ORDER],automatic_retries=0,construction_admitted=False) + approved.write_json(destination/'RESULT.json',report) + try: + report['source_manifest']=verify_sources() + rows,report['capture']=capture_qualified(destination) + approved.write_json(destination/'CAPTURE-RECEIPT.json',report['capture']) + report['post_qualifier_cleanup']=dict(unreachable_objects_collected=gc.collect(),charged_to_outer=True, + after_all_original_qualifier_checks=True,captured_keys_retained=True,gc_policy_unchanged=True) + report['corpus']=archive_corpus(rows,destination) + module,report['key_build']=compile_and_load(destination) + controls=approved.finite_controls(module) + approved.write_json(destination/'FINITE-CONTROLS.json',controls) + report['finite_controls']=dict(status=controls['status'],receipts=len(controls['receipts']),natural_rehashes=controls['natural_rehashes']) + del controls + expected=approved.literal_oracle(rows,16384) + if expected[3]!={k:v for k,v in STATS.items() if k!='bypasses'}:raise ValueError('actual source counters match literal key oracle') + report['oracle_output']=approved.retain_full(destination,'oracle',expected) + approved.write_json(destination/'RESULT.json',report) + for name,mode in ORDER: + wall=time.perf_counter_ns();process=time.process_time_ns() + actual=module.run(mode,rows,16384) + process=time.process_time_ns()-process;wall=time.perf_counter_ns()-wall + sample=dict(name=name,mode=mode,calls=CALLS,wall=wall/1e9,cpu=process/1e9) + report['samples'].append(sample) + sample['output']=approved.retain_full(destination,name,actual) + approved.write_json(destination/'RESULT.json',report) + approved.assert_equal(actual,expected,mode) + if mode==1 and actual[3]['rehashes']<1:raise ValueError('actual custom replay exercises natural rehash') + sample['full_output_equality']=True + del actual + approved.write_json(destination/'RESULT.json',report) + verify_sources();verify_copy() + report['conditional_screen']=screen(report['samples']) + report['status']='PASS_ACTUAL_KEY_COMPARISON_ONLY' + except BaseException as error: + report['status']='FAIL_RETAINED_NO_RETRY' + report['failure']=dict(type=type(error).__name__,message=str(error)) + (destination/'traceback.txt').write_text(traceback.format_exc()) + raise + finally: + report['child_cold_through_final_receipt_boundary']=dict(wall=time.perf_counter()-COLD_START,cpu_including_compiler_children=cpu()-COLD_CPU, + excludes_process_startup_exit_and_this_final_write=True) + report['parent_outer_guard_receipt_required']=True + approved.write_json(destination/'RESULT.json',report) + print(json.dumps(dict(status=report['status'],screen=report['conditional_screen']['status'],result=str(destination/'RESULT.json')))) diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/NATIVE-SOURCE.json b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/NATIVE-SOURCE.json new file mode 100644 index 0000000000..c8373bd1b2 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/NATIVE-SOURCE.json @@ -0,0 +1,3 @@ +{ + "sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" +} diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/native_cache.c b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/native_cache.c new file mode 100644 index 0000000000..58ff026cbb --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/baseline-public/native_cache.c @@ -0,0 +1,272 @@ +/* Exact bounded cache/control only. All Fraction arithmetic stays in Python. + * Chris R / Clear1nsight, substantial OpenAI Codex/Astra assistance. Apache-2.0. + */ +#define PY_SSIZE_T_CLEAN +#include +#include + +/* Diagnostic capture only: off by default; exact existing contribution keys. */ +#define ACTUAL_CAPTURE_CALLS ((Py_ssize_t)2579750) +static PyObject *capture_keys=NULL; +static int capture_active=0; + +static int capture_key(PyObject *key) { + if (!capture_active || !capture_keys) { + PyErr_SetString(PyExc_RuntimeError,"capture protocol inactive"); return -1; + } + if (PyList_GET_SIZE(capture_keys)>=ACTUAL_CAPTURE_CALLS) { + PyErr_SetString(PyExc_OverflowError,"actual capture exceeds fixed complete call count"); return -1; + } + return PyList_Append(capture_keys,key); +} +static PyObject *capture_begin(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + if (capture_active || capture_keys) { + PyErr_SetString(PyExc_RuntimeError,"one active actual capture only"); return NULL; + } + capture_keys=PyList_New(0); + if (!capture_keys) return NULL; + capture_active=1; Py_RETURN_NONE; +} +static PyObject *capture_take(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + if (!capture_active || !capture_keys || PyList_GET_SIZE(capture_keys)!=ACTUAL_CAPTURE_CALLS) { + PyErr_SetString(PyExc_RuntimeError,"complete active actual key capture required"); return NULL; + } + PyObject *answer=PyList_AsTuple(capture_keys); + if (!answer) return NULL; + capture_active=0; Py_CLEAR(capture_keys); + return answer; +} +static PyObject *capture_abort(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + capture_active=0; Py_CLEAR(capture_keys); Py_RETURN_NONE; +} +static PyMethodDef capture_methods[]={ + {"_capture_begin",capture_begin,METH_NOARGS,"Begin one complete actual key capture."}, + {"_capture_take",capture_take,METH_NOARGS,"Take every captured original key, then clear."}, + {"_capture_abort",capture_abort,METH_NOARGS,"Idempotently clear capture on every path."}, + {NULL,NULL,0,NULL} +}; + +typedef struct { + PyObject_HEAD + PyObject *dict, *weights, *tokens, *compute, *num, *den, *fraction; + PyObject **ring; + Py_ssize_t capacity, used, head, calls, hits, misses, evictions; + int ready, busy; +} Cache; +typedef struct { + PyObject_HEAD + vectorcallfunc vectorcall; + Cache *cache; + PyObject *q, *qn, *qd; +} Event; +static PyTypeObject CacheType, EventType; + +static int cache_traverse(Cache *s, visitproc visit, void *arg) { + Py_VISIT(s->dict); Py_VISIT(s->weights); Py_VISIT(s->tokens); + Py_VISIT(s->compute); Py_VISIT(s->num); Py_VISIT(s->den); Py_VISIT(s->fraction); + if (s->ring) for (Py_ssize_t i=0;icapacity;i++) Py_VISIT(s->ring[i]); + return 0; +} +static int cache_clear(Cache *s) { + s->ready=0; s->busy=1; + if (s->ring) { + for (Py_ssize_t i=0;icapacity;i++) Py_CLEAR(s->ring[i]); + PyMem_Free(s->ring); s->ring=NULL; + } + Py_CLEAR(s->dict); Py_CLEAR(s->weights); Py_CLEAR(s->tokens); + Py_CLEAR(s->compute); Py_CLEAR(s->num); Py_CLEAR(s->den); Py_CLEAR(s->fraction); + return 0; +} +static void cache_dealloc(Cache *s) { + PyObject_GC_UnTrack(s); cache_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static int event_traverse(Event *s, visitproc visit, void *arg) { + Py_VISIT(s->cache); Py_VISIT(s->q); Py_VISIT(s->qn); Py_VISIT(s->qd); return 0; +} +static int event_clear(Event *s) { + Py_CLEAR(s->cache); Py_CLEAR(s->q); Py_CLEAR(s->qn); Py_CLEAR(s->qd); return 0; +} +static void event_dealloc(Event *s) { + PyObject_GC_UnTrack(s); event_clear(s); Py_TYPE(s)->tp_free((PyObject *)s); +} +static PyObject *event_disabled(PyTypeObject *type, PyObject *args, PyObject *kw) { + (void)type; (void)args; (void)kw; + PyErr_SetString(PyExc_TypeError,"events are created only by Cache.event"); return NULL; +} +static int is_pair(PyObject *p) { + return (PyList_CheckExact(p)||PyTuple_CheckExact(p)) && PySequence_Size(p)>=2; +} +static PyObject *cache_new(PyTypeObject *type, PyObject *args, PyObject *kw) { + if (kw && PyDict_Size(kw)) { PyErr_SetString(PyExc_TypeError,"positional cache arguments only");return NULL; } + PyObject *cap,*weights,*tokens,*compute,*num,*den,*fraction; + if (!PyArg_UnpackTuple(args,"Cache",7,7,&cap,&weights,&tokens,&compute,&num,&den,&fraction)) return NULL; + if (!PyLong_CheckExact(cap)) { PyErr_SetString(PyExc_ValueError,"integer capacity");return NULL; } + Py_ssize_t ncap=PyLong_AsSsize_t(cap); + if (ncap<1 || ncap>16384 || PyErr_Occurred()) { if(!PyErr_Occurred()) PyErr_SetString(PyExc_ValueError,"capacity 1..16384");return NULL; } + if (!(PyList_CheckExact(weights)||PyTuple_CheckExact(weights)) || !PyList_CheckExact(tokens) || !PyFunction_Check(compute) || !PyType_Check(fraction) || Py_TYPE(num)!=&PyMemberDescr_Type || Py_TYPE(den)!=&PyMemberDescr_Type || !Py_TYPE(num)->tp_descr_get || !Py_TYPE(den)->tp_descr_get) { + PyErr_SetString(PyExc_TypeError,"exact native packet types");return NULL; + } + Py_ssize_t n=PySequence_Size(weights); + if (PyList_GET_SIZE(tokens)!=n) { PyErr_SetString(PyExc_ValueError,"weight/token size");return NULL; } + Cache *s=(Cache *)type->tp_alloc(type,0); + if (!s) return NULL; + s->capacity=ncap; + s->dict=PyDict_New();s->weights=PyTuple_New(n);s->tokens=PyTuple_New(n); + s->ring=PyMem_Calloc((size_t)ncap,sizeof(PyObject *)); + if (!s->dict || !s->weights || !s->tokens || !s->ring) { if(!PyErr_Occurred())PyErr_NoMemory();Py_DECREF(s);return NULL; } + s->compute=Py_NewRef(compute);s->num=Py_NewRef(num);s->den=Py_NewRef(den);s->fraction=Py_NewRef(fraction); + for (Py_ssize_t i=0;iweights,i,pair); + PyObject *token=PySequence_GetItem(tokens,i); + if (!token) { Py_DECREF(s);return NULL; } + if (!PyLong_CheckExact(token)) { Py_DECREF(token);Py_DECREF(s);PyErr_SetString(PyExc_TypeError,"integer token");return NULL; } + Py_ssize_t t=PyLong_AsSsize_t(token); + if (t<0 || t>=16384 || PyErr_Occurred()) { Py_DECREF(token);Py_DECREF(s);if(!PyErr_Occurred())PyErr_SetString(PyExc_ValueError,"bounded token");return NULL; } + PyTuple_SET_ITEM(s->tokens,i,token); + } + s->ready=1;return (PyObject *)s; +} +static PyObject *member(PyObject *descriptor, PyObject *object, PyObject *type) { + return Py_TYPE(descriptor)->tp_descr_get(descriptor,object,type); +} +static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) { + Cache *s=e->cache; + if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,"native site index");return NULL; } + if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,"exact Fraction coefficients");return NULL; } + PyObject *parts[4]={NULL,NULL,NULL,NULL}; + for (int k=0;k<4;k++) { + parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction); + if (!parts[k] || !PyLong_CheckExact(parts[k])) { + for(int j=0;j<4;j++)Py_XDECREF(parts[j]); + if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,"integer Fraction slots"); + return NULL; + } + } + PyObject *key=PyTuple_New(7); + if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);return NULL;} + PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]); + PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd)); + PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i))); + if(capture_active && capture_key(key)<0){Py_DECREF(key);return NULL;} + if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,"native counter overflow");return NULL;} + s->calls++; + PyObject *result=PyDict_GetItemWithError(s->dict,key); + if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);return result;} + if(PyErr_Occurred()){Py_DECREF(key);return NULL;} + s->misses++; + PyObject *pair=PyTuple_GET_ITEM(s->weights,i); + PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)}; + result=PyObject_Vectorcall(s->compute,argv,5,NULL); + if(!result){Py_DECREF(key);return NULL;} + if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"four exact contributions");return NULL;} + for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"Fraction contributions");return NULL;} + if(s->used==s->capacity){ + PyObject *oldkey=s->ring[s->head]; + if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++; + } + if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);return NULL;} + s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++; + return result; +} +static int begin_event(Event *e) { + if(!e->cache||!e->cache->ready){PyErr_SetString(PyExc_RuntimeError,"cleared native event");return -1;} + if(e->cache->busy){PyErr_SetString(PyExc_RuntimeError,"reentrant native event");return -1;} + e->cache->busy=1;return 0; +} +static PyObject *event_call(PyObject *obj, PyObject *const *args, size_t nargsf, PyObject *kw) { + Event *e=(Event *)obj; + if(PyVectorcall_NARGS(nargsf)!=3 || (kw&&PyTuple_GET_SIZE(kw))){PyErr_SetString(PyExc_TypeError,"event(old,v,index)");return NULL;} + if(!PyLong_CheckExact(args[2])){PyErr_SetString(PyExc_TypeError,"integer site index");return NULL;} + Py_ssize_t i=PyLong_AsSsize_t(args[2]);if(PyErr_Occurred())return NULL; + if(begin_event(e)<0)return NULL; + PyObject *result=contribution(e,args[0],args[1],i);e->cache->busy=0;return result; +} +static PyObject *cache_event(Cache *s, PyObject *q) { + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + if(!Py_IS_TYPE(q,(PyTypeObject *)s->fraction)){PyErr_SetString(PyExc_TypeError,"exact Fraction scalar");return NULL;} + Event *e=(Event *)EventType.tp_alloc(&EventType,0);if(!e)return NULL; + e->vectorcall=event_call;e->cache=(Cache *)Py_NewRef((PyObject *)s);e->q=Py_NewRef(q); + e->qn=member(s->num,q,s->fraction); + if(!e->qn){Py_DECREF(e);return NULL;} + e->qd=member(s->den,q,s->fraction); + if(!e->qd){Py_DECREF(e);return NULL;} + if(!PyLong_CheckExact(e->qn)||!PyLong_CheckExact(e->qd)){Py_DECREF(e);PyErr_SetString(PyExc_TypeError,"integer scalar slots");return NULL;} + return (PyObject *)e; +} +static PyObject *cache_statistics(Cache *s, PyObject *unused) { + (void)unused; + if(!s->ready){PyErr_SetString(PyExc_RuntimeError,"cleared cache");return NULL;} + return Py_BuildValue("{s:n,s:n,s:n,s:n,s:n,s:n,s:n}","calls",s->calls,"hits",s->hits,"misses",s->misses,"evictions",s->evictions,"bypasses",(Py_ssize_t)0,"resident",PyDict_Size(s->dict),"capacity",s->capacity); +} +static PyObject *event_apply(Event *e, PyObject *args) { + PyObject *dst,*src,*scores; + if(!PyArg_UnpackTuple(args,"apply",3,3,&dst,&src,&scores))return NULL; + if(!PyDict_CheckExact(dst)||!PyDict_CheckExact(src)||dst==src||!PyList_CheckExact(scores)||PyList_GET_SIZE(scores)!=3){PyErr_SetString(PyExc_TypeError,"distinct exact rows and three scores");return NULL;} + if(begin_event(e)<0)return NULL; + Cache *s=e->cache; + PyObject *pair=NULL,*result=NULL; + PyObject *view=PyObject_CallMethod(src,"items",NULL); + PyObject *iterator=view?PyObject_GetIter(view):NULL; + Py_XDECREF(view); + if(!iterator)goto fail; + while((pair=PyIter_Next(iterator))){ + if(!PyTuple_CheckExact(pair)||PyTuple_GET_SIZE(pair)!=2){PyErr_SetString(PyExc_TypeError,"dict item pair");goto fail;} + PyObject *index=PyTuple_GET_ITEM(pair,0),*value=PyTuple_GET_ITEM(pair,1); + if(!PyLong_CheckExact(index)){PyErr_SetString(PyExc_TypeError,"integer source site");goto fail;} + Py_ssize_t i=PyLong_AsSsize_t(index);if(PyErr_Occurred())goto fail; + PyObject *zeroarg=PyLong_FromLong(0);if(!zeroarg)goto fail; + PyObject *zero=PyObject_CallOneArg(s->fraction,zeroarg);Py_DECREF(zeroarg);if(!zero)goto fail; + PyObject *old=PyDict_GetItemWithError(dst,index); + if(old){Py_INCREF(old);Py_DECREF(zero);}else if(PyErr_Occurred()){Py_DECREF(zero);goto fail;}else old=zero; + result=contribution(e,old,value,i);Py_DECREF(old);if(!result)goto fail; + for(int k=0;k<3;k++){ + PyObject *score=PyList_GetItem(scores,k); + if(!score)goto fail; + Py_INCREF(score); + PyObject *next=PyNumber_InPlaceAdd(score,PyTuple_GET_ITEM(result,k+1)); + Py_DECREF(score); + if(!next)goto fail; + if(PyList_SetItem(scores,k,next)<0)goto fail; + } + int truth=PyObject_IsTrue(PyTuple_GET_ITEM(result,0)); + if(truth<0)goto fail; + if(truth){if(PyDict_SetItem(dst,index,PyTuple_GET_ITEM(result,0))<0)goto fail;} + else{ + PyObject *present=PyDict_GetItemWithError(dst,index); + if(present){if(PyDict_DelItem(dst,index)<0)goto fail;} + else if(PyErr_Occurred())goto fail; + } + Py_CLEAR(result);Py_CLEAR(pair); + } + if(PyErr_Occurred())goto fail; + Py_DECREF(iterator);s->busy=0;Py_RETURN_NONE; +fail:Py_XDECREF(result);Py_XDECREF(pair);Py_XDECREF(iterator);s->busy=0;return NULL; +} +static PyMethodDef cache_methods[]={{"event",(PyCFunction)cache_event,METH_O,"Fresh scalar context."},{"statistics",(PyCFunction)cache_statistics,METH_NOARGS,"Full counters."},{NULL,NULL,0,NULL}}; +static PyMethodDef event_methods[]={{"apply",(PyCFunction)event_apply,METH_VARARGS,"Same coefficient loop and Python numeric operations."},{NULL,NULL,0,NULL}}; +static PyTypeObject CacheType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Cache",.tp_basicsize=sizeof(Cache),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC, + .tp_new=cache_new,.tp_dealloc=(destructor)cache_dealloc,.tp_traverse=(traverseproc)cache_traverse,.tp_clear=(inquiry)cache_clear,.tp_methods=cache_methods}; +static PyTypeObject EventType={PyVarObject_HEAD_INIT(NULL,0) + .tp_name="_fraction_native.Event",.tp_basicsize=sizeof(Event),.tp_flags=Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_HAVE_VECTORCALL, + .tp_new=event_disabled,.tp_dealloc=(destructor)event_dealloc,.tp_traverse=(traverseproc)event_traverse,.tp_clear=(inquiry)event_clear, + .tp_call=PyVectorcall_Call,.tp_vectorcall_offset=offsetof(Event,vectorcall),.tp_methods=event_methods}; +static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_fraction_native","Bounded cache; exact Python arithmetic.",-1,capture_methods}; +PyMODINIT_FUNC PyInit__fraction_native(void){ + if(PyType_Ready(&CacheType)<0||PyType_Ready(&EventType)<0)return NULL; + PyObject *m=PyModule_Create(&module);if(!m)return NULL; + if(PyModule_AddObjectRef(m,"Cache",(PyObject *)&CacheType)<0){Py_DECREF(m);return NULL;} + return m; +} diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture.inc b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture.inc new file mode 100644 index 0000000000..69ea5fe99b --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture.inc @@ -0,0 +1,43 @@ +/* Diagnostic capture only: off by default; exact existing contribution keys. */ +#define ACTUAL_CAPTURE_CALLS ((Py_ssize_t)2579750) +static PyObject *capture_keys=NULL; +static int capture_active=0; + +static int capture_key(PyObject *key) { + if (!capture_active || !capture_keys) { + PyErr_SetString(PyExc_RuntimeError,"capture protocol inactive"); return -1; + } + if (PyList_GET_SIZE(capture_keys)>=ACTUAL_CAPTURE_CALLS) { + PyErr_SetString(PyExc_OverflowError,"actual capture exceeds fixed complete call count"); return -1; + } + return PyList_Append(capture_keys,key); +} +static PyObject *capture_begin(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + if (capture_active || capture_keys) { + PyErr_SetString(PyExc_RuntimeError,"one active actual capture only"); return NULL; + } + capture_keys=PyList_New(0); + if (!capture_keys) return NULL; + capture_active=1; Py_RETURN_NONE; +} +static PyObject *capture_take(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + if (!capture_active || !capture_keys || PyList_GET_SIZE(capture_keys)!=ACTUAL_CAPTURE_CALLS) { + PyErr_SetString(PyExc_RuntimeError,"complete active actual key capture required"); return NULL; + } + PyObject *answer=PyList_AsTuple(capture_keys); + if (!answer) return NULL; + capture_active=0; Py_CLEAR(capture_keys); + return answer; +} +static PyObject *capture_abort(PyObject *module, PyObject *unused) { + (void)module; (void)unused; + capture_active=0; Py_CLEAR(capture_keys); Py_RETURN_NONE; +} +static PyMethodDef capture_methods[]={ + {"_capture_begin",capture_begin,METH_NOARGS,"Begin one complete actual key capture."}, + {"_capture_take",capture_take,METH_NOARGS,"Take every captured original key, then clear."}, + {"_capture_abort",capture_abort,METH_NOARGS,"Idempotently clear capture on every path."}, + {NULL,NULL,0,NULL} +}; diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture_actual.py b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture_actual.py new file mode 100644 index 0000000000..2cb61c4997 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/capture_actual.py @@ -0,0 +1,114 @@ +"""Source-bound full qualifier and unsampled key capture; no alternate workload.""" +from hashlib import sha256 +import contextlib +import json +from pathlib import Path +import sys + +HERE=Path(__file__).resolve().parent +ROUND=HERE.parent.parent if HERE.parent.name=='stages' else HERE.parent +BASE=HERE/'baseline-public' +ORIGINAL=ROUND/'baseline-public' +FULL_SHA='ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0' +BASE_SHA='78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb' +CAPTURE_SHA='83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e' +CALLS=2579750 +STATS=dict(calls=CALLS,hits=2252966,misses=326784,evictions=310400,bypasses=0,resident=16384,capacity=16384) +OUTPUT='954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9' +EXPECTED=dict(all_actual_witness_rows_equal=True,coefficient_scale_bits=55,coordinates=799,events=25984, + finite_fixtures=dict(cases=120,controls=['nondyadic scalar','inexact scale division','nondyadic weight'],events=4240), + guards=dict(owned=22,prefix=26,public=23),source_controls=6, + source_result_sha256='cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98') + + +def need(ok,why): + if not ok:raise ValueError(why) + + +def verify_copy(): + receipt=json.loads((HERE/'SOURCE-EDITS.json').read_text()) + need(receipt['original_native_sha256']==BASE_SHA and receipt['diagnostic_native_sha256']==CAPTURE_SHA,'capture source identities') + need(receipt['changed_baseline_files']==['native_cache.c','NATIVE-SOURCE.json'],'only declared baseline changes') + inventories=[] + for directory in (ORIGINAL,BASE): + need(not any(p.is_symlink() for p in directory.rglob('*')),'no baseline symlinks') + inventories.append({str(p.relative_to(directory)) for p in directory.rglob('*') if p.is_file() and '__pycache__' not in p.parts}) + need(inventories[0]==inventories[1]==set(receipt['original_inventory']) and len(inventories[0])==164,'exact original and copied 164-file census') + for relative,pin in receipt['original_inventory'].items(): + original=ORIGINAL/relative;copied=BASE/relative + need(sha256(original.read_bytes()).hexdigest()==pin['sha256'] and original.stat().st_mode&0o777==pin['mode'],'original source bytes/mode: '+relative) + need(copied.stat().st_mode&0o777==pin['mode'],'copied mode: '+relative) + if relative not in ('native_cache.c','NATIVE-SOURCE.json'): + need(sha256(copied.read_bytes()).hexdigest()==pin['sha256'],'unchanged copied bytes: '+relative) + raw=(BASE/'native_cache.c').read_bytes() + need(sha256(raw).hexdigest()==CAPTURE_SHA,'capture C exact hash') + need(json.loads((BASE/'NATIVE-SOURCE.json').read_text())==dict(sha256=CAPTURE_SHA),'capture loader pin') + restored=raw.decode() + for edit in reversed(receipt['edits']): + need(restored.count(edit['after'])==1,'unique inverse capture seam') + restored=restored.replace(edit['after'],edit['before']) + need(sha256(restored.encode()).hexdigest()==BASE_SHA,'inverse restores complete original native C') + return dict(copied_files=164,original_native_sha256=BASE_SHA,capture_native_sha256=CAPTURE_SHA, + inverse_exact=True,other_bytes_and_all_modes_equal=True) + + +class Capture: + def __init__(self): + self.factories=0;self.calls=0;self.rows=None;self.native=None;self.word_digest=None + def factory(self,original_factory,native_backend,full_captures): + def create(reference,expected_word): + self.factories+=1;need(self.factories==1,'one source-bound actual factory') + original=original_factory(reference,expected_word) + self.word_digest=reference.digest(expected_word) + def call(word,weights,rounded): + if reference.digest(word)!=self.word_digest:return original(word,weights,rounded) + self.calls+=1;need(self.calls==1,'one complete actual invocation, no repeated capture') + native=native_backend.load();self.native=native + need(native_backend.receipt()['source_sha256']==CAPTURE_SHA,'capturing the source-pinned native build') + try: + native._capture_begin() + result=original(word,weights,rounded) + need(len(full_captures)==1 and full_captures[0]==dict(statistics=STATS,output_sha256=OUTPUT,tokens=3587),'original actual counters/digest and exact weight-token count') + self.rows=native._capture_take() + need(type(self.rows) is tuple and len(self.rows)==CALLS,'all actual keys taken exactly once') + return result + finally: + native._capture_abort() + return call + return create + + +def capture_qualified(destination): + before=verify_copy();capture=Capture();path=BASE/'full.py';raw=path.read_bytes() + need(sha256(raw).hexdigest()==FULL_SHA,'unchanged original full qualifier') + source=raw.decode();seam=" namespace=dict(entry.__dict__);namespace['_native_trace']=native_trace\n" + replacement=" namespace=dict(entry.__dict__);namespace['_native_trace']=_capture_factory(native_trace,native_backend,captures)\n" + need(source.count(seam)==1,'one authenticated full namespace seam') + changed=source.replace(seam,replacement) + namespace=dict(__name__='_actual_key_capture',__file__=str(path),_capture_factory=capture.factory) + sys.path.insert(0,str(BASE)) + try: + exec(compile(changed,str(path),'exec'),namespace) + log=destination/'FULL-QUALIFIER.stdout.txt' + with log.open('w') as stream,contextlib.redirect_stdout(stream):namespace['main'](True) + records=[json.loads(line) for line in log.read_text().splitlines() if line.startswith('{')] + qualified=[row for row in records if row.get('mode')=='qualify'] + native=[row for row in records if row.get('status')=='PASS_COMPLETE_NATIVE_COVERAGE'] + need(len(qualified)==1 and qualified[0]['receipt']==EXPECTED,'complete frozen qualification receipt and all actual witness rows') + need(len(native)==1 and native[0]['actual']==dict(statistics=STATS,output_sha256=OUTPUT,tokens=3587),'complete original native receipt') + need(native[0]['native_finite_included'] and native[0]['integer_oracle_unchanged'] and native[0]['compiler_children_charged'],'original qualifier coverage markers') + need(capture.factories==capture.calls==1 and capture.rows is not None,'one complete unsampled key capture') + need(verify_copy()==before,'baseline bytes/modes and inverse unchanged after qualifier') + rows=capture.rows;capture.rows=None + need(all(type(key) is tuple and len(key)==7 and all(type(x) is int for x in key) for key in rows),'every original key has exactly seven exact PyLong fields') + return rows,dict(status='PASS_COMPLETE_ACTUAL_KEY_CAPTURE',calls=len(rows),expected_word_digest=capture.word_digest, + original_actual=native[0]['actual'],qualification_receipt=qualified[0]['receipt'],native_build=native[0]['build'],source_copy=before, + full_original_sha256=FULL_SHA,full_in_memory_wrapper_sha256=sha256(changed.encode()).hexdigest(), + original_fraction_operations_and_all_full_witness_checks_retained=True,capture_phase_is_performance_sample=False) + except BaseException: + capture.rows=None + raise + finally: + if capture.native is not None:capture.native._capture_abort() + # Explicitly release this owned wrapper namespace; no GC-policy change. + namespace.clear() diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/keypilot.c b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/keypilot.c new file mode 100644 index 0000000000..772e101868 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/keypilot.c @@ -0,0 +1,230 @@ +/* Finite key-only comparator, not Cache/Event API replacement. + * Baseline provenance: native_cache.c contribution(), Chris R / Clear1nsight, + * substantial OpenAI Codex/Astra assistance. Apache-2.0. + * All keys are exact seven-PyLong tuples; no arbitrary callbacks or cyclic values. + */ +#define PY_SSIZE_T_CLEAN +#include +#include +#include + +#define WIDTH 7 +#define EMPTY ((Py_ssize_t)-1) +#define TOMB ((Py_ssize_t)-2) +#define MAX_ROWS 3000000 +#define PREFIX_EVERY 80 + +typedef struct { + PyObject *part[WIDTH], *value; + uint64_t hash; + Py_ssize_t slot; +} Entry; +typedef struct { + Entry *entry; + Py_ssize_t *table, size, capacity, used, head, tombs, rehashes; +} Custom; + +static int fault(Py_ssize_t at, int phase, Py_ssize_t wanted, int wanted_phase) { + if (at == wanted && phase == wanted_phase) { + PyErr_SetString(PyExc_MemoryError, "declared finite cleanup fault"); + return -1; + } + return 0; +} +static void entry_clear(Entry *e) { + for (int j=0;jpart[j]); + Py_CLEAR(e->value); +} +static void custom_clear(Custom *s) { + if (s->entry) { + for (Py_ssize_t j=0;jcapacity;j++) entry_clear(&s->entry[j]); + PyMem_Free(s->entry); + } + PyMem_Free(s->table); +} +static Py_ssize_t *new_table(Py_ssize_t size) { + Py_ssize_t *p=PyMem_Malloc((size_t)size * sizeof(*p)); + if (!p) { PyErr_NoMemory(); return NULL; } + for (Py_ssize_t j=0;j> 2); + h *= UINT64_C(0xbf58476d1ce4e5b9); + } + *answer=h; + return 0; +} +static int equal_parts(Entry *e, PyObject *const part[WIDTH]) { + for (int j=0;jpart[j], part[j], Py_EQ); + if (eq <= 0) return eq; + } + return 1; +} +/* Return 1 for found, 0 for absent, -1 for error; never treat a tomb as empty. */ +static int lookup(Custom *s, PyObject *const part[WIDTH], uint64_t hash, + Py_ssize_t *entry_index) { + Py_ssize_t slot=(Py_ssize_t)(hash & (uint64_t)(s->size-1)); + for (Py_ssize_t steps=0;stepssize;steps++) { + Py_ssize_t ix=s->table[slot]; + if (ix == EMPTY) return 0; + if (ix >= 0 && s->entry[ix].hash == hash) { + int eq=equal_parts(&s->entry[ix],part); + if (eq < 0) return -1; + if (eq) { *entry_index=ix; return 1; } + } + slot=(slot+1)&(s->size-1); + } + PyErr_SetString(PyExc_RuntimeError,"table unexpectedly has no empty slot"); + return -1; +} +static Py_ssize_t vacant_slot(Py_ssize_t *table, Py_ssize_t size, uint64_t hash) { + Py_ssize_t slot=(Py_ssize_t)(hash & (uint64_t)(size-1)); + for (Py_ssize_t steps=0;stepssize); + if (!next) return -1; + for (Py_ssize_t j=0;jcapacity;j++) if (s->entry[j].value) { + Py_ssize_t slot=vacant_slot(next,s->size,s->entry[j].hash); + if (slot < 0) { PyMem_Free(next); return -1; } + next[slot]=j; + } + /* Publish only after the new table is complete. */ + PyMem_Free(s->table); s->table=next; + for (Py_ssize_t j=0;jsize;j++) if (next[j]>=0) s->entry[next[j]].slot=j; + s->tombs=0; s->rehashes++; + return 0; +} +static int exact_int(PyObject *o, Py_ssize_t *v, const char *name) { + if (!PyLong_CheckExact(o)) { PyErr_Format(PyExc_TypeError,"exact int required: %s",name); return -1; } + *v=PyLong_AsSsize_t(o); + return PyErr_Occurred() ? -1 : 0; +} +static PyObject *run(PyObject *module, PyObject *args) { + (void)module; + PyObject *kind_o,*rows,*cap_o,*fail_o=NULL,*phase_o=NULL; + Py_ssize_t kind,cap,fail_at=-1,phase_n=0; + if (!PyArg_UnpackTuple(args,"run",3,5,&kind_o,&rows,&cap_o,&fail_o,&phase_o)) return NULL; + if (exact_int(kind_o,&kind,"kind")<0 || exact_int(cap_o,&cap,"capacity")<0) return NULL; + if (fail_o && exact_int(fail_o,&fail_at,"fail_at")<0) return NULL; + if (phase_o && exact_int(phase_o,&phase_n,"fail_phase")<0) return NULL; + if ((kind!=0 && kind!=1) || cap<1 || cap>16384 || fail_at < -1 || phase_n<0 || phase_n>6) { + PyErr_SetString(PyExc_ValueError,"kind 0/1, capacity 1..16384, fail_at >= -1, phase 0..6"); return NULL; + } + if (!PyTuple_CheckExact(rows)) { PyErr_SetString(PyExc_TypeError,"exact tuple of keys"); return NULL; } + Py_ssize_t n=PyTuple_GET_SIZE(rows); + if (n>MAX_ROWS || fail_at>=n) { PyErr_SetString(PyExc_ValueError,"bounded corpus/failure index"); return NULL; } + if ((fail_at==-1)!=(phase_n==0) || (kind==0 && phase_n==6)) { + PyErr_SetString(PyExc_ValueError,"consistent failure specification; rehash fault is custom only"); return NULL; + } + for (Py_ssize_t i=0;i=s.size*3/4 || (i==fail_at && phase_n==6))) { + /* Phase 6 simulates allocation failure before publishing a new table. */ + if (rehash(&s,i==fail_at && phase_n==6)<0) goto done; + } + if (used==cap) { + if (kind==0) { + if (PyDict_DelItem(dict,ring[head])<0) goto done; + Py_CLEAR(ring[head]); + } else { + Entry *old=&s.entry[head]; + s.table[old->slot]=TOMB; s.tombs++; + entry_clear(old); s.used--; + } + used--; evictions++; flag|=2; + } + if (fault(i,3,fail_at,(int)phase_n)<0) goto done; + if (kind==0) { + if (PyDict_SetItem(dict,key,result)<0) goto done; + ring[head]=key; key=NULL; + } else { + Py_ssize_t slot=vacant_slot(s.table,s.size,hash); if (slot<0) goto done; + Entry *e=&s.entry[head]; + for (int j=0;jpart[j]=Py_NewRef(part[j]); + e->value=Py_NewRef(result); e->hash=hash; e->slot=slot; + if (s.table[slot]==TOMB) s.tombs--; + s.table[slot]=head; s.used++; + } + head=(head+1)%cap; used++; + if (fault(i,4,fail_at,(int)phase_n)<0) goto done; + } + Py_CLEAR(key); + PyTuple_SET_ITEM(ids,i,result); result=NULL; + PyBytes_AS_STRING(flags)[i]=(char)flag; + if (fault(i,5,fail_at,(int)phase_n)<0) goto done; + if ((i+1)%PREFIX_EVERY==0 || i+1==n) { + PyObject *p=Py_BuildValue("(nnnnn)",i+1,hits,misses,evictions,used); + if (!p) goto done; + PyTuple_SET_ITEM(prefix,prefix_index++,p); + } + } + stats=Py_BuildValue("{s:n,s:n,s:n,s:n,s:n,s:n,s:n}","calls",n,"hits",hits,"misses",misses,"evictions",evictions,"resident",used,"capacity",cap,"rehashes",s.rehashes); + if (!stats) goto done; + answer=PyTuple_Pack(4,ids,flags,prefix,stats); +done: + Py_XDECREF(key); Py_XDECREF(result); Py_XDECREF(dict); + if (ring) { for (Py_ssize_t j=0;j dict: + manifest = json.loads((ROOT / "FROZEN-SOURCE.json").read_text()) + base = ROOT.parent.parent if ROOT.parent.name == "stages" else ROOT.parent + groups = ((ROOT, manifest["files_sha256"]), + (base, manifest["reference_files_sha256"])) + for directory, pins in groups: + for relative, expected in pins.items(): + path = directory / relative + if path.is_symlink() or not path.is_file(): + raise RuntimeError(f"source is absent or symlink: {relative}") + actual = hashlib.sha256(path.read_bytes()).hexdigest() + if actual != expected: + raise RuntimeError(f"source pin mismatch: {relative}") + return manifest + + +def compile_and_load(destination: Path): + manifest = verify_sources() + build = destination / "build" + build.mkdir() # Existing directory is an error; never reuse a built answer. + source = ROOT / "keypilot.c" + copied = build / "keypilot.c" + copied.write_bytes(source.read_bytes()) + copied_sha256 = hashlib.sha256(copied.read_bytes()).hexdigest() + if copied_sha256 != manifest["files_sha256"]["keypilot.c"]: + raise RuntimeError("compiler snapshot differs from the declared C source pin") + suffix = sysconfig.get_config_var("EXT_SUFFIX") + if not isinstance(suffix, str) or not suffix: + raise RuntimeError("missing extension suffix") + extension = build / ("_keypilot" + suffix) + compiler = shlex.split(sysconfig.get_config_var("CC") or "cc") + command = compiler + ["-O3", "-std=c11", "-fPIC", "-shared", "-Wall", "-Wextra", "-Werror"] + for directory in sorted({sysconfig.get_path("include"), sysconfig.get_path("platinclude")}): + if directory: + command.extend(["-I", directory]) + command.extend([str(copied), "-o", str(extension)]) + receipt = {"command": command, "cwd": str(ROOT), "python": sys.version, + "executable": sys.executable, "platform": sys.platform, + "source_sha256": copied_sha256, + "source_manifest": manifest} + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + completed = subprocess.run(command, cwd=ROOT, capture_output=True, text=True, + check=False, timeout=60) + (build / "stdout.txt").write_text(completed.stdout) + (build / "stderr.txt").write_text(completed.stderr) + receipt["returncode"] = completed.returncode + receipt["stdout_bytes"] = len(completed.stdout.encode()) + receipt["stderr_bytes"] = len(completed.stderr.encode()) + if completed.returncode or completed.stdout or completed.stderr: + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + raise RuntimeError("single compiler attempt failed or emitted output; see retained BUILD.json and compiler logs") + if hashlib.sha256(copied.read_bytes()).hexdigest() != copied_sha256: + raise RuntimeError("compiler snapshot changed during the single build") + receipt["extension_sha256"] = hashlib.sha256(extension.read_bytes()).hexdigest() + (build / "BUILD.json").write_text(json.dumps(receipt, indent=2) + "\n") + verify_sources() + spec = importlib.util.spec_from_file_location("_keypilot", extension) + if spec is None or spec.loader is None: + raise RuntimeError("extension has no loader") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module, receipt diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/prepare_source.py b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/prepare_source.py new file mode 100644 index 0000000000..ba450d5a74 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/prepare_source.py @@ -0,0 +1,50 @@ +"""Source/file/hash preparation only; no compiler, imported science or workload.""" +from pathlib import Path +from hashlib import sha256 +import json +import shutil + +HERE=Path(__file__).resolve().parent +ROUND=HERE.parent +ORIGINAL=ROUND/'baseline-public' +COPY=HERE/'baseline-public' +BASE_SHA='78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb' +raw=(ORIGINAL/'native_cache.c').read_bytes() +if sha256(raw).hexdigest()!=BASE_SHA:raise ValueError('original native source pin') +source=raw.decode() +header='#define PY_SSIZE_T_CLEAN\n#include \n#include \n' +key_end=' PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i)));\n' +module='static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_fraction_native","Bounded cache; exact Python arithmetic.",-1,NULL};' +edits=[dict(label='capture-state-and-separate-methods',before=header,after=header+'\n'+(HERE/'capture.inc').read_text()), + dict(label='retain-original-key-before-original-lookup',before=key_end,after=key_end+' if(capture_active && capture_key(key)<0){Py_DECREF(key);return NULL;}\n'), + dict(label='expose-separate-capture-methods',before=module,after=module.replace(',-1,NULL};',',-1,capture_methods};'))] +changed=source +for edit in edits: + if changed.count(edit['before'])!=1:raise ValueError('one exact capture seam: '+edit['label']) + changed=changed.replace(edit['before'],edit['after']) +restored=changed +for edit in reversed(edits): + if restored.count(edit['after'])!=1:raise ValueError('one inverse capture seam') + restored=restored.replace(edit['after'],edit['before']) +if restored.encode()!=raw:raise ValueError('capture patch inverses to original bytes') +if COPY.exists():raise ValueError('fresh baseline copy only') +original_inventory={} +for path in sorted(ORIGINAL.rglob('*')): + if path.is_symlink():raise ValueError('no original symlinks') + if not path.is_file():continue + if '__pycache__' in path.parts:continue + relative=str(path.relative_to(ORIGINAL));target=COPY/relative + target.parent.mkdir(parents=True,exist_ok=True);shutil.copy2(path,target) + original_inventory[relative]={'sha256':sha256(path.read_bytes()).hexdigest(),'mode':path.stat().st_mode&0o777} + if target.read_bytes()!=path.read_bytes() or target.stat().st_mode&0o777!=original_inventory[relative]['mode']:raise ValueError('exact initial copy') +if len(original_inventory)!=164:raise ValueError('expected original 164-file census') +new_sha=sha256(changed.encode()).hexdigest() +for name,data in [('native_cache.c',changed.encode()),('NATIVE-SOURCE.json',(json.dumps({'sha256':new_sha},indent=2)+'\n').encode())]: + path=COPY/name;mode=original_inventory[name]['mode'];path.chmod(mode|0o200);path.write_bytes(data);path.chmod(mode) +receipt={'status':'SOURCE_ONLY_CAPTURE_PREPARED','original_native_sha256':BASE_SHA,'diagnostic_native_sha256':new_sha,'changed_baseline_files':['native_cache.c','NATIVE-SOURCE.json'],'baseline_file_count':164,'original_inventory':original_inventory,'edits':edits,'exact_original_complete_c_source_restored':True,'compilation':False,'numerical_execution':False} +(HERE/'SOURCE-EDITS.json').write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') +for name,pin in {'keypilot.c':'ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6','load_pilot.py':'d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968','run_pilot.py':'e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e'}.items(): + original=ROUND/'cache-key-pilot'/name + if sha256(original.read_bytes()).hexdigest()!=pin:raise ValueError('approved comparator/helper pin') + shutil.copy2(original,HERE/name) +print(json.dumps({'copied_baseline_files':164,'diagnostic_native_sha256':new_sha,'original_native_sha256':BASE_SHA,'source_only':True})) diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/run_pilot.py b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/run_pilot.py new file mode 100644 index 0000000000..b8c416b6b2 --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/run_pilot.py @@ -0,0 +1,383 @@ +"""One frozen finite pilot. No warmups, searches, automatic retries or science imports.""" +from __future__ import annotations +import time +_COLD_WALL_START = time.perf_counter() +import resource + +def process_and_child_cpu(): + own = resource.getrusage(resource.RUSAGE_SELF) + child = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + child.ru_utime + child.ru_stime + +_COLD_CPU_START = process_and_child_cpu() +import argparse +from array import array +from collections import deque +import hashlib +import json +from pathlib import Path +import struct +import sys +import traceback +from load_pilot import ROOT, compile_and_load, verify_sources + +EVENTS = 32768 +LOOKUPS_PER_EVENT = 80 +KEYS_PER_EVENT = 10 +REPETITIONS = 8 +CALLS = EVENTS * LOOKUPS_PER_EVENT +CAPACITY = 16384 +ACTUAL_CALLS = 2579750 +ORDER = (("B1", 0), ("C1", 1), ("C2", 1), ("B2", 0)) +BASELINE = {"wall": 34.66178539200337, "cpu": 34.47} +INTEGER_GROSS = {"wall": 4.684712576272432, "cpu": 4.683428714999984} +RESERVE = {"wall": 0.5, "cpu": 0.5} + + +def write_json(path, data): + path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n") + + +def literal_oracle(rows, capacity): + """Independent ordinary dict + deque, no C/custom hash or shared lookup code.""" + cache = {} + fifo = deque() + ids = [] + flags = bytearray() + prefixes = [] + hits = misses = evictions = 0 + for i, key in enumerate(rows, 1): + value = cache.get(key) + flag = 0 + if value is not None: + hits += 1 + else: + misses += 1 + value = misses + flag = 1 + if len(fifo) == capacity: + del cache[fifo.popleft()] + evictions += 1 + flag |= 2 + cache[key] = value + fifo.append(key) + ids.append(value) + flags.append(flag) + if i % LOOKUPS_PER_EVENT == 0 or i == len(rows): + prefixes.append((i, hits, misses, evictions, len(cache))) + stats = dict(calls=len(rows), hits=hits, misses=misses, evictions=evictions, + resident=len(cache), capacity=capacity) + return tuple(ids), bytes(flags), tuple(prefixes), stats + + +def assert_equal(actual, expected, mode): + if type(actual) is not tuple or len(actual) != 4: + raise AssertionError("malformed output packet") + # Full sequence comparisons; hashes never substitute for equality. + for index, name in ((0, "ordered IDs"), (1, "ordered hit/miss/eviction flags"), + (2, "all 80-operation prefixes")): + if actual[index] != expected[index]: + raise AssertionError(f"mismatched {name}") + actual_stats = dict(actual[3]) + rehashes = actual_stats.pop("rehashes", None) + if type(rehashes) is not int or rehashes < 0 or actual_stats != expected[3]: + raise AssertionError("mismatched counters or rehash metadata") + if mode == 0 and rehashes != 0: + raise AssertionError("baseline must report zero custom rehashes") + + +def retain_full(destination, name, result): + ids = array("Q", result[0]) + if ids.itemsize != 8: + raise RuntimeError("Q output format is not 64 bits on this interpreter") + id_path = destination / (name + "-ids.u64") + with id_path.open("wb") as stream: + ids.tofile(stream) + flag_path = destination / (name + "-flags.u8") + flag_path.write_bytes(result[1]) + prefix_path = destination / (name + "-prefixes.json") + write_json(prefix_path, result[2]) + return {"ids": id_path.name, "flags": flag_path.name, + "prefixes": prefix_path.name, "id_byteorder": sys.byteorder, + "id_itemsize": ids.itemsize, "calls": len(result[0]), + "stats": result[3], + "ids_sha256": hashlib.sha256(ids.tobytes()).hexdigest(), + "flags_sha256": hashlib.sha256(result[1]).hexdigest()} + + +def clone_key(key): + # int(existing_int) may preserve object identity; decimal construction avoids + # that for non-interned values. Small immortal/cached ints may still be shared. + return tuple(int(str(field)) for field in key) + + +def finite_key(i): + return (i * 2 + 10001, 2, -3, 4, -i * 2 - 10001, 8, i % 3587) + + +def tracked_objects(rows): + unique = {id(rows): rows} + for row in rows: + unique[id(row)] = row + for field in row: + # Small cached integers can acquire legitimate references from the + # retained counter/ID receipts, so they cannot diagnose key leaks. + if not -5 <= field <= 256: + unique[id(field)] = field + return list(unique.values()) + + +def refs(objects): + return tuple(sys.getrefcount(obj) for obj in objects) + + +def finite_controls(module): + receipts = [] + p = sys.hash_info.modulus + collision_keys = tuple((p*i, -p*i, p*(i+1), 1, 0, 1, p*(i+2)) for i in range(1, 21)) + if len({hash(key) for key in collision_keys}) != 1: + raise AssertionError("declared exact-PyLong and tuple hash collision construction failed") + a = finite_key(1) + a_equal = clone_key(a) + if a_equal != a or a_equal[0] is a[0]: + raise AssertionError("distinct numerically equal key control failed") + big = (1 << 8191) + 73 + broad = ((0, 0, 0, 0, 0, 0, 0), + (-1, 1, -2, 2, -3, 3, -4), + (big, -big, big-1, 1, -big+1, 2, 3586)) + cases = [ + ("empty", (), 1), + ("numeric-equality-and-no-FIFO-refresh", (a, finite_key(2), a_equal, + finite_key(3), a_equal, finite_key(2)), 2), + ("signed-zero-8192-bit", broad + tuple(clone_key(k) for k in broad), 3), + ("full-hash-and-table-collisions", collision_keys + collision_keys[5:] + + tuple(clone_key(k) for k in collision_keys), 16), + ("capacity-one", tuple(finite_key(i) for i in range(40)), 1), + ("tombstone-rehash-turnover", tuple(finite_key(i) for i in range(512)) + + tuple(finite_key(i) for i in range(480, 512)), 16), + ("full-capacity-turnover", tuple(finite_key(i) for i in range(16416)) + + tuple(finite_key(i) for i in range(16390, 16416)), 16384), + ] + natural_rehashes = 0 + for name, rows, cap in cases: + expected = literal_oracle(rows, cap) + tracked = tracked_objects(rows) + before = refs(tracked) + for mode in (0, 1): + actual = module.run(mode, rows, cap) + assert_equal(actual, expected, mode) + if mode == 1: + natural_rehashes += actual[3]["rehashes"] + receipts.append({"control": name, "mode": mode, "stats": actual[3], + "ordered_ids": actual[0], "ordered_flags": list(actual[1]), + "prefixes": actual[2], "full_equality": True}) + del actual + if refs(tracked) != before: + raise AssertionError(f"reference leak on success: {name}/{mode}") + if natural_rehashes < 1: + raise AssertionError("finite controls never exercised natural rehash") + + class IntSubclass(int): + def __hash__(self): + raise AssertionError("subclass hash must never run") + def __eq__(self, other): + raise AssertionError("subclass comparison must never run") + class TupleSubclass(tuple): + pass + bad_calls = [ + (False, (a,), 2), (2, (a,), 2), (0, (a,), True), + (0, (a,), IntSubclass(2)), (0, (a,), 0), (0, (a,), -1), + (0, (a,), 16385), (0, (a,), 1 << 100), + (0, [a], 2), (0, TupleSubclass((a,)), 2), + (0, (a[:-1],), 2), (0, (a + (1,),), 2), + (0, (list(a),), 2), (0, (TupleSubclass(a),), 2), + (0, ((True,) + a[1:],), 2), + (0, ((IntSubclass(a[0]),) + a[1:],), 2), + (0, ((object(),) + a[1:],), 2), (0, ((1.5,) + a[1:],), 2), + (0, (("1",) + a[1:],), 2), (0, ((None,) + a[1:],), 2), + (0, (a,), 2, True, 1), (0, (a,), 2, 0, True), + (0, (a,), 2, -2, 1), (0, (a,), 2, 0, 7), + (0, (a,), 2, -1, 1), (0, (a,), 2, 0, 0), + (0, (a,), 2, 1, 1), (0, (a,), 2, 0, 6), + ] + for index, args in enumerate(bad_calls): + # Type/capacity/row rejection is shared prevalidation, but check both arms + # whenever the explicit test does not itself target the mode selector. + modes = (None,) if index < 2 else (0, 1) + for mode in modes: + packet = args if mode is None else (mode,) + args[1:] + if index == len(bad_calls)-1 and mode == 1: + continue # phase 6 is a supported custom-only cleanup hook. + try: + module.run(*packet) + except (TypeError, ValueError, OverflowError): + receipts.append({"rejection": index, "mode": mode, "rejected": True}) + else: + raise AssertionError(f"malformed packet accepted: {index}/{mode}") + fault_rows = tuple(finite_key(i) for i in range(8)) + tracked = tracked_objects(fault_rows) + before = refs(tracked) + for mode in (0, 1): + for phase in range(1, 7 if mode else 6): + try: + module.run(mode, fault_rows, 2, 4, phase) + except MemoryError: + pass + else: + raise AssertionError(f"declared fault did not fire: {mode}/{phase}") + if refs(tracked) != before: + raise AssertionError(f"reference leak after failure: {mode}/{phase}") + receipts.append({"cleanup_fault_mode": mode, "phase": phase, + "raised_MemoryError": True, "reference_counts_equal": True}) + hit_rows = (a, a_equal, a, a_equal) + tracked = tracked_objects(hit_rows) + before = refs(tracked) + for mode in (0, 1): + for phase in (1, 5): + try: + module.run(mode, hit_rows, 2, 2, phase) + except MemoryError: + pass + else: + raise AssertionError(f"declared hit fault did not fire: {mode}/{phase}") + if refs(tracked) != before: + raise AssertionError(f"reference leak after hit failure: {mode}/{phase}") + receipts.append({"cleanup_hit_fault_mode": mode, "phase": phase, + "raised_MemoryError": True, "reference_counts_equal": True}) + return {"status": "PASS_FINITE_KEY_ONLY", "receipts": receipts, + "natural_rehashes": natural_rehashes, + "allocator_failures_exhaustive": False} + + +def timed_corpus(): + rows = [] + qs = ((-3, 1), (-1, 2), (0, 1), (1, 1), (3, 2), (1, 4), (5, 8)) + for event in range(EVENTS): + qn, qd = qs[event % len(qs)] + first = [] + second = [] + for offset in range(KEYS_PER_EVENT): + serial = event * KEYS_PER_EVENT + offset + old_num = (serial * 2 + 1) * (-1 if serial % 2 else 1) + old_den = 1 << (serial % 13) + v_num = 0 if serial % 19 == 0 else (2*(serial % 511)+1) * (-1 if serial % 3 == 0 else 1) + v_den = 1 if v_num == 0 else 1 << ((serial // 13) % 9) + key = (old_num, old_den, qn, qd, v_num, v_den, serial % 3587) + first.append(key) + second.append(clone_key(key)) + for repeat in range(REPETITIONS): + rows.extend(first if repeat % 2 == 0 else second) + if len(rows) != CALLS: + raise AssertionError("frozen work-unit count mismatch") + return tuple(rows) + + +def optimistic_screen(samples): + indexed = {sample["name"]: sample for sample in samples} + result = {"interpretation": "ILLUSTRATIVE_OPTIMISTIC_SCREEN_ONLY", + "measured_complete_saving": False, "construction_admitted": False, + "integer_residual_assumed_seconds": 0, + "new_bill_reserve_measured": False, "actual_calls_for_illustration": ACTUAL_CALLS, + "real_integer_residual": "UNPRICED_NONZERO", + "complete_new_validation_build_bill": "UNPRICED_NONZERO", + "diagnostic_integer_regions_include_clock_overhead": True} + gates = [] + for metric in ("wall", "cpu"): + deltas = [indexed["B1"][metric] - indexed["C1"][metric], + indexed["B2"][metric] - indexed["C2"][metric]] + smaller = min(deltas) + per_call = smaller / CALLS + illustrative = per_call * ACTUAL_CALLS + optimistic = INTEGER_GROSS[metric] + illustrative - RESERVE[metric] + threshold = BASELINE[metric] * 0.15 + gate = optimistic >= threshold + gates.append(gate) + result[metric] = {"paired_gross_seconds": deltas, + "smaller_paired_gross_seconds": smaller, + "synthetic_gross_seconds_per_call": per_call, + "illustrative_key_saving_at_actual_calls": illustrative, + "diagnostic_integer_gross_region": INTEGER_GROSS[metric], + "provisional_new_bill_reserve": RESERVE[metric], + "optimistic_budget_seconds": optimistic, + "necessary_15pct_threshold_seconds": threshold, + "necessary_threshold_met": gate} + result["status"] = ("HEADROOM_FOR_SOURCE_SPECIFIC_COST_DESIGN_ONLY" if all(gates) + else "REJECT_THIS_OPTIMISTIC_NOMINATION") + return result + + +def main(destination): + if destination.exists(): + raise RuntimeError("fresh output directory required; no answer/build reuse") + destination.mkdir(parents=True) + report = {"status": "STARTED", "scope": "finite synthetic key-only comparator", + "source_only_preparation_precedes_parent_run": True, + "performance_publication": False, "construction_admitted": False, + "frozen_order": [name for name, _ in ORDER], "calls_per_sample": CALLS, + "events": EVENTS, "lookups_per_event": LOOKUPS_PER_EVENT, + "capacity": CAPACITY, "samples": [], "automatic_retries": 0} + write_json(destination / "RESULT.json", report) + try: + report["source_manifest"] = verify_sources() + module, report["build"] = compile_and_load(destination) + controls = finite_controls(module) + write_json(destination / "FINITE-CONTROLS.json", controls) + report["finite_controls"] = controls["status"] + rows = timed_corpus() + corpus_hash = hashlib.sha256() + for row in rows: + corpus_hash.update(struct.pack("<7q", *row)) + report["corpus_sha256_little_endian_i64_fields"] = corpus_hash.hexdigest() + expected = literal_oracle(rows, CAPACITY) + expected_counts = dict(calls=CALLS, hits=EVENTS*KEYS_PER_EVENT*7, + misses=EVENTS*KEYS_PER_EVENT, + evictions=EVENTS*KEYS_PER_EVENT-CAPACITY, + resident=CAPACITY, capacity=CAPACITY) + if expected[3] != expected_counts: + raise AssertionError("synthetic trace does not have its frozen hit/miss/FIFO counts") + report["oracle_output"] = retain_full(destination, "oracle", expected) + write_json(destination / "RESULT.json", report) + for name, mode in ORDER: + wall_start = time.perf_counter_ns() + cpu_start = time.process_time_ns() + actual = module.run(mode, rows, CAPACITY) + cpu_elapsed = time.process_time_ns() - cpu_start + wall_elapsed = time.perf_counter_ns() - wall_start + sample = {"name": name, "mode": mode, "calls": CALLS, + "wall": wall_elapsed/1e9, "cpu": cpu_elapsed/1e9} + report["samples"].append(sample) + # Retain a failed output as well; no failing sample is discarded. + sample["output"] = retain_full(destination, name, actual) + write_json(destination / "RESULT.json", report) + assert_equal(actual, expected, mode) + if mode == 1 and actual[3]["rehashes"] < 1: + raise AssertionError("timed candidate never exercised natural rehash") + sample["full_output_equality"] = True + del actual + write_json(destination / "RESULT.json", report) + verify_sources() + report["optimistic_screen"] = optimistic_screen(report["samples"]) + report["status"] = "PASS_FINITE_KEY_COMPARISON_ONLY" + except BaseException as exc: + report["status"] = "FAIL_RETAINED_NO_RETRY" + report["failure"] = {"type": type(exc).__name__, "message": str(exc)} + (destination / "traceback.txt").write_text(traceback.format_exc()) + raise + finally: + # Parent's guard receipt remains authoritative for process startup, exit, + # this final write, group RSS and whole-command compiler-child CPU. + report["child_cold_through_final_receipt_boundary"] = { + "wall": time.perf_counter() - _COLD_WALL_START, + "cpu_including_compiler_children": process_and_child_cpu() - _COLD_CPU_START, + "excludes_process_startup_exit_and_this_final_write": True} + report["parent_outer_guard_receipt_required"] = True + write_json(destination / "RESULT.json", report) + print(json.dumps({"status": report["status"], "screen": report["optimistic_screen"]["status"], + "result": str(destination / "RESULT.json")})) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + arguments = parser.parse_args() + main(arguments.output.resolve()) diff --git a/research/verification-key-headroom/context/stages/actual-key-pilot-v1/stage_entry.py b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/stage_entry.py new file mode 100644 index 0000000000..633023acce --- /dev/null +++ b/research/verification-key-headroom/context/stages/actual-key-pilot-v1/stage_entry.py @@ -0,0 +1,7 @@ +"""Parent-frozen guarded entry; source-preparation copies cannot execute.""" +from pathlib import Path +from actual_driver import main +stage=Path(__file__).resolve().parent +if stage.parent.name!='stages' or stage.name!='actual-key-pilot-v1': + raise RuntimeError('requires immutable stages/actual-key-pilot-v1 copy') +main(stage.parent.parent/'runtime/actual-key-pilot-v1-artifacts') diff --git a/research/verification-key-headroom/data/DATA.json b/research/verification-key-headroom/data/DATA.json new file mode 100644 index 0000000000..ba0924f46f --- /dev/null +++ b/research/verification-key-headroom/data/DATA.json @@ -0,0 +1,117 @@ +{ + "actual_corpus": { + "complete_streaming_value_readback": true, + "compressed_bytes": 7945691, + "file": "actual-keys-v1.pickle.gz", + "format": { + "block_keys": 4096, + "calls": 2579750, + "cross_block_identity_preserved": false, + "format": "actual-keys-v1", + "key_fields": 7, + "order": "original contribution order", + "pickle_protocol": 5, + "values": "exact signed Python integers" + }, + "replay_uses_original_captured_objects": true, + "sha256": "660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699" + }, + "capture": { + "calls": 2579750, + "capture_phase_is_performance_sample": false, + "expected_word_digest": "a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c", + "full_in_memory_wrapper_sha256": "656a30e959c282c1bfb30e6ae2106fabb0376180247dcc14084afcd1c6eeac40", + "full_original_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "native_build": { + "SOABI": "cpython-312-x86_64-linux-gnu", + "binary_sha256": "968e2768ba782dff148206adbe938b6c3cf3183e0ad8376f4389821f6b5e174c", + "cold_build_load_wall_seconds": 0.3853255169815384, + "compiler": "/usr/bin/cc", + "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", + "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", + "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", + "flags": [ + "-O2", + "-shared", + "-fPIC", + "-std=c11", + "-Wall", + "-Werror", + "-I/usr/include/python3.12" + ], + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "source_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" + }, + "original_actual": { + "output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "tokens": 3587 + }, + "original_fraction_operations_and_all_full_witness_checks_retained": true, + "qualification_receipt": { + "all_actual_witness_rows_equal": true, + "coefficient_scale_bits": 55, + "coordinates": 799, + "events": 25984, + "finite_fixtures": { + "cases": 120, + "controls": [ + "nondyadic scalar", + "inexact scale division", + "nondyadic weight" + ], + "events": 4240 + }, + "guards": { + "owned": 22, + "prefix": 26, + "public": 23 + }, + "source_controls": 6, + "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98" + }, + "source_copy": { + "capture_native_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "copied_files": 164, + "inverse_exact": true, + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "other_bytes_and_all_modes_equal": true + }, + "status": "PASS_COMPLETE_ACTUAL_KEY_CAPTURE" + }, + "canonical_outputs": { + "ids": { + "file": "canonical-ids.u64.gz", + "uncompressed_bytes": 20638000, + "uncompressed_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "transport_sha256": "51753090e6ae4b02651590963341dc30e2424a00b49adb88ba65b05e03901fc5", + "compressed_bytes": 2980010 + }, + "flags": { + "file": "canonical-flags.u8.gz", + "uncompressed_bytes": 2579750, + "uncompressed_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "transport_sha256": "8acb6dd4d577dcb964ee1ef027eab9f0c91b811ad445bd93f8e1804a8d447001", + "compressed_bytes": 142123 + }, + "prefixes": { + "file": "canonical-prefixes.json.gz", + "uncompressed_bytes": 2141131, + "uncompressed_sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74", + "transport_sha256": "0960e36d7c43f9b37dc1550778ff60a55de02d7ab8a83c1f4c7cdd691ffec3b8", + "compressed_bytes": 315973 + } + }, + "all_samples_value_equal": true, + "all_original_samples_retained_locally": true, + "comparison_scope": "ordered opaqueIDs/hit-miss-evictionflags/all80-step/finalprefixes, not Fraction/API integration", + "decompressed_payload_is_authoritative": true +} diff --git a/research/verification-key-headroom/data/actual-keys-v1.pickle.gz b/research/verification-key-headroom/data/actual-keys-v1.pickle.gz new file mode 100644 index 0000000000..31af3a69fa Binary files /dev/null and b/research/verification-key-headroom/data/actual-keys-v1.pickle.gz differ diff --git a/research/verification-key-headroom/data/canonical-flags.u8.gz b/research/verification-key-headroom/data/canonical-flags.u8.gz new file mode 100644 index 0000000000..f85b666764 Binary files /dev/null and b/research/verification-key-headroom/data/canonical-flags.u8.gz differ diff --git a/research/verification-key-headroom/data/canonical-ids.u64.gz b/research/verification-key-headroom/data/canonical-ids.u64.gz new file mode 100644 index 0000000000..ded74d9970 Binary files /dev/null and b/research/verification-key-headroom/data/canonical-ids.u64.gz differ diff --git a/research/verification-key-headroom/data/canonical-prefixes.json.gz b/research/verification-key-headroom/data/canonical-prefixes.json.gz new file mode 100644 index 0000000000..da04301c10 Binary files /dev/null and b/research/verification-key-headroom/data/canonical-prefixes.json.gz differ diff --git a/research/verification-key-headroom/evidence/ACTUAL-KEY-PARENT-SOURCE-CHECK.json b/research/verification-key-headroom/evidence/ACTUAL-KEY-PARENT-SOURCE-CHECK.json new file mode 100644 index 0000000000..fb98bb9d8c --- /dev/null +++ b/research/verification-key-headroom/evidence/ACTUAL-KEY-PARENT-SOURCE-CHECK.json @@ -0,0 +1,16 @@ +{ + "status": "PASS_PARENT_SOURCE_ONLY_ACTUAL_CAPTURE_CHECK", + "manifest_sha256": "04ee8ee199bfddc692232ac97adf457d41c33f22d66c0caddd0afced26b3656a", + "all_source_reference_pins": true, + "python_AST_parse": true, + "copied_baseline_files": 164, + "changed_only": [ + "NATIVE-SOURCE.json", + "native_cache.c" + ], + "exact_original_C_reversal": true, + "comparator_helpers_byte_identical": true, + "compiler_or_scientific_execution": false, + "resource_fit": "unproven; one guardedattemptifsourceclear", + "independent_review": "pendingfinalhashclearance" +} diff --git a/research/verification-key-headroom/evidence/ACTUAL-KEY-PILOT-REVIEW.md b/research/verification-key-headroom/evidence/ACTUAL-KEY-PILOT-REVIEW.md new file mode 100644 index 0000000000..850a540f42 --- /dev/null +++ b/research/verification-key-headroom/evidence/ACTUAL-KEY-PILOT-REVIEW.md @@ -0,0 +1,276 @@ +# Actual-key capture and replay: independent source review + +Date: 2026-10-28. Status: SOURCE-ONLY CLEARANCE FOR ONE RESOURCE-MONITORED +ATTEMPT; MEMORY FIT AND RUNTIME COMPLETION ARE NOT ESTABLISHED. No source blocker +was found at the final pins below. This reviewer read source, compared bytes, +reversed declared text edits and recorded hashes only. No compiler, scientific +import, corpus construction, benchmark, browser/network/Git action or agent +execution was performed. Only this new report was written; earlier reviews and +all worker/source files remain unchanged. + +This is a distinct information gate for the exact actual key sequence. The failed +synthetic nomination remains failed. No private integer owner, GMP dependency, +new key algorithm, GC optimization, full-cache integration or complete speedup +is admitted. The further 15% complete PR5864 wall AND CPU target remains unmet. + +## Capture source and object ownership + +The copied native_cache.c has three declared edits: separate capture state and +methods, one hook after the original seven-item key is fully constructed, and +exposure of the three capture methods. The hook retains that existing tuple; +it does not reconstruct, normalize, serialize or deduplicate its fields. All +original numeric operations, Fraction callback, F(0), score ordering, iteration, +row updates, FIFO operations and Cache.statistics remain in place. + +An independent directory byte comparison found only native_cache.c and +NATIVE-SOURCE.json different from the original baseline tree. Independent +text-only reversal of SOURCE-EDITS.json produced original complete C SHA-256 +78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb. +The runtime source check additionally requires the exact 164-file census, all +original/copy modes, all unchanged bytes, the capture C hash and its loader pin. + +capture.inc owns a list reference while capture is active. Appending acquires a +reference to the original tuple; normal contribution cleanup retains its original +behavior. All tuple fields are the already-qualified exact PyLong objects, so +extending their lifetimes introduces no foreign finalizer/cyclic-value domain. +The fixed 2,579,750-call ceiling rejects an extra key before appending it. + +Take requires exactly that count, converts only the outer list to a tuple, then +clears capture state and the list owner. It preserves every key and field object +identity. If conversion fails, the list remains owned until the finally-path +abort. Abort is idempotent and clears active state before releasing the list. +Allocation failure, incomplete capture or duplicate capture cannot become a +successful partial dataset. Retained-field lifetime and altered allocation/GC +costs remain real diagnostic costs; they are not performance improvements. + +## Exact invocation, restoration and complete qualification + +capture_actual.py binds the unchanged full.py hash and replaces one unique +namespace seam in memory. The wrapper is installed only around the original +actual native_trace factory. It requires one factory and one invocation whose +word digest equals the source-bound expected-word digest; other words call the +original function with capture inactive. + +Capture begins inside a try/finally. The unchanged original trace must complete +and satisfy its original actual receipt before keys can be taken: 2,579,750 +calls, 2,252,966 hits, 326,784 misses, 310,400 evictions, zero bypasses, 16,384 +residents/capacity, 3,587 tokens and the original actual output digest. The inner +finally aborts on every return/error path, including failed begin/take. The outer +finally aborts again if a native module was obtained, and clears only its owned +wrapper namespace. A failed later qualification drops the captured corpus. + +The entire original full qualifier still runs, including inherited finite/source/ +ownership controls, independent integer/Fraction work, Observation and signed +witness comparisons. Its stdout is retained. The driver requires the complete +qualification receipt with 120 finite fixtures, 25,984 events, 799 coordinates, +all actual witness rows equal and the original source-result digest, plus the +original native coverage receipt. It checks every captured key is an exact +seven-tuple of exact integers and revalidates source bytes/modes afterward. + +The parent explicitly authorized one gc.collect after all original qualification +checks and wrapper release. It is charged to the outer command, keeps captured +keys alive, and changes no collector policy parameters. This cleanup does not +reopen the closed standalone GC optimization route. No collector policy is +changed during the original qualifier or replay. + +## Complete corpus retention and unchanged replay + +actual_driver.py writes a versioned gzip/pickle-protocol-5 stream containing all +keys in original order. Blocks contain at most 4,096 keys; pickler and unpickler +memos are cleared at block boundaries. Streaming readback compares every block's +values/order against the captured tuple and rejects trailing objects. File +hashing is streamed. Arbitrary-width signed PyLong values are preserved without +fixed-width packing. The archive expressly does not promise cross-block object +identity; timed replay uses the original live captured objects, not readback +replacements. There is no second materialized full corpus or sampling fallback. + +The approved keypilot.c, load_pilot.py and run_pilot.py hashes are unchanged. +The historical synthetic generator/entrypoint remains in that helper module but +is never invoked by this driver. Only its approved finite suite, literal Python +dict/deque oracle, full-output writer and comparison helper are reused. + +The oracle must reproduce the actual source calls/hits/misses/evictions/residency +and capacity exactly. B1,C1,C2,B2 each use every captured key and fresh private +state. Every opaque miss ID, hit/miss/eviction flag, 80-operation/final-partial +prefix and core statistic must equal the oracle. Baseline rehash metadata must +be zero; each custom replay must exercise natural rehashing. The full corpus, +oracle, all four outputs, compiler receipts, finite controls and failed outputs +are retained. No timing sample can be discarded or replaced. + +The capture cache uses the original -O2/-Wall/-Werror loader. The unchanged +key comparator uses shared -O3/-Wall/-Wextra/-Werror flags for both replay arms, +checks its compiler-input snapshot and rejects compiler output or failure. +Neither replay arm performs Fraction arithmetic, descriptor extraction, callback +validation, score updates or complete qualification. Actual values/order and +field identities are now observed, but replay still changes the working set and +arithmetic/allocation interleaving. A key-only delta is not a complete saving. + +## Resource gate and execution preconditions + +Memory fit is unresolved. The plan estimates about 248 MB for captured tuples, +23 MB for list pointers and 21 MB of transient outer-tuple overlap. Capturing +references also preserves otherwise transient integer allocations. Its four +40-byte distinct old/v-field assumption contributes about 413 MB; adding the +prior roughly 117 MB baseline and 150 MB of replay/output/allocator allowance +gives about 972 MB. This is not an upper bound, and allocation rounding, wider +fields, reduced sharing or retained frames can exceed 1 GiB. The plan itself +recognizes that 64-byte retained integers could exceed the cap. Gzip size cannot +establish an in-memory bound. + +Wrapper namespaces are released and the permitted post-qualification collection +runs before oracle/replay. Archive/readback are block-bounded. Nevertheless, +captured fields remain live throughout comparator compilation, its finite +controls, oracle and replay; the source review cannot guarantee peak RSS or wall completion. +Full qualification, capture, serialization and two cold builds are all paid. +The earlier qualifier's timing is not a time bound on this changed diagnostic. + +Execution clearance therefore means ONLY the parent's single monitored attempt, +with these existing preconditions: + +- Copy the complete prepared tree, including all 164 baseline files and modes; + copying only the manifest's explicit file list is insufficient. +- Use the fresh exact stages/actual-key-pilot-v1 wrapper and fresh artifact path + through the unchanged serial guard: 180 seconds, sampled 1-GiB process-group + RSS and the shared 1,500-second ledger. The parent reported about 702.875 + seconds spent at nomination time; the parent must check the live ledger. +- Include process startup/exit, both compiler children, all controls, capture, + corpus/oracle work, cleanup, output persistence and final writes in the outer + receipt. The child's partial clock is not that authoritative bill. +- Treat any resource, source, capture, oracle, compiler or qualification failure + as a retained final failure of this attempt. No truncation, deduplication, + resampling, cap increase, alternate workload or automatic retry is admitted. + +If the unchanged guard is unavailable, no execution is cleared. A cap-triggered +failure would establish that this implementation did not fit that observed +resource envelope; it would not be permission to weaken capture completeness. + +## Interpretation of a future result + +The source-specific question is whether the exact actual keys change the failed +synthetic cost premise. This diagnostic does not replace any historical B/C +sample. Even a positive actual-key delta is combined only conditionally with the +4.684712576 wall / 4.683428715 CPU integer gross anchor from a DIFFERENT run, +including diagnostic overhead. That sum is not a same-run measured complete gain. + +The 5.199267809 wall / 5.1705 CPU requirements remain fixed screen anchors derived +from earlier baseline medians, not universal runtime bounds. Zero integer +residual is an optimistic rejection assumption; the 0.5-second reserve is +provisional and unmeasured. Retained integer/key runtime, integration, complete +new validation and cold-build costs remain unpriced. A negative result closes +this nomination under the declared gate; a positive result permits only cost +and contract design, never construction admission or a claim that the complete +objective has been achieved. + +## Final source identities + +Paths are relative to actual-key-pilot/. Hashes were read directly after the +worker's readiness signal; the unchanged approved helper pins are also recorded. + +| File | SHA-256 | +| --- | --- | +| FROZEN-SOURCE.json | 04ee8ee199bfddc692232ac97adf457d41c33f22d66c0caddd0afced26b3656a | +| capture_actual.py | 71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56 | +| actual_driver.py | bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2 | +| capture.inc | 22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8 | +| baseline-public/native_cache.c | 83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e | +| baseline-public/full.py | ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0 | +| SOURCE-EDITS.json | c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a | +| prepare_source.py | 84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c | +| stage_entry.py | e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b | +| keypilot.c | ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6 | +| load_pilot.py | d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968 | +| run_pilot.py | e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e | +| PLAN.md | b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458 | +| REPRODUCE.md | 74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851 | + +## Post-run receipt interpretation and engineering impasse + +Added 2026-10-28 after the parent's one guarded attempt. This addendum is a +read-only interpretation of retained receipts, not an independent numerical +replay. No source, input, captured corpus or old sample was changed. + +runtime/runs/actual-key-pilot-v1/receipt.json reports PASS, exit 0, +42.639824142999714 outer wall seconds, 40.86 user plus 1.68 system seconds, +437,825,536 bytes sampled process-group RSS, empty stderr, no termination and +unchanged source bytes/modes. Source inventory SHA-256 is +225ae409b5400b746690d271a90ddd2aab7d042134434f52007e951c26f2f5d1. +Thus this attempt completed within the unchanged limits; the earlier resource +uncertainty did not cause its rejection. The observed footprint is not a bound +for another runtime, host or implementation. + +runtime/actual-key-pilot-v1-artifacts/RESULT.json records +PASS_COMPLETE_ACTUAL_KEY_CAPTURE and PASS_ACTUAL_KEY_COMPARISON_ONLY. The entire +original qualification passed: 120 fixtures, 25,984 events, 799 coordinates, +all actual witness rows equal and the original source/result digests. The actual +receipt retains 2,579,750 calls, 2,252,966 hits, 326,784 misses, 310,400 evictions, +zero bypasses, 16,384 residents/capacity and 3,587 tokens. + +All 2,579,750 seven-field keys were captured without sampling. The complete +7,945,691-byte actual-keys-v1.pickle.gz archive has SHA-256 +660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699. +The receipt records complete streaming value/order readback and confirms that +replay used the original captured objects. The finite comparator suite passed +82 control receipts with 50 natural rehashes. All four fixed BCCB samples match +the independent oracle in every ordered ID, flag and prefix, with the original +actual core counters. Each C replay records 23 natural rehashes; B records zero. +Compiler source pins match the reviewed sources, and the key compiler returned +zero with empty logs. No retries occurred. This reviewer inspected those +receipts rather than independently reloading or rerunning the retained corpus. + +| Retained actual-key sample | Wall seconds | CPU seconds | +| --- | ---: | ---: | +| B1 | 0.477255588 | 0.477131657 | +| C1 | 0.307855024 | 0.307762678 | +| C2 | 0.313469836 | 0.313226221 | +| B2 | 0.474210388 | 0.474076689 | + +The declared smaller paired actual-key difference is 0.160740552 wall / +0.160850468 CPU seconds. Even allowing ZERO retained integer runtime and ZERO +new bill, its conditional sum with the earlier different-run integer gross +anchor is only 4.845453128272432 wall / 4.844279182999983 CPU seconds, below the +fixed 5.199267808800505 wall / 5.1705 CPU requirements. With the provisional +0.5-second reserve, the result is 4.345453128272432 / 4.344279182999983 and +REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION. The negative decision therefore +does not depend on treating that provisional reserve as a measured bill. + +The actual-key information gap identified after the synthetic pilot is now +closed. The new corpus improves source specificity, but does not rescue the +nominated key-plus-integer cost premise. Successful capture, finite correctness +and a faster key-only comparator do not constitute a complete speedup. The +capture phase is explicitly not a baseline performance sample, the integer +anchor came from another run and includes instrumentation overhead, and complete +integration/callback/ownership/build/validation costs remain unpriced. + +### What is justified now + +No further scientific action is currently identified or funded under the +unchanged objective, oracle contract and nomination gates. Repeating the +capture/comparator, substituting another corpus, provisioning GMP, constructing +the private integer owner or integrating this cache would proceed past the +failed cost gate without new supporting evidence. The fact that the full goal +remains unmet is not such evidence. Nor should a positive control/correctness +status be recast as performance admission. + +The meaningful authorized continuation is non-scientific evidence closeout and +publication: preserve the exact source-pinned actual corpus, original qualifier +and cache receipts, complete ordered outputs, raw costs and both failed screens. +The parent reports the full 135,724,869-byte artifact tree is retained. Publication +should distinguish the reusable corpus and successful bounded checks from the +negative cost result and the still-unfulfilled complete PR5864 target. This +review itself performed no publication or Git operation. + +Reopening requires a materially different source-specific mechanism, not another +request for actual-key data already supplied here. A concrete proposal must name +its exact source pin and changed code boundary, explain the saved work while +preserving the current arithmetic/return/witness contract, and supply evidence +for a disjoint saving or changed complete cost profile beyond this rejected +nomination. Its nonzero retained runtime, cold compilation/load and complete new +validation bill must leave enough wall AND CPU headroom under the stated gates. +A cumulative profile number, zero-cost thought experiment, available dependency +or favorable repeat is insufficient. No such paid proposal is established by +these retained results, and this review introduces no new hypothesis search. + +This is a candid engineering impasse under the present evidence, not a universal +impossibility theorem. The further 15% complete PR5864 goal remains unmet; no +private integer owner, GMP route, full-cache integration, construction admission +or mathematical/kappa conclusion follows. diff --git a/research/verification-key-headroom/evidence/ADJACENT-PRECEDENTS.json b/research/verification-key-headroom/evidence/ADJACENT-PRECEDENTS.json new file mode 100644 index 0000000000..656e66362f --- /dev/null +++ b/research/verification-key-headroom/evidence/ADJACENT-PRECEDENTS.json @@ -0,0 +1,26 @@ +{ + "exhaustive_novelty_audit": false, + "no_performance_equivalence_claim": true, + "parent_source": "bounded signed-in Chrome read reported by publication parent", + "predecessors": [ + { + "author": "JoyboyBrian", + "pr": 4947, + "scope": "immutable exact-matrix inverse cache; different workload and unreplayed author timings" + }, + { + "additional_credit": [ + "Chafik Boukhalfa", + "Ali Romman", + "Rohan Arun" + ], + "author": "ywz65", + "pr": 2506, + "scope": "complete immutable P104 binary-matrix/address cache; different workload and unreplayed author timings" + } + ], + "query": "exact open-PR phrase \"cache key\"", + "reported_closed": 3, + "reported_open": 0, + "their_performance_not_replayed": true +} diff --git a/research/verification-key-headroom/evidence/ARCHIVE-MAP.json b/research/verification-key-headroom/evidence/ARCHIVE-MAP.json new file mode 100644 index 0000000000..35ce18c2ab --- /dev/null +++ b/research/verification-key-headroom/evidence/ARCHIVE-MAP.json @@ -0,0 +1,288 @@ +{ + "copied_files": [ + { + "bytes": 1266, + "original_round_path": "POST-ASSESSMENT-GC-RESULT.json", + "package_path": "evidence/POST-ASSESSMENT-GC-RESULT.json", + "sha256": "caace396f7de2379905500e2da1696de5b08970214e3418708037070cb0434bf" + }, + { + "bytes": 8059, + "original_round_path": "JOINT-DIAGNOSTIC-REVIEW.md", + "package_path": "evidence/JOINT-DIAGNOSTIC-REVIEW.md", + "sha256": "6374ac5865a7fc12000a264e632181a49a0f70d1ab20e222537aa77322d77bab" + }, + { + "bytes": 681, + "original_round_path": "JOINT-PARENT-SOURCE-CHECK.json", + "package_path": "evidence/JOINT-PARENT-SOURCE-CHECK.json", + "sha256": "f4f802bb2ff778760db77b8715b5fba4349517830ba58acabb1e0f08af4131e0" + }, + { + "bytes": 14874, + "original_round_path": "CACHE-KEY-PILOT-REVIEW.md", + "package_path": "evidence/CACHE-KEY-PILOT-REVIEW.md", + "sha256": "61e672e788a2bec260c64e7d1427f653b150b49e3ce2c02300336562bdde28f1" + }, + { + "bytes": 17267, + "original_round_path": "ACTUAL-KEY-PILOT-REVIEW.md", + "package_path": "evidence/ACTUAL-KEY-PILOT-REVIEW.md", + "sha256": "d07e34bc2e6ef34b269233dbde911a436030e0e9e7138addb328ef1c598b019a" + }, + { + "bytes": 564, + "original_round_path": "ACTUAL-KEY-PARENT-SOURCE-CHECK.json", + "package_path": "evidence/ACTUAL-KEY-PARENT-SOURCE-CHECK.json", + "sha256": "ba0a8faa3869e3905d02b64fc0d7a1fa0a2f830d5c4862447a8cc3d9a81a00f0" + }, + { + "bytes": 18968, + "original_round_path": "REMAINING-ROUTE-REASSESSMENT.md", + "package_path": "evidence/REMAINING-ROUTE-REASSESSMENT.md", + "sha256": "caddd8fb6c8128ac907a668b491c9aab981362d9f1b66377084271e10f8f1289" + }, + { + "bytes": 17237, + "original_round_path": "JOINT-CACHE-INTEGER-PLAN.md", + "package_path": "evidence/JOINT-CACHE-INTEGER-PLAN.md", + "sha256": "2ab423b3b2afc628d6505d71d777febd8160eda72327b7f2e080afa2947092e0" + }, + { + "bytes": 712, + "original_round_path": "HEADROOM-INPUT-COMMIT.json", + "package_path": "evidence/HEADROOM-INPUT-COMMIT.json", + "sha256": "d0354398ca9dd5d5c0d5e93c8e13c1dc2522a2cf41fae333a30bac63783949c0" + }, + { + "bytes": 16149, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/RESULT.json", + "package_path": "evidence/actual/RESULT.json", + "sha256": "3e7768a75f7eee36a10303fd8fdfa26b7b1c03a2777cf19ded1e70c456a454a7" + }, + { + "bytes": 2452, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/CAPTURE-RECEIPT.json", + "package_path": "evidence/actual/CAPTURE-RECEIPT.json", + "sha256": "065d0088fbbc633f19e7881171123fae30b4495e2f6bc5eedcfb1c722bc48c29" + }, + { + "bytes": 14102, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/FULL-QUALIFIER.stdout.txt", + "package_path": "evidence/actual/FULL-QUALIFIER.stdout.txt", + "sha256": "0f94a000fa740ec7095b98383c8d954dc4a6ebeb66c3991f5bab9989a43bd703" + }, + { + "bytes": 11178, + "original_round_path": "runtime/cache-key-pilot-v1-artifacts/RESULT.json", + "package_path": "evidence/synthetic/RESULT.json", + "sha256": "17d20360c792a6917f77f1d5c50ffa773b9f290200dd540ce5c79d6178521078" + }, + { + "bytes": 5608, + "original_round_path": "actual-key-pilot/RESULTS.md", + "package_path": "evidence/actual/RESULTS.md", + "sha256": "e9884794d7fe0887ab13fc85861f333cab9414ce4367ffe60002a0bee5529e1b" + }, + { + "bytes": 4473, + "original_round_path": "cache-key-pilot/RESULTS.md", + "package_path": "evidence/synthetic/RESULTS.md", + "sha256": "cdfc77cd7ccc623549f23c1ca887bc897fff45c4a859c995e3b9b127f4b33088" + }, + { + "bytes": 1044, + "original_round_path": "runtime/runs/gc-attribution-v1/receipt.json", + "package_path": "evidence/runs/gc-attribution-v1/receipt.json", + "sha256": "6f0353fd85ba9e6fcc46cf42bf681cb865a8738efff18dfa858dde32648ed74e" + }, + { + "bytes": 16524, + "original_round_path": "runtime/runs/gc-attribution-v1/stdout.txt", + "package_path": "evidence/runs/gc-attribution-v1/stdout.txt", + "sha256": "c9b2b773719e034fb6cf08b4e02045765ea884e0d83683a3ce1e05d03882d9e1" + }, + { + "bytes": 0, + "original_round_path": "runtime/runs/gc-attribution-v1/stderr.txt", + "package_path": "evidence/runs/gc-attribution-v1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 82, + "original_round_path": "runtime/runs/gc-attribution-v1/usage.json", + "package_path": "evidence/runs/gc-attribution-v1/usage.json", + "sha256": "a2aa4df97d4df37bcb2f2c0482918a8569dd6a25f260e2e499a16192791fee3f" + }, + { + "bytes": 1048, + "original_round_path": "runtime/runs/joint-cost-screen-v1/receipt.json", + "package_path": "evidence/runs/joint-cost-screen-v1/receipt.json", + "sha256": "db20985314263b71b5909fc33debedad9f22352292522a964ba6fb35708b5e6b" + }, + { + "bytes": 63282, + "original_round_path": "runtime/runs/joint-cost-screen-v1/stdout.txt", + "package_path": "evidence/runs/joint-cost-screen-v1/stdout.txt", + "sha256": "e369ccaf1f73fc1842b752d9caf57d871b5e2553f11115ba252dff1d5ffebcd6" + }, + { + "bytes": 0, + "original_round_path": "runtime/runs/joint-cost-screen-v1/stderr.txt", + "package_path": "evidence/runs/joint-cost-screen-v1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 82, + "original_round_path": "runtime/runs/joint-cost-screen-v1/usage.json", + "package_path": "evidence/runs/joint-cost-screen-v1/usage.json", + "sha256": "0c52220df26c509401b4b659e93537935ce613e92378eae0554609be8a418051" + }, + { + "bytes": 1041, + "original_round_path": "runtime/runs/cache-key-pilot-v1/receipt.json", + "package_path": "evidence/runs/cache-key-pilot-v1/receipt.json", + "sha256": "77db0c4b14458e42d07c0a2e804708a0c7485d667a7a52807513bb4d8bb6824e" + }, + { + "bytes": 282, + "original_round_path": "runtime/runs/cache-key-pilot-v1/stdout.txt", + "package_path": "evidence/runs/cache-key-pilot-v1/stdout.txt", + "sha256": "df207bff8a8705ebfcffb38e29cb75f92723fd3513872430721555a8a8a5a541" + }, + { + "bytes": 0, + "original_round_path": "runtime/runs/cache-key-pilot-v1/stderr.txt", + "package_path": "evidence/runs/cache-key-pilot-v1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 81, + "original_round_path": "runtime/runs/cache-key-pilot-v1/usage.json", + "package_path": "evidence/runs/cache-key-pilot-v1/usage.json", + "sha256": "628bc46e484b2a7298826e9e1b53a58a06f6af3f71dffb0e5fadd6050dcd338a" + }, + { + "bytes": 1047, + "original_round_path": "runtime/runs/actual-key-pilot-v1/receipt.json", + "package_path": "evidence/runs/actual-key-pilot-v1/receipt.json", + "sha256": "d23967e470c1522cb4e6877eca91c1a9441cec83c33c48f1d6b67d4278b96398" + }, + { + "bytes": 295, + "original_round_path": "runtime/runs/actual-key-pilot-v1/stdout.txt", + "package_path": "evidence/runs/actual-key-pilot-v1/stdout.txt", + "sha256": "308ffe27bf48a493ab1f50a35f34961230b773a2c31fa859578dcf23b9b489d3" + }, + { + "bytes": 0, + "original_round_path": "runtime/runs/actual-key-pilot-v1/stderr.txt", + "package_path": "evidence/runs/actual-key-pilot-v1/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 82, + "original_round_path": "runtime/runs/actual-key-pilot-v1/usage.json", + "package_path": "evidence/runs/actual-key-pilot-v1/usage.json", + "sha256": "86ce16ddc6a814f3bfb5e78f1fcab5219c29da1d1bbc27bc63eab390b18fa6a0" + }, + { + "bytes": 1629, + "original_round_path": "stages/gc-attribution-v1/PLAN.json", + "package_path": "evidence/source/gc-attribution-v1/PLAN.json", + "sha256": "d4a81fb820ea7cc6d363da651afd389e0570161eecce0982f97cc2672a15ad65" + }, + { + "bytes": 5829, + "original_round_path": "stages/gc-attribution-v1/diagnostic.py", + "package_path": "evidence/source/gc-attribution-v1/diagnostic.py", + "sha256": "fb4aa2c876e25119017c31507dd373bb0ba857e3d2de81a090d24b1440086383" + }, + { + "bytes": 5329, + "original_round_path": "stages/joint-cost-screen-v1/prepare_source.py", + "package_path": "evidence/source/joint-cost-screen-v1/prepare_source.py", + "sha256": "92e8ae1370f47c2cf2659a738f3bd561299755c3347be5aa9256fd17a994dd13" + }, + { + "bytes": 2416, + "original_round_path": "stages/joint-cost-screen-v1/PLAN.json", + "package_path": "evidence/source/joint-cost-screen-v1/PLAN.json", + "sha256": "e72e95207e1f191f0e83bcbe1cac665d45c353737c08624fdcaca7c9a8b8c548" + }, + { + "bytes": 3211, + "original_round_path": "stages/joint-cost-screen-v1/contribution_diagnostic.c", + "package_path": "evidence/source/joint-cost-screen-v1/contribution_diagnostic.c", + "sha256": "2e62c74ae8121d806caa7f3d79ab29b8b9390ba2c06896a539ce1213932e38cd" + }, + { + "bytes": 15103, + "original_round_path": "stages/joint-cost-screen-v1/diagnostic.py", + "package_path": "evidence/source/joint-cost-screen-v1/diagnostic.py", + "sha256": "fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee" + }, + { + "bytes": 39843, + "original_round_path": "stages/joint-cost-screen-v1/SOURCE-EDITS.json", + "package_path": "evidence/source/joint-cost-screen-v1/SOURCE-EDITS.json", + "sha256": "91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8" + }, + { + "bytes": 6172, + "original_round_path": "stages/joint-cost-screen-v1/joint_diag.inc", + "package_path": "evidence/source/joint-cost-screen-v1/joint_diag.inc", + "sha256": "91e0e716c7ea9ca532991277ddf2535dfb34d00d4a25212ffe192927f6f6ae35" + }, + { + "bytes": 403, + "original_round_path": "stages/cache-key-pilot-v1/stage_entry.py", + "package_path": "evidence/source/cache-key-pilot-v1/stage_entry.py", + "sha256": "3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9" + }, + { + "bytes": 1783, + "original_round_path": "stages/cache-key-pilot-v1/FROZEN-SOURCE.json", + "package_path": "evidence/source/cache-key-pilot-v1/FROZEN-SOURCE.json", + "sha256": "b8f843524f62ed239927db894c4699b3d945900cd9681b78f6d32dfa06e1f3de" + }, + { + "bytes": 5227, + "original_round_path": "stages/cache-key-pilot-v1/PLAN.md", + "package_path": "evidence/source/cache-key-pilot-v1/PLAN.md", + "sha256": "18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5" + }, + { + "bytes": 3288, + "original_round_path": "stages/cache-key-pilot-v1/REPRODUCE.md", + "package_path": "evidence/source/cache-key-pilot-v1/REPRODUCE.md", + "sha256": "167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941" + }, + { + "bytes": 1005, + "original_round_path": "stages/cache-key-pilot-v1/PARENT-PLAN.json", + "package_path": "evidence/source/cache-key-pilot-v1/PARENT-PLAN.json", + "sha256": "7d7af10fea01ddf6e9fe9fba9b91991d65537e2dd9a2f0eb1a36b6660b66efcb" + }, + { + "bytes": 3935, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/build/BUILD.json", + "package_path": "evidence/actual/key-build/BUILD.json", + "sha256": "c797ce0f665e17120a80b0835df43093e82dd973edf803bd19de1daca092a3e4" + }, + { + "bytes": 0, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/build/stdout.txt", + "package_path": "evidence/actual/key-build/stdout.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 0, + "original_round_path": "runtime/actual-key-pilot-v1-artifacts/build/stderr.txt", + "package_path": "evidence/actual/key-build/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + } + ], + "historical_paths_are_not_reproduction_commands": true, + "joint_result_package_path": "context/JOINT-COST-DIAGNOSTIC-RESULT.json" +} diff --git a/research/verification-key-headroom/evidence/CACHE-KEY-PILOT-REVIEW.md b/research/verification-key-headroom/evidence/CACHE-KEY-PILOT-REVIEW.md new file mode 100644 index 0000000000..4258ffbbdc --- /dev/null +++ b/research/verification-key-headroom/evidence/CACHE-KEY-PILOT-REVIEW.md @@ -0,0 +1,240 @@ +# Synthetic cache-key pilot: independent source review + +Date: 2026-10-28. Status: SOURCE-ONLY CLEARANCE FOR ONE FIXED GUARDED PILOT. +No remaining source blocker was found at the final hashes below. This reviewer +read source and recorded hashes only; no compiler, extension import, numerical +workload, benchmark, network/browser/Git action or new hypothesis search was +performed. Only this new review report was written. + +This clearance concerns a synthetic key-table comparison. Neither arm implements +the production Cache/Event/Fraction contract. The further 15% complete PR5864 +wall AND CPU target remains unmet; the standalone GC route remains closed. + +## C representation, ownership and control flow + +keypilot.c:111-141 validates exact integer selectors/capacities/failure controls, +exact outer/inner tuples, width seven and exact PyLong fields before allocation +or hashing. Bool, subclasses and foreign objects cannot reach hash/equality +callbacks. Capacity is 1..16384 and row count is at most 3,000,000; allocation-size, +ring-index, table-size and miss-ID arithmetic remain within these fixed bounds. + +The custom table owns seven references and one opaque result reference per +resident entry. Stack probe fields borrow from the still-live immutable input. +Hits acquire a result reference; misses create a monotone PyLong ID. Transferring +a result to the output tuple clears the local owner. Baseline dictionary/ring +ownership is separate, and each receives/releases the references it owns. + +All hash mixing uses uint64_t arithmetic, including conversion from Py_hash_t; +wraparound is defined. Numeric hashing uses the public API. Equal field values +therefore have equal combined hashes, but the implementation never substitutes +hash or pointer equality for complete seven-field numeric equality. Linear +probing passes tombstones and stops at EMPTY. Size is a power of two, at least +twice capacity and at least eight. The occupied-plus-tomb threshold triggers a +same-size rehash before a miss proceeds, preserving empty slots for termination. + +FIFO entry indices stay fixed during rehash. A new table is constructed before +publication; every live entry's slot is then refreshed. Eviction marks the old +slot as a tombstone, clears the old entry, and inserts at the FIFO head. Tombstone +reuse decrements the tomb count. Hits do not advance the head. There is no shared +cache state across calls and no state carried between B/C samples. + +Every allocation/error/fault exit reaches common cleanup. Partially initialized +output and prefix tuples, local lookup/result ownership, baseline dictionary and +ring, custom entries, and old/new rehash tables are covered. The pre-publication +rehash failure leaves the original table available for cleanup. All owned key +fields/results are exact integers, so the private C storage introduces no +arbitrary finalizer or cyclic-object domain. These are source findings, not a +claim that runtime ownership has already been tested. + +## Independent finite comparisons and failure coverage + +The driver uses a separate literal Python dict/deque oracle. Every ordered miss +ID, hit/miss/eviction flag, 80-operation prefix and core statistic must match. +Custom rehash counts are metadata, not compared to oracle core counters: B must +report zero; C must exercise natural rehashing in the finite suite and timed +corpus. No digest replaces full equality. + +Fixed controls cover zero, signs, 8192-bit values, separately allocated equal +integers, deliberately identical per-field/tuple hashes, table collisions, +capacities 1/2/3/16/16384, no FIFO refresh on hits, turnover and tombstones. +Malformed row/type/bounds controls reject both arms where applicable. Declared +miss faults cover temporary ownership, value creation, eviction, stored ownership, +output transfer and custom rehash failure before publication. Fixed repeated-key +faults additionally cover hit-result ownership at phases 1 and 5 in both arms. +Success and failure controls compare raw reference counts for row/key objects +and noncached integers. Small cached integers are excluded because retained +receipts may legitimately reference them. This is bounded cleanup coverage, +explicitly not exhaustive allocator-fault or production-callback coverage. + +Two review gaps were closed before freeze: hit cleanup now has reachable fixed +fault cases, and the loader explicitly verifies its compiler-input snapshot +against the manifest before compilation and again afterward. Baseline rehash-zero +checking and precise inner/outer destruction wording are also present. + +## Corpus, timing fairness and retained evidence + +The frozen synthetic corpus has 32,768 contexts, 80 lookups/context, 2,621,440 +lookups, 327,680 misses, 2,293,760 hits and 311,296 evictions at capacity 16,384. +It has small normalized dyadic fields, one small q/context, bounded tokens and +alternating independently allocated equal tuples. Broad 8192-bit and forced +collision cases stay in the separate finite suite. The corpus is generated by +fixed arithmetic, source-pinned and hashed before timing, with no data search, +workload choice, warmup loop or adaptive repetition. + +Both arms run in the same compiled extension with the same flags and identical +input validation/output/prefix work. B allocates a fresh seven-int tuple and +uses PyDict plus FIFO; C probes the custom table and owns fields on insertion. +Both exclude Fraction arithmetic, descriptor extraction, callback/result-type +checks, Event.apply, score additions and row updates. Private cache destruction +is inside each C-call interval. Returned-output destruction, exact comparison +and persistence occur outside inner timing but remain in the outer command. +The fixed order is B1,C1,C2,B2 with fresh private state. Required finite controls +precede these samples; this does not make each inner call a cold process. + +All four samples are retained. The oracle and each sample preserve full ordered +64-bit ID files, flag bytes, prefix JSON and core counters. Byte order and the +eight-byte ID format are recorded. The comparison uses the smaller of the two +predeclared paired differences separately for wall and CPU; no unfavorable +sample can be replaced. A mismatch or other failure aborts without retry. + +## Source binding and the outer bill + +The manifest pins the C, loader, driver, stage entry, plan and reproduction text, +plus the cited diagnostic/reference sources. The loader rejects absent/symlinked +or mismatched inputs, uses a fresh build directory, binds its copied C bytes +before and after compilation, records the built extension hash, and rechecks +source pins. The final PyModuleDef explicitly initializes its trailing fields. +Both arms use -O3/-std=c11/-Wall/-Wextra/-Werror; any compiler output or nonzero +return is retained and rejected. The production loader uses -O2, which is another +reason not to transfer the pilot delta directly into a production timing claim. + +stage_entry.py requires the exact stages/cache-key-pilot-v1 location and a fresh +artifact destination. The reproduction command uses the parent's existing serial +guard, with 180-second wall and 1-GiB sampled process-group RSS caps and the shared +1,500-second ledger. The compiler has its own 60-second subprocess timeout. The +parent guard remains authoritative for whole-process startup/exit, final writes, +compiler-child CPU, finite controls, corpus/oracle construction, all samples and +output persistence. The child's partial cold clock explicitly excludes startup, +exit and its last write. This review did not execute or independently validate +those runtime receipts. + +## What the synthetic budget can and cannot establish + +Multiplying the synthetic per-call difference by 2,579,750 actual calls is an +ILLUSTRATIVE CONDITIONAL TRANSFER. It is not a measured actual-trace saving, a +measured upper bound on actual-trace savings, or complete PR5864 performance. +The transfer assumes favorable correspondence in key sizes, identity reuse, +hit distance, collision distribution, allocator/cache behavior and compiler +context that the pilot does not demonstrate. + +The 34.661785392 wall / 34.47 CPU medians are fixed historical screen anchors, +not universal runtime bounds. Adding the earlier 4.684712576 wall / 4.683428715 +CPU integer diagnostic region assumes zero retained integer cost; that region +also includes diagnostic overhead and is not measured removable time. The +0.5-second reserve is provisional, not the complete paid new bill. + +A failed illustrative screen can justify stopping this nomination under those +assumptions; it cannot prove that every actual-source route is impossible. +Passing preserves only an unpriced hypothesis. Actual key behavior, nonzero +retained integer/key work, production callback/ownership compatibility, source +qualification, cold builds and complete validation remain required. No micro +result admits construction, publication, a complete speedup or mathematical gain. + +## Final frozen source identities + +Paths are relative to cache-key-pilot/. These were read directly after the final +worker readiness signal and the parent's compiler-hygiene correction. + +| File | SHA-256 | +| --- | --- | +| keypilot.c | ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6 | +| load_pilot.py | d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968 | +| run_pilot.py | e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e | +| FROZEN-SOURCE.json | b8f843524f62ed239927db894c4699b3d945900cd9681b78f6d32dfa06e1f3de | +| stage_entry.py | 3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9 | +| PLAN.md | 18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5 | +| REPRODUCE.md | 167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941 | + +## Post-run receipt interpretation and engineering decision + +Added 2026-10-28 after the parent's single guarded execution. This addendum reads +retained receipts only; it is not an independent numerical replay or a new +benchmark. No reviewed source or raw output was changed. + +The authoritative runtime/runs/cache-key-pilot-v1/receipt.json reports PASS, +exit 0, 6.57319842200377 outer wall seconds, 6.30 user plus 0.21 system seconds, +303,071,232 bytes sampled process-group RSS, empty stderr and unchanged source +bytes/modes. Source inventory SHA-256 is +eccda3323288ff1dc4e80b97e6cd16572ceebd87ffbaaff075236b4087e07227. +The retained compiler receipt binds the reviewed C source, reports exit 0 with +empty compiler logs under -Werror, and identifies extension SHA-256 +3f7af5c42da7a9c5287488227fbb3027761b700657e18c4cc532f067f3609b0d. + +runtime/cache-key-pilot-v1-artifacts/FINITE-CONTROLS.json records +PASS_FINITE_KEY_ONLY, 82 retained control receipts and 50 natural rehashes. +RESULT.json records PASS_FINITE_KEY_COMPARISON_ONLY, zero retries and the fixed +B1,C1,C2,B2 order. Each sample has 2,621,440 calls, 2,293,760 hits, 327,680 misses, +311,296 evictions and 16,384 residents. Both C samples report 26 natural rehashes; +both B samples report zero. All ordered IDs, flags and prefixes were compared +exactly to the independent oracle, with full_output_equality true for all four +samples. The full output artifacts remain retained; this reviewer inspected the +receipts rather than recomparing their binary contents. + +| Retained sample | Wall seconds | CPU seconds | +| --- | ---: | ---: | +| B1 | 0.487316342 | 0.487164264 | +| C1 | 0.357074977 | 0.356983922 | +| C2 | 0.338865159 | 0.338782096 | +| B2 | 0.513840729 | 0.513694743 | + +The predeclared smaller paired difference is 0.130241365 wall / 0.130180342 CPU +seconds. The driver's illustrative transfer to the actual call count is only +0.1281700749812126 wall / 0.12811002245883943 CPU seconds. These are conditional +translations of synthetic results, not observed PR5864 savings or upper bounds. + +Even granting ZERO retained integer runtime and ZERO incremental new bill, the +same diagnostic integer gross region plus that illustrative key saving gives +4.812882651253644 wall / 4.811538737458823 CPU seconds, below the fixed anchors' +required 5.199267808800505 wall / 5.1705 CPU savings. With the declared provisional +0.5-second reserve, the driver reports 4.312882651253644 / 4.311538737458823 and +REJECT_THIS_OPTIMISTIC_NOMINATION. Thus the negative decision does not depend on +claiming that 0.5 seconds is an actual measured bill. Correct finite behavior and +a faster synthetic key loop do not fund the complete target. + +### Decision under the unchanged objective + +No further scientific action is presently justified by these retained findings. +The new result closes the nominated key-plus-private-integer cost premise under +its declared illustrative assumptions. It does not prove a universal obstruction, +and it does not establish that the actual trace could never differ. However, +uncertainty about that transfer is not positive cost evidence. Integrating a full +production cache, constructing a private integer owner, provisioning GMP, taking +a favorable repeat or substituting a new synthetic workload would spend work +past a failed nomination gate without a demonstrated complete budget. + +The parent's reported shared spend is 702.875387315 of 1,500 seconds. The present +engineering impasse is therefore failed demonstrated headroom under the retained +contract, not exhaustion of the execution cap or missing user permission. The +primary complete PR5864 target remains unmet. A separately successful matrix +workload and completion/publication of the four opportunity assessments do not +satisfy it. No mathematical or kappa conclusion follows from this pilot. + +A concrete reopening condition is new source-specific evidence that changes the +cost premise. For example, an independently supplied, source-pinned actual-key +corpus and replay result could show that actual value widths, identity reuse, +hit distances and collision behavior yield materially greater savings than this +synthetic corpus. It would need exact FIFO/output/counter preservation and an +honest account of the actual capture/replay and validation costs. Another +qualifying input would be an independently supplied candidate or implementation +with a complete owner/callback contract and a measured nonzero retained-runtime +and new-build/control bill demonstrating enough combined headroom. Merely having +an available dependency or a large cumulative profile number would not qualify. +These are requirements on new evidence, not authorization to launch those runs +now or a new hypothesis search. + +An explicit user change to the performance target, workload or allowed operation +boundary would instead define a revised task and acceptance contract; it would +not retroactively complete this one. Until new evidence or such a changed task +exists, the justified next work is evidence closeout and a candid status handoff. +There is no supported next optimization experiment to recommend solely because +the stated target remains unfinished. diff --git a/research/verification-key-headroom/evidence/HEADROOM-CONTEXT-EARLY-REVIEW.json b/research/verification-key-headroom/evidence/HEADROOM-CONTEXT-EARLY-REVIEW.json new file mode 100644 index 0000000000..45403ee121 --- /dev/null +++ b/research/verification-key-headroom/evidence/HEADROOM-CONTEXT-EARLY-REVIEW.json @@ -0,0 +1,9 @@ +{ + "status": "PASS", + "actual_stage_files": 177, + "measured_inventory_files": 177, + "baseline_files": 164, + "all_original_bytes_modes_and_stored_stage_bytes_equal": true, + "issues": [], + "scope": "Parent static source-only copy check; no imports/compiler/corpus/replay" +} diff --git a/research/verification-key-headroom/evidence/HEADROOM-INPUT-COMMIT.json b/research/verification-key-headroom/evidence/HEADROOM-INPUT-COMMIT.json new file mode 100644 index 0000000000..81bb98ca98 --- /dev/null +++ b/research/verification-key-headroom/evidence/HEADROOM-INPUT-COMMIT.json @@ -0,0 +1,14 @@ +{ + "base": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "input_commit": "f901e992a3846ff0351bfb0caf75b6167788cd74", + "branch": "verify/actual-key-headroom-20261028", + "package": "research/verification-key-headroom", + "official_PR5864_input_pin": "head:ccb92b752ab31df4220780a580cc14d9e86ffeca:research/c-verification-feasibility/inputs/PR5864.tar", + "files": [ + "research/verification-key-headroom/data/canonical-prefixes.json.gz", + "research/verification-key-headroom/data/DATA.json", + "research/verification-key-headroom/data/actual-keys-v1.pickle.gz", + "research/verification-key-headroom/data/canonical-ids.u64.gz", + "research/verification-key-headroom/data/canonical-flags.u8.gz" + ] +} diff --git a/research/verification-key-headroom/evidence/JOINT-CACHE-INTEGER-PLAN.md b/research/verification-key-headroom/evidence/JOINT-CACHE-INTEGER-PLAN.md new file mode 100644 index 0000000000..bdb6217876 --- /dev/null +++ b/research/verification-key-headroom/evidence/JOINT-CACHE-INTEGER-PLAN.md @@ -0,0 +1,288 @@ +# One joint cache/integer cost screen + +**Scope: one diagnostic, not an optimization or a replacement B/C sample.** +The further 15% complete PR5864 wall/CPU target remains unmet. Prior integer, +GC, rational and formatting results are not added together. This diagnostic +measures the two nominated boundaries in the same fresh complete qualifier, +rejects any overlap, and leaves all retained runtime and new costs unpriced. +A passing screen opens cost design only; it does not admit construction. + +## Exact prepared boundary + +The complete `baseline-public/` tree was copied into `joint-cost-screen/`. +Its 164 files retain the original bytes and modes except two declared files: +`native_cache.c` gains diagnostic clocks/markers and separate diagnostic module +methods, and `NATIVE-SOURCE.json` pins that instrumented C source. The driver +compares every copied file against both the fresh recorded inventory and the +current original baseline. Historical `.research-export.json` remains +predecessor provenance, not a claim that the instrumented copy is that export. + +`SOURCE-EDITS.json` records three reversible text edits. Removing them restores +the entire exact original C source. Removing only timer/marker statements from +the contribution body restores its original statements byte-for-byte. In +particular `member()` already uses direct `tp_descr_get`; no nonexistent +Python-call saving is credited there. `event_apply`, its original eager `F(0)`, +all Fraction miss callbacks, score operations, exception/rejection order and +`Cache.statistics()` remain unchanged. + +Eligible intervals are: + +1. Original selected integer `Engine.ideal`, `error_trace`, and `reverse_all`, + using a local constructor facade without changing the loaded original + module/class/functions. Counts must be exactly 4, 121 and 121. Actual-word, + finite and modified-word calls are classified outside the measured intervals. +2. Native `contribution()` before the original miss callback: input/slot guards, + seven-tuple key construction, lookup, hit cleanup, miss/counter bookkeeping, + and every corresponding error exit. +3. Native `contribution()` after the callback returns: result guards/cleanup, + key insertion and FIFO eviction, including callback-failure cleanup. These + guards remain necessary work; including them makes the envelope generous. + +The pre-callback clock stops before `PyObject_Vectorcall`; the post-callback +clock starts only after it returns. No callback or score arithmetic interval +is included in key time. A callback-depth marker excludes nested key work +inside callbacks; the fixed frozen workload must report none. The integer +activity marker encloses both start/end clock pairs. Any key/integer overlap, +nested key interval, unbalanced depth, clock/protocol error or phase-total +mismatch rejects the diagnostic after retaining the original execution record. +All hits, misses and error paths are accounted for without changing the +original cache counters or cache API. + +The unchanged `full.main(True)` qualifier still runs its original native finite, +Observation, 120-program differential, actual 25,984-event / 799-coordinate, +reverse/literal, output-type and full signed-witness checks. Its actual cache +census remains 2,579,750 calls, 2,252,966 hits, 326,784 misses, 310,400 evictions, +16,384 resident/capacity, zero bypasses and 3,587 tokens. Its scientific output +checks are not replaced with diagnostic counters. The four unchanged custody +checks remain separately registered, as in the original timed qualifier scope. + +## Declared screen + +For each metric, use the fixed current-round baseline median B: +wall 34.66178539200337 seconds and CPU 34.47 seconds. The fixed previous maximum +repeat spreads are wall 2.713637237990042 and CPU 2.35 seconds. + +Let I be the same-run disjoint original integer union and K the same-run +nonoverlapping native key regions. Let R be the nonzero retained/replacement +runtime and A every added validation, ownership, conversion and cold-build cost. + +```text +U = I + K only after all overlap checks pass +required = max(0.15*B, 0.50, fixed_previous_repeat_spread) +actual potential saving = U - R - A +``` + +The zero-cost necessary screen requires U strictly above the threshold in +both metrics: approximately 5.199267809 wall / 5.1705 CPU seconds. Failure in +either metric stops this joint nomination. The second necessary screen reserves +0.50 seconds in each metric for new controls. This is an explicit provisional +planning reserve, not a measured cost and not the complete A bill. Passing both +screens means only `HEADROOM_FOR_COST_DESIGN_ONLY`. R and the complete A remain +`UNPRICED_NONZERO`; a later candidate must still pass its own complete noise and +15% gates with all costs paid. + +Both C clocks use `clock_gettime`: monotonic wall and current-process CPU. +Original integer methods use Python's corresponding wall/process CPU clocks. +The outer guarded GNU-time command pays compiler-child CPU. Timer overhead is +charged, making U an intentionally optimistic observed envelope. A fixed +512-empty-interval clock calibration is recorded separately; it is never +subtracted, multiplied into a saving, or used to qualify performance. GC may +occur inside either interval family and is not added separately. No values +from earlier runs are included in U. A one-run result is an engineering screen, +not a universal runtime upper bound or a new performance sample. + +## Candidate whose cost design this could inform + +The joint hypothesis combines two distinct changes, neither implemented here: + +- One private integer state per Engine invocation, removing repeated row + validation/copying and per-event return packets while preserving exact + arbitrary-width semantics, all byte streams and all required snapshots. +- A private native key representation or lookup table using stack probes and + owned stored keys, avoiding fresh seven-tuples on hits and repeated hashing + of event-constant q/token parts. Full seven-field integer equality, collision + handling, original FIFO/counter behavior, same cached return identity, + exactly one original Python callback per miss and original failure controls + remain mandatory. No result/state/cache crosses a backend or invocation. + +Key interning is metadata ownership, not arithmetic-result sharing. It must +preserve the existing canonical key domain and all negative/fallback controls. +Changing hashing does not authorize changing equality or omitting collision +checks. Moving insertion or eviction across the original callback is not +permitted merely to save time. Python Fraction arithmetic and score-update +order remain unchanged; this is not the stopped rational-arithmetic route. + +A checked 128-bit integer fast lane is conceivable only as a private tagged +representation with a complete arbitrary-width Python-int fallback. Every +conversion and intermediate operation must detect overflow before undefined +signed C behavior. In particular multiplication before exact division, +`abs(INT128_MIN)`, signed shifts, large exponents, weighted score products, +and cancellation after a too-large intermediate require correct fallback. +A small final answer does not justify computing a too-large intermediate in +128 bits. Promotion must occur before performing the unsafe operation. All +external values/types remain the original exact Python integers/Fractions. + +Scale 55 or small sampled outputs alone do not prove that the full workload +fits 128 bits. No width census or coverage assumption is supplied here. Public +CPython 3.12 conversion costs, tagged-state ownership, fallback frequency and +materialization must be paid. A future design must specify platform support +or use the unchanged arbitrary-width path when the compiler lacks the fast +lane; unknown platform behavior is not admissible. No fast lane is implemented. +GMP is not nominated in this round: local headers are absent and its dependency, +build, conversion and independent validation bill is unpriced. Nothing was +installed or fetched. + +## Minimum future bill, if the envelope survives + +Retain all original scientific/native/Observation/finite/custody obligations and +all signed/large-integer/formatting cases. Add new owner lifecycle, alias and +returned-mutation isolation, failed-run cleanup, reentry, buffer ownership and +allocation-overflow controls. Validate every newly moved branch, exact division, +peak/tie/Pareto and snapshot rule. For a fast lane, test below/at/above both signed +limits, all promotions, overflowing intermediates with small final results, +negative shifts/division cases, and large fallback-only values against the +unchanged Fraction oracle. + +For new keys, retain all key-field, canonical equality, hash-collision, FIFO +wrap, exception-before-eviction, callback reentry, metadata mutation, source/ +getter/callback drift and capacity/fallback controls. Add borrowed-probe versus +owned-key lifetime, q/token context identity, large-int key equality, collision +chains and insertion-failure cases. A new layout must not turn a stale slot +reference into a valid key. Price fresh source/runtime binding, cold compiler/ +link/load, all added tests, full caller comparisons, snapshots, conversions, +memory and exact-source publication checks. The provisional 0.50 reserve does +not establish that this bill fits. + +## Frozen source handoff and parent invocation + +- Driver `joint-cost-screen/diagnostic.py`: + `fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee`. +- Instrumented copied `baseline-public/native_cache.c`: + `039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3`. +- Reversible `SOURCE-EDITS.json`: + `91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8`. +- `joint_diag.inc`: + `91e0e716c7ea9ca532991277ddf2535dfb34d00d4a25212ffe192927f6f6ae35`. +- `contribution_diagnostic.c`: + `2e62c74ae8121d806caa7f3d79ab29b8b9390ba2c06896a539ce1213932e38cd`. + +Original native C remains at +`78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb`; +original full.py and integer.py pins remain respectively +`ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0` and +`82a73e4bcf1835bfdd510c7ad5538625c1b380c559b671e6a67be490615a743a`. + +After the parent freezes the entire subtree as +`stages/joint-cost-screen-v1/`, the exact guarded invocation from the workspace +root is: + +```sh +python3 outputs/c-verification-all-opportunities-20261027/run_guarded.py joint-cost-screen-v1 stages/joint-cost-screen-v1/diagnostic.py +``` + +Do not use `--initial`: the initial 600-second phase is closed. The parent must +check the current shared 1,500-second ledger, retain the 180-second / 1 GiB +limits, and preserve any failure without automatic retry. The driver resolves +the same original baseline correctly from either its preparation subtree or +that frozen stage. The root runner records the stage and unchanged originals. + +Text/AST, source-inventory and reversible-edit preparation checks passed without +scientific imports or execution. A separate Astra reviewer reported no source +blocker at the hashes above and independently confirmed the restored original +C hash and two-file delta. That is source review, not compilation or runtime +validation. This worker performed no compilation, numerical test, timing, +network/browser operation, Git mutation or optimization construction. Parent +owns the one diagnostic run and its outcome; no result is pre-claimed here. + +## Result appendix: parent's one guarded run + +The parent completed the frozen `joint-cost-screen-v1` run. Saved evidence is +`JOINT-COST-DIAGNOSTIC-RESULT.json` and +`runtime/runs/joint-cost-screen-v1/{receipt.json,stdout.txt,stderr.txt,usage.json}`. +This worker inspected the saved records without executing them. + +| Same-run eligible envelope | Wall seconds | CPU seconds | +| --- | ---: | ---: | +| Original integer method union | 4.684712576 | 4.683428715 | +| Native key regions, including finite controls | 2.614091766 | 2.577710656 | +| Verified disjoint joint union | 7.298804342 | 7.261139371 | +| Fixed zero-cost threshold | 5.199267809 | 5.170500000 | + +Both free-cost and provisional 0.50-second reserve screens passed. The recorded +status is **HEADROOM_FOR_COST_DESIGN_ONLY**, with `construction_admitted=false`. +The 7.3-second envelope is not removable savings: it contains retained work, +normal source guards and diagnostic timing overhead. Neither the raw envelope +nor a calibration-adjusted estimate is a performance qualification. + +All 246 integer markers balanced; no overlap, nesting, clock failure, protocol +failure or unfinished phase was recorded. Lookup phases account for 2,600,825 +entries: 2,253,383 hits, 347,439 misses and three error exits. The 347,439 +post-callback phases account for 347,433 insertions and six error exits. All +phases closed and no callback-nested key work was included. Original actual +cache counters, complete scientific/witness receipts and source checks passed. + +The outer command recorded 35.519699135 wall seconds, 33.69 user plus 1.70 system +CPU seconds, 117,006,336 sampled process-group RSS bytes, exit 0 and empty stderr. +Source bytes/modes remained unchanged. The separate 512-empty-interval clock +calibration recorded 0.000513510 wall / 0.000512329 CPU seconds. It was neither +subtracted nor scaled, and must remain that way. No earlier integer/GC timing +was added. The outer time includes diagnostic costs and is not a new B/C sample. + +## Next gate: one cheap unprofiled custom-key corpus, before integer construction + +The next permissible work is a **bounded custom-key feasibility design and +finite-corpus comparison**, not private integer state, a 128-bit lane, GMP or a +complete new caller. This appendix does not prepare or execute that prototype. +Its purpose is to reject an unhelpful key representation cheaply before paying +for the larger owner. The existing direct descriptor access is already native; +the actual target is temporary seven-tuple ownership/hash/lookup work. + +Before its first build, freeze one key representation, source identity, ownership +contract, deterministic corpus, repetition/noise rule and command budget. +Do not select among multiple layouts or revise the corpus after timings. Use +one unchanged original-cache baseline and one candidate that changes only key +bookkeeping. Keep every original Python contribution callback and returned +Fraction value/type, cache hit identity, callback order, FIFO counters and +failure rules. Use separate fresh cache instances/processes; share no computed +results or PASS receipts between implementations. + +The fixed corpus should exercise the existing public contribution interface, +with original callbacks on misses, and include: + +- Each of the seven key fields varied; equal canonical q values in different + Event instances; repeated hits; misses; capacity 1/2/16 and one bounded full + 16,384-entry FIFO wrap. No change to token equality or capacity semantics. +- Deliberate full-hash collisions and distinct keys, zero/negative values, + large integer components beyond 128 bits and at least the existing 8,192-bit + fallback cases. Stack probes must never escape; stored keys must own all + required references, including q/token context data. +- Exact ordered result tuples and original statistics after every step, exact + callback argument/call sequence, hit return identity, callback failure before + eviction, reentry and input/metadata mutation controls. Preserve the original + finite native suite; its apply/F(0)/score code remains unchanged. + +Keep the corpus bounded and declared in advance, for example no more than +65,536 contribution calls per process, rather than extracting or replaying the +entire actual word to rescue a weak micro result. Do not turn the old 2.6-million +call count into a scaling multiplier for these synthetic timings. + +A suitable bounded order is one finite correctness gate, then one fixed BCCB +corpus comparison in fresh processes, with no automatic retry and all four +samples retained. A total command allocation must be fixed by the parent from +the remaining shared ledger before starting. Both complete command costs +(including cold builds/new controls) and the unprofiled corpus wall/CPU times +must be retained. No per-lookup clocks belong in that comparison. Any correctness, +ownership, callback-order or statistics failure stops the key nomination. A +candidate that has no repeat-consistent positive corpus effect in both wall and +CPU under the predeclared rule also stops it; do not proceed to private integer +construction or search for a more favorable corpus. + +If the key-only corpus passes, it establishes only that this exact key design +has a useful bounded effect on that corpus. It does not establish actual-word +savings, a scale factor, or enough complete gain. The next source-specific cost +plan must still debit nonzero integer retained work, nonzero key retained work, +cold compilation, conversion/ownership and every additional validation cost. +It must not set the original 4.68-second integer region to zero or count the +instrumented 2.61-second key envelope as saved. The provisional 0.50 allowance +remains a planning reserve, not the full bill. Only a priced affirmative gate +could justify larger construction; the primary further-15% goal is still unmet. diff --git a/research/verification-key-headroom/evidence/JOINT-DIAGNOSTIC-REVIEW.md b/research/verification-key-headroom/evidence/JOINT-DIAGNOSTIC-REVIEW.md new file mode 100644 index 0000000000..d03784d8da --- /dev/null +++ b/research/verification-key-headroom/evidence/JOINT-DIAGNOSTIC-REVIEW.md @@ -0,0 +1,130 @@ +# Joint integer and contribution-key diagnostic: independent source review + +Date: 2026-10-28. Final status: SOURCE-ONLY CLEARANCE FOR ONE GUARDED DIAGNOSTIC; +NO CONSTRUCTION OR PERFORMANCE ADMISSION. No source blocker was found in the +final files identified below. This reviewer performed only source reads, +text comparison/reversal and hashes. No scientific import, compiler, numerical +run, benchmark, browser/network/Git action or further hypothesis search was +performed. Only this newly created report is owned by this review. + +The proposed action is one fixed, guarded information diagnostic of the unchanged +complete PR5864 workload. It is not a candidate optimization or a new B/C sample. +The previously closed standalone GC route stays closed. A negative optimistic +cost envelope may reject the nominated joint boundary; a positive envelope +cannot establish an achievable saving or admit construction. + +## C fragments and assembly + +The contribution wrapper preserves the original statements in order: exact +Fraction and index guards, four direct member-slot reads, seven-component key +construction, calls/hits/misses, full dictionary equality, original callback +arguments, result validation, FIFO eviction and insertion. The callback remains +the original PyObject_Vectorcall(s->compute, argv, 5, NULL). + +The lookup timer closes once on every visible early error, cache hit or miss. +On a miss it closes before callback depth is incremented and before the Python +callback is invoked. Callback depth is decremented after either a successful or +exceptional callback return. A fresh post-callback timer covers result validation +and FIFO/insertion/cleanup; each error and its success close that timer. Existing +Python exceptions survive these C timing helpers: they use no Python operation +that sets an exception, and preserve errno around clock_gettime. The original +error, refcount and arithmetic order is retained. + +Contribution calls made from inside a callback are counted separately and +excluded from eligible timing while callback depth is nonzero. Eligible key +intervals mark nesting and integer activity. Entering an integer interval while +a key interval is active also marks overlap. The completed driver rejects every +nonzero nesting/overlap/error indicator and any unbalanced depth or phase total. + +The complete C diff leaves Event.apply, Cache.statistics, cache/event construction +and ownership/GC methods unchanged. Each original F(0), all three ordered score +additions, row update order, counters and the cache statistics API remain intact. +Four separate diagnostic methods are added to the module; no field is added to +Cache.statistics. + +prepare_source.py declares three unique C edits and their exact inverse. It +strips only declared timer/marker statements from the replacement contribution +function and requires equality to the original function bytes. An independent +text-only reversal of the three receipt edits produced SHA-256 +78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb, +the exact original complete C source hash. An independent directory byte +comparison found only native_cache.c and NATIVE-SOURCE.json different between +the original and diagnostic baseline trees. These source checks do not establish +compilation or runtime correctness. + +## Completed driver review + +diagnostic.py:35-74 authenticates both original and copied baseline file sets, +each original file's bytes/mode, and every unchanged copy. It permits exactly +native_cache.c and NATIVE-SOURCE.json as declared copy changes, checks their +exact content pins, and reverses the three C edits to the fixed original hash. +The same checks run again after the complete qualifier. Generated __pycache__ +files are explicitly outside the file census; original-file and copied-tree +symlink checks remain active. The existing cold loader still snapshots and +compiles its authenticated C source and retains its build receipt. + +The integer facade authenticates the archived integer.py source and delegates to +its original Engine. The loaded module and Engine class are retained, and the +driver checks the class identity after qualification. Lines 114-154 place the C +activity marker before both start clocks and remove it only after both end +clocks. Nested finally blocks clear the marker and Python depth on a callee +exception or a clock failure. Incomplete timers cannot pass. The original +function's return is propagated; original callee exceptions are re-raised unless +a diagnostic failure aborts the command. Metadata/classification is outside the +eligible integer union. Expected family counts are exactly 4 ideal, 121 +error_trace and 121 reverse_all calls; nested integer intervals are rejected. + +Lines 197-217 reject nonzero key/integer/callback depths, clock/protocol errors, +key nesting and integer/key overlap. C integer enter/leave counts must match all +246 observed integer calls. Each key phase requires equal entries/closed/timed +counts, no excluded nested callback interval and nonnegative measured durations. +Lookup hit/miss/error totals partition entries; every miss must have exactly one +post-callback result/cleanup interval partitioned into insertion or error. Thus +the same-run sum is admitted only as a disjoint diagnostic observation. + +Lines 220-245 require the exact full.py hash, exactly one namespace seam and +exactly one archived integer-load seam. They execute the transformed original +full qualifier once with native=True. Original actual digest/cache-counter +checks, finite/source/ownership controls, independent Fraction calculation and +complete witness validation are retained. No B arm, repeat loop, alternate +workload argument, GC-cost addition or prior-run addition is introduced. + +## Accounting and execution boundary + +The key buckets include retained guards, reference management and validation as +well as possible future key-table work. Their raw observed cost is not an +achievable saving. The original Fraction callback, per-item F(0) and score +arithmetic stay outside this nominated key boundary. + +Clock reads, diagnostic counters/markers and classification/reporting incur real +cost. Calibration may describe perturbation but cannot be credited as savings. +It runs outside the eligible totals and is not subtracted; the driver verifies +it left diagnostic totals unchanged. The raw instrumented integer plus disjoint +key time is a generous information screen against the fixed wall AND CPU gates. +Instrumentation may perturb costs, so this is no universal runtime bound. + +The final report always sets performance_sample, optimization_constructed and +construction_admitted to false. Even HEADROOM_FOR_COST_DESIGN_ONLY leaves +retained integer/key runtime and complete validation/build costs explicitly +UNPRICED_NONZERO. The 0.5-second reserve is provisional, not a measured bill. +Original residual work, new controls, cold compilation/link/load, compiler-child +CPU and independent correctness obligations remain unpaid by a positive screen. + +The parent may freeze these exact sources and run the single diagnostic under +the existing serial/resource/shared-budget guard. Execution, runtime preservation +receipts and compilation remain unverified by this reviewer. Every failure must +be retained; this source clearance does not authorize a favorable reroll. + +## Frozen review identities + +All paths below are relative to joint-cost-screen/. Hashes were read directly +after the worker's readiness signal; no reviewed source file was edited here. + +| File | SHA-256 | +| --- | --- | +| diagnostic.py | fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee | +| baseline-public/native_cache.c | 039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3 | +| SOURCE-EDITS.json | 91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8 | +| joint_diag.inc | 91e0e716c7ea9ca532991277ddf2535dfb34d00d4a25212ffe192927f6f6ae35 | +| contribution_diagnostic.c | 2e62c74ae8121d806caa7f3d79ab29b8b9390ba2c06896a539ce1213932e38cd | +| prepare_source.py | 92e8ae1370f47c2cf2659a738f3bd561299755c3347be5aa9256fd17a994dd13 | diff --git a/research/verification-key-headroom/evidence/JOINT-PARENT-SOURCE-CHECK.json b/research/verification-key-headroom/evidence/JOINT-PARENT-SOURCE-CHECK.json new file mode 100644 index 0000000000..c29f01ec45 --- /dev/null +++ b/research/verification-key-headroom/evidence/JOINT-PARENT-SOURCE-CHECK.json @@ -0,0 +1,18 @@ +{ + "status": "PASS_PARENT_STATIC_SOURCE_ONLY_CHECK", + "expected_hashes": { + "diagnostic.py": "fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee", + "baseline-public/native_cache.c": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3", + "SOURCE-EDITS.json": "91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8" + }, + "baseline_files": 164, + "changed_baseline_files": [ + "NATIVE-SOURCE.json", + "native_cache.c" + ], + "complete_C_inverse_matches_original": true, + "diagnostic_python_AST_parse": true, + "compiler_or_numerical_execution": false, + "independent_review": "pending", + "no_optimization_constructed": true +} diff --git a/research/verification-key-headroom/evidence/ORIGINAL-OUTPUTS.json b/research/verification-key-headroom/evidence/ORIGINAL-OUTPUTS.json new file mode 100644 index 0000000000..042eccc6de --- /dev/null +++ b/research/verification-key-headroom/evidence/ORIGINAL-OUTPUTS.json @@ -0,0 +1,95 @@ +{ + "all_five_payload_hashes_equal": true, + "canonical_committed_payloads": "data/DATA.json", + "full_original_files_retained_locally": true, + "id_byteorder": "little", + "id_itemsize": 8, + "outputs": { + "B1": { + "flags.u8": { + "bytes": 2579750, + "original_file": "B1-flags.u8", + "sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98" + }, + "ids.u64": { + "bytes": 20638000, + "original_file": "B1-ids.u64", + "sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3" + }, + "prefixes.json": { + "bytes": 2141131, + "original_file": "B1-prefixes.json", + "sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74" + } + }, + "B2": { + "flags.u8": { + "bytes": 2579750, + "original_file": "B2-flags.u8", + "sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98" + }, + "ids.u64": { + "bytes": 20638000, + "original_file": "B2-ids.u64", + "sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3" + }, + "prefixes.json": { + "bytes": 2141131, + "original_file": "B2-prefixes.json", + "sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74" + } + }, + "C1": { + "flags.u8": { + "bytes": 2579750, + "original_file": "C1-flags.u8", + "sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98" + }, + "ids.u64": { + "bytes": 20638000, + "original_file": "C1-ids.u64", + "sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3" + }, + "prefixes.json": { + "bytes": 2141131, + "original_file": "C1-prefixes.json", + "sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74" + } + }, + "C2": { + "flags.u8": { + "bytes": 2579750, + "original_file": "C2-flags.u8", + "sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98" + }, + "ids.u64": { + "bytes": 20638000, + "original_file": "C2-ids.u64", + "sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3" + }, + "prefixes.json": { + "bytes": 2141131, + "original_file": "C2-prefixes.json", + "sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74" + } + }, + "oracle": { + "flags.u8": { + "bytes": 2579750, + "original_file": "oracle-flags.u8", + "sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98" + }, + "ids.u64": { + "bytes": 20638000, + "original_file": "oracle-ids.u64", + "sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3" + }, + "prefixes.json": { + "bytes": 2141131, + "original_file": "oracle-prefixes.json", + "sha256": "9a95282d58c237e977c78d2b0ceba1f3e85f9c59a1cbc8227f3a00ce65c5bf74" + } + } + }, + "retained_original_runtime_bytes": 135724869 +} diff --git a/research/verification-key-headroom/evidence/POST-ASSESSMENT-GC-RESULT.json b/research/verification-key-headroom/evidence/POST-ASSESSMENT-GC-RESULT.json new file mode 100644 index 0000000000..6db61032a0 --- /dev/null +++ b/research/verification-key-headroom/evidence/POST-ASSESSMENT-GC-RESULT.json @@ -0,0 +1,28 @@ +{ + "status": "COMPLETE_POST_ASSESSMENT_GC_INFORMATION_GATE", + "execution": "PASS", + "headroom": "FAIL_STANDALONE_ZERO_COST_AND_PROVISIONAL_RESERVE_GATES", + "gc_seconds": { + "cpu": 1.5343074439999695, + "wall": 1.5398082226747647 + }, + "collections": 3607, + "all_generation_observation_counts_match_stats": true, + "full_qualifier_coverage": "120fixtures,25984actualevents799coordinates,fullwitnesses,nativecallstatistics/source/counterreceipts unchanged", + "arithmetic_gc_policy": "unchanged; callback state restored", + "source_bytes_modes": "unchanged", + "performance_sample": false, + "construction_admitted": false, + "no_retries": true, + "disjointness_warning": "GC overlaps may exist with old integer intervals; no summation", + "source_review": "REMAINING-ROUTE-REASSESSMENT.md", + "full_report": "runtime/gc-attribution-v1/REPORT.json", + "guard_receipt": "runtime/runs/gc-attribution-v1/receipt.json", + "total_shared_spent_seconds": 660.7824897581013, + "total_guarded_commands": 37, + "outer_diagnostic_wall_seconds": 30.301242657005787, + "outer_time_not_new_benchmark": true, + "shared_cap_seconds": 1500, + "initial600phase": "closed, not reset; one post-assessment diagnostic only", + "updated_utc": "2026-10-27T14:17:48.686508+00:00" +} diff --git a/research/verification-key-headroom/evidence/REMAINING-ROUTE-REASSESSMENT.md b/research/verification-key-headroom/evidence/REMAINING-ROUTE-REASSESSMENT.md new file mode 100644 index 0000000000..5289954431 --- /dev/null +++ b/research/verification-key-headroom/evidence/REMAINING-ROUTE-REASSESSMENT.md @@ -0,0 +1,280 @@ +# Remaining PR5864 route: bounded source-only reassessment + +Date: 2026-10-28. Status: **BOUNDED REASSESSMENT COMPLETE; GC STANDALONE +HEADROOM REJECTED; NO NEW OPTIMIZATION CONSTRUCTION ADMITTED.** + +The further-15% complete wall AND CPU target over frozen PR5864 remains unmet. +The separate matrix result does not contribute to it. I inspected current PLAN, +FINAL-RESULTS, the retained integer screens, the complete diagnostic profile, +exact PR5864 native helpers, and the archived original Observation/qualification +entry points. This source review itself executed no import of the scientific +modules, compiler, numerical run, timing experiment, network/browser action or +Git operation. It changed only this newly created report. The parent separately +performed the one justified guarded GC attribution diagnostic; its retained +result is incorporated below by read-only interpretation. Kappa, Work1/Work2 +mathematics and feeds remain paused. + +## Decision + +There is no presently funded target-sized complete saving from non-arithmetic +Fraction traversal, formatting, dispatch or custody. The one justified new +information boundary was **cyclic-GC time during the unchanged full qualifier**. +The parent's completed passive diagnostic observed 1.539808223 wall / 1.534307444 +CPU seconds across all 3,607 collections. Both values are below the fixed +5.199267809 wall / 5.1705 CPU necessary savings, even with zero replacement cost. +The standalone GC route therefore closes without construction or another run. +The diagnostic passed its instrumentation and preservation checks; the cost +premise failed. Its outer runtime is not a new performance sample. + +The combined private-integer/GMP plus custom contribution-key route is logically +open but not funded. The integer-only zero-cost screen does not rule out a sum +with genuinely disjoint costs. Conversely, its 4.855 seconds cannot be treated +as an achievable saving, and the failed 6.47% integer/format measurement cannot +be credited as an admitted increment. No development/procurement is justified +merely by adding those numbers. + +## Governing target and retained evidence + +The round PLAN.json explicitly requires a further >=15% complete improvement, +all four assessments, complete checks, source/input/type/witness preservation, +cold compilation/link/load, compiler-child CPU and independent Fraction +arithmetic. The older workspace working plan describes the completed earlier +PR5848 objective; it is not authority to mark this later target complete. + +The fixed PR5864 source is 3f15c943e4ad6479f03e674c80fff1269a16ccfe. The latest +retained complete PR5864 baseline medians used by the current screens are +34.66178539200337 wall and 34.47 CPU seconds. Their necessary 15% savings are +5.199267808800505 wall and 5.1705 CPU seconds, before pricing any candidate work. +The conservative repeat/noise requirements remain additional acceptance gates. +The older published 32.771297/32.74 medians are historical evidence, not a reason +to silently substitute a more favorable threshold into this round. + +INTEGER-COMPLETE-GATE.json retains all six samples and reports 2.2430075800220948 +wall / 2.14 CPU median savings for integer+formatting, failing both 15% and the +declared spread gate. INTEGER-OWNED-BOUNDARY-SCREEN.json times a disjoint union of +all 246 original integer ideal/error/reverse calls, 4.855752163886791 wall / +4.853204029000002 CPU seconds. Even deleting that whole union fails the target +for that nomination alone. This is a historical scoped engineering screen, not +a bound on a disjoint combined route, future host, or different algorithm. + +The existing complete cProfile observation is 91.703902 seconds internally and +85.851249 total profiled self time. Those instrumented totals are not comparable +to the unprofiled complete medians. In particular, neither adding nested +cumulative totals nor multiplying profiler shares by an unprofiled baseline +establishes removable complete time. + +## What the existing profile actually leaves open + +| Boundary | Existing diagnostic evidence | Consequence | +| --- | --- | --- | +| Fraction arithmetic/dispatch | 13,144,283 `_add`, 20,977,151 `_from_coprime_ints`, 16,559,270 arithmetic `forward`, 6,191,034 constructor calls | Dominant family, but these calls are retained by the proposed non-arithmetic scope; their cumulative time is not a free C budget. | +| Already-native coefficient application | 32,081 Event.apply calls; 5.312390519 profiled self / 27.795364567 cumulative seconds | Self includes its entire native cache/iteration/bookkeeping boundary. Children include retained arithmetic. Moving this loop to C again saves nothing by itself. | +| Literal Fraction ideal | Four calls, 0.756078007 self / 12.508224794 cumulative | The large cumulative number mostly includes retained work. It does not fund the deferred ideal-loop translation. | +| Literal sparse add helper | 80,221 calls, 1.002795202 self / 4.422012828 cumulative | A C traversal can remove Python control overhead, but must still perform every original Fraction multiply/add, zero construction and zero test in order. | +| Actual native outer trace | One call, 0.456372428 self / 30.784078018 cumulative | Most work is already in the native apply or retained arithmetic children. | +| Fraction witness hash helper | 771,660 calls, 1.222708276 self / 1.690911496 cumulative | Real formatting boundary, but no unprofiled >5.2-second pool is demonstrated. | +| Whole deepcopy family | 287 outer calls; 1.131755349 self / 2.576362563 cumulative, with 1,258,781 total recursive calls | Do not add `_deepcopy_list`, `_deepcopy_dict` or tuple cumulative times to this parent. | +| Canonical JSON encoder | 178 calls, 0.540982591 self/cumulative | Already uses native encoding machinery; a new serializer has an exact-byte compatibility bill. | +| Archive baseline context | 14 calls, 0.526949619 cumulative | Source/custody setup does not show target-sized headroom. | + +These rows are attribution clues, not additive savings or universal upper bounds. +They provide no credible argument that a traversal-only implementation can remove +>5.2 seconds after all its new checks while retaining the dominant arithmetic. + +## Materially distinct non-arithmetic boundary considered: observation payloads + +A concrete source-local alternative is to replace only the payload preparation +inside Observation._call with an exact native tree operation, while retaining +Observation._call/finish/take state transitions and both independent calculations. +The changed objects would be the owned helper implementing `deepcopy(value)` and +the immediate canonical digest of that saved value. The returned deep snapshot, +its digest and all checks would remain the same. The entry's complete ideal and +error/witness equality checks would remain literal and active. + +Such a helper could traverse an admitted exact dict/list/tuple/str/int/bool/ +Fraction tree once to construct the private clone and prepare canonical bytes. +It must preserve dictionary insertion order, tuple/list distinctions, integer +and Fraction types, copy memo aliasing, shared immutable Fraction behavior, +exact key-to-string conversion and JSON separators/sorting. Unsupported/custom +objects and cycles would take the original path with its exception order. It +must not merge mutable output custody between the candidate and Fraction pass. + +All before/after input fingerprints remain. `take()` must still recompute the +saved-output digest to detect drift; the earlier recorded digest cannot replace +that check. Both backend outputs still must exist independently and be compared +in full. Four separate registered custody controls are outside BOTH timed PR5864 +arms, so speeding those controls cannot count toward the complete target. + +This is distinct from rational arithmetic and the owned-integer design, but its +only identified inclusive cost pools are deepcopy and canonical encoding above. +There is no unprofiled evidence of >5.2 seconds, and fusion cannot delete all +copying, allocation, hashing or drift checks. Its substantial alias/type/source/ +exception validation bill makes it an unfunded hypothesis. No C tree helper or +full diagnostic is nominated on this evidence. + +The same conclusion applies to combining the outer Fraction traversal and hash +helpers while retaining every original operation. Exact objects affected would +be source-bound bodies of `precision.add`, ideal's iteration/scaling/norm loop, +error_trace's outer event/finalization loop, update_hash and execute/reverse_cut +traversal. `Fraction`, its arithmetic methods, constructors, ordered operands, +signed witnesses and final result types would stay original. `sum(map(abs,...), +F(0))` is already a native summation loop; its arithmetic cost is not removed by +another wrapper. No positive budget is obtained by relabeling its cumulative +time as Python traversal. The previously deferred ideal-loop idea remains +unfunded; failure of other candidates is not evidence in its favor. + +## Contribution-key representation: a valid but tight disjoint candidate + +The actual trace performs 2,579,750 contribution lookups with 2,252,966 hits. +Current native_cache.c:96-97 already calls the member descriptor's C `tp_descr_get` +directly. It does not call Python `__get__` or PyObject_CallFunctionObjArgs to read +slots. There are four reads per contribution, 10,319,000 actual reads, plus the +two scalar reads once per Event context. The earlier indirect-call premise was +corrected and supplies no optimization budget. + +Directly dereferencing a qualified Fraction slot would remove only a small +existing C accessor boundary, while adding CPython layout/descriptor offset, +owner, bounds/alignment, NULL-slot, refcount, malformed-packet and freshness +obligations. Standalone, the target would require roughly half a microsecond +saved per one of those four reads, before paying anything new. No measured +attribution supports that premise. A slot-access micro is not nominated. + +A more substantial distinct change is an owned stack/custom-key lookup table +that avoids allocating and hashing a fresh seven-PyLong tuple on every hit. +The exact changed objects would be Cache.dict/ring key storage and contribution's +key construction/lookup/eviction implementation, not Event.apply arithmetic. +Original Fraction miss computation, all three ordered score additions, per-item +F(0), source iteration, row writes and counters must stay unchanged. Exact +canonical seven-component equality, full collision resolution, FIFO behavior, +callback failure before eviction, ownership/GC/reentry and bounded residency +remain mandatory. Pointer identity alone cannot replace numeric key equality. +Prehashing immutable q/token components is permissible only with full equality +and source/type qualification; it cannot change hit/miss/eviction receipts. + +A standalone custom-key route needs about two microseconds per actual lookup to +reach the target, while retaining all its other work. The 5.312 profiled native +self seconds include far more than tuple creation, and are not unprofiled +removable seconds. There is no present positive standalone cost screen. + +The integer-only ceiling plus this disjoint lookup work is logically different: +under the extremely generous assumption of zero integer-engine cost and zero +added checks, an additional 0.343516 wall / 0.317296 CPU seconds could cross the +necessary thresholds. But a real owner retains arithmetic, witnesses, copying, +conversions and checks. If it retained even one second of that integer work, +lookup savings would need to exceed approximately 1.343516/1.317296 seconds plus +the entire new bill. This is an algebraic requirement, not a predicted saving. +The failed integer candidate's observed 2.14 CPU saving cannot be substituted as +an admitted guaranteed contribution. + +A private GMP integer owner could in principle reduce allocation of intermediate +PyLong values while the independent Fraction arithmetic remains Python-based. +No such implementation or paid cost exists. Parent-supplied local metadata says +libgmp10 runtime 6.3.0 exists but development headers/unversioned linker library +do not. Runtime presence does not provide a supported pinned C interface or CI +route. Procurement/build/source/ABI/license/environment, arbitrary-width +conversion, exact dyadic divisions, all event/prefix outputs and finite controls +would need explicit pricing. Do not invent private ABI declarations or treat a +new dependency as free. No procurement or GMP pilot is nominated now. + +If new disjoint evidence later reopens this combined route, test the cheap +custom-key premise first with one predeclared frozen cache corpus and exact +FIFO/counter/prefix comparisons, before provisioning GMP. The optimistic screen +must include a stated nonzero residual integer cost and a conservative new bill; +using zero residual cost may only reject, never admit the construction. Tiny +high-hit micro gains are not complete performance measurements, and no favorable +repeat may replace a failed sample. + +## The single new GC attribution diagnostic: completed, negative headroom + +The profile records millions of transient Fraction/object allocations and a +large live sparse-state/cache graph. Automatic cyclic collections can be charged +to allocation sites and are not isolated as an explicit gc.collect entry. The +parent's existing profile extraction finds only three explicit gc.collect calls +and about 0.00984 seconds, which does not bound automatic collection work. +This justified one materially distinct attribution observation. The parent then +ran a fresh cold **unchanged complete PR5864** command under the serial guard, +with predeclared 180-second, 1-GiB and shared 1,500-second caps and zero retries. +The frozen diagnostic source is stages/gc-attribution-v1/diagnostic.py, SHA-256 +fb4aa2c876e25119017c31507dd373bb0ba857e3d2de81a090d24b1440086383. No scientific +source, Fraction arithmetic or GC policy was changed. A passive gc.callbacks +observer paired collection start/stop wall and process-CPU times and retained +the raw intervals. All observed cyclic collections were included, including the +original explicit controls; this is generous to an automatic-GC-only hypothesis. + +The retained runtime/gc-attribution-v1/REPORT.json reports +PASS_PASSIVE_COMPLETE_GC_ATTRIBUTION, with all 3,607 intervals paired. Each +generation's observed count exactly matches its gc.get_stats collection delta: + +| Generation | Collections | Collected objects | Wall seconds | CPU seconds | +| --- | ---: | ---: | ---: | ---: | +| 0 | 3,281 | 2,023 | 0.327509545 | 0.323191992 | +| 1 | 297 | 504 | 0.282419085 | 0.281874846 | +| 2 | 29 | 942 | 0.929879592 | 0.929240606 | +| Nonoverlapping total | 3,607 | 3,469 | 1.539808223 | 1.534307444 | + +No uncollectable objects were reported. Callback-list identity and contents were +restored; enabled state, thresholds, debug and garbage state were unchanged. +The parent reports unchanged scientific receipts, source bytes/modes and empty +stderr: actual digest 954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9, +2,579,750 calls / 2,252,966 hits / 326,784 misses / 310,400 evictions / 3,587 +tokens, and 120 fixtures / 25,984 events / 799 coordinates with the original +full witness and source receipt. Its guarded outer measurement was 30.301243 +wall / 30.24 CPU seconds and 118,304,768 bytes RSS. This instrumentation run is +explicitly not a performance sample and cannot replace a baseline or candidate +sample in the complete acceptance calculation. + +The observed collector union is below both fixed necessary savings: +1.5398082226747647 < 5.199267808800505 wall and +1.5343074439999695 < 5.1705 CPU seconds. Even zero-cost removal of every observed +collection cannot fund the standalone target in this observation. The report's +additional 0.5-second control reserve is provisional, not a measured new bill; +the zero-cost rejection already holds without it. Both recorded cost gates are +false and construction_admitted is false. No GC policy implementation or +favorable timing reroll follows this result. + +Timer/callback allocation and existing callbacks may perturb or inflate the +observation. This is a bounded engineering rejection of the standalone cost +premise, not a universal runtime bound or proof about all future hosts and +algorithms. Compiler-child costs remain in the outer command rather than the +Python-process collector bucket. + +Do not add collector intervals to the 4.855-second integer union: collections can +occur inside those integer calls, and the two existing observations are not one +disjoint partition. Any future combined claim needs same-run overlap-aware +attribution. Optional caller provenance may explain which allocation family is +active, but a Python stack containing a function is not by itself exclusive +ownership of the collector's heap-scanning cost. + +Even a large GC bill does not make `gc.disable`, threshold changes, gc.freeze, +removing traversal flags or altering callback/finalizer timing semantically free. +The original Fraction allocations and operations remain required. Any prospective +policy needs an explicit stable-private-object domain, full cycle/finalizer/ +exception/cleanup/restore controls, no suppressed foreign behavior, and all +postponed collection/cleanup cost paid before the complete command ends. The +negative attribution result supplies no reason to design that policy now. + +## What blocks construction and what reopens it + +No missing user authorization prevented this source review or the completed +bounded attribution diagnostic. The concrete constraint is the conjunction of +the fixed complete target, retained literal Fraction arithmetic/validation, +cold costs and currently unpriced residual work. All measured target-workload +nominees failed their declared gates; the remaining profile shares do not prove +an implementable disjoint saving. That is an evidence/engineering limitation, +not achievement of the goal and not a universal obstruction. + +A construction can reopen only on materially new evidence. The reviewed GC +observation does not supply it. A distinct supported route would need measured +disjoint custom-cache savings plus an honestly priced residual integer/GMP route +and supported pinned dependency environment, or another new cost boundary with +its own complete proof and bill. A separate explicit user change of +scope/target/runtime constraints would define a different task; it must not be +inferred from this goal continuation or from the unrelated matrix success. + +The single GC diagnostic failed its necessary cost gate. Its negative receipt +is retained and the route is closed without a timing reroll. No more broadly +implemented Fraction/C mechanism is presently justified by this reassessment. +This bounded report ends here; it does not extend the hypothesis search. The +further PR5864 target remains unfulfilled. This is an evidence/engineering +limitation under the retained contract, not a permission blocker or a claim of +universal impossibility. diff --git a/research/verification-key-headroom/evidence/actual/CAPTURE-RECEIPT.json b/research/verification-key-headroom/evidence/actual/CAPTURE-RECEIPT.json new file mode 100644 index 0000000000..44febca784 --- /dev/null +++ b/research/verification-key-headroom/evidence/actual/CAPTURE-RECEIPT.json @@ -0,0 +1,71 @@ +{ + "calls": 2579750, + "capture_phase_is_performance_sample": false, + "expected_word_digest": "a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c", + "full_in_memory_wrapper_sha256": "656a30e959c282c1bfb30e6ae2106fabb0376180247dcc14084afcd1c6eeac40", + "full_original_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "native_build": { + "SOABI": "cpython-312-x86_64-linux-gnu", + "binary_sha256": "968e2768ba782dff148206adbe938b6c3cf3183e0ad8376f4389821f6b5e174c", + "cold_build_load_wall_seconds": 0.3853255169815384, + "compiler": "/usr/bin/cc", + "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", + "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", + "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", + "flags": [ + "-O2", + "-shared", + "-fPIC", + "-std=c11", + "-Wall", + "-Werror", + "-I/usr/include/python3.12" + ], + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "source_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" + }, + "original_actual": { + "output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "tokens": 3587 + }, + "original_fraction_operations_and_all_full_witness_checks_retained": true, + "qualification_receipt": { + "all_actual_witness_rows_equal": true, + "coefficient_scale_bits": 55, + "coordinates": 799, + "events": 25984, + "finite_fixtures": { + "cases": 120, + "controls": [ + "nondyadic scalar", + "inexact scale division", + "nondyadic weight" + ], + "events": 4240 + }, + "guards": { + "owned": 22, + "prefix": 26, + "public": 23 + }, + "source_controls": 6, + "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98" + }, + "source_copy": { + "capture_native_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "copied_files": 164, + "inverse_exact": true, + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "other_bytes_and_all_modes_equal": true + }, + "status": "PASS_COMPLETE_ACTUAL_KEY_CAPTURE" +} diff --git a/research/verification-key-headroom/evidence/actual/FULL-QUALIFIER.stdout.txt b/research/verification-key-headroom/evidence/actual/FULL-QUALIFIER.stdout.txt new file mode 100644 index 0000000000..a4d9e48e5c --- /dev/null +++ b/research/verification-key-headroom/evidence/actual/FULL-QUALIFIER.stdout.txt @@ -0,0 +1,9 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "968e2768ba782dff148206adbe938b6c3cf3183e0ad8376f4389821f6b5e174c", "cold_build_load_wall_seconds": 0.3853255169815384, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "968e2768ba782dff148206adbe938b6c3cf3183e0ad8376f4389821f6b5e174c", "cold_build_load_wall_seconds": 0.3853255169815384, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 30.01548} diff --git a/research/verification-key-headroom/evidence/actual/RESULT.json b/research/verification-key-headroom/evidence/actual/RESULT.json new file mode 100644 index 0000000000..e4f71d7764 --- /dev/null +++ b/research/verification-key-headroom/evidence/actual/RESULT.json @@ -0,0 +1,414 @@ +{ + "automatic_retries": 0, + "calls_per_sample": 2579750, + "capture": { + "calls": 2579750, + "capture_phase_is_performance_sample": false, + "expected_word_digest": "a06445539ad73fe16deae66fef8c52ffc39f5f14c765eab3dc3d98e0e2d8074c", + "full_in_memory_wrapper_sha256": "656a30e959c282c1bfb30e6ae2106fabb0376180247dcc14084afcd1c6eeac40", + "full_original_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "native_build": { + "SOABI": "cpython-312-x86_64-linux-gnu", + "binary_sha256": "968e2768ba782dff148206adbe938b6c3cf3183e0ad8376f4389821f6b5e174c", + "cold_build_load_wall_seconds": 0.3853255169815384, + "compiler": "/usr/bin/cc", + "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", + "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", + "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", + "flags": [ + "-O2", + "-shared", + "-fPIC", + "-std=c11", + "-Wall", + "-Werror", + "-I/usr/include/python3.12" + ], + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "source_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e" + }, + "original_actual": { + "output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", + "statistics": { + "bypasses": 0, + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + }, + "tokens": 3587 + }, + "original_fraction_operations_and_all_full_witness_checks_retained": true, + "qualification_receipt": { + "all_actual_witness_rows_equal": true, + "coefficient_scale_bits": 55, + "coordinates": 799, + "events": 25984, + "finite_fixtures": { + "cases": 120, + "controls": [ + "nondyadic scalar", + "inexact scale division", + "nondyadic weight" + ], + "events": 4240 + }, + "guards": { + "owned": 22, + "prefix": 26, + "public": 23 + }, + "source_controls": 6, + "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98" + }, + "source_copy": { + "capture_native_sha256": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "copied_files": 164, + "inverse_exact": true, + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "other_bytes_and_all_modes_equal": true + }, + "status": "PASS_COMPLETE_ACTUAL_KEY_CAPTURE" + }, + "child_cold_through_final_receipt_boundary": { + "cpu_including_compiler_children": 42.193544, + "excludes_process_startup_exit_and_this_final_write": true, + "wall": 42.33505417298875 + }, + "conditional_screen": { + "complete_new_validation_build_bill": "UNPRICED_NONZERO", + "construction_admitted": false, + "cpu": { + "different_run_integer_gross_anchor": 4.683428714999984, + "necessary_15pct_threshold_seconds": 5.1705, + "necessary_threshold_met": false, + "optimistic_budget_seconds": 4.344279182999983, + "paired_key_only_seconds": [ + 0.16936897899999998, + 0.16085046799999997 + ], + "provisional_reserve_seconds": 0.5, + "smaller_key_only_seconds": 0.16085046799999997, + "zero_reserve_budget_seconds": 4.844279182999983 + }, + "integer_anchor_from_different_run": true, + "integer_anchor_includes_clock_overhead": true, + "integer_residual_assumed_seconds": 0, + "measured_actual_key_only": true, + "measured_complete_saving": false, + "real_integer_residual": "UNPRICED_NONZERO", + "reserve_measured": false, + "status": "REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION", + "synthetic_failed_screen_remains_closed": true, + "wall": { + "different_run_integer_gross_anchor": 4.684712576272432, + "necessary_15pct_threshold_seconds": 5.199267808800505, + "necessary_threshold_met": false, + "optimistic_budget_seconds": 4.345453128272432, + "paired_key_only_seconds": [ + 0.16940056400000003, + 0.16074055199999998 + ], + "provisional_reserve_seconds": 0.5, + "smaller_key_only_seconds": 0.16074055199999998, + "zero_reserve_budget_seconds": 4.845453128272432 + } + }, + "construction_admitted": false, + "corpus": { + "complete_streaming_value_readback": true, + "compressed_bytes": 7945691, + "file": "actual-keys-v1.pickle.gz", + "format": { + "block_keys": 4096, + "calls": 2579750, + "cross_block_identity_preserved": false, + "format": "actual-keys-v1", + "key_fields": 7, + "order": "original contribution order", + "pickle_protocol": 5, + "values": "exact signed Python integers" + }, + "replay_uses_original_captured_objects": true, + "sha256": "660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699" + }, + "finite_controls": { + "natural_rehashes": 50, + "receipts": 82, + "status": "PASS_FINITE_KEY_ONLY" + }, + "frozen_order": [ + "B1", + "C1", + "C2", + "B2" + ], + "key_build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-O3", + "-std=c11", + "-fPIC", + "-shared", + "-Wall", + "-Wextra", + "-Werror", + "-I", + "/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/actual-key-pilot-v1-artifacts/build/keypilot.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/actual-key-pilot-v1-artifacts/build/_keypilot.cpython-312-x86_64-linux-gnu.so" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/stages/actual-key-pilot-v1", + "executable": "/usr/bin/python3.12", + "extension_sha256": "33e04798eebdca3c1409ccd7737063055e87dadc2634d5a1ccc382a6111c4dc9", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "source_manifest": { + "files_sha256": { + "PLAN.md": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458", + "REPRODUCE.md": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851", + "SOURCE-EDITS.json": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a", + "actual_driver.py": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2", + "baseline-public/NATIVE-SOURCE.json": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26", + "baseline-public/native_cache.c": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "capture.inc": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8", + "capture_actual.py": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "prepare_source.py": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + }, + "frozen_plan": { + "automatic_retries": 0, + "block_keys": 4096, + "calls_per_sample": 2579750, + "capacity": 16384, + "complete_original_qualifier_required": true, + "construction_admitted": false, + "evictions": 310400, + "hits": 2252966, + "integer_anchor_from_different_run": true, + "misses": 326784, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "per_command_seconds": 180, + "process_group_rss_bytes": 1073741824, + "samples": 4, + "tokens": 3587, + "whole_actual_corpus_retained": true + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "baseline-public/full.py": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "cache-key-pilot/keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "cache-key-pilot/load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "cache-key-pilot/run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_ACTUAL_KEY_NOMINATION_UNEXECUTED" + }, + "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "stderr_bytes": 0, + "stdout_bytes": 0 + }, + "oracle_output": { + "calls": 2579750, + "flags": "oracle-flags.u8", + "flags_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "oracle-ids.u64", + "ids_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "prefixes": "oracle-prefixes.json", + "stats": { + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "resident": 16384 + } + }, + "parent_outer_guard_receipt_required": true, + "post_qualifier_cleanup": { + "after_all_original_qualifier_checks": true, + "captured_keys_retained": true, + "charged_to_outer": true, + "gc_policy_unchanged": true, + "unreachable_objects_collected": 27213 + }, + "samples": [ + { + "calls": 2579750, + "cpu": 0.477131657, + "full_output_equality": true, + "mode": 0, + "name": "B1", + "output": { + "calls": 2579750, + "flags": "B1-flags.u8", + "flags_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "B1-ids.u64", + "ids_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "prefixes": "B1-prefixes.json", + "stats": { + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "rehashes": 0, + "resident": 16384 + } + }, + "wall": 0.477255588 + }, + { + "calls": 2579750, + "cpu": 0.307762678, + "full_output_equality": true, + "mode": 1, + "name": "C1", + "output": { + "calls": 2579750, + "flags": "C1-flags.u8", + "flags_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "C1-ids.u64", + "ids_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "prefixes": "C1-prefixes.json", + "stats": { + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "rehashes": 23, + "resident": 16384 + } + }, + "wall": 0.307855024 + }, + { + "calls": 2579750, + "cpu": 0.313226221, + "full_output_equality": true, + "mode": 1, + "name": "C2", + "output": { + "calls": 2579750, + "flags": "C2-flags.u8", + "flags_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "C2-ids.u64", + "ids_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "prefixes": "C2-prefixes.json", + "stats": { + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "rehashes": 23, + "resident": 16384 + } + }, + "wall": 0.313469836 + }, + { + "calls": 2579750, + "cpu": 0.474076689, + "full_output_equality": true, + "mode": 0, + "name": "B2", + "output": { + "calls": 2579750, + "flags": "B2-flags.u8", + "flags_sha256": "2d0cc2afaf3b056b3ee223d9c220f4be54e3cb8528551f3fbea99611c8392c98", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "B2-ids.u64", + "ids_sha256": "e4e31e2bd54509f9ff9646a5cb4130930fac62e63352d2f5fe1df8fd6f3cc5b3", + "prefixes": "B2-prefixes.json", + "stats": { + "calls": 2579750, + "capacity": 16384, + "evictions": 310400, + "hits": 2252966, + "misses": 326784, + "rehashes": 0, + "resident": 16384 + } + }, + "wall": 0.474210388 + } + ], + "scope": "source-specific full actual-key capture and key-only replay", + "source_manifest": { + "files_sha256": { + "PLAN.md": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458", + "REPRODUCE.md": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851", + "SOURCE-EDITS.json": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a", + "actual_driver.py": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2", + "baseline-public/NATIVE-SOURCE.json": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26", + "baseline-public/native_cache.c": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "capture.inc": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8", + "capture_actual.py": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "prepare_source.py": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + }, + "frozen_plan": { + "automatic_retries": 0, + "block_keys": 4096, + "calls_per_sample": 2579750, + "capacity": 16384, + "complete_original_qualifier_required": true, + "construction_admitted": false, + "evictions": 310400, + "hits": 2252966, + "integer_anchor_from_different_run": true, + "misses": 326784, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "per_command_seconds": 180, + "process_group_rss_bytes": 1073741824, + "samples": 4, + "tokens": 3587, + "whole_actual_corpus_retained": true + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "baseline-public/full.py": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "cache-key-pilot/keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "cache-key-pilot/load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "cache-key-pilot/run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_ACTUAL_KEY_NOMINATION_UNEXECUTED" + }, + "status": "PASS_ACTUAL_KEY_COMPARISON_ONLY" +} diff --git a/research/verification-key-headroom/evidence/actual/RESULTS.md b/research/verification-key-headroom/evidence/actual/RESULTS.md new file mode 100644 index 0000000000..1d75c3bce4 --- /dev/null +++ b/research/verification-key-headroom/evidence/actual/RESULTS.md @@ -0,0 +1,32 @@ +# Actual-key pilot: complete capture passed; conditional nomination rejected + +The parent executed the frozen actual-key pilot once on 2026-10-28. The guard returned `PASS`; the driver returned `PASS_ACTUAL_KEY_COMPARISON_ONLY`. Its predeclared screen returned **`REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION`** for both wall time and CPU. This provides no admission of the complete PR5864 >=15% target, integer-owner construction, GMP provisioning or full cache integration. The earlier failed synthetic nomination remains closed. + +Evidence: [outer guard receipt](../runtime/runs/actual-key-pilot-v1/receipt.json), [driver result](../runtime/actual-key-pilot-v1-artifacts/RESULT.json), [capture receipt](../runtime/actual-key-pilot-v1-artifacts/CAPTURE-RECEIPT.json), [finite controls](../runtime/actual-key-pilot-v1-artifacts/FINITE-CONTROLS.json), and [frozen source manifest](../stages/actual-key-pilot-v1/FROZEN-SOURCE.json). This report interprets bounded retained metadata; it performs no rerun, corpus replay or new hypothesis test. + +The full original qualifier, using its original cache with the diagnostic capture hook, retained its Fraction operations, callbacks, counters and complete signed-witness checks. It passed the frozen receipt: 25,984 events, 799 coordinates, 120 finite fixtures, six source controls, coefficient scale 55, all actual witness rows equal, and source result digest `cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98`. The actual Fraction output retained digest `954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9`. + +Every one of the **2,579,750 actual seven-field keys** was captured in order, with 3,587 weight tokens. The complete corpus was persisted as [actual-keys-v1.pickle.gz](../runtime/actual-key-pilot-v1-artifacts/actual-keys-v1.pickle.gz): **7,945,691 bytes**, SHA-256 `660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699`. Bounded streaming readback checked all values and their order. Replay used the original captured objects; the archive preserves arbitrary-width signed integer values/order and does not promise cross-block object identity. + +The four fresh-state B,C,C,B replays each matched the separate literal dict/deque oracle for every ordered result ID, hit/miss/eviction flag and 80-operation/final-partial prefix. Their statistics also matched the original actual cache: 2,252,966 hits, 326,784 misses, 310,400 FIFO evictions and 16,384 residents at capacity 16,384. Both custom samples paid for 23 natural rehashes; baseline custom-rehash counters were zero. The 82 finite-control receipts passed and exercised 50 natural rehashes. These controls are finite, not exhaustive allocator-failure or general GC proofs. + +| Actual-key sample | Wall seconds | CPU seconds | +|---|---:|---:| +| B1 | 0.477255588 | 0.477131657 | +| C1 | 0.307855024 | 0.307762678 | +| C2 | 0.313469836 | 0.313226221 | +| B2 | 0.474210388 | 0.474076689 | + +The predeclared smaller paired B−C difference was **0.160740552 seconds wall / 0.160850468 CPU**. This is a measured difference for the source-specific actual-key-only replay, with no call-count extrapolation. Both inner arms omit descriptors, Fraction arithmetic and miss callbacks and use opaque miss IDs, so this difference is not a measured complete-verification gain. + +| Conditional engineering budget | Wall seconds | CPU seconds | +|---|---:|---:| +| Earlier integer gross anchor + measured actual-key-only difference − provisional 0.5-second reserve | 4.345453128 | 4.344279183 | +| Same calculation with the reserve reduced to zero | 4.845453128 | 4.844279183 | +| Necessary 15% saving against the fixed complete baseline | 5.199267809 | 5.170500000 | + +Both calculations fail despite assigning **zero retained integer runtime**. The earlier integer gross anchor comes from a different run and includes diagnostic clock overhead; it is not an achieved saving or a same-run removable-cost bound. The reserve is provisional and unmeasured. Real retained integer runtime and complete future integration/build/validation costs remain unpriced and nonzero. This result rejects this actual-key conditional nomination; it supplies no actual complete-runtime gain, actual-trace upper bound or global impossibility result. + +The authoritative cold bill was **42.639824143 seconds wall / 42.54 seconds CPU**, including the original qualifier, capture, both cold builds, finite controls, full corpus persistence/readback, oracle, all four samples and output persistence. CPU is the guard's rounded user-plus-system measurement including compiler children. Sampled peak process-group RSS was **437,825,536 bytes**, within the unchanged 1-GiB cap. The command had no termination condition or stderr; source bytes and modes remained unchanged. The key compiler returned zero with empty stdout/stderr. One explicit collection after every original qualifier check was charged outside replay timings, retained all keys and changed no GC policy; it is not credited as an optimization. + +The retained runtime artifact tree contains **135,724,869 bytes**, including the corpus, oracle and every trial's complete outputs. No sample was discarded, no retry occurred, and no additional execution or investigation was performed for this report. The useful result is the complete source-specific corpus and reproducible negative conditional-budget evidence. Candidate integration with the literal Fraction callback/API, ownership and general GC behavior remains unproved and unadmitted. Frozen sources and manifests are unchanged; this separate report records the subsequent parent-owned execution. diff --git a/research/verification-key-headroom/evidence/actual/key-build/BUILD.json b/research/verification-key-headroom/evidence/actual/key-build/BUILD.json new file mode 100644 index 0000000000..0372aa7991 --- /dev/null +++ b/research/verification-key-headroom/evidence/actual/key-build/BUILD.json @@ -0,0 +1,77 @@ +{ + "command": [ + "x86_64-linux-gnu-gcc", + "-O3", + "-std=c11", + "-fPIC", + "-shared", + "-Wall", + "-Wextra", + "-Werror", + "-I", + "/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/actual-key-pilot-v1-artifacts/build/keypilot.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/actual-key-pilot-v1-artifacts/build/_keypilot.cpython-312-x86_64-linux-gnu.so" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/stages/actual-key-pilot-v1", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "executable": "/usr/bin/python3.12", + "platform": "linux", + "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "source_manifest": { + "files_sha256": { + "PLAN.md": "b62bec29d60d7a9a9e031e98c07b56a4ea5ee5c2c239cbc42713acdf32371458", + "REPRODUCE.md": "74bb8c96ade203414bbbaf0745adffc5a108a67dcf5190e0bfeeb391fff26851", + "SOURCE-EDITS.json": "c539220ad4068cfa76c1f6d26e29bcede638313589005ea7454ef2a679b8e63a", + "actual_driver.py": "bc364f3ab46b9716c9998222ae61818504cb2fbfa3d3343e947c1d84e986a3e2", + "baseline-public/NATIVE-SOURCE.json": "d2d93c28f0617ba5577dc16a5305b8a2f4a3629f6f98079211cb1ae24444da26", + "baseline-public/native_cache.c": "83acea581d685a1e6b1e68f12935f35d874e209633be76411eb7ee9482a9920e", + "capture.inc": "22e16daa223baa84f4a146ec120d7c50a545f0a114683313247d6db1570437c8", + "capture_actual.py": "71d962b7923b8686f92de6b5b3c14bcd0f93fee850a3349961d80c9cc3d43a56", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "prepare_source.py": "84611134f98cba42d40ed21be32f1660bdb00ac89854a99aeae7491580181a9c", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "e88705640969df2a8896d05549449adc4331b2c09b18541525fcd80ee30fa12b" + }, + "frozen_plan": { + "automatic_retries": 0, + "block_keys": 4096, + "calls_per_sample": 2579750, + "capacity": 16384, + "complete_original_qualifier_required": true, + "construction_admitted": false, + "evictions": 310400, + "hits": 2252966, + "integer_anchor_from_different_run": true, + "misses": 326784, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "per_command_seconds": 180, + "process_group_rss_bytes": 1073741824, + "samples": 4, + "tokens": 3587, + "whole_actual_corpus_retained": true + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "baseline-public/full.py": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "cache-key-pilot/keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "cache-key-pilot/load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "cache-key-pilot/run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_ACTUAL_KEY_NOMINATION_UNEXECUTED" + }, + "returncode": 0, + "stdout_bytes": 0, + "stderr_bytes": 0, + "extension_sha256": "33e04798eebdca3c1409ccd7737063055e87dadc2634d5a1ccc382a6111c4dc9" +} diff --git a/research/verification-key-headroom/evidence/actual/key-build/stderr.txt b/research/verification-key-headroom/evidence/actual/key-build/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/actual/key-build/stdout.txt b/research/verification-key-headroom/evidence/actual/key-build/stdout.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/receipt.json b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/receipt.json new file mode 100644 index 0000000000..dfa5ebb092 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "actual-key-pilot-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": "9c804a77e9c7fab6196314abf0a1be11d6bd932d44a1208cde3d6aa8b18c5e7c", + "sampled_process_group_rss_bytes": 437825536, + "script": "stages/actual-key-pilot-v1/stage_entry.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "225ae409b5400b746690d271a90ddd2aab7d042134434f52007e951c26f2f5d1", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 295, + "stdout_sha256": "308ffe27bf48a493ab1f50a35f34961230b773a2c31fa859578dcf23b9b489d3", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 432100, + "system_seconds": 1.68, + "user_seconds": 40.86 + }, + "wall_seconds": 42.639824142999714 +} diff --git a/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/stderr.txt b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/stdout.txt b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/stdout.txt new file mode 100644 index 0000000000..f2c99b4474 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/stdout.txt @@ -0,0 +1 @@ +{"status": "PASS_ACTUAL_KEY_COMPARISON_ONLY", "screen": "REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION", "result": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/actual-key-pilot-v1-artifacts/RESULT.json"} diff --git a/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/usage.json b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/usage.json new file mode 100644 index 0000000000..7b1d5c47bc --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/actual-key-pilot-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":40.86,"system_seconds":1.68,"kernel_max_rss_kib":432100,"exit":0} diff --git a/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/receipt.json b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/receipt.json new file mode 100644 index 0000000000..42d1d1834e --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "cache-key-pilot-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": "34e1b50de22b984e70d6ca30157f920af632f376e44c6ca790f5a3275d16ce90", + "sampled_process_group_rss_bytes": 303071232, + "script": "stages/cache-key-pilot-v1/stage_entry.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "eccda3323288ff1dc4e80b97e6cd16572ceebd87ffbaaff075236b4087e07227", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 282, + "stdout_sha256": "df207bff8a8705ebfcffb38e29cb75f92723fd3513872430721555a8a8a5a541", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 294516, + "system_seconds": 0.21, + "user_seconds": 6.3 + }, + "wall_seconds": 6.57319842200377 +} diff --git a/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/stderr.txt b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/stdout.txt b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/stdout.txt new file mode 100644 index 0000000000..a783b6b928 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/stdout.txt @@ -0,0 +1 @@ +{"status": "PASS_FINITE_KEY_COMPARISON_ONLY", "screen": "REJECT_THIS_OPTIMISTIC_NOMINATION", "result": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/cache-key-pilot-v1-artifacts/RESULT.json"} diff --git a/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/usage.json b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/usage.json new file mode 100644 index 0000000000..8570d8b870 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/cache-key-pilot-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":6.30,"system_seconds":0.21,"kernel_max_rss_kib":294516,"exit":0} diff --git a/research/verification-key-headroom/evidence/runs/gc-attribution-v1/receipt.json b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/receipt.json new file mode 100644 index 0000000000..bd2e5f7876 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "gc-attribution-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": "5e2ab9f0a67c5938c2bd93846f0434e2e76e33dda98bcc7c1c0f1af19ec09b4b", + "sampled_process_group_rss_bytes": 118304768, + "script": "stages/gc-attribution-v1/diagnostic.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "04c13a9ccea74e9cd98898d42e2cb466e4a32209aaf85b2c1e46ca69d4788f5f", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 16524, + "stdout_sha256": "c9b2b773719e034fb6cf08b4e02045765ea884e0d83683a3ce1e05d03882d9e1", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 114080, + "system_seconds": 0.18, + "user_seconds": 30.06 + }, + "wall_seconds": 30.301242657005787 +} diff --git a/research/verification-key-headroom/evidence/runs/gc-attribution-v1/stderr.txt b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/runs/gc-attribution-v1/stdout.txt b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/stdout.txt new file mode 100644 index 0000000000..6b6f0ed57c --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/stdout.txt @@ -0,0 +1,10 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "931772d17bcb86323196ac09f69274b38bf5c53c65bb4e55f832a4000f56c4d0", "cold_build_load_wall_seconds": 0.29832719700061716, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "931772d17bcb86323196ac09f69274b38bf5c53c65bb4e55f832a4000f56c4d0", "cold_build_load_wall_seconds": 0.29832719700061716, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 27.717748} +{"arithmetic_changed": false, "by_generation": [{"collected": 2023, "cpu_seconds": 0.3231919919999616, "generation": 0, "observed_collections": 3281, "stats_delta_collections": 3281, "uncollectable": 0, "wall_seconds": 0.3275095453718677}, {"collected": 504, "cpu_seconds": 0.2818748460000046, "generation": 1, "observed_collections": 297, "stats_delta_collections": 297, "uncollectable": 0, "wall_seconds": 0.2824190852988977}, {"collected": 942, "cpu_seconds": 0.9292406060000034, "generation": 2, "observed_collections": 29, "stats_delta_collections": 29, "uncollectable": 0, "wall_seconds": 0.9298795920039993}], "callback_overhead": "start/stop and existing callbacks can inflate or perturb observations; not a universal machine/runtime bound", "callbacks_restored": true, "construction_admitted": false, "do_not_add_to_prior_integer_union": "GC intervals may overlap the earlier original-integer intervals; no disjoint combination attribution exists", "fixed_baseline_medians": {"cpu": 34.47, "wall": 34.66178539200337}, "fixed_noise_spreads": {"cpu": 2.3500000000000014, "wall": 2.713637237990042}, "future_policy_requires_separate_cycle_finalizer_restore_and_complete_paid_validation": true, "gc_policy_changed": false, "observation": "all observed cyclic collections, including the original explicit finite collect controls; automatic-only removable bill cannot be larger", "observed_disjoint_gc_seconds": {"cpu": 1.5343074439999695, "wall": 1.5398082226747647}, "performance_sample": false, "preliminary_reserve_screen_pass": false, "provisional_new_control_reserve_seconds": {"cpu": 0.5, "wall": 0.5}, "reserve_is_actual_measured_bill": false, "runtime_gc_policy_unchanged": true, "scope": "same frozen PR5864 full_C qualifier; unchanged separate custody scope", "source_full_sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0", "standalone_zero_cost_screen_pass": false, "stats_after": [{"collected": 2163, "collections": 3293, "uncollectable": 0}, {"collected": 504, "collections": 298, "uncollectable": 0}, {"collected": 942, "collections": 29, "uncollectable": 0}], "stats_before": [{"collected": 140, "collections": 12, "uncollectable": 0}, {"collected": 0, "collections": 1, "uncollectable": 0}, {"collected": 0, "collections": 0, "uncollectable": 0}], "status": "PASS_PASSIVE_COMPLETE_GC_ATTRIBUTION", "zero_cost_threshold_seconds": {"cpu": 5.1705, "wall": 5.199267808800505}} diff --git a/research/verification-key-headroom/evidence/runs/gc-attribution-v1/usage.json b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/usage.json new file mode 100644 index 0000000000..63dbc615a0 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/gc-attribution-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":30.06,"system_seconds":0.18,"kernel_max_rss_kib":114080,"exit":0} diff --git a/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/receipt.json b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/receipt.json new file mode 100644 index 0000000000..2f2122ece8 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "joint-cost-screen-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": "6b1221b3e9aeee639d8724bd0165a2052f0bdc34252c6bd14870210bde0ede7f", + "sampled_process_group_rss_bytes": 117006336, + "script": "stages/joint-cost-screen-v1/diagnostic.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "333e987bff5e290e3899bfbdadf9414c429b7831c340bb9ea0b6747c8df8978a", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 63282, + "stdout_sha256": "e369ccaf1f73fc1842b752d9caf57d871b5e2553f11115ba252dff1d5ffebcd6", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 112812, + "system_seconds": 1.7, + "user_seconds": 33.69 + }, + "wall_seconds": 35.51969913498033 +} diff --git a/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/stderr.txt b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/stdout.txt b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/stdout.txt new file mode 100644 index 0000000000..5b34421096 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/stdout.txt @@ -0,0 +1,10 @@ +{"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"} +{"all_coverage_preserved": true, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "2ee6c21274f1c7236027432e11289ce866ec8c3594605916d83ea752a5d2005b", "cold_build_load_wall_seconds": 0.3519840280059725, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3"}, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_coverage_preserved": true, "inherited": {"all_complete_values_and_types_equal": true, "cases": 241, "controls": ["returned-mutation-isolated", "source-drift", "Fraction-type-drift", "module-byte-drift", "live-code-drift", "nested-live-code-drift", "omitted-witness", "omitted-rounded-sites", "wrong-coefficient", "wrong-weighted-increment", "bad-role", "bad-scalar", "missing-weight", "restore-success", "restore-exception", "fresh-derivation", "key-field-0", "key-field-1", "key-field-2", "key-field-3", "key-field-4", "FIFO-eviction", "canonical-key", "hash-collision", "disabled", "invalid-capacity--1", "invalid-capacity-16385", "invalid-capacity-True", "invalid-capacity-1.5", "uncached-exception-0", "uncached-exception-1", "fresh-call-table", "stats-mutation", "failed-call-clears-stats"], "events": 10164, "status": "PASS_FINITE_FRACTION_TABLE_FEASIBILITY"}, "new_control_count": 20, "new_controls": ["all-241-fixtures-take-certified-domain", "subtypes-and-foreign-types-fall-back-without-custom-methods", "metaclass-container", "metaclass-scalar", "original-fallback-dict-subclass", "original-fallback-program-subclass", "original-fallback-event-subclass", "original-fallback-weights-subclass", "original-fallback-row-subclass", "original-fallback-rounded-subclass", "original-fallback-Fraction-subclass", "original-fallback-integer-weights", "original-fallback-boolean-public", "exact-internal-type-preservation-at-certified-updates", "malformed-outcome-missing-weight", "malformed-outcome-bad-role", "malformed-outcome-bad-scalar", "malformed-outcome-short-event", "recertification-invalidates-certified-method", "disabled-capacity-not-certified"], "status": "PASS_TYPE_GATE_FINITE_FEASIBILITY"}, "new_control_count": 9, "new_controls": ["canonical-full-pair-tokens", "weight-token-hash-collision", "bounded-context-overflow", "event-q-canonical-equality-and-FIFO-counters", "six-complete-trace-counter-and-type-comparisons", "source-site-weight-ownership", "wrong-token-alias-detected", "overflow-fallback-preserves-original", "fresh-token-and-cache-lifetimes"], "status": "PASS_COMPACT_KEY_FINITE_ONLY"}, "new_control_count": 10, "new_controls": ["changed-getter-invalidates", "changed-live-getter-code", "foreign-slot-probe-is-pure", "changed-attribute-lookup", "missing-attribute-handler-presence", "binding-restored", "slot-path-selected", "post-derive-getter-drift-literal-fallback", "uninitialized-unused-weight-fallback", "foreign-slot-value-fallback"], "status": "PASS_SLOT_KEY_FINITE_ONLY"}, "native_control_count": 45, "native_controls": ["canonical-keys-FIFO-wrap-counters", "native-hash-collision", "exact-one-callback-per-miss", "uncached-native-error-0", "uncached-native-error-1", "full-cache-failure-before-eviction", "cache-survives-callback-exception", "capacity-0", "capacity--1", "capacity-16385", "capacity-True", "capacity-1.5", "capacity-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index--1", "index-3", "index-10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "index-True", "index-0", "arity", "keywords", "exact-operand", "exact-scalar", "event-creation", "descriptor-protocol", "token-length", "token-range", "partial-init-length", "partial-init-weight", "callback-result-shape", "callback-result-type", "callback-reentry", "event-owns-parent", "GC-callback-cycle", "native-statistics-isolated", "native-coefficient-loop", "same-row-lowlevel-rejection", "dict-iterator-mutation-safe", "callback-list-mutation-safe", "native-source-authenticated", "callback-descriptor-is-pure", "plain-callback-rejected", "live-callback-code-drift", "owned-metadata-snapshot", "same-row-source-fallback", "malformed-scalar-literal-fallback"], "status": "PASS_NATIVE_FINITE_ONLY"} +{"backends": 2, "controls": ["one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "one-use", "closed-call", "missing", "duplicate", "changed-weights", "changed-rounding", "changed-word", "original-malformed-rejection", "propagated-exception", "failed-finish", "failed-take", "fresh-context-not-previous-pass", "aborted-take", "input-mutation"], "events": 5, "status": "PASS_FINITE_FEASIBILITY_ONLY"} +{"actual": {"output_sha256": "954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9", "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "tokens": 3587}, "build": {"SOABI": "cpython-312-x86_64-linux-gnu", "binary_sha256": "2ee6c21274f1c7236027432e11289ce866ec8c3594605916d83ea752a5d2005b", "cold_build_load_wall_seconds": 0.3519840280059725, "compiler": "/usr/bin/cc", "compiler_cpu_accounting": "outer GNU time user+system includes compiler children", "compiler_version": "cc (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0", "extension_suffix": ".cpython-312-x86_64-linux-gnu.so", "flags": ["-O2", "-shared", "-fPIC", "-std=c11", "-Wall", "-Werror", "-I/usr/include/python3.12"], "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "source_sha256": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3"}, "compiler_children_charged": true, "integer_oracle_unchanged": true, "native_finite_included": true, "status": "PASS_COMPLETE_NATIVE_COVERAGE"} +PASS_P104_SINGLE_PASS_QUALIFICATION +{"mode": "qualify", "receipt": {"all_actual_witness_rows_equal": true, "coefficient_scale_bits": 55, "coordinates": 799, "events": 25984, "finite_fixtures": {"cases": 120, "controls": ["nondyadic scalar", "inexact scale division", "nondyadic weight"], "events": 4240}, "guards": {"owned": 22, "prefix": 26, "public": 23}, "source_controls": 6, "source_result_sha256": "cc7739703ed23532d187949c8507d09c13ac4c152e07a930f0087cde0d7a3d98"}, "seconds": 32.602927} +{"arithmetic_changed":false,"calibration_subtracted":false,"callbacks_and_score_arithmetic_excluded_from_key_regions":true,"clock_overhead_calibration":{"clock_gettime_calls_per_interval":4,"cpu_seconds":0.000512329,"empty_intervals":512,"subtracted_from_envelope":false,"wall_seconds":0.00051351},"complete_new_validation_and_build_bill":"UNPRICED_NONZERO","construction_admitted":false,"expected_actual_fraction_output_checked_by_original_full":"954c7448ff74d78753828e9623ad44c46da9e5ce459420b6e50a5d47294250b9","expected_actual_native_counters_checked_by_original_full":{"bypasses":0,"calls":2579750,"capacity":16384,"evictions":310400,"hits":2252966,"misses":326784,"resident":16384},"fixed_baseline_medians":{"cpu":34.47,"wall":34.66178539200337},"fixed_noise_spreads":{"cpu":2.3500000000000014,"wall":2.713637237990042},"full_source_sha256":"ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0","gc_added_separately":false,"instrumented_driver_sha256":"89525456cc6130419ec97e35348156bf25ddc1db691d6752590fa351f98cf256","integer":{"counts":{"error_trace":121,"ideal":4,"reverse_all":121},"disjoint_union_seconds":{"cpu":4.683428714999984,"wall":4.684712576272432},"expected_actual_program_length":25984,"records":[{"classification":"actual_word","cpu_seconds":0.466810433,"exception":null,"family":"ideal","outermost":true,"program_length":25984,"wall_seconds":0.46696532200439833},{"classification":"actual_word","cpu_seconds":2.81241495,"exception":null,"family":"error_trace","outermost":true,"program_length":25984,"wall_seconds":2.8127848140138667},{"classification":"actual_word","cpu_seconds":0.9579453329999996,"exception":null,"family":"reverse_all","outermost":true,"program_length":25984,"wall_seconds":0.9580617039755452},{"classification":"modified_word_control","cpu_seconds":0.28259738600000084,"exception":"ValueError","family":"ideal","outermost":true,"program_length":25985,"wall_seconds":0.2826643980224617},{"classification":"modified_word_control","cpu_seconds":0.03382899800000061,"exception":"ValueError","family":"ideal","outermost":true,"program_length":25984,"wall_seconds":0.033892175008077174},{"classification":"modified_word_control","cpu_seconds":0.03272733100000025,"exception":"ValueError","family":"ideal","outermost":true,"program_length":25984,"wall_seconds":0.032770830002846196},{"classification":"finite_fixture","cpu_seconds":0.00014333500000418553,"exception":null,"family":"error_trace","outermost":true,"program_length":5,"wall_seconds":0.00014666098286397755},{"classification":"finite_fixture","cpu_seconds":7.521100000218439e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":5,"wall_seconds":7.6786003774032e-05},{"classification":"finite_fixture","cpu_seconds":0.00013484299999788618,"exception":null,"family":"error_trace","outermost":true,"program_length":6,"wall_seconds":0.00013654999202117324},{"classification":"finite_fixture","cpu_seconds":7.442399999746385e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":6,"wall_seconds":7.573998300358653e-05},{"classification":"finite_fixture","cpu_seconds":0.00015547299999951747,"exception":null,"family":"error_trace","outermost":true,"program_length":7,"wall_seconds":0.00015692700981162488},{"classification":"finite_fixture","cpu_seconds":9.245599999729848e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":7,"wall_seconds":9.409800986759365e-05},{"classification":"finite_fixture","cpu_seconds":0.00014759500000138814,"exception":null,"family":"error_trace","outermost":true,"program_length":8,"wall_seconds":0.00014910101890563965},{"classification":"finite_fixture","cpu_seconds":8.850300000062816e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":8,"wall_seconds":8.982999133877456e-05},{"classification":"finite_fixture","cpu_seconds":0.0001872420000026409,"exception":null,"family":"error_trace","outermost":true,"program_length":9,"wall_seconds":0.00019355700351297855},{"classification":"finite_fixture","cpu_seconds":0.00010550600000414079,"exception":null,"family":"reverse_all","outermost":true,"program_length":9,"wall_seconds":0.0001068450219463557},{"classification":"finite_fixture","cpu_seconds":0.0002670599999987644,"exception":null,"family":"error_trace","outermost":true,"program_length":10,"wall_seconds":0.000269146024947986},{"classification":"finite_fixture","cpu_seconds":0.0002538740000019857,"exception":null,"family":"reverse_all","outermost":true,"program_length":10,"wall_seconds":0.0002565199974924326},{"classification":"finite_fixture","cpu_seconds":0.0002382879999984766,"exception":null,"family":"error_trace","outermost":true,"program_length":11,"wall_seconds":0.00024023899459280074},{"classification":"finite_fixture","cpu_seconds":0.0001540379999980246,"exception":null,"family":"reverse_all","outermost":true,"program_length":11,"wall_seconds":0.00015580898616462946},{"classification":"finite_fixture","cpu_seconds":0.00022328400000048987,"exception":null,"family":"error_trace","outermost":true,"program_length":12,"wall_seconds":0.00022500299382954836},{"classification":"finite_fixture","cpu_seconds":0.00012888500000229897,"exception":null,"family":"reverse_all","outermost":true,"program_length":12,"wall_seconds":0.0001302769815083593},{"classification":"finite_fixture","cpu_seconds":0.00022304400000194846,"exception":null,"family":"error_trace","outermost":true,"program_length":13,"wall_seconds":0.00022472100681625307},{"classification":"finite_fixture","cpu_seconds":0.0001284590000025787,"exception":null,"family":"reverse_all","outermost":true,"program_length":13,"wall_seconds":0.00012978099402971566},{"classification":"finite_fixture","cpu_seconds":0.0002524999999948818,"exception":null,"family":"error_trace","outermost":true,"program_length":14,"wall_seconds":0.00025414401898160577},{"classification":"finite_fixture","cpu_seconds":0.00014358800000024985,"exception":null,"family":"reverse_all","outermost":true,"program_length":14,"wall_seconds":0.00014494001516140997},{"classification":"finite_fixture","cpu_seconds":0.0002859749999970518,"exception":null,"family":"error_trace","outermost":true,"program_length":15,"wall_seconds":0.0002875810023397207},{"classification":"finite_fixture","cpu_seconds":0.00018371299999841995,"exception":null,"family":"reverse_all","outermost":true,"program_length":15,"wall_seconds":0.00018518301658332348},{"classification":"finite_fixture","cpu_seconds":0.00025831099999606977,"exception":null,"family":"error_trace","outermost":true,"program_length":16,"wall_seconds":0.00026007098495028913},{"classification":"finite_fixture","cpu_seconds":0.00017818599999941398,"exception":null,"family":"reverse_all","outermost":true,"program_length":16,"wall_seconds":0.00018336100038141012},{"classification":"finite_fixture","cpu_seconds":0.0002676890000046228,"exception":null,"family":"error_trace","outermost":true,"program_length":17,"wall_seconds":0.0002691960253287107},{"classification":"finite_fixture","cpu_seconds":0.00017271099999760509,"exception":null,"family":"reverse_all","outermost":true,"program_length":17,"wall_seconds":0.00017434201436117291},{"classification":"finite_fixture","cpu_seconds":0.0002922219999987874,"exception":null,"family":"error_trace","outermost":true,"program_length":18,"wall_seconds":0.00029381999047473073},{"classification":"finite_fixture","cpu_seconds":0.0001688069999943309,"exception":null,"family":"reverse_all","outermost":true,"program_length":18,"wall_seconds":0.000170087005244568},{"classification":"finite_fixture","cpu_seconds":0.00029680000000098516,"exception":null,"family":"error_trace","outermost":true,"program_length":19,"wall_seconds":0.0002984059974551201},{"classification":"finite_fixture","cpu_seconds":0.00016654800000281966,"exception":null,"family":"reverse_all","outermost":true,"program_length":19,"wall_seconds":0.0001681669964455068},{"classification":"finite_fixture","cpu_seconds":0.00032493799999855355,"exception":null,"family":"error_trace","outermost":true,"program_length":20,"wall_seconds":0.00033070798963308334},{"classification":"finite_fixture","cpu_seconds":0.000175624999997126,"exception":null,"family":"reverse_all","outermost":true,"program_length":20,"wall_seconds":0.00017700600437819958},{"classification":"finite_fixture","cpu_seconds":0.00031795700000003535,"exception":null,"family":"error_trace","outermost":true,"program_length":21,"wall_seconds":0.00031974600278772414},{"classification":"finite_fixture","cpu_seconds":0.00018624200000516566,"exception":null,"family":"reverse_all","outermost":true,"program_length":21,"wall_seconds":0.00018757698126137257},{"classification":"finite_fixture","cpu_seconds":0.00032234399999708785,"exception":null,"family":"error_trace","outermost":true,"program_length":22,"wall_seconds":0.00032402199576608837},{"classification":"finite_fixture","cpu_seconds":0.00019960499999882586,"exception":null,"family":"reverse_all","outermost":true,"program_length":22,"wall_seconds":0.00020128700998611748},{"classification":"finite_fixture","cpu_seconds":0.0003766159999969432,"exception":null,"family":"error_trace","outermost":true,"program_length":23,"wall_seconds":0.00038322099135257304},{"classification":"finite_fixture","cpu_seconds":0.0002059429999974327,"exception":null,"family":"reverse_all","outermost":true,"program_length":23,"wall_seconds":0.0002074289950542152},{"classification":"finite_fixture","cpu_seconds":0.0003429729999950837,"exception":null,"family":"error_trace","outermost":true,"program_length":24,"wall_seconds":0.00034464302007108927},{"classification":"finite_fixture","cpu_seconds":0.00021414800000485457,"exception":null,"family":"reverse_all","outermost":true,"program_length":24,"wall_seconds":0.0002156049886252731},{"classification":"finite_fixture","cpu_seconds":0.0004563769999990086,"exception":null,"family":"error_trace","outermost":true,"program_length":25,"wall_seconds":0.0004584520065691322},{"classification":"finite_fixture","cpu_seconds":0.000245812000002843,"exception":null,"family":"reverse_all","outermost":true,"program_length":25,"wall_seconds":0.00024732400197535753},{"classification":"finite_fixture","cpu_seconds":0.00039169299999741725,"exception":null,"family":"error_trace","outermost":true,"program_length":26,"wall_seconds":0.0003935459826607257},{"classification":"finite_fixture","cpu_seconds":0.00022258699999611053,"exception":null,"family":"reverse_all","outermost":true,"program_length":26,"wall_seconds":0.00022420601453632116},{"classification":"finite_fixture","cpu_seconds":0.00038179899999590816,"exception":null,"family":"error_trace","outermost":true,"program_length":27,"wall_seconds":0.00038345897337421775},{"classification":"finite_fixture","cpu_seconds":0.0002175920000055953,"exception":null,"family":"reverse_all","outermost":true,"program_length":27,"wall_seconds":0.00021915198885835707},{"classification":"finite_fixture","cpu_seconds":0.0004347349999989092,"exception":null,"family":"error_trace","outermost":true,"program_length":28,"wall_seconds":0.00044012500438839197},{"classification":"finite_fixture","cpu_seconds":0.0002322879999994143,"exception":null,"family":"reverse_all","outermost":true,"program_length":28,"wall_seconds":0.00023370198323391378},{"classification":"finite_fixture","cpu_seconds":0.00041895199999686383,"exception":null,"family":"error_trace","outermost":true,"program_length":29,"wall_seconds":0.0004207479942124337},{"classification":"finite_fixture","cpu_seconds":0.00023903299999972205,"exception":null,"family":"reverse_all","outermost":true,"program_length":29,"wall_seconds":0.00024045599275268614},{"classification":"finite_fixture","cpu_seconds":0.0004059759999961443,"exception":null,"family":"error_trace","outermost":true,"program_length":30,"wall_seconds":0.0004077500198036432},{"classification":"finite_fixture","cpu_seconds":0.00022203500000017584,"exception":null,"family":"reverse_all","outermost":true,"program_length":30,"wall_seconds":0.00022341599105857313},{"classification":"finite_fixture","cpu_seconds":0.0005100389999981303,"exception":null,"family":"error_trace","outermost":true,"program_length":31,"wall_seconds":0.0005118839908391237},{"classification":"finite_fixture","cpu_seconds":0.000261691000005726,"exception":null,"family":"reverse_all","outermost":true,"program_length":31,"wall_seconds":0.00026312400586903095},{"classification":"finite_fixture","cpu_seconds":0.0005485579999984225,"exception":null,"family":"error_trace","outermost":true,"program_length":32,"wall_seconds":0.0005504399887286127},{"classification":"finite_fixture","cpu_seconds":0.0003075969999954964,"exception":null,"family":"reverse_all","outermost":true,"program_length":32,"wall_seconds":0.0003090790123678744},{"classification":"finite_fixture","cpu_seconds":0.0004959830000004217,"exception":null,"family":"error_trace","outermost":true,"program_length":33,"wall_seconds":0.0004978899960406125},{"classification":"finite_fixture","cpu_seconds":0.0002532930000000988,"exception":null,"family":"reverse_all","outermost":true,"program_length":33,"wall_seconds":0.00025469399406574667},{"classification":"finite_fixture","cpu_seconds":0.0005474539999994477,"exception":null,"family":"error_trace","outermost":true,"program_length":34,"wall_seconds":0.0005493889912031591},{"classification":"finite_fixture","cpu_seconds":0.0002776729999993677,"exception":null,"family":"reverse_all","outermost":true,"program_length":34,"wall_seconds":0.0002792289888020605},{"classification":"finite_fixture","cpu_seconds":0.0005078269999998497,"exception":null,"family":"error_trace","outermost":true,"program_length":35,"wall_seconds":0.0005096190143376589},{"classification":"finite_fixture","cpu_seconds":0.00027787999999873136,"exception":null,"family":"reverse_all","outermost":true,"program_length":35,"wall_seconds":0.000279305997537449},{"classification":"finite_fixture","cpu_seconds":0.0004850939999982984,"exception":null,"family":"error_trace","outermost":true,"program_length":36,"wall_seconds":0.0004871870041824877},{"classification":"finite_fixture","cpu_seconds":0.00024183000000022048,"exception":null,"family":"reverse_all","outermost":true,"program_length":36,"wall_seconds":0.00024327999562956393},{"classification":"finite_fixture","cpu_seconds":0.0006031759999984843,"exception":null,"family":"error_trace","outermost":true,"program_length":37,"wall_seconds":0.0006051560048945248},{"classification":"finite_fixture","cpu_seconds":0.00033352699999511515,"exception":null,"family":"reverse_all","outermost":true,"program_length":37,"wall_seconds":0.00033496200921945274},{"classification":"finite_fixture","cpu_seconds":0.0005333400000040456,"exception":null,"family":"error_trace","outermost":true,"program_length":38,"wall_seconds":0.0005351479921955615},{"classification":"finite_fixture","cpu_seconds":0.0002953500000018039,"exception":null,"family":"reverse_all","outermost":true,"program_length":38,"wall_seconds":0.00029678401187993586},{"classification":"finite_fixture","cpu_seconds":0.0005386380000018676,"exception":null,"family":"error_trace","outermost":true,"program_length":39,"wall_seconds":0.0005406580166891217},{"classification":"finite_fixture","cpu_seconds":0.00030443499999677215,"exception":null,"family":"reverse_all","outermost":true,"program_length":39,"wall_seconds":0.00030603399500250816},{"classification":"finite_fixture","cpu_seconds":0.0007210309999976516,"exception":null,"family":"error_trace","outermost":true,"program_length":40,"wall_seconds":0.0007231030031107366},{"classification":"finite_fixture","cpu_seconds":0.000479905999995367,"exception":null,"family":"reverse_all","outermost":true,"program_length":40,"wall_seconds":0.0004819000023417175},{"classification":"finite_fixture","cpu_seconds":0.0006298369999981901,"exception":null,"family":"error_trace","outermost":true,"program_length":41,"wall_seconds":0.0006317030056379735},{"classification":"finite_fixture","cpu_seconds":0.0003358240000039814,"exception":null,"family":"reverse_all","outermost":true,"program_length":41,"wall_seconds":0.00033726502442732453},{"classification":"finite_fixture","cpu_seconds":0.0006242360000001668,"exception":null,"family":"error_trace","outermost":true,"program_length":42,"wall_seconds":0.0006260699883569032},{"classification":"finite_fixture","cpu_seconds":0.0003255029999991166,"exception":null,"family":"reverse_all","outermost":true,"program_length":42,"wall_seconds":0.0003270150045864284},{"classification":"finite_fixture","cpu_seconds":0.0006341550000001916,"exception":null,"family":"error_trace","outermost":true,"program_length":43,"wall_seconds":0.0006360859842970967},{"classification":"finite_fixture","cpu_seconds":0.000351638000005039,"exception":null,"family":"reverse_all","outermost":true,"program_length":43,"wall_seconds":0.0003532049886416644},{"classification":"finite_fixture","cpu_seconds":0.0005850350000002891,"exception":null,"family":"error_trace","outermost":true,"program_length":44,"wall_seconds":0.0005870770255569369},{"classification":"finite_fixture","cpu_seconds":0.00029871400000303083,"exception":null,"family":"reverse_all","outermost":true,"program_length":44,"wall_seconds":0.0003002459998242557},{"classification":"finite_fixture","cpu_seconds":0.0005904739999991193,"exception":null,"family":"error_trace","outermost":true,"program_length":45,"wall_seconds":0.0005924149882048368},{"classification":"finite_fixture","cpu_seconds":0.00035894300000194335,"exception":null,"family":"reverse_all","outermost":true,"program_length":45,"wall_seconds":0.000360539008397609},{"classification":"finite_fixture","cpu_seconds":0.0007180089999963002,"exception":null,"family":"error_trace","outermost":true,"program_length":46,"wall_seconds":0.0007199079846031964},{"classification":"finite_fixture","cpu_seconds":0.00036865300000243906,"exception":null,"family":"reverse_all","outermost":true,"program_length":46,"wall_seconds":0.0003702759859152138},{"classification":"finite_fixture","cpu_seconds":0.0006785230000048159,"exception":null,"family":"error_trace","outermost":true,"program_length":47,"wall_seconds":0.0006810780032537878},{"classification":"finite_fixture","cpu_seconds":0.0003606820000001676,"exception":null,"family":"reverse_all","outermost":true,"program_length":47,"wall_seconds":0.00036225400981493294},{"classification":"finite_fixture","cpu_seconds":0.0005927680000041846,"exception":null,"family":"error_trace","outermost":true,"program_length":48,"wall_seconds":0.0005947909958194941},{"classification":"finite_fixture","cpu_seconds":0.0003320269999989023,"exception":null,"family":"reverse_all","outermost":true,"program_length":48,"wall_seconds":0.00033353501930832863},{"classification":"finite_fixture","cpu_seconds":0.0006729699999965533,"exception":null,"family":"error_trace","outermost":true,"program_length":49,"wall_seconds":0.0006748079904355109},{"classification":"finite_fixture","cpu_seconds":0.00042327199999903087,"exception":null,"family":"reverse_all","outermost":true,"program_length":49,"wall_seconds":0.00042537899571470916},{"classification":"finite_fixture","cpu_seconds":0.0007041619999981208,"exception":null,"family":"error_trace","outermost":true,"program_length":50,"wall_seconds":0.0007072379812598228},{"classification":"finite_fixture","cpu_seconds":0.0005358390000012037,"exception":null,"family":"reverse_all","outermost":true,"program_length":50,"wall_seconds":0.00053795101121068},{"classification":"finite_fixture","cpu_seconds":0.0007270519999948988,"exception":null,"family":"error_trace","outermost":true,"program_length":51,"wall_seconds":0.0007291090150829405},{"classification":"finite_fixture","cpu_seconds":0.0004175970000019902,"exception":null,"family":"reverse_all","outermost":true,"program_length":51,"wall_seconds":0.0004193390195723623},{"classification":"finite_fixture","cpu_seconds":0.0007032029999933798,"exception":null,"family":"error_trace","outermost":true,"program_length":52,"wall_seconds":0.0007052169821690768},{"classification":"finite_fixture","cpu_seconds":0.000352722999998889,"exception":null,"family":"reverse_all","outermost":true,"program_length":52,"wall_seconds":0.0003541340120136738},{"classification":"finite_fixture","cpu_seconds":0.0006563889999995354,"exception":null,"family":"error_trace","outermost":true,"program_length":53,"wall_seconds":0.0006583080103155226},{"classification":"finite_fixture","cpu_seconds":0.00040455599999944525,"exception":null,"family":"reverse_all","outermost":true,"program_length":53,"wall_seconds":0.0004061350191477686},{"classification":"finite_fixture","cpu_seconds":0.0008041829999996253,"exception":null,"family":"error_trace","outermost":true,"program_length":54,"wall_seconds":0.0008059109968598932},{"classification":"finite_fixture","cpu_seconds":0.0004334829999947942,"exception":null,"family":"reverse_all","outermost":true,"program_length":54,"wall_seconds":0.00043510799878276885},{"classification":"finite_fixture","cpu_seconds":0.000748314999995614,"exception":null,"family":"error_trace","outermost":true,"program_length":55,"wall_seconds":0.0007503170054405928},{"classification":"finite_fixture","cpu_seconds":0.00039218999999945936,"exception":null,"family":"reverse_all","outermost":true,"program_length":55,"wall_seconds":0.0003937039873562753},{"classification":"finite_fixture","cpu_seconds":0.0007158480000057921,"exception":null,"family":"error_trace","outermost":true,"program_length":56,"wall_seconds":0.0007178939995355904},{"classification":"finite_fixture","cpu_seconds":0.00037048600000133547,"exception":null,"family":"reverse_all","outermost":true,"program_length":56,"wall_seconds":0.0003719509986694902},{"classification":"finite_fixture","cpu_seconds":0.0007888640000004443,"exception":null,"family":"error_trace","outermost":true,"program_length":57,"wall_seconds":0.000790806021541357},{"classification":"finite_fixture","cpu_seconds":0.00039068699999944556,"exception":null,"family":"reverse_all","outermost":true,"program_length":57,"wall_seconds":0.0003924180055037141},{"classification":"finite_fixture","cpu_seconds":0.0009870989999996027,"exception":null,"family":"error_trace","outermost":true,"program_length":58,"wall_seconds":0.0009893440001178533},{"classification":"finite_fixture","cpu_seconds":0.000490261000003045,"exception":null,"family":"reverse_all","outermost":true,"program_length":58,"wall_seconds":0.0004918829945381731},{"classification":"finite_fixture","cpu_seconds":0.0007919929999999908,"exception":null,"family":"error_trace","outermost":true,"program_length":59,"wall_seconds":0.0007937680056784302},{"classification":"finite_fixture","cpu_seconds":0.00041902199999555023,"exception":null,"family":"reverse_all","outermost":true,"program_length":59,"wall_seconds":0.0004205779987387359},{"classification":"finite_fixture","cpu_seconds":0.0009626649999958659,"exception":null,"family":"error_trace","outermost":true,"program_length":60,"wall_seconds":0.0009643759985920042},{"classification":"finite_fixture","cpu_seconds":0.0005500830000002566,"exception":null,"family":"reverse_all","outermost":true,"program_length":60,"wall_seconds":0.0005518139805644751},{"classification":"finite_fixture","cpu_seconds":0.0008089869999992061,"exception":null,"family":"error_trace","outermost":true,"program_length":61,"wall_seconds":0.0008109210175462067},{"classification":"finite_fixture","cpu_seconds":0.0004530530000010913,"exception":null,"family":"reverse_all","outermost":true,"program_length":61,"wall_seconds":0.0004548550059553236},{"classification":"finite_fixture","cpu_seconds":0.0009862970000042992,"exception":null,"family":"error_trace","outermost":true,"program_length":62,"wall_seconds":0.000988504005363211},{"classification":"finite_fixture","cpu_seconds":0.0005403040000047099,"exception":null,"family":"reverse_all","outermost":true,"program_length":62,"wall_seconds":0.0005420820089057088},{"classification":"finite_fixture","cpu_seconds":0.0010192639999999642,"exception":null,"family":"error_trace","outermost":true,"program_length":63,"wall_seconds":0.0010213720088358968},{"classification":"finite_fixture","cpu_seconds":0.0005207570000038686,"exception":null,"family":"reverse_all","outermost":true,"program_length":63,"wall_seconds":0.0005224320048000664},{"classification":"finite_fixture","cpu_seconds":0.0008628089999973554,"exception":null,"family":"error_trace","outermost":true,"program_length":64,"wall_seconds":0.0008648359798826277},{"classification":"finite_fixture","cpu_seconds":0.0004855410000033089,"exception":null,"family":"reverse_all","outermost":true,"program_length":64,"wall_seconds":0.0004874130245298147},{"classification":"finite_fixture","cpu_seconds":0.0011713899999961086,"exception":null,"family":"error_trace","outermost":true,"program_length":65,"wall_seconds":0.0011805260146502405},{"classification":"finite_fixture","cpu_seconds":0.0005708859999984384,"exception":null,"family":"reverse_all","outermost":true,"program_length":65,"wall_seconds":0.0005726699891965836},{"classification":"finite_fixture","cpu_seconds":0.0011818360000006578,"exception":null,"family":"error_trace","outermost":true,"program_length":66,"wall_seconds":0.0011838439968414605},{"classification":"finite_fixture","cpu_seconds":0.0005968450000040093,"exception":null,"family":"reverse_all","outermost":true,"program_length":66,"wall_seconds":0.000598366983467713},{"classification":"finite_fixture","cpu_seconds":0.0010762960000008093,"exception":null,"family":"error_trace","outermost":true,"program_length":67,"wall_seconds":0.001078705012332648},{"classification":"finite_fixture","cpu_seconds":0.000536252999999931,"exception":null,"family":"reverse_all","outermost":true,"program_length":67,"wall_seconds":0.0005382019735407084},{"classification":"finite_fixture","cpu_seconds":0.000905258999999603,"exception":null,"family":"error_trace","outermost":true,"program_length":68,"wall_seconds":0.0009072610118892044},{"classification":"finite_fixture","cpu_seconds":0.0004415940000015439,"exception":null,"family":"reverse_all","outermost":true,"program_length":68,"wall_seconds":0.00044345599599182606},{"classification":"finite_fixture","cpu_seconds":0.000903330999996399,"exception":null,"family":"error_trace","outermost":true,"program_length":69,"wall_seconds":0.0009102470066864043},{"classification":"finite_fixture","cpu_seconds":0.0005234230000041862,"exception":null,"family":"reverse_all","outermost":true,"program_length":69,"wall_seconds":0.0005249939858913422},{"classification":"finite_fixture","cpu_seconds":0.0008097159999991277,"exception":null,"family":"error_trace","outermost":true,"program_length":70,"wall_seconds":0.0008116200042422861},{"classification":"finite_fixture","cpu_seconds":0.00046308200000311217,"exception":null,"family":"reverse_all","outermost":true,"program_length":70,"wall_seconds":0.00046472199028357863},{"classification":"finite_fixture","cpu_seconds":0.000883508000001143,"exception":null,"family":"error_trace","outermost":true,"program_length":71,"wall_seconds":0.0008853540057316422},{"classification":"finite_fixture","cpu_seconds":0.0005278459999971119,"exception":null,"family":"reverse_all","outermost":true,"program_length":71,"wall_seconds":0.0005339839844964445},{"classification":"finite_fixture","cpu_seconds":0.0008980179999937832,"exception":null,"family":"error_trace","outermost":true,"program_length":72,"wall_seconds":0.0008997730037663132},{"classification":"finite_fixture","cpu_seconds":0.00046848499999896376,"exception":null,"family":"reverse_all","outermost":true,"program_length":72,"wall_seconds":0.00047008501132950187},{"classification":"finite_fixture","cpu_seconds":0.0009215079999975728,"exception":null,"family":"error_trace","outermost":true,"program_length":73,"wall_seconds":0.0009335569920949638},{"classification":"finite_fixture","cpu_seconds":0.0005218889999980547,"exception":null,"family":"reverse_all","outermost":true,"program_length":73,"wall_seconds":0.0005234749987721443},{"classification":"finite_fixture","cpu_seconds":0.0009699949999983914,"exception":null,"family":"error_trace","outermost":true,"program_length":74,"wall_seconds":0.0009719010267872363},{"classification":"finite_fixture","cpu_seconds":0.0005751719999977922,"exception":null,"family":"reverse_all","outermost":true,"program_length":74,"wall_seconds":0.0005769220006186515},{"classification":"finite_fixture","cpu_seconds":0.00016540600000070071,"exception":null,"family":"error_trace","outermost":true,"program_length":5,"wall_seconds":0.0001672340149525553},{"classification":"finite_fixture","cpu_seconds":8.077900000103e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":5,"wall_seconds":8.215001435019076e-05},{"classification":"finite_fixture","cpu_seconds":0.00013186300000000983,"exception":null,"family":"error_trace","outermost":true,"program_length":6,"wall_seconds":0.00013337700511328876},{"classification":"finite_fixture","cpu_seconds":7.410299999577319e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":6,"wall_seconds":7.534000906161964e-05},{"classification":"finite_fixture","cpu_seconds":0.00014018500000645417,"exception":null,"family":"error_trace","outermost":true,"program_length":7,"wall_seconds":0.00014185599866323173},{"classification":"finite_fixture","cpu_seconds":7.636299999802532e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":7,"wall_seconds":7.76439846958965e-05},{"classification":"finite_fixture","cpu_seconds":0.00013441000000113945,"exception":null,"family":"error_trace","outermost":true,"program_length":8,"wall_seconds":0.00013581098755821586},{"classification":"finite_fixture","cpu_seconds":8.42940000040926e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":8,"wall_seconds":8.563499432057142e-05},{"classification":"finite_fixture","cpu_seconds":0.00015905000000060454,"exception":null,"family":"error_trace","outermost":true,"program_length":9,"wall_seconds":0.0001607910089660436},{"classification":"finite_fixture","cpu_seconds":9.353099999742653e-05,"exception":null,"family":"reverse_all","outermost":true,"program_length":9,"wall_seconds":9.483000030741096e-05},{"classification":"finite_fixture","cpu_seconds":0.00015107000000114112,"exception":null,"family":"error_trace","outermost":true,"program_length":10,"wall_seconds":0.0001524980179965496},{"classification":"finite_fixture","cpu_seconds":0.00013862100000494593,"exception":null,"family":"reverse_all","outermost":true,"program_length":10,"wall_seconds":0.0001401000190526247},{"classification":"finite_fixture","cpu_seconds":0.00018284100000443004,"exception":null,"family":"error_trace","outermost":true,"program_length":11,"wall_seconds":0.00018437899416312575},{"classification":"finite_fixture","cpu_seconds":0.00010612700000223185,"exception":null,"family":"reverse_all","outermost":true,"program_length":11,"wall_seconds":0.00010742200538516045},{"classification":"finite_fixture","cpu_seconds":0.00019088799999877892,"exception":null,"family":"error_trace","outermost":true,"program_length":12,"wall_seconds":0.0001926789991557598},{"classification":"finite_fixture","cpu_seconds":0.00010932100000360379,"exception":null,"family":"reverse_all","outermost":true,"program_length":12,"wall_seconds":0.00011068000458180904},{"classification":"finite_fixture","cpu_seconds":0.00019194000000055667,"exception":null,"family":"error_trace","outermost":true,"program_length":13,"wall_seconds":0.0001933479798026383},{"classification":"finite_fixture","cpu_seconds":0.00011167400000289263,"exception":null,"family":"reverse_all","outermost":true,"program_length":13,"wall_seconds":0.00011319699115119874},{"classification":"finite_fixture","cpu_seconds":0.00022051799999900368,"exception":null,"family":"error_trace","outermost":true,"program_length":14,"wall_seconds":0.00022200500825420022},{"classification":"finite_fixture","cpu_seconds":0.0001299320000001103,"exception":null,"family":"reverse_all","outermost":true,"program_length":14,"wall_seconds":0.00013141598901711404},{"classification":"finite_fixture","cpu_seconds":0.0002870530000009808,"exception":null,"family":"error_trace","outermost":true,"program_length":15,"wall_seconds":0.00028899998869746923},{"classification":"finite_fixture","cpu_seconds":0.00013176800000280764,"exception":null,"family":"reverse_all","outermost":true,"program_length":15,"wall_seconds":0.0001331249950453639},{"classification":"finite_fixture","cpu_seconds":0.00022680600000057893,"exception":null,"family":"error_trace","outermost":true,"program_length":16,"wall_seconds":0.00022838101722300053},{"classification":"finite_fixture","cpu_seconds":0.00013158600000195975,"exception":null,"family":"reverse_all","outermost":true,"program_length":16,"wall_seconds":0.0001329020014964044},{"classification":"finite_fixture","cpu_seconds":0.0002557899999970914,"exception":null,"family":"error_trace","outermost":true,"program_length":17,"wall_seconds":0.0002573060046415776},{"classification":"finite_fixture","cpu_seconds":0.00015454100000056314,"exception":null,"family":"reverse_all","outermost":true,"program_length":17,"wall_seconds":0.00015591800911352038},{"classification":"finite_fixture","cpu_seconds":0.0002311320000032424,"exception":null,"family":"error_trace","outermost":true,"program_length":18,"wall_seconds":0.00023278401931747794},{"classification":"finite_fixture","cpu_seconds":0.00014364200000471783,"exception":null,"family":"reverse_all","outermost":true,"program_length":18,"wall_seconds":0.00014508698950521648},{"classification":"finite_fixture","cpu_seconds":0.00028555700000509887,"exception":null,"family":"error_trace","outermost":true,"program_length":19,"wall_seconds":0.00028711199411191046},{"classification":"finite_fixture","cpu_seconds":0.00016130199999508932,"exception":null,"family":"reverse_all","outermost":true,"program_length":19,"wall_seconds":0.00016271401545964181},{"classification":"finite_fixture","cpu_seconds":0.00028834599999782995,"exception":null,"family":"error_trace","outermost":true,"program_length":20,"wall_seconds":0.0002899190003518015},{"classification":"finite_fixture","cpu_seconds":0.00016102600000067468,"exception":null,"family":"reverse_all","outermost":true,"program_length":20,"wall_seconds":0.00016239102114923298},{"classification":"finite_fixture","cpu_seconds":0.000323231999999507,"exception":null,"family":"error_trace","outermost":true,"program_length":21,"wall_seconds":0.00032486399868503213},{"classification":"finite_fixture","cpu_seconds":0.00020316200000536355,"exception":null,"family":"reverse_all","outermost":true,"program_length":21,"wall_seconds":0.0002080590056721121},{"classification":"finite_fixture","cpu_seconds":0.0003158209999938322,"exception":null,"family":"error_trace","outermost":true,"program_length":22,"wall_seconds":0.00031760698766447604},{"classification":"finite_fixture","cpu_seconds":0.0001776340000034793,"exception":null,"family":"reverse_all","outermost":true,"program_length":22,"wall_seconds":0.00017908602603711188},{"classification":"finite_fixture","cpu_seconds":0.0003375300000030279,"exception":null,"family":"error_trace","outermost":true,"program_length":23,"wall_seconds":0.00033913698280230165},{"classification":"finite_fixture","cpu_seconds":0.00018624099999442478,"exception":null,"family":"reverse_all","outermost":true,"program_length":23,"wall_seconds":0.00018761400133371353},{"classification":"finite_fixture","cpu_seconds":0.00033312799999407616,"exception":null,"family":"error_trace","outermost":true,"program_length":24,"wall_seconds":0.00033464899752289057},{"classification":"finite_fixture","cpu_seconds":0.00019222600000290413,"exception":null,"family":"reverse_all","outermost":true,"program_length":24,"wall_seconds":0.00019369900110177696},{"classification":"finite_fixture","cpu_seconds":0.0003622549999988678,"exception":null,"family":"error_trace","outermost":true,"program_length":25,"wall_seconds":0.0003639799833763391},{"classification":"finite_fixture","cpu_seconds":0.00020208099999763363,"exception":null,"family":"reverse_all","outermost":true,"program_length":25,"wall_seconds":0.00020334700820967555},{"classification":"finite_fixture","cpu_seconds":0.0005969140000061657,"exception":null,"family":"error_trace","outermost":true,"program_length":26,"wall_seconds":0.0005988780176267028},{"classification":"finite_fixture","cpu_seconds":0.00030627699999996594,"exception":null,"family":"reverse_all","outermost":true,"program_length":26,"wall_seconds":0.00030800202512182295},{"classification":"finite_fixture","cpu_seconds":0.00041758899999422283,"exception":null,"family":"error_trace","outermost":true,"program_length":27,"wall_seconds":0.00041932601016014814},{"classification":"finite_fixture","cpu_seconds":0.00022191600000098788,"exception":null,"family":"reverse_all","outermost":true,"program_length":27,"wall_seconds":0.00022345100296661258},{"classification":"finite_fixture","cpu_seconds":0.0004690920000030019,"exception":null,"family":"error_trace","outermost":true,"program_length":28,"wall_seconds":0.0004707580083049834},{"classification":"finite_fixture","cpu_seconds":0.0002628829999977711,"exception":null,"family":"reverse_all","outermost":true,"program_length":28,"wall_seconds":0.00026455699116922915},{"classification":"finite_fixture","cpu_seconds":0.00040088800000148694,"exception":null,"family":"error_trace","outermost":true,"program_length":29,"wall_seconds":0.0004026360111311078},{"classification":"finite_fixture","cpu_seconds":0.00024790199999813467,"exception":null,"family":"reverse_all","outermost":true,"program_length":29,"wall_seconds":0.0002493899955879897},{"classification":"finite_fixture","cpu_seconds":0.0003247639999983676,"exception":null,"family":"error_trace","outermost":true,"program_length":30,"wall_seconds":0.0003264860133640468},{"classification":"finite_fixture","cpu_seconds":0.00018521500000190372,"exception":null,"family":"reverse_all","outermost":true,"program_length":30,"wall_seconds":0.00018658197950571775},{"classification":"finite_fixture","cpu_seconds":0.0005028180000010707,"exception":null,"family":"error_trace","outermost":true,"program_length":31,"wall_seconds":0.0005045229918323457},{"classification":"finite_fixture","cpu_seconds":0.00027881099999405023,"exception":null,"family":"reverse_all","outermost":true,"program_length":31,"wall_seconds":0.0002802789967972785},{"classification":"finite_fixture","cpu_seconds":0.0005080990000010388,"exception":null,"family":"error_trace","outermost":true,"program_length":32,"wall_seconds":0.0005097539979033172},{"classification":"finite_fixture","cpu_seconds":0.0002878680000009126,"exception":null,"family":"reverse_all","outermost":true,"program_length":32,"wall_seconds":0.00028934498550370336},{"classification":"finite_fixture","cpu_seconds":0.0004491369999968242,"exception":null,"family":"error_trace","outermost":true,"program_length":33,"wall_seconds":0.00045100602437742054},{"classification":"finite_fixture","cpu_seconds":0.00023924799999974766,"exception":null,"family":"reverse_all","outermost":true,"program_length":33,"wall_seconds":0.00024072499945759773},{"classification":"finite_fixture","cpu_seconds":0.0005583840000014106,"exception":null,"family":"error_trace","outermost":true,"program_length":34,"wall_seconds":0.0005601519951596856},{"classification":"finite_fixture","cpu_seconds":0.00030376800000198045,"exception":null,"family":"reverse_all","outermost":true,"program_length":34,"wall_seconds":0.00030525799957104027},{"classification":"finite_fixture","cpu_seconds":0.0005313119999996729,"exception":null,"family":"error_trace","outermost":true,"program_length":35,"wall_seconds":0.0005365980032365769},{"classification":"finite_fixture","cpu_seconds":0.0003111549999985641,"exception":null,"family":"reverse_all","outermost":true,"program_length":35,"wall_seconds":0.00031268701422959566},{"classification":"finite_fixture","cpu_seconds":0.0005150950000043508,"exception":null,"family":"error_trace","outermost":true,"program_length":36,"wall_seconds":0.0005168149946257472},{"classification":"finite_fixture","cpu_seconds":0.0003032699999963029,"exception":null,"family":"reverse_all","outermost":true,"program_length":36,"wall_seconds":0.00030487400363199413},{"classification":"finite_fixture","cpu_seconds":0.0005494279999993523,"exception":null,"family":"error_trace","outermost":true,"program_length":37,"wall_seconds":0.000551136996364221},{"classification":"finite_fixture","cpu_seconds":0.0003177330000028178,"exception":null,"family":"reverse_all","outermost":true,"program_length":37,"wall_seconds":0.0003190720162820071},{"classification":"finite_fixture","cpu_seconds":0.0005048499999986689,"exception":null,"family":"error_trace","outermost":true,"program_length":38,"wall_seconds":0.000506484997458756},{"classification":"finite_fixture","cpu_seconds":0.0002674799999979882,"exception":null,"family":"reverse_all","outermost":true,"program_length":38,"wall_seconds":0.0002690829860512167},{"classification":"finite_fixture","cpu_seconds":0.0005493470000033085,"exception":null,"family":"error_trace","outermost":true,"program_length":39,"wall_seconds":0.0005510629853233695},{"classification":"finite_fixture","cpu_seconds":0.00028910400000370373,"exception":null,"family":"reverse_all","outermost":true,"program_length":39,"wall_seconds":0.00029049100703559816},{"classification":"finite_fixture","cpu_seconds":0.0006743049999968775,"exception":null,"family":"error_trace","outermost":true,"program_length":40,"wall_seconds":0.0006761649856343865},{"classification":"finite_fixture","cpu_seconds":0.00033628599999957487,"exception":null,"family":"reverse_all","outermost":true,"program_length":40,"wall_seconds":0.0003377599932719022},{"classification":"finite_fixture","cpu_seconds":0.0005429320000018834,"exception":null,"family":"error_trace","outermost":true,"program_length":41,"wall_seconds":0.0005445849965326488},{"classification":"finite_fixture","cpu_seconds":0.0003050529999981677,"exception":null,"family":"reverse_all","outermost":true,"program_length":41,"wall_seconds":0.00030645300284959376},{"classification":"finite_fixture","cpu_seconds":0.0005892870000039352,"exception":null,"family":"error_trace","outermost":true,"program_length":42,"wall_seconds":0.0005949450132902712},{"classification":"finite_fixture","cpu_seconds":0.0003266889999977707,"exception":null,"family":"reverse_all","outermost":true,"program_length":42,"wall_seconds":0.0003285080019850284},{"classification":"finite_fixture","cpu_seconds":0.0006104029999960403,"exception":null,"family":"error_trace","outermost":true,"program_length":43,"wall_seconds":0.0006122740160208195},{"classification":"finite_fixture","cpu_seconds":0.0003407709999976305,"exception":null,"family":"reverse_all","outermost":true,"program_length":43,"wall_seconds":0.00034233101177960634},{"classification":"finite_fixture","cpu_seconds":0.0005100819999981354,"exception":null,"family":"error_trace","outermost":true,"program_length":44,"wall_seconds":0.0005118419940117747},{"classification":"finite_fixture","cpu_seconds":0.0002899640000038062,"exception":null,"family":"reverse_all","outermost":true,"program_length":44,"wall_seconds":0.0002914220094680786},{"classification":"finite_fixture","cpu_seconds":0.0005679970000045387,"exception":null,"family":"error_trace","outermost":true,"program_length":45,"wall_seconds":0.0005695870204363018},{"classification":"finite_fixture","cpu_seconds":0.0003053579999985345,"exception":null,"family":"reverse_all","outermost":true,"program_length":45,"wall_seconds":0.0003069849917665124},{"classification":"finite_fixture","cpu_seconds":0.0006163540000017065,"exception":null,"family":"error_trace","outermost":true,"program_length":46,"wall_seconds":0.0006181209755595773},{"classification":"finite_fixture","cpu_seconds":0.0003390749999994114,"exception":null,"family":"reverse_all","outermost":true,"program_length":46,"wall_seconds":0.00034045299980789423},{"classification":"finite_fixture","cpu_seconds":0.0007048080000018331,"exception":null,"family":"error_trace","outermost":true,"program_length":47,"wall_seconds":0.000709834013832733},{"classification":"finite_fixture","cpu_seconds":0.00039225999999814576,"exception":null,"family":"reverse_all","outermost":true,"program_length":47,"wall_seconds":0.00039365902193821967},{"classification":"finite_fixture","cpu_seconds":0.0006885789999984127,"exception":null,"family":"error_trace","outermost":true,"program_length":48,"wall_seconds":0.0006901239976286888},{"classification":"finite_fixture","cpu_seconds":0.0003742540000004624,"exception":null,"family":"reverse_all","outermost":true,"program_length":48,"wall_seconds":0.00037577300099655986},{"classification":"finite_fixture","cpu_seconds":0.0007642650000008189,"exception":null,"family":"error_trace","outermost":true,"program_length":49,"wall_seconds":0.0007659099937882274},{"classification":"finite_fixture","cpu_seconds":0.00042872400000248945,"exception":null,"family":"reverse_all","outermost":true,"program_length":49,"wall_seconds":0.00043020700104534626},{"classification":"finite_fixture","cpu_seconds":0.0007181249999987926,"exception":null,"family":"error_trace","outermost":true,"program_length":50,"wall_seconds":0.0007201400003395975},{"classification":"finite_fixture","cpu_seconds":0.0003679320000031794,"exception":null,"family":"reverse_all","outermost":true,"program_length":50,"wall_seconds":0.000369468005374074},{"classification":"finite_fixture","cpu_seconds":0.0008098570000001359,"exception":null,"family":"error_trace","outermost":true,"program_length":51,"wall_seconds":0.0008162379963323474},{"classification":"finite_fixture","cpu_seconds":0.00042853499999750966,"exception":null,"family":"reverse_all","outermost":true,"program_length":51,"wall_seconds":0.00043027798528783023},{"classification":"finite_fixture","cpu_seconds":0.000693945999998391,"exception":null,"family":"error_trace","outermost":true,"program_length":52,"wall_seconds":0.0006955930148251355},{"classification":"finite_fixture","cpu_seconds":0.0003763960000000566,"exception":null,"family":"reverse_all","outermost":true,"program_length":52,"wall_seconds":0.0003779969993047416},{"classification":"finite_fixture","cpu_seconds":0.0006773129999970706,"exception":null,"family":"error_trace","outermost":true,"program_length":53,"wall_seconds":0.0006789749895688146},{"classification":"finite_fixture","cpu_seconds":0.00036254300000138073,"exception":null,"family":"reverse_all","outermost":true,"program_length":53,"wall_seconds":0.0003638869966380298},{"classification":"finite_fixture","cpu_seconds":0.0007084790000035923,"exception":null,"family":"error_trace","outermost":true,"program_length":54,"wall_seconds":0.0007103410025592893},{"classification":"finite_fixture","cpu_seconds":0.00038912099999777183,"exception":null,"family":"reverse_all","outermost":true,"program_length":54,"wall_seconds":0.0003906239871867001}]},"integer_source_sha256":"82a73e4bcf1835bfdd510c7ad5538625c1b380c559b671e6a67be490615a743a","key_disjoint_union_seconds":{"cpu":2.577710656000054,"wall":2.6140917660009224},"native_key_regions":{"after_callback":{"closed":347439,"cpu_seconds":0.4405703460000047,"entries":347439,"errors":6,"excluded_callback":0,"hits":0,"inserted":347433,"misses":0,"timed":347439,"wall_seconds":0.44372518899999314},"callback_depth":0,"clock_failures":0,"integer_depth":0,"integer_enters":246,"integer_leaves":246,"integer_overlap_intervals":0,"key_depth":0,"lookup":{"closed":2600825,"cpu_seconds":2.1371403100000492,"entries":2600825,"errors":3,"excluded_callback":0,"hits":2253383,"inserted":0,"misses":347439,"timed":2600825,"wall_seconds":2.1703665770009293},"nested_key_intervals":0,"protocol_errors":0},"necessary_zero_cost_threshold_seconds":{"cpu":5.1705,"wall":5.199267808800505},"optimization_constructed":false,"original_cache_statistics_unchanged":true,"original_fraction_callback_and_score_order_unchanged":true,"outer_cpu_must_include_compiler_children":true,"overlap_rejected":true,"performance_sample":false,"prior_run_numbers_added":false,"provisional_new_control_reserve_seconds":{"cpu":0.5,"wall":0.5},"provisional_reserve_is_measured_bill":false,"reserve_gate":{"cpu":true,"wall":true},"retained_integer_runtime":"UNPRICED_NONZERO","retained_key_runtime":"UNPRICED_NONZERO","same_run_disjoint_union_seconds":{"cpu":7.261139371000038,"wall":7.298804342273354},"scope":"same frozen PR5864 full_C qualifier scope; original separately registered custody scope unchanged","screen_status":"HEADROOM_FOR_COST_DESIGN_ONLY","source_copy":{"all_other_baseline_bytes_and_modes_equal":true,"copied_baseline_files":164,"current_original_baseline_compared_per_file":true,"diagnostic_edits_reverse_to_exact_original":true,"diagnostic_native_sha256":"039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3","original_native_sha256":"78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb"},"status":"PASS_JOINT_COST_DIAGNOSTIC","zero_cost_gate":{"cpu":true,"wall":true}} diff --git a/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/usage.json b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/usage.json new file mode 100644 index 0000000000..6c7238c328 --- /dev/null +++ b/research/verification-key-headroom/evidence/runs/joint-cost-screen-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":33.69,"system_seconds":1.70,"kernel_max_rss_kib":112812,"exit":0} diff --git a/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/FROZEN-SOURCE.json b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/FROZEN-SOURCE.json new file mode 100644 index 0000000000..ea0238f82f --- /dev/null +++ b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/FROZEN-SOURCE.json @@ -0,0 +1,41 @@ +{ + "files_sha256": { + "PLAN.md": "18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5", + "REPRODUCE.md": "167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9" + }, + "frozen_plan": { + "automatic_retries": 0, + "calls_per_sample": 2621440, + "capacity": 16384, + "construction_admitted": false, + "events": 32768, + "evictions_per_sample": 311296, + "hits_per_sample": 2293760, + "integer_residual_assumed_for_rejection_only": 0, + "lookups_per_event": 80, + "misses_per_sample": 327680, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "performance_publication": false, + "provisional_new_bill_reserve_seconds": 0.5, + "reserve_measured": false, + "samples": 4 + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "JOINT-DIAGNOSTIC-REVIEW.md": "6374ac5865a7fc12000a264e632181a49a0f70d1ab20e222537aa77322d77bab", + "REMAINING-ROUTE-REASSESSMENT.md": "caddd8fb6c8128ac907a668b491c9aab981362d9f1b66377084271e10f8f1289", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_PREPARED_UNEXECUTED" +} diff --git a/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PARENT-PLAN.json b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PARENT-PLAN.json new file mode 100644 index 0000000000..d00ec23cbb --- /dev/null +++ b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PARENT-PLAN.json @@ -0,0 +1,24 @@ +{ + "status": "FROZEN_REVIEWED_ONE_COLD_KEY_ONLY_PILOT", + "created_utc": "2026-10-27T15:05:15.618336+00:00", + "manifest_sha256": "b8f843524f62ed239927db894c4699b3d945900cd9681b78f6d32dfa06e1f3de", + "source_C_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "driver_sha256": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "one_command": true, + "automatic_retries": 0, + "calls_per_sample": 2621440, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "shared_spent_before_seconds": 696.3021888930816, + "shared_cap_seconds": 1500, + "command_cap_seconds": 180, + "groupRSS_bytes": 1073741824, + "source_only_review": "IndependentAstrareviewfinalhashclearance +parentcompleteC/Pythonsourcecheck", + "scope": "Synthetickey-onlycostfeasibility, opaqueIDs, noFractionAPIorfullperformanceclaim", + "output": "runtime/cache-key-pilot-v1-artifacts/RESULT.json", + "compilation_flags": "-O3sharedbotharms; production-O2 timingsnotdirectlyinferred" +} diff --git a/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PLAN.md b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PLAN.md new file mode 100644 index 0000000000..314d520145 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/PLAN.md @@ -0,0 +1,19 @@ +# Finite key-only source plan + +Status: SOURCE PREPARATION ONLY; no compiler, scientific import or workload has been run by the author. Parent alone may freeze and run this one pilot. This is not a production Cache/Event replacement or complete performance claim. + +The original reference is `../baseline-public/native_cache.c`, especially contribution lines 99–137. It constructs a fresh seven-PyLong tuple, looks it up in a Python dictionary, invokes the literal Fraction callback on misses, validates four Fraction results, then evicts FIFO and inserts. member() already uses direct tp_descr_get. No descriptor-call saving is claimed. + +Both pilot arms accept pre-extracted exact seven-int tuples and return opaque monotone miss IDs. Their timed calls exclude Fraction construction, arithmetic, miss callback/result type checks, descriptor extraction, Event.apply, score additions, source iteration, and row updates. Both retain fresh key storage, numeric equality, hash collisions, FIFO capacity, result ownership and ordered hit/miss/eviction outputs. Both include identical input validation, output allocation and prefix counters. Private cache/key destruction is inside each timed C call; destruction of returned output packets occurs after the clock and is paid by the outer command. These omissions prevent full Cache/API compatibility and prevent applying the synthetic per-call difference as a measured PR5864 saving. + +The baseline arm preserves the relevant tuple/dictionary/FIFO sequence, but uses opaque IDs instead of the actual four-Fraction callback. The custom arm stores seven owned exact PyLong references per resident entry, probes with a borrowed stack key, hashes every field using public PyObject_Hash, compares all seven fields with public numeric equality, resolves collisions by linear probing, retains tombstones, and performs paid same-size rehashes at 75% occupied-or-tomb occupancy. Table size is the smallest power of two at least twice capacity, with a minimum of eight. FIFO ring position is stable across rehashes; hits do not refresh FIFO. No private integer layout, GMP ABI, arbitrary callback, mutable stored value or general GC object is introduced. + +Frozen proposal: one cold child, inner order B,C,C,B; no warmup, retries, calibration subtraction or favorable-repeat replacement. Each timed call has 32,768 event contexts, 80 lookups/context, 2,621,440 total lookups, 327,680 distinct miss keys, seven hits/miss and capacity 16,384. Each event uses one small q. Fields represent small normalized dyadics with at most 20-bit old numerators, powers-of-two denominators no larger than 4096, and tokens 0..3586. Two independently allocated equal key tuples alternate within repetitions, including non-interned equal PyLong values. This is deliberately synthetic, not an actual PR5864 trace. Full expected misses/hits/evictions are checked by a separate literal Python dict+deque oracle. + +Broad untimed finite controls include 8192-bit signed values, zero, separately allocated equal integers, exact-PyLong/hash/table collisions, capacities 1/2/3/16/16384, FIFO turnover, no refresh on hit, tombstones and natural rehashes. Rejection controls cover bool, subclasses, foreign values, malformed rows and bounds. Declared failure points cover temporary lookup ownership, value creation, eviction, stored ownership, output ownership, explicit hit-result cleanup, and pre-publication custom rehash allocation failure; raw reference counts before/after must match. These hooks do not claim exhaustive allocator fault coverage. + +Every full ordered output is retained as native-endian unsigned 64-bit result IDs, one flag byte per lookup (0=hit, 1=miss, 3=miss+eviction), and JSON prefix counters after each 80 operations/final partial context. B and C are compared exactly to the independent oracle, not only by digest. All four samples are kept. Byte order and item size are recorded. + +The screen uses min(B1-C1, B2-C2), separately for wall and CPU, divided by fixed calls, then multiplied by actual 2,579,750 calls solely as an illustrative optimistic budget. Integer residual is generously ZERO; 0.5 seconds for new controls is a declared provisional reserve, not a measured complete bill. Add that illustrative key saving to the diagnostic integer gross region 4.684712576272432 wall / 4.683428714999984 CPU and subtract reserve. Compare with 15% of fixed complete B: 5.199267808800505 wall / 5.1705 CPU. Diagnostic region clocks include overhead and are not measured removable runtime. Failure may reject nomination; passing only preserves an unpriced hypothesis. Real retained integer runtime, actual-trace key runtime, procurement/builds and all new validation remain unpriced. + +Outer cold measurement must include process startup, compiler subprocess CPU, source pins, loader, corpus construction, finite controls, literal oracle, all four samples, exact output comparison and output persistence. Inner measurements are separate. The parent must use the existing single 180-second, 1-GiB group guard and shared 1500-second ledger (previously spent 696.302189 seconds); zero automatic retries. Proposed total is 10–30 seconds, not a guarantee. Do not execute this child outside that guard. diff --git a/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/REPRODUCE.md b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/REPRODUCE.md new file mode 100644 index 0000000000..5241ffe49d --- /dev/null +++ b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/REPRODUCE.md @@ -0,0 +1,38 @@ +# Parent-only single-run reproduction + +Author performed source/text/AST/hash operations only. The C extension has NOT been compiled or imported and no control/corpus/timing has executed. Review and freeze first. This command is not authorization to repeat or refreeze after a failed run. + +From the project directory `/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453`, the parent may create the new immutable stage using only file operations: + +```bash +python3 - <<'PY' +from pathlib import Path +import hashlib, json, shutil +base = Path('outputs/c-verification-all-opportunities-20261027') +source = base / 'cache-key-pilot' +stage = base / 'stages/cache-key-pilot-v1' +manifest = json.loads((source / 'FROZEN-SOURCE.json').read_text()) +for name, digest in manifest['files_sha256'].items(): + assert hashlib.sha256((source / name).read_bytes()).hexdigest() == digest, name +for name, digest in manifest['reference_files_sha256'].items(): + assert hashlib.sha256((base / name).read_bytes()).hexdigest() == digest, name +stage.mkdir() +for name in [*manifest['files_sha256'], 'FROZEN-SOURCE.json']: + shutil.copy2(source / name, stage / name) +print('Frozen stage:', stage.resolve()) +PY +``` + +After independent clearance and the parent's ledger check, run exactly once through the existing serial guard: + +```bash +/usr/bin/python3.12 outputs/c-verification-all-opportunities-20261027/run_guarded.py cache-key-pilot-v1 stages/cache-key-pilot-v1/stage_entry.py +``` + +Do not use `--initial`: the initial 600-second phase is closed. Do not add `--optimized`. The guard already fixes PYTHONHASHSEED=0, applies the 180-second wall / 1-GiB sampled process-group RSS limits, serializes execution, includes compiler children in its outer `/usr/bin/time` bill, and charges the 1500-second aggregate. It admits only scripts inside a newly frozen stage. The wrapper requires that exact stage name and writes only to a fresh `runtime/cache-key-pilot-v1-artifacts` directory. All four B,C,C,B samples use fresh state, and the extension is compiled in a fresh build directory. No warmup or answer/build reuse occurs. + +Retain both `runtime/runs/cache-key-pilot-v1/receipt.json` and the whole `runtime/cache-key-pilot-v1-artifacts/` tree, including failed outputs/build diagnostics if any. The outer guard receipt, rather than the child's partial cold clock, determines the charged bill. An unsuccessful run stops this proposal; zero automatic retries. + +Artifacts include `BUILD.json` and compiler logs in `build/`, `FINITE-CONTROLS.json`, oracle and all four full ordered `*-ids.u64` / `*-flags.u8` / `*-prefixes.json` files, and `RESULT.json`. The ID files use the recorded host byte order and exactly 8 bytes per ID; the flag byte is 0 for hit, 1 for miss, 3 for miss plus eviction. Prefix rows are calls/hits/misses/evictions/resident. The driver compares every ID, flag and prefix to the separate literal Python dict/deque oracle before any nomination screen. + +Only the frozen synthetic key-only problem is tested. Passing its optimistic arithmetic does not satisfy complete PR5864 >=15% wall/CPU, the noise spread gate, full Fraction/API compatibility, the source-specific actual-trace cost, or the full new bill. No price from this pilot may be called an actual complete saving. diff --git a/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/stage_entry.py b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/stage_entry.py new file mode 100644 index 0000000000..a9cc9618bb --- /dev/null +++ b/research/verification-key-headroom/evidence/source/cache-key-pilot-v1/stage_entry.py @@ -0,0 +1,8 @@ +"""Parent-frozen guarded entry. Never run this from the preparation directory.""" +from pathlib import Path +from run_pilot import main + +stage = Path(__file__).resolve().parent +if stage.parent.name != "stages" or stage.name != "cache-key-pilot-v1": + raise RuntimeError("requires parent's immutable stages/cache-key-pilot-v1 copy") +main(stage.parent.parent / "runtime" / "cache-key-pilot-v1-artifacts") diff --git a/research/verification-key-headroom/evidence/source/gc-attribution-v1/PLAN.json b/research/verification-key-headroom/evidence/source/gc-attribution-v1/PLAN.json new file mode 100644 index 0000000000..9ddc72a74a --- /dev/null +++ b/research/verification-key-headroom/evidence/source/gc-attribution-v1/PLAN.json @@ -0,0 +1,27 @@ +{ + "created_utc": "2026-10-27T14:10:25.521510+00:00", + "phase": "one post-assessment information diagnostic within unchanged1500s sharedcap; initial600s feasibility phase remains closed", + "maximum_commands": 1, + "automatic_retries": 0, + "parent_only_serial_runner": true, + "command_seconds": 180, + "sampled_groupRSS_bytes": 1073741824, + "spent_before_seconds": 630.4812471010955, + "diagnostic": "passive gc.callbacks start/stop during original full.main(True), no math/code/GC-policy replacement", + "selection": "measure a previously unattributed cost, not reroll a failed timing series", + "standalone_zero_cost_threshold": { + "wall": 5.199267808800505, + "cpu": 5.1705 + }, + "provisional_added_control_reserve": { + "wall": 0.5, + "cpu": 0.5 + }, + "provisional_reserve_not_measured_bill": true, + "passing_is_not_construction_permission": "Actual C-policy/ownership/cycle/finalizer/restore/finite/cold costs and independent correctness require separate admission.", + "stop_if_below": "Close standaloneGC nomination; do not disable GC or alter type tracking or repeat this diagnostic. No summation with overlapping integer timings.", + "scientific_coverage": "Original finite/native/Observation/source/counter/fullresult checks,120fixtures25984actualevents799coords, completewitnesses; unchanged original benchmark scope excludes separatecustody equally.", + "source_sha256": "fb4aa2c876e25119017c31507dd373bb0ba857e3d2de81a090d24b1440086383", + "primary_API": "https://docs.python.org/3.12/library/gc.html#gc.callbacks", + "review": "Astraxhigh source-only interim recommendation; full report pending" +} diff --git a/research/verification-key-headroom/evidence/source/gc-attribution-v1/diagnostic.py b/research/verification-key-headroom/evidence/source/gc-attribution-v1/diagnostic.py new file mode 100644 index 0000000000..52fa06d3e5 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/gc-attribution-v1/diagnostic.py @@ -0,0 +1,104 @@ +"""One passive complete PR5864 cyclic-GC attribution; not a performance sample.""" +import gc +from hashlib import sha256 +import json +from pathlib import Path +import sys +import time + +ROUND=Path(__file__).resolve().parents[2] +BASE=ROUND/'baseline-public' +OUTPUT=ROUND/'runtime/gc-attribution-v1' +FULL_SHA='ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0' +BASELINE={'wall':34.66178539200337,'cpu':34.47} +NOISE={'wall':2.713637237990042,'cpu':2.3500000000000014} + +def need(ok,message): + if not ok:raise ValueError(message) + +def main(): + need(sha256((BASE/'full.py').read_bytes()).hexdigest()==FULL_SHA,'exact frozen PR5864 full source') + OUTPUT.mkdir(exist_ok=False) + original_callbacks=gc.callbacks + callbacks_before=tuple(original_callbacks) + enabled_before=gc.isenabled() + threshold_before=gc.get_threshold() + debug_before=gc.get_debug() + garbage_before=tuple(id(x) for x in gc.garbage) + stats_before=gc.get_stats() + records=[];errors=[];active=[] + def callback(phase,info): + # Collector callbacks cannot raise: retain diagnostic errors and reject + # outside the callback rather than emit an ignored/unraisable error. + if phase=='start': + if active:errors.append('nested-start') + active.append((info.get('generation'),time.perf_counter(),time.process_time())) + elif phase=='stop': + ended_cpu=time.process_time();ended_wall=time.perf_counter() + if not active: + errors.append('unmatched-stop');return + generation,started_wall,started_cpu=active.pop() + if info.get('generation')!=generation:errors.append('generation-mismatch') + if not active: + records.append({'generation':generation,'wall_seconds':ended_wall-started_wall, + 'cpu_seconds':ended_cpu-started_cpu,'collected':info.get('collected'), + 'uncollectable':info.get('uncollectable')}) + else:errors.append('unknown-phase') + original_callbacks.append(callback) + callback_state_at_end=None + error=None + try: + sys.path.insert(0,str(BASE)) + import full + full.main(True) + except BaseException as caught: + error=type(caught).__name__ + raise + finally: + callback_state_at_end=(gc.callbacks is original_callbacks and + tuple(gc.callbacks)==callbacks_before+(callback,)) + # Slice assignment retains the same public callback-list identity. + original_callbacks[:]=callbacks_before + need(gc.callbacks is original_callbacks,'GC callback list identity unchanged') + need(tuple(gc.callbacks)==callbacks_before,'exact callback state restored') + need(gc.isenabled()==enabled_before,'GC enabled state unchanged') + need(gc.get_threshold()==threshold_before,'GC thresholds unchanged') + need(gc.get_debug()==debug_before,'GC debug state unchanged') + need(tuple(id(x) for x in gc.garbage)==garbage_before,'GC garbage list unchanged') + need(callback_state_at_end,'only the appended passive timer callback present') + need(not active and not errors,'paired disjoint GC observations') + stats_after=gc.get_stats() + by_generation=[] + for generation in range(3): + rows=[r for r in records if r['generation']==generation] + delta=stats_after[generation]['collections']-stats_before[generation]['collections'] + # Statistics snapshots can cause allocation/collection before registration + # or after removal; do not pretend any unobserved interval was measured. + by_generation.append({'generation':generation,'observed_collections':len(rows), + 'stats_delta_collections':delta,'wall_seconds':sum(r['wall_seconds'] for r in rows), + 'cpu_seconds':sum(r['cpu_seconds'] for r in rows), + 'collected':sum(r['collected'] for r in rows), + 'uncollectable':sum(r['uncollectable'] for r in rows)}) + union={m:sum(r[m+'_seconds'] for r in records) for m in ('wall','cpu')} + zero={m:max(0.15*BASELINE[m],0.5,NOISE[m]) for m in ('wall','cpu')} + reserve={'wall':0.5,'cpu':0.5} + report={'status':'PASS_PASSIVE_COMPLETE_GC_ATTRIBUTION','performance_sample':False, + 'arithmetic_changed':False,'gc_policy_changed':False,'construction_admitted':False, + 'scope':'same frozen PR5864 full_C qualifier; unchanged separate custody scope', + 'observation':'all observed cyclic collections, including the original explicit finite collect controls; automatic-only removable bill cannot be larger', + 'callback_overhead':'start/stop and existing callbacks can inflate or perturb observations; not a universal machine/runtime bound', + 'callbacks_restored':True,'runtime_gc_policy_unchanged':True,'source_full_sha256':FULL_SHA, + 'fixed_baseline_medians':BASELINE,'fixed_noise_spreads':NOISE, + 'observed_disjoint_gc_seconds':union,'zero_cost_threshold_seconds':zero, + 'provisional_new_control_reserve_seconds':reserve, + 'reserve_is_actual_measured_bill':False, + 'future_policy_requires_separate_cycle_finalizer_restore_and_complete_paid_validation':True, + 'standalone_zero_cost_screen_pass':all(union[m]>zero[m] for m in union), + 'preliminary_reserve_screen_pass':all(union[m]>zero[m]+reserve[m] for m in union), + 'do_not_add_to_prior_integer_union':'GC intervals may overlap the earlier original-integer intervals; no disjoint combination attribution exists', + 'by_generation':by_generation,'stats_before':stats_before,'stats_after':stats_after, + 'records':records} + (OUTPUT/'REPORT.json').write_text(json.dumps(report,indent=2,sort_keys=True)+'\n') + print(json.dumps({k:v for k,v in report.items() if k!='records'},sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/PLAN.json b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/PLAN.json new file mode 100644 index 0000000000..f39359761d --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/PLAN.json @@ -0,0 +1,38 @@ +{ + "created_utc": "2026-10-27T14:25:35.020009+00:00", + "goal_previous_turn": "PROGRESS:one passive completeGC diagnostic closed standalone nomination without changingpolicy", + "new_scope": "One same-run disjoint grosscost screen: original integerEngine+nativecontributionkeybookkeeping; notnewimplementation/timingreroll", + "scientific_runner": "idle, parentonly; Astra source preparation active", + "source_owner": "/root/astra_integer_format ownsjoint-cost-screen/ andJOINT-CACHE-INTEGER-PLAN.md", + "baseline": "FrozenPR5864 samefull_Cqualifier, nativechecksandindependentFractionoperations retained; separateunchangedcustodyscope", + "mandatory_disjointness": "NativeCkeyregions excludeFractionmiss/score operations. Detectcachecalls duringintegerEngineintervals and rejectoverlap. NeveraddoldGCintervals.", + "zero_cost_gate_seconds": { + "wall": 5.199267808800505, + "cpu": 5.1705 + }, + "nonzero_provisional_reserve_seconds": { + "wall": 0.5, + "cpu": 0.5 + }, + "reserve_is_measured_actual_bill": false, + "screen_only": "Timingoverheadnotcreditedassaving. Zero-costpassnotconstructionadmission; requirepricedresidualinteger/key/finite/coldcosts.", + "caps": { + "one_serial_diagnostic": true, + "command_seconds": 180, + "groupRSS_bytes": 1073741824, + "shared_seconds": 1500, + "spent_before": 660.7824897581013, + "automatic_retries": 0 + }, + "candidate_types": "Privateintegerstate with checkedwidth+arbitrarywidthfallback ORproperlypricedGMP; customcache mustretainexactsevencomponentkeyequality/FIFO/counters/ownership/reentry; noactualconstructionadmitted", + "preservation": "Allsources,oldrecordsandoriginalthreadpreserved; otherworkpaused", + "status": "FROZEN_SOURCE_CLEARED_ONE_DIAGNOSTIC", + "frozen_utc": "2026-10-27T14:41:34.280155+00:00", + "source_driver_sha256": "fb7dd1e71c461754987c7e1af941d8220ec4b17806e0cdec27be977fdc39dfee", + "source_C_sha256": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3", + "source_edits_sha256": "91a10a6e14fb718f2c3cd44a547cb2576fb1dda0a832884a2a5c064e137d81c8", + "parent_static": "PASS164filesonlyC+hashchanged,reversesexactoriginal", + "independent_source_review": "Astraxhighclearedatfrozenhashes; reportoutsideclosure", + "no_new_optimization": true, + "executable": "python3 -B outputs/c-verification-all-opportunities-20261027/run_guarded.py joint-cost-screen-v1 stages/joint-cost-screen-v1/diagnostic.py" +} diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/SOURCE-EDITS.json b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/SOURCE-EDITS.json new file mode 100644 index 0000000000..cfacb4e648 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/SOURCE-EDITS.json @@ -0,0 +1,689 @@ +{ + "baseline_file_count": 164, + "changed_baseline_files": [ + "native_cache.c", + "NATIVE-SOURCE.json" + ], + "compilation": false, + "diagnostic_native_sha256": "039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3", + "edits": [ + { + "after": "#ifndef _POSIX_C_SOURCE\n#define _POSIX_C_SOURCE 200809L\n#endif\n#define PY_SSIZE_T_CLEAN\n#include \n#include \n#include \n#include \n#include \n\n/* Diagnostic only: no Python numeric operation, original cache counter or\n * error state is changed. CLOCK_PROCESS_CPUTIME_ID is current-process CPU. */\ntypedef struct {\n unsigned long long entries, closed, timed, excluded_callback;\n unsigned long long hits, misses, inserted, errors;\n double wall, cpu;\n} JointPhase;\ntypedef struct {\n struct timespec wall, cpu;\n int valid;\n} JointClock;\ntypedef struct {\n JointClock start;\n int phase, eligible;\n} JointTimer;\nstatic JointPhase joint_phases[2];\nstatic unsigned long long joint_key_depth, joint_integer_depth, joint_callback_depth;\nstatic unsigned long long joint_clock_failures, joint_protocol_errors;\nstatic unsigned long long joint_nested_intervals, joint_integer_overlaps;\nstatic unsigned long long joint_integer_enters, joint_integer_leaves;\nenum { JOINT_LOOKUP=0, JOINT_AFTER=1 };\nenum { JOINT_HIT=0, JOINT_MISS=1, JOINT_INSERTED=2, JOINT_ERROR=3 };\nstatic void joint_inc(unsigned long long *value) {\n if (*value==ULLONG_MAX) {\n if (joint_protocol_errorsphase];\n if (timer->eligible) {\n JointClock end=joint_clock();\n if (!end.valid) joint_inc(&joint_clock_failures);\n if (end.valid && timer->start.valid) {\n double wall=joint_delta(end.wall,timer->start.wall);\n double cpu=joint_delta(end.cpu,timer->start.cpu);\n if (wall<0 || cpu<0) joint_inc(&joint_protocol_errors);\n else { phase->wall+=wall;phase->cpu+=cpu; }\n }\n if (!joint_key_depth) joint_inc(&joint_protocol_errors);\n else joint_key_depth--;\n }\n joint_inc(&phase->closed);\n if (outcome==JOINT_HIT) joint_inc(&phase->hits);\n else if (outcome==JOINT_MISS) joint_inc(&phase->misses);\n else if (outcome==JOINT_INSERTED) joint_inc(&phase->inserted);\n else joint_inc(&phase->errors);\n}\nstatic PyObject *joint_integer_enter(PyObject *self, PyObject *unused) {\n (void)self;(void)unused;\n if (joint_key_depth) joint_inc(&joint_integer_overlaps);\n joint_inc(&joint_integer_enters);joint_inc(&joint_integer_depth);\n Py_RETURN_NONE;\n}\nstatic PyObject *joint_integer_leave(PyObject *self, PyObject *unused) {\n (void)self;(void)unused;\n joint_inc(&joint_integer_leaves);\n if (!joint_integer_depth) joint_inc(&joint_protocol_errors);\n else joint_integer_depth--;\n Py_RETURN_NONE;\n}\nstatic PyObject *joint_phase_dict(JointPhase *p) {\n return Py_BuildValue(\"{s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:d,s:d}\",\n \"entries\",p->entries,\"closed\",p->closed,\"timed\",p->timed,\n \"excluded_callback\",p->excluded_callback,\"hits\",p->hits,\n \"misses\",p->misses,\"inserted\",p->inserted,\"errors\",p->errors,\n \"wall_seconds\",p->wall,\"cpu_seconds\",p->cpu);\n}\nstatic PyObject *joint_diagnostics(PyObject *self, PyObject *unused) {\n (void)self;(void)unused;\n PyObject *lookup=joint_phase_dict(&joint_phases[JOINT_LOOKUP]);\n PyObject *after=joint_phase_dict(&joint_phases[JOINT_AFTER]);\n if (!lookup || !after) {Py_XDECREF(lookup);Py_XDECREF(after);return NULL;}\n PyObject *result=Py_BuildValue(\"{s:O,s:O,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K}\",\n \"lookup\",lookup,\"after_callback\",after,\n \"key_depth\",joint_key_depth,\"integer_depth\",joint_integer_depth,\n \"callback_depth\",joint_callback_depth,\"clock_failures\",joint_clock_failures,\n \"protocol_errors\",joint_protocol_errors,\"nested_key_intervals\",joint_nested_intervals,\n \"integer_overlap_intervals\",joint_integer_overlaps,\n \"integer_enters\",joint_integer_enters,\"integer_leaves\",joint_integer_leaves);\n Py_DECREF(lookup);Py_DECREF(after);return result;\n}\nstatic PyObject *joint_clock_calibration(PyObject *self, PyObject *unused) {\n (void)self;(void)unused;\n unsigned long long failures=0;\n JointClock start=joint_clock();\n for (int i=0;i<512;i++) {\n JointClock a=joint_clock(),b=joint_clock();\n if (!a.valid || !b.valid) failures++;\n }\n JointClock end=joint_clock();\n if (!start.valid || !end.valid || failures) {\n PyErr_SetString(PyExc_RuntimeError,\"joint diagnostic calibration clock failure\");return NULL;\n }\n return Py_BuildValue(\"{s:i,s:i,s:d,s:d,s:O}\",\n \"empty_intervals\",512,\"clock_gettime_calls_per_interval\",4,\n \"wall_seconds\",joint_delta(end.wall,start.wall),\n \"cpu_seconds\",joint_delta(end.cpu,start.cpu),\n \"subtracted_from_envelope\",Py_False);\n}\nstatic PyMethodDef joint_module_methods[]={\n {\"_joint_integer_enter\",joint_integer_enter,METH_NOARGS,\"Diagnostic activity marker only.\"},\n {\"_joint_integer_leave\",joint_integer_leave,METH_NOARGS,\"Diagnostic activity marker only.\"},\n {\"_joint_diagnostics\",joint_diagnostics,METH_NOARGS,\"Separate diagnostics; existing cache statistics unchanged.\"},\n {\"_joint_clock_calibration\",joint_clock_calibration,METH_NOARGS,\"Record clock overhead; never subtract it.\"},\n {NULL,NULL,0,NULL}\n};\n", + "before": "#define PY_SSIZE_T_CLEAN\n#include \n#include \n", + "label": "diagnostic-clocks-markers-and-separate-module-methods" + }, + { + "after": "static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) {\n Cache *s=e->cache;\n JointTimer timer=joint_start(JOINT_LOOKUP);\n if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,\"native site index\");joint_stop(&timer,JOINT_ERROR);return NULL; }\n if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,\"exact Fraction coefficients\");joint_stop(&timer,JOINT_ERROR);return NULL; }\n PyObject *parts[4]={NULL,NULL,NULL,NULL};\n for (int k=0;k<4;k++) {\n parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction);\n if (!parts[k] || !PyLong_CheckExact(parts[k])) {\n for(int j=0;j<4;j++)Py_XDECREF(parts[j]);\n if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,\"integer Fraction slots\");\n joint_stop(&timer,JOINT_ERROR);return NULL;\n }\n }\n PyObject *key=PyTuple_New(7);\n if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);joint_stop(&timer,JOINT_ERROR);return NULL;}\n PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]);\n PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd));\n PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i)));\n if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,\"native counter overflow\");joint_stop(&timer,JOINT_ERROR);return NULL;}\n s->calls++;\n PyObject *result=PyDict_GetItemWithError(s->dict,key);\n if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_HIT);return result;}\n if(PyErr_Occurred()){Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;}\n s->misses++;\n PyObject *pair=PyTuple_GET_ITEM(s->weights,i);\n PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)};\n joint_stop(&timer,JOINT_MISS);\n joint_inc(&joint_callback_depth);\n result=PyObject_Vectorcall(s->compute,argv,5,NULL);\n if (!joint_callback_depth) joint_inc(&joint_protocol_errors);else joint_callback_depth--;\n timer=joint_start(JOINT_AFTER);\n if(!result){Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;}\n if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,\"four exact contributions\");joint_stop(&timer,JOINT_ERROR);return NULL;}\n for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,\"Fraction contributions\");joint_stop(&timer,JOINT_ERROR);return NULL;}\n if(s->used==s->capacity){\n PyObject *oldkey=s->ring[s->head];\n if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;}\n Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++;\n }\n if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;}\n s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++;\n joint_stop(&timer,JOINT_INSERTED);\n return result;\n}\n", + "before": "static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) {\n Cache *s=e->cache;\n if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,\"native site index\");return NULL; }\n if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,\"exact Fraction coefficients\");return NULL; }\n PyObject *parts[4]={NULL,NULL,NULL,NULL};\n for (int k=0;k<4;k++) {\n parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction);\n if (!parts[k] || !PyLong_CheckExact(parts[k])) {\n for(int j=0;j<4;j++)Py_XDECREF(parts[j]);\n if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,\"integer Fraction slots\");\n return NULL;\n }\n }\n PyObject *key=PyTuple_New(7);\n if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);return NULL;}\n PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]);\n PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd));\n PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i)));\n if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,\"native counter overflow\");return NULL;}\n s->calls++;\n PyObject *result=PyDict_GetItemWithError(s->dict,key);\n if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);return result;}\n if(PyErr_Occurred()){Py_DECREF(key);return NULL;}\n s->misses++;\n PyObject *pair=PyTuple_GET_ITEM(s->weights,i);\n PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)};\n result=PyObject_Vectorcall(s->compute,argv,5,NULL);\n if(!result){Py_DECREF(key);return NULL;}\n if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,\"four exact contributions\");return NULL;}\n for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,\"Fraction contributions\");return NULL;}\n if(s->used==s->capacity){\n PyObject *oldkey=s->ring[s->head];\n if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);return NULL;}\n Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++;\n }\n if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);return NULL;}\n s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++;\n return result;\n}\n", + "label": "timed-original-contribution-with-callback-gap" + }, + { + "after": "static struct PyModuleDef module={PyModuleDef_HEAD_INIT,\"_fraction_native\",\"Bounded cache; exact Python arithmetic.\",-1,joint_module_methods};", + "before": "static struct PyModuleDef module={PyModuleDef_HEAD_INIT,\"_fraction_native\",\"Bounded cache; exact Python arithmetic.\",-1,NULL};", + "label": "expose-only-separate-diagnostic-module-methods" + } + ], + "exact_original_complete_c_source_restored": true, + "exact_original_contribution_restored": true, + "numerical_execution": false, + "original_inventory": { + ".gitignore": { + "mode": 420, + "sha256": "bb3b9556fe4404790732de3f54d1e6d8d213775e13c07d342b3e051f20ffce78" + }, + ".research-export.json": { + "mode": 420, + "sha256": "bd8d548de371bfce83238f51c8c5487d1e7d57ade1b77a82dd84e2e648ede0b0" + }, + "GETTER-SHAPES.json": { + "mode": 420, + "sha256": "0ca61c0d9062b93d16957357f2190b702a99be0104d980abeba4ae20a81eaed4" + }, + "NATIVE-SOURCE.json": { + "mode": 420, + "sha256": "2bc3043374685ece68f0091238ab038f6cfcd13be80610b5e348d61984cb11f3" + }, + "NOTICE": { + "mode": 420, + "sha256": "f82a0634dc69dfdedfe5fd8773a6a01dc1d7ba5f3e1857e99eb1598881d7be83" + }, + "PROOF.md": { + "mode": 420, + "sha256": "ba072aae5886b26f0700b2c8011bbef2c20b534518e20cbab28e18440f654b9b" + }, + "README.md": { + "mode": 420, + "sha256": "73c53677bd6dd5663b9cc54a754ea05fbf41b71a03eb5589e2920a4ef0518c95" + }, + "RESULT.json": { + "mode": 420, + "sha256": "2205b4b72326a0c05fe365757f0e7b058f53f3b1e9b0aae4cef7a95284451188" + }, + "SOURCES.json": { + "mode": 420, + "sha256": "540e1d56182c716a8f3ba13a2e15021f573df2aa28eea8c3330cfce81abdfedc" + }, + "TASK.json": { + "mode": 420, + "sha256": "b4cb8dcbce6665305c6306dac5763ef7669cc74c2371b20f09503aa45759132c" + }, + "VALIDATION.json": { + "mode": 420, + "sha256": "0411806fa5fb5d2f00d22be2565ed1de6dab51a187e61a3a120f7588dced52d4" + }, + "VERIFY.json": { + "mode": 420, + "sha256": "3470371b5937e7fa209e4bffb198dc0bf7e1d0c0c3d864c8cd1e00594ab95d53" + }, + "actual_audit.py": { + "mode": 420, + "sha256": "4ba909ed874b966db0ed32a986eb746908ba507a2a6491147ae15ba67d42883a" + }, + "benchmark.py": { + "mode": 420, + "sha256": "813d43c1a9b2178b20df9cef37f75c02bf27d6fe06e2733dd89191c9829209b5" + }, + "compact_finite.py": { + "mode": 420, + "sha256": "9a9ba69920c5b2b880869b0a72eb5fab43be21d79efd8e4152dd886ecfd859d1" + }, + "compact_parent.py": { + "mode": 420, + "sha256": "448fba3f199cb4e36707c86819a319d207d8d24062fb5478c06aeea98f6df61a" + }, + "custody.py": { + "mode": 420, + "sha256": "f9bc4a39bd19e1392ef96cb829978a17c47df0b5a0fda178f0ef684e0e31231f" + }, + "entry_finite.py": { + "mode": 420, + "sha256": "ff7c8d70bdd1b4d265536484c8a8e801154beb38bf14c914aba5137a64dfded9" + }, + "entry_parent.py": { + "mode": 420, + "sha256": "cf83523a35acdea39cbe48cf04a775ab9d00f673525108e71a5dc6005650a7fe" + }, + "evidence/FINITE-INERT-GC-FIXTURE.py.txt": { + "mode": 420, + "sha256": "03e29a0d747483953eb00c29473ddb0220e4d87d767751f40139becac8e907d4" + }, + "evidence/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "bf3eb5bb02c4c599bcbc0911fd9304b64fe13e9d60b0d40daf611fa03491468b" + }, + "evidence/NATIVE-CACHE-PRECONSTRUCTION-REVIEW.md": { + "mode": 420, + "sha256": "d2b60cc550a0e7162a2eec5aaf41c992ff9baee9f24d9bed881481cf7ba13767" + }, + "evidence/NATIVE-CACHE-REVIEW-SOURCES.json": { + "mode": 420, + "sha256": "a58a253ae64e92ce105aabd6710a60912be21d2d9934c870ab64929eb3e5f8e9" + }, + "evidence/NATIVE-FULL-SEAM-FINAL-REVIEW.md": { + "mode": 420, + "sha256": "3efff7564cdc96fae1d3952f7c2bc155d5780dd77d697b9b5d17cef77a64a448" + }, + "evidence/NATIVE-REVIEW-FINAL-STATE.json": { + "mode": 420, + "sha256": "3b4e1bd244e3f4b961a05991d4e78d4e851bef933cabf979f6a515007ecb3243" + }, + "evidence/PLAN.json": { + "mode": 420, + "sha256": "49da164ebdc20284a19e45fb3fceb5191e2640bcebd2c162fe9974483b352434" + }, + "evidence/SCREEN.json": { + "mode": 420, + "sha256": "6d466b633ae23dab2041e8831a7d1c47d36400b657f253ef41b4bc762d6ac22c" + }, + "evidence/SEALED-RESULT.json": { + "mode": 420, + "sha256": "746d5540f2313a218be0ad465735110cc02d1362a46f8c571cd2d1f36f8aed8f" + }, + "evidence/fraction-compact-key-20261027/SCREEN.json": { + "mode": 420, + "sha256": "b8d93597082850f885ce734952e01ceb89aefc2cff19aa7757e1b259ff3d8d83" + }, + "evidence/fraction-compact-key-20261027/STATE.json": { + "mode": 420, + "sha256": "f8ff3ac6eca3044d1cd427239c4d2e1ef54c0e1be17aa4e155a464c021440f7a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/receipt.json": { + "mode": 420, + "sha256": "8f608d40345ac81a2291103adf1ece209c8720903018d6a9f920cc57c1648f1a" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/stdout.txt": { + "mode": 420, + "sha256": "0d41c44e7ea9bef7da4fe7f9601b6a23510c8746231cbf79ec594fb7c5b12d26" + }, + "evidence/fraction-compact-key-20261027/micro-compact-key/usage.json": { + "mode": 420, + "sha256": "e84efb3708263d8b4b9bd472e8879c500897928e6eb0f1183f80f156031f30fe" + }, + "evidence/fraction-direct-add-20261027/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "f427abd01c45b1d56753b8a39ea88c588b5a1f54ff0dbc60219090536fbe6e93" + }, + "evidence/fraction-direct-add-20261027/SCREEN.json": { + "mode": 420, + "sha256": "429059e44df33949dbcd907b7a8e9df49120115ad3550076fa38a6e1b9615834" + }, + "evidence/fraction-direct-add-20261027/STATE.json": { + "mode": 420, + "sha256": "f038b074b12ae10167e1a80dd08d77d24fbc7f25bfb1c546d9d212b2e7222a17" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/receipt.json": { + "mode": 420, + "sha256": "18eda73aebf55b311d43f6a872d80b796311521a990a7f062d70e4764c1c6df5" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/stdout.txt": { + "mode": 420, + "sha256": "cca5a795cb8100863e5e6cfc840b79e3811f9e2e199c3be01d07a1dc3c07e6a2" + }, + "evidence/fraction-direct-add-20261027/micro-direct-add/usage.json": { + "mode": 420, + "sha256": "ac5cc180d273ab21ecfc5e763508086d74037e1cc65eab478e8ca681e027246e" + }, + "evidence/fraction-slot-key-20261027/HARNESS-CORRECTION.json": { + "mode": 420, + "sha256": "45faebecc9bb40a21dafdb2240e3672f82c3705f6edb0d7f83f3965a6131534d" + }, + "evidence/fraction-slot-key-20261027/STATE.json": { + "mode": 420, + "sha256": "963dd53c68632f56695218ac173ec46d3f557365a2a116646b5f6b3c6bf0eb20" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/receipt.json": { + "mode": 420, + "sha256": "bea42a7c8b4a150bfb31ef6dba22c01f6e0d470e305bb50ac7aef1dc832bf875" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/stdout.txt": { + "mode": 420, + "sha256": "de8c34120ca983a6c0ef155909c2953be3864543d92215cb56cbfb4593173a5c" + }, + "evidence/fraction-slot-key-20261027/micro-slot-key/usage.json": { + "mode": 420, + "sha256": "f60def8912348130cb992911e37358ca5379b82547c6f8d03313e0f69f4d9fd5" + }, + "evidence/portable/runs/complete-native/receipt.json": { + "mode": 420, + "sha256": "c9d5b36efb21aac51f14dc5ed1d03938965468e7ee57ac95adaf4283e2ac95f0" + }, + "evidence/portable/runs/complete-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/portable/runs/complete-native/stdout.txt": { + "mode": 420, + "sha256": "90c4d99abcc6c6eb1ca534524b75232b8d623db6877f6bf7409ac141a3219a7b" + }, + "evidence/portable/runs/complete-native/usage.json": { + "mode": 420, + "sha256": "2ec34075d9c98dc04a448dffebb441ae7c39411cb68fcb88c8a6836fe3f86b10" + }, + "evidence/runtime/GATE-2.json": { + "mode": 420, + "sha256": "12e058ca48316703fdeee6fb05ec914a2becc7ca22d847b635b46f106e4a33f7" + }, + "evidence/runtime/GATE-6.json": { + "mode": 420, + "sha256": "32582dc8496e2a30ad7bf687d79b56a8922bfa937484c1e2fbd6375f9832d5de" + }, + "evidence/runtime/benchmark.py": { + "mode": 420, + "sha256": "ff64227e14bffe4223bcf2b73bc3443a79e65b063e4b8c09e7bf6e79c13b7dfa" + }, + "evidence/runtime/dispatch.py": { + "mode": 420, + "sha256": "25c36c8e6f35e35ae890715ab347af355a5a429ad18d76b98bcf19a9e39f58e8" + }, + "evidence/runtime/guard.py": { + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "evidence/runtime/runs/B1/receipt.json": { + "mode": 420, + "sha256": "15ae07aaf6a89e6c4f18d8595eada97109c32b54e6a1aacfe585b842fedda9e5" + }, + "evidence/runtime/runs/B1/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B1/stdout.txt": { + "mode": 420, + "sha256": "5a7ec74287edb31e6f401867c0eb2b4758a110e6e4131498226296a5f435cde9" + }, + "evidence/runtime/runs/B1/usage.json": { + "mode": 420, + "sha256": "d77f0361b49ef1568faa33bf5c3b943be3e180d30b39aa65b3047a58f9bde342" + }, + "evidence/runtime/runs/B2/receipt.json": { + "mode": 420, + "sha256": "7639daead89612d3222340e4536f36ff7d831fd16293326d23e0f1722b7799a9" + }, + "evidence/runtime/runs/B2/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B2/stdout.txt": { + "mode": 420, + "sha256": "cd094b9eea390f0c39922618b1e0b0a5b36f67ac59108755a475fc2930188ac0" + }, + "evidence/runtime/runs/B2/usage.json": { + "mode": 420, + "sha256": "6f3beed8792e6009c05fca27558285e2181b70f62c6662127e1702857020ea35" + }, + "evidence/runtime/runs/B3/receipt.json": { + "mode": 420, + "sha256": "3d0867a967cbce1e71e2a7d24414e7a6c6db0426ca029f7749ea96d159ff96c8" + }, + "evidence/runtime/runs/B3/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/B3/stdout.txt": { + "mode": 420, + "sha256": "c358f72bcfe6d424948f4e17be786109fe95429acadc1e1ef33f120dd1ce3cd2" + }, + "evidence/runtime/runs/B3/usage.json": { + "mode": 420, + "sha256": "f19f78b4595c739f0d20ebb796c20779624ab08847bba0d8f32fa56995c6876c" + }, + "evidence/runtime/runs/C1/receipt.json": { + "mode": 420, + "sha256": "9763ceec4da7db54fc61cb7f8440ffbccc3b9f3b291d2bce485fe309319e68ba" + }, + "evidence/runtime/runs/C1/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C1/stdout.txt": { + "mode": 420, + "sha256": "94b8b578bdc812bf9c3a12e80bf2f00978000c6cc47119a180d4d003a1d0c20f" + }, + "evidence/runtime/runs/C1/usage.json": { + "mode": 420, + "sha256": "7ae8a2c8da0df9297fdac821bb154fa1e0df25e65ef38392c3fa5b0d20546bb0" + }, + "evidence/runtime/runs/C2/receipt.json": { + "mode": 420, + "sha256": "56f0f5891a6efc138028647593e4221c63d19f3eebe161850928e0cc498a3579" + }, + "evidence/runtime/runs/C2/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C2/stdout.txt": { + "mode": 420, + "sha256": "e5fae97b197190e7942f4af65ae80fdb7d8e57617640bdd268bb2774b2518e7c" + }, + "evidence/runtime/runs/C2/usage.json": { + "mode": 420, + "sha256": "848270e33cb93b68616858dc2f4a29cee0d448f773d01ae2166340e8c9657da5" + }, + "evidence/runtime/runs/C3/receipt.json": { + "mode": 420, + "sha256": "410eac666993518da4194bc8d97898d27b2c419aca19dc17f4fe35afc9bd30c9" + }, + "evidence/runtime/runs/C3/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/C3/stdout.txt": { + "mode": 420, + "sha256": "56dc7baee49bc0aceabc9589593de191e31874345f83579664757ba96e40a193" + }, + "evidence/runtime/runs/C3/usage.json": { + "mode": 420, + "sha256": "db595914a3c5f525232fe5bdd05736341c099109d6c3ae9549732d69d62783af" + }, + "evidence/runtime/runs/actual-native-apply/receipt.json": { + "mode": 420, + "sha256": "ce25c3eadd0217792c71d9210731c74deba23a5f72c8d9702588e3ce45796af3" + }, + "evidence/runtime/runs/actual-native-apply/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/actual-native-apply/stdout.txt": { + "mode": 420, + "sha256": "e68b03d1d1c96b980621d6dc35d471e4961c5684324d715f85ad746eeea430c5" + }, + "evidence/runtime/runs/actual-native-apply/usage.json": { + "mode": 420, + "sha256": "882cbf16af189133f2aa3a4c93015948602727c02732284034ca4b1467030746" + }, + "evidence/runtime/runs/apply-micro-native/receipt.json": { + "mode": 420, + "sha256": "06e3527151b2d5e2eee489067dec52d0410ff3327458687f9dc687e01e82a46a" + }, + "evidence/runtime/runs/apply-micro-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/apply-micro-native/stdout.txt": { + "mode": 420, + "sha256": "3d02fcbf3cddbfe1bf4d8a80b8f40e579b3ea41ab4c14ee15b2044d7ac56d70c" + }, + "evidence/runtime/runs/apply-micro-native/usage.json": { + "mode": 420, + "sha256": "5004e11aa586c7fc6e47477b1c6f87436204678d99cd07cb1b27e0c10ea725ea" + }, + "evidence/runtime/runs/finite-native-O/receipt.json": { + "mode": 420, + "sha256": "ac9e69f91b6f9f7cf9889e0d4f67853d28b3f572f56b798b805f3b200c093410" + }, + "evidence/runtime/runs/finite-native-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-O/stdout.txt": { + "mode": 420, + "sha256": "5958ee0382e335e0e57b25f0fded9c9ae3918f246bd959b7e76440451959fc18" + }, + "evidence/runtime/runs/finite-native-O/usage.json": { + "mode": 420, + "sha256": "a585fe650eb13967479010eee888bfd1f938e787b47a024ed842f5992c8c97f5" + }, + "evidence/runtime/runs/finite-native-bound-debug/receipt.json": { + "mode": 420, + "sha256": "f35190d3f6f44b36ecfc69eeaba7cb907e01c66fb3861d230f74071bda12f432" + }, + "evidence/runtime/runs/finite-native-bound-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-bound-debug/stdout.txt": { + "mode": 420, + "sha256": "3ea12be81fa51a0f5d74ed668d55f36524f6aaeae7b76efd11624b3b86b15a87" + }, + "evidence/runtime/runs/finite-native-bound-debug/usage.json": { + "mode": 420, + "sha256": "787c1f8a6faf35fc38b35640b80f4f4878d93e2b720f95c75804a39a66b6dbd6" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/receipt.json": { + "mode": 420, + "sha256": "90c80a86baee5789617f5fc3fae29150d3a309a39985e48d51c1f5fba44d956c" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/stdout.txt": { + "mode": 420, + "sha256": "d62396a142f6c365a13d31ed9db68f5a4efe702093d99a340cc73c8e97d4bfd1" + }, + "evidence/runtime/runs/finite-native-cleanup-debug/usage.json": { + "mode": 420, + "sha256": "ef40cce80cd1e4c7e3f1736858405cce35d0e3509cefdaa18f752609c23618c0" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/receipt.json": { + "mode": 420, + "sha256": "fa80b52cc3e05b88af3adc56d4a49e1eec494ca448d8696d17a676108ee295b6" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/stdout.txt": { + "mode": 420, + "sha256": "406ad2c71dde19af5e4c9997c46c6ceb8a6a327c12c8213b4617efef47e87221" + }, + "evidence/runtime/runs/finite-native-debug-cleanup/usage.json": { + "mode": 420, + "sha256": "af42dfc6bee4e225b887cf65cb64b24927610fdcf6a1f3a87a1a1b25b367a0ad" + }, + "evidence/runtime/runs/finite-native-debug/receipt.json": { + "mode": 420, + "sha256": "eeff743db6af10a1c31f35fcc257817dcfd9932f811425a4acaa21ad1b780581" + }, + "evidence/runtime/runs/finite-native-debug/stderr.txt": { + "mode": 420, + "sha256": "1e58b0030f6a620590941fd889e912b49605b16d6bff0cdb0269317305a56877" + }, + "evidence/runtime/runs/finite-native-debug/stdout.txt": { + "mode": 420, + "sha256": "517ab979ea958fdadf2c9e9542421752677cabe5ea1595658bb6535d51e07ad1" + }, + "evidence/runtime/runs/finite-native-debug/usage.json": { + "mode": 420, + "sha256": "9625570f93d0dc82d5a77a41740c0953c468d654efcf9ba627bd2b752e355407" + }, + "evidence/runtime/runs/finite-native-final-debug/receipt.json": { + "mode": 420, + "sha256": "7b17d0aad98ba249427ab8194c4a717ba125ab0fa82c7a2c93a25a67247fe71a" + }, + "evidence/runtime/runs/finite-native-final-debug/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-final-debug/stdout.txt": { + "mode": 420, + "sha256": "b1b4336083ec54f132ec96e3d32253bce249ec2d79e8e790b7151dc3a913b5a6" + }, + "evidence/runtime/runs/finite-native-final-debug/usage.json": { + "mode": 420, + "sha256": "fa6a30ec2ba9236e753770c3119ae97b0787d8899bafbf354fa1e28af1221b32" + }, + "evidence/runtime/runs/finite-native-initial/receipt.json": { + "mode": 420, + "sha256": "4e9247f995f51a6c41effebf86bd564b351ae1314ad200078a01b70d5a153972" + }, + "evidence/runtime/runs/finite-native-initial/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-initial/stdout.txt": { + "mode": 420, + "sha256": "132dbf612655631727322fe5e75c64009ec0d27edfc36e24c7f5c7802dd8a60b" + }, + "evidence/runtime/runs/finite-native-initial/usage.json": { + "mode": 420, + "sha256": "ffe0d3d988b42f5126dce5f9d58273dd0ef6aa51326244de3a1cd53b547b49e3" + }, + "evidence/runtime/runs/finite-native-packet-O/receipt.json": { + "mode": 420, + "sha256": "bd32551ccf3402addce6aae49f2cd44c0e038787b9bd29def006d45341b8282e" + }, + "evidence/runtime/runs/finite-native-packet-O/stderr.txt": { + "mode": 420, + "sha256": "6234cdc3b985c9e4355437da48846e852d1ba11ce8d15814ec3711734f38b3d8" + }, + "evidence/runtime/runs/finite-native-packet-O/stdout.txt": { + "mode": 420, + "sha256": "888063666924c013dbce1b2f199c90c90f87742cc09a423e6e335dba926a51fb" + }, + "evidence/runtime/runs/finite-native-packet-O/usage.json": { + "mode": 420, + "sha256": "df17d082be74415eebb9fac37fdc88bc0285e189b20f0d8a30d90bbeb5ae4675" + }, + "evidence/runtime/runs/finite-native-reviewed-O/receipt.json": { + "mode": 420, + "sha256": "5079e96b3320603270e9ebda7b648f07b1aa1b1633edde1525a4a8899153da3a" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-reviewed-O/stdout.txt": { + "mode": 420, + "sha256": "83c424e31cc422df948afa1f7ee1d716a4336144a12f893bc39cfee6ebfe6d36" + }, + "evidence/runtime/runs/finite-native-reviewed-O/usage.json": { + "mode": 420, + "sha256": "d4942ac244308864bf440dd2e798aeab258212afe5c5abcbded80187a26e2998" + }, + "evidence/runtime/runs/finite-native-snapshot-O/receipt.json": { + "mode": 420, + "sha256": "629447d5ab1e8f3bfac2396ea22bcc9a22f7dd652341eabf2730588d544da0de" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/finite-native-snapshot-O/stdout.txt": { + "mode": 420, + "sha256": "9305bbb70a364966598fbd21cc340202eca4915ad01bc6f7ba1409c2af55e519" + }, + "evidence/runtime/runs/finite-native-snapshot-O/usage.json": { + "mode": 420, + "sha256": "1fd3c023a6a93e2b2d7a916805050dcc90602a1fa565cb2fa5fdb9c0a951da5b" + }, + "evidence/runtime/runs/full-native-O/receipt.json": { + "mode": 420, + "sha256": "c88cc7c1fc9013c193f7d711ba880fd89b10563564da9d12f2caac95005a2448" + }, + "evidence/runtime/runs/full-native-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/full-native-O/stdout.txt": { + "mode": 420, + "sha256": "0b1a800f3c996f7269d9fe1def0cd23dd8def45aa4c4cc9231f083838bd0ee54" + }, + "evidence/runtime/runs/full-native-O/usage.json": { + "mode": 420, + "sha256": "930eb0ff15a0576bfabb6d6308795c306d1e6a084882af5d1f8f44c3c7173ef1" + }, + "evidence/runtime/runs/micro-native/receipt.json": { + "mode": 420, + "sha256": "cd00535242d599a660abfe09afa0de1a526661fba4fb5ac3e5cac3011b3452d4" + }, + "evidence/runtime/runs/micro-native/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/micro-native/stdout.txt": { + "mode": 420, + "sha256": "9e4aa00d01e596696171b4c4ca70451359bc8e57433c169d11180c25b38643e9" + }, + "evidence/runtime/runs/micro-native/usage.json": { + "mode": 420, + "sha256": "647d2e5d6e8f3b920bf3aa45da9c55228eb7dad228be3f1be358942b0935b143" + }, + "evidence/runtime/runs/packaged-native-finite-O/receipt.json": { + "mode": 420, + "sha256": "143cd363ee86bc4551d8bd60acb583d248f23997ed8813550d1d8d695e59e00d" + }, + "evidence/runtime/runs/packaged-native-finite-O/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite-O/stdout.txt": { + "mode": 420, + "sha256": "e2f4c31106c5391b090c20762ad751450f4482be5b2d837f5533bd96c5d5157b" + }, + "evidence/runtime/runs/packaged-native-finite-O/usage.json": { + "mode": 420, + "sha256": "8ca63f00ccb90e0412c4588e759719105dbc63067f0a7d50887189d0babfe041" + }, + "evidence/runtime/runs/packaged-native-finite/receipt.json": { + "mode": 420, + "sha256": "99f4fb47ac46777817b961e81c907267948f6e446263e48e12f59e9124554d7d" + }, + "evidence/runtime/runs/packaged-native-finite/stderr.txt": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "evidence/runtime/runs/packaged-native-finite/stdout.txt": { + "mode": 420, + "sha256": "b9f8cd5829de1799caa90e5101bb9e6dd28d9c61eef93fcc9a4c17ff561199ab" + }, + "evidence/runtime/runs/packaged-native-finite/usage.json": { + "mode": 420, + "sha256": "c314931eef9ebd68d3ff9fe6fea02b667904f26a673b2134980de884de0d41b3" + }, + "finite.py": { + "mode": 420, + "sha256": "22a3adb7569737ab92ca6d6eea57f7b0d7e05b6a6eaa972070312ef6edabb359" + }, + "fraction_table.py": { + "mode": 420, + "sha256": "d70f8095002ffedb06fd6851e5b6d127e2f24c3ad31404130216345416159cf4" + }, + "frozen.py": { + "mode": 420, + "sha256": "a5848c4290e96fc639bd15beb3d533e49fa026e9e0333381543acdb0bf1a9547" + }, + "full.py": { + "mode": 420, + "sha256": "ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0" + }, + "full_B.py": { + "mode": 420, + "sha256": "96aa4b72aea17cf5675e59a5de1c35558ffca401ff99a1c42cd38559f06bc30a" + }, + "full_C.py": { + "mode": 420, + "sha256": "a181613fb7c922fcbca543c4cee2495c1d8fbb0df5c5beaf64da9e091b718394" + }, + "guard.py": { + "mode": 420, + "sha256": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751" + }, + "inputs/PR5848.tar": { + "mode": 420, + "sha256": "f899600acb6966a6b028ffbf1e33a94061615626b510feaca8cb073f03a34de6" + }, + "micro.py": { + "mode": 420, + "sha256": "b4fcb48bce4d35494a0e36301a5275d27c814e3f10fd9d39fbc3457a92890f53" + }, + "micro_apply.py": { + "mode": 420, + "sha256": "1b44ffefc38697019e7bf06bdac2ba851acd3de39a0a8c82211a5c6b5246b12e" + }, + "native_backend.py": { + "mode": 420, + "sha256": "f1fe0d4484ef86c7baa3a30c5d537950cb227b1979d825c61ab09ceead5f533d" + }, + "native_cache.c": { + "mode": 420, + "sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb" + }, + "parent_finite.py": { + "mode": 420, + "sha256": "b2df739750829d7bf1a6446ea79d02a65641d7a85ead56d7ad941069bb146e4f" + }, + "replay.py": { + "mode": 420, + "sha256": "fc7b1390c2e0e7ef3b1aafda090c28fa50166388118930a324115c2d6d9eb4d9" + }, + "replay_driver.py": { + "mode": 420, + "sha256": "67a0f22d11b895efb74c29710d2ef78832ebd25581d6c4670b0f44f5f66ab528" + }, + "slot_binding.py": { + "mode": 420, + "sha256": "f2f3193461b9f705a2683107c2305c40d2f82d9f1087a2af25cf9e88f45fc593" + }, + "slot_finite.py": { + "mode": 420, + "sha256": "5e23174a5b37e014b154e3030b2e96e08f2aeeedc723f0273f829f68ca481390" + }, + "slot_parent.py": { + "mode": 420, + "sha256": "b1ee09c1dfd4e36677b57dd71124d4d30f38c7df5f460a787fde3636b91e4e24" + }, + "table_parent.py": { + "mode": 420, + "sha256": "d598b8a757251c1e38ed77af6cc2aebe1b8ae23ad29ce06bff3ca973eb56dbc4" + }, + "verify.py": { + "mode": 420, + "sha256": "ccd207f55c0879738bcaeb5f1df6bd34427ea0ae675cd365fad1150ec19ffd82" + } + }, + "original_native_sha256": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "status": "SOURCE_ONLY_DIAGNOSTIC_PREPARED" +} diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/contribution_diagnostic.c b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/contribution_diagnostic.c new file mode 100644 index 0000000000..357a1e9641 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/contribution_diagnostic.c @@ -0,0 +1,45 @@ +static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) { + Cache *s=e->cache; + JointTimer timer=joint_start(JOINT_LOOKUP); + if (i<0 || i>=PyTuple_GET_SIZE(s->tokens)) { PyErr_SetString(PyExc_IndexError,"native site index");joint_stop(&timer,JOINT_ERROR);return NULL; } + if (!Py_IS_TYPE(old,(PyTypeObject *)s->fraction)||!Py_IS_TYPE(v,(PyTypeObject *)s->fraction)) { PyErr_SetString(PyExc_TypeError,"exact Fraction coefficients");joint_stop(&timer,JOINT_ERROR);return NULL; } + PyObject *parts[4]={NULL,NULL,NULL,NULL}; + for (int k=0;k<4;k++) { + parts[k]=member(k%2?s->den:s->num,k<2?old:v,s->fraction); + if (!parts[k] || !PyLong_CheckExact(parts[k])) { + for(int j=0;j<4;j++)Py_XDECREF(parts[j]); + if(!PyErr_Occurred())PyErr_SetString(PyExc_TypeError,"integer Fraction slots"); + joint_stop(&timer,JOINT_ERROR);return NULL; + } + } + PyObject *key=PyTuple_New(7); + if(!key){for(int j=0;j<4;j++)Py_DECREF(parts[j]);joint_stop(&timer,JOINT_ERROR);return NULL;} + PyTuple_SET_ITEM(key,0,parts[0]);PyTuple_SET_ITEM(key,1,parts[1]); + PyTuple_SET_ITEM(key,2,Py_NewRef(e->qn));PyTuple_SET_ITEM(key,3,Py_NewRef(e->qd)); + PyTuple_SET_ITEM(key,4,parts[2]);PyTuple_SET_ITEM(key,5,parts[3]);PyTuple_SET_ITEM(key,6,Py_NewRef(PyTuple_GET_ITEM(s->tokens,i))); + if(s->calls==PY_SSIZE_T_MAX){Py_DECREF(key);PyErr_SetString(PyExc_OverflowError,"native counter overflow");joint_stop(&timer,JOINT_ERROR);return NULL;} + s->calls++; + PyObject *result=PyDict_GetItemWithError(s->dict,key); + if(result){s->hits++;Py_INCREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_HIT);return result;} + if(PyErr_Occurred()){Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;} + s->misses++; + PyObject *pair=PyTuple_GET_ITEM(s->weights,i); + PyObject *argv[5]={old,e->q,v,PyTuple_GET_ITEM(pair,0),PyTuple_GET_ITEM(pair,1)}; + joint_stop(&timer,JOINT_MISS); + joint_inc(&joint_callback_depth); + result=PyObject_Vectorcall(s->compute,argv,5,NULL); + if (!joint_callback_depth) joint_inc(&joint_protocol_errors);else joint_callback_depth--; + timer=joint_start(JOINT_AFTER); + if(!result){Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;} + if(!PyTuple_CheckExact(result)||PyTuple_GET_SIZE(result)!=4){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"four exact contributions");joint_stop(&timer,JOINT_ERROR);return NULL;} + for(int k=0;k<4;k++)if(!Py_IS_TYPE(PyTuple_GET_ITEM(result,k),(PyTypeObject *)s->fraction)){Py_DECREF(result);Py_DECREF(key);PyErr_SetString(PyExc_TypeError,"Fraction contributions");joint_stop(&timer,JOINT_ERROR);return NULL;} + if(s->used==s->capacity){ + PyObject *oldkey=s->ring[s->head]; + if(PyDict_DelItem(s->dict,oldkey)<0){Py_DECREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;} + Py_CLEAR(s->ring[s->head]);s->used--;s->evictions++; + } + if(PyDict_SetItem(s->dict,key,result)<0){Py_DECREF(result);Py_DECREF(key);joint_stop(&timer,JOINT_ERROR);return NULL;} + s->ring[s->head]=key;s->head=(s->head+1)%s->capacity;s->used++; + joint_stop(&timer,JOINT_INSERTED); + return result; +} diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/diagnostic.py b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/diagnostic.py new file mode 100644 index 0000000000..4cc7fa6ea5 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/diagnostic.py @@ -0,0 +1,281 @@ +"""One same-run disjoint integer + native-key cost diagnostic, not optimization. + +Source-only at handoff. Parent owns every compiler/scientific/timing execution. +Existing Fraction callbacks, F(0), score operations and cache statistics stay +unchanged. A separate C activity marker rejects overlap with integer windows. +""" +from hashlib import sha256 +import json +from pathlib import Path +import sys +import time +from types import ModuleType + +HERE = Path(__file__).resolve().parent +ROUND = HERE.parent.parent if HERE.parent.name == 'stages' else HERE.parent +BASE = HERE / 'baseline-public' +ORIGINAL_BASE = ROUND / 'baseline-public' +FULL_SHA256 = 'ce6f15ca892db095d4b9f79b58cb3c199b18da341def761c577cc8651abc0cc0' +INTEGER_SHA256 = '82a73e4bcf1835bfdd510c7ad5538625c1b380c559b671e6a67be490615a743a' +BASE_NATIVE_SHA256 = '78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb' +DIAGNOSTIC_NATIVE_SHA256 = '039c2c5fce353cf8be526c14f5f824dbc2b072999accddc310cc575e65e903f3' +BASELINE = dict(wall=34.66178539200337, cpu=34.47) +NOISE = dict(wall=2.713637237990042, cpu=2.3500000000000014) +RESERVE = dict(wall=0.50, cpu=0.50) +EXPECTED_COUNTS = dict(ideal=4, error_trace=121, reverse_all=121) +FAMILIES = tuple(EXPECTED_COUNTS) +sys.path.insert(0, str(BASE)) + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def verify_copy(): + receipt = json.loads((HERE / 'SOURCE-EDITS.json').read_text()) + need(receipt['original_native_sha256'] == BASE_NATIVE_SHA256 and + receipt['diagnostic_native_sha256'] == DIAGNOSTIC_NATIVE_SHA256, + 'exact declared diagnostic source identities') + need(receipt['changed_baseline_files'] == ['native_cache.c', 'NATIVE-SOURCE.json'], + 'only declared baseline diagnostic files changed') + need(not any(path.is_symlink() for path in BASE.rglob('*')), 'no copied baseline symlinks') + original_files = {str(path.relative_to(ORIGINAL_BASE)) for path in ORIGINAL_BASE.rglob('*') + if path.is_file() and '__pycache__' not in path.parts} + need(original_files == set(receipt['original_inventory']), 'current original baseline census') + files = {str(path.relative_to(BASE)) for path in BASE.rglob('*') + if path.is_file() and '__pycache__' not in path.parts} + need(files == set(receipt['original_inventory']), 'complete copied baseline file census') + for relative, expected in receipt['original_inventory'].items(): + path = BASE / relative + original = ORIGINAL_BASE / relative + need(original.is_file() and not original.is_symlink(), 'regular original baseline source') + need(sha256(original.read_bytes()).hexdigest() == expected['sha256'] and + original.stat().st_mode & 0o777 == expected['mode'], 'current original baseline matches frozen copy inventory') + need(not path.is_symlink() and path.is_file(), 'regular copied baseline source') + need(path.stat().st_mode & 0o777 == expected['mode'], 'copied baseline mode') + if relative not in ('native_cache.c', 'NATIVE-SOURCE.json'): + need(sha256(path.read_bytes()).hexdigest() == expected['sha256'], + 'unchanged copied baseline file: ' + relative) + raw = (BASE / 'native_cache.c').read_bytes() + need(sha256(raw).hexdigest() == DIAGNOSTIC_NATIVE_SHA256, 'exact diagnostic C source') + need(json.loads((BASE / 'NATIVE-SOURCE.json').read_text()) == + dict(sha256=DIAGNOSTIC_NATIVE_SHA256), 'diagnostic cold-build source pin') + restored = raw.decode() + for edit in reversed(receipt['edits']): + need(restored.count(edit['after']) == 1, 'unique reverse diagnostic seam') + restored = restored.replace(edit['after'], edit['before']) + need(sha256(restored.encode()).hexdigest() == BASE_NATIVE_SHA256, + 'diagnostic C reverses to exact original C') + return dict(original_native_sha256=BASE_NATIVE_SHA256, + diagnostic_native_sha256=DIAGNOSTIC_NATIVE_SHA256, + copied_baseline_files=len(files), all_other_baseline_bytes_and_modes_equal=True, + current_original_baseline_compared_per_file=True, + diagnostic_edits_reverse_to_exact_original=True) + + +def plain_json(value): + kind = type(value) + if kind in (str, int, float, bool, type(None)): + return True + if kind in (list, tuple): + return all(plain_json(item) for item in value) + if kind is dict: + return all(type(key) in (str, int) and plain_json(item) + for key, item in value.items()) + return False + + +class Ledger: + def __init__(self, digest, actual_word, native): + self.digest, self.native = digest, native + self.actual_key = digest(actual_word) + self.actual_length = len(actual_word['program']) + self.depth = 0 + self.records, self.diagnostic_errors = [], [] + self.union_wall = self.union_cpu = 0.0 + + def metadata(self, word): + length, classification = None, 'unclassified' + try: + if type(word) is dict and type(word.get('program')) in (list, tuple): + length = len(word['program']) + if plain_json(word): + if self.digest(word) == self.actual_key: + classification = 'actual_word' + elif length is not None and length < self.actual_length: + classification = 'finite_fixture' + else: + classification = 'modified_word_control' + except Exception as error: + self.diagnostic_errors.append(type(error).__name__) + return length, classification + + def call(self, backend, family, word, args): + function = getattr(backend, family) + outermost = self.depth == 0 + self.depth += 1 + marked = False + elapsed_wall = elapsed_cpu = None + error_type = None + try: + if outermost: + self.native._joint_integer_enter() + marked = True + started_wall = time.perf_counter() + started_cpu = time.process_time() + try: + return function(word, *args) + except BaseException as error: + error_type = type(error).__name__ + raise + finally: + # Activity marker stays set until BOTH end clocks are sampled. + elapsed_cpu = time.process_time() - started_cpu + elapsed_wall = time.perf_counter() - started_wall + finally: + # Also clear a marker if a clock/diagnostic call failed. Original + # callee exceptions are re-raised; diagnostic failures cannot PASS. + try: + if marked: + marked = False + self.native._joint_integer_leave() + finally: + self.depth -= 1 + if elapsed_wall is None or elapsed_cpu is None: + self.diagnostic_errors.append('incomplete-timer') + else: + if outermost: + self.union_wall += elapsed_wall + self.union_cpu += elapsed_cpu + length, classification = self.metadata(word) + self.records.append(dict(family=family, program_length=length, + classification=classification, outermost=outermost, + exception=error_type, wall_seconds=elapsed_wall, cpu_seconds=elapsed_cpu)) + + def report(self): + counts = {name: sum(row['family'] == name for row in self.records) + for name in FAMILIES} + need(self.depth == 0 and not self.diagnostic_errors, 'balanced complete integer timers') + need(counts == EXPECTED_COUNTS, 'all original integer family calls retained') + need(all(row['outermost'] for row in self.records), 'no nested integer timing overlap') + return dict(counts=counts, expected_actual_program_length=self.actual_length, + disjoint_union_seconds=dict(wall=self.union_wall, cpu=self.union_cpu), + records=self.records) + + +_LEDGERS, _ORIGINAL_MODULES, _NATIVES = [], [], [] + + +def timed_integer(module, reference, actual_word): + path = Path(module.__file__) + need(not path.is_symlink() and sha256(path.read_bytes()).hexdigest() == INTEGER_SHA256, + 'exact original integer source') + import native_backend + native = native_backend.load() + need(native_backend.receipt()['source_sha256'] == DIAGNOSTIC_NATIVE_SHA256, + 'activity marker belongs to the exact instrumented native module') + original_engine = module.Engine + ledger = Ledger(reference.digest, actual_word, native) + _LEDGERS.append(ledger); _ORIGINAL_MODULES.append((module, original_engine)); _NATIVES.append(native) + + class TimedEngine: + def __init__(self, ref): self._backend = original_engine(ref) + def __getattr__(self, name): return getattr(self._backend, name) + def ideal(self, word): return ledger.call(self._backend, 'ideal', word, ()) + def error_trace(self, word, weights, rounded): + return ledger.call(self._backend, 'error_trace', word, (weights, rounded)) + def reverse_all(self, word, weights, rounded): + return ledger.call(self._backend, 'reverse_all', word, (weights, rounded)) + + facade = ModuleType(module.__name__ + '_joint_diagnostic') + facade.__dict__.update(module.__dict__) + facade.Engine = TimedEngine + return facade + + +def checked_key_report(native, integer): + data = native._joint_diagnostics() + for name in ('key_depth', 'integer_depth', 'callback_depth', 'clock_failures', + 'protocol_errors', 'nested_key_intervals', 'integer_overlap_intervals'): + need(data[name] == 0, 'zero diagnostic imbalance/overlap/error: ' + name) + total_integer = sum(integer['counts'].values()) + need(data['integer_enters'] == data['integer_leaves'] == total_integer, + 'every integer window has one balanced C activity marker') + lookup, after = data['lookup'], data['after_callback'] + for phase in (lookup, after): + need(phase['entries'] == phase['closed'] == phase['timed'], + 'all key intervals timed and closed') + need(phase['excluded_callback'] == 0, 'frozen callbacks contain no nested key interval') + need(phase['wall_seconds'] >= 0 and phase['cpu_seconds'] >= 0, 'nonnegative key clock intervals') + need(lookup['entries'] == lookup['hits'] + lookup['misses'] + lookup['errors'], + 'lookup outcomes partition all hit/miss/error entries') + need(lookup['inserted'] == 0 and after['hits'] == after['misses'] == 0, + 'phase outcomes are source-specific') + need(after['entries'] == after['inserted'] + after['errors'] == lookup['misses'], + 'every miss callback has exactly one closed after-callback region') + return data + + +def main(): + need(len(sys.argv) == 1, 'no alternate diagnostic workload or arguments') + copy_receipt = verify_copy() + path = BASE / 'full.py' + raw = path.read_bytes() + need(sha256(raw).hexdigest() == FULL_SHA256, 'exact original full qualifier source') + source = raw.decode() + before = " namespace=dict(entry.__dict__);namespace['_native_trace']=native_trace\n" + after = ''' integer_seam=" integer = v.load('integer_backend', package/'integer.py')\\n" + require(changed.count(integer_seam)==1,'one unchanged integer diagnostic seam') + changed=changed.replace(integer_seam," integer = _timed_integer(v.load('integer_backend', package/'integer.py'), reference, word)\\n") + namespace=dict(entry.__dict__);namespace['_native_trace']=native_trace + namespace['_timed_integer']=_timed_integer +''' + need(source.count(before) == 1, 'one authenticated full namespace seam') + source = source.replace(before, after) + namespace = dict(__name__='_joint_cost_diagnostic', __file__=str(path), _timed_integer=timed_integer) + exec(compile(source, str(path), 'exec'), namespace) + namespace['main'](True) + need(len(_LEDGERS) == len(_NATIVES) == 1, 'one selected original integer family and native module') + need(all(module.Engine is engine for module, engine in _ORIGINAL_MODULES), + 'original loaded Engine classes and methods unchanged') + integer = _LEDGERS[0].report() + keys = checked_key_report(_NATIVES[0], integer) + calibration = _NATIVES[0]._joint_clock_calibration() + need(_NATIVES[0]._joint_diagnostics() == keys, 'clock calibration does not alter diagnostic totals') + need(verify_copy() == copy_receipt, 'copied baseline and diagnostic source remain unchanged') + key_union = {kind: keys['lookup'][kind + '_seconds'] + keys['after_callback'][kind + '_seconds'] + for kind in ('wall', 'cpu')} + union = {kind: integer['disjoint_union_seconds'][kind] + key_union[kind] + for kind in ('wall', 'cpu')} + threshold = {kind: max(0.15 * BASELINE[kind], 0.50, NOISE[kind]) for kind in ('wall', 'cpu')} + free = {kind: union[kind] > threshold[kind] for kind in ('wall', 'cpu')} + reserved = {kind: union[kind] - RESERVE[kind] > threshold[kind] for kind in ('wall', 'cpu')} + status = ('REJECT_FREE_CEILING' if not all(free.values()) else + 'REJECT_PROVISIONAL_RESERVE' if not all(reserved.values()) else + 'HEADROOM_FOR_COST_DESIGN_ONLY') + result = dict(status='PASS_JOINT_COST_DIAGNOSTIC', screen_status=status, + performance_sample=False, optimization_constructed=False, construction_admitted=False, + arithmetic_changed=False, original_fraction_callback_and_score_order_unchanged=True, + original_cache_statistics_unchanged=True, source_copy=copy_receipt, + full_source_sha256=FULL_SHA256, integer_source_sha256=INTEGER_SHA256, + instrumented_driver_sha256=sha256(source.encode()).hexdigest(), + expected_actual_native_counters_checked_by_original_full=namespace['ACTUAL_STATS'], + expected_actual_fraction_output_checked_by_original_full=namespace['OUTPUT'], + integer=integer, native_key_regions=keys, key_disjoint_union_seconds=key_union, + same_run_disjoint_union_seconds=union, overlap_rejected=True, + fixed_baseline_medians=BASELINE, fixed_noise_spreads=NOISE, + necessary_zero_cost_threshold_seconds=threshold, zero_cost_gate=free, + provisional_new_control_reserve_seconds=RESERVE, + provisional_reserve_is_measured_bill=False, reserve_gate=reserved, + retained_integer_runtime='UNPRICED_NONZERO', retained_key_runtime='UNPRICED_NONZERO', + complete_new_validation_and_build_bill='UNPRICED_NONZERO', + clock_overhead_calibration=calibration, calibration_subtracted=False, + gc_added_separately=False, prior_run_numbers_added=False, + callbacks_and_score_arithmetic_excluded_from_key_regions=True, + outer_cpu_must_include_compiler_children=True, + scope='same frozen PR5864 full_C qualifier scope; original separately registered custody scope unchanged') + print(json.dumps(result, sort_keys=True, separators=(',', ':'))) + + +if __name__ == '__main__': main() diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/joint_diag.inc b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/joint_diag.inc new file mode 100644 index 0000000000..09879249b5 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/joint_diag.inc @@ -0,0 +1,136 @@ +/* Diagnostic only: no Python numeric operation, original cache counter or + * error state is changed. CLOCK_PROCESS_CPUTIME_ID is current-process CPU. */ +typedef struct { + unsigned long long entries, closed, timed, excluded_callback; + unsigned long long hits, misses, inserted, errors; + double wall, cpu; +} JointPhase; +typedef struct { + struct timespec wall, cpu; + int valid; +} JointClock; +typedef struct { + JointClock start; + int phase, eligible; +} JointTimer; +static JointPhase joint_phases[2]; +static unsigned long long joint_key_depth, joint_integer_depth, joint_callback_depth; +static unsigned long long joint_clock_failures, joint_protocol_errors; +static unsigned long long joint_nested_intervals, joint_integer_overlaps; +static unsigned long long joint_integer_enters, joint_integer_leaves; +enum { JOINT_LOOKUP=0, JOINT_AFTER=1 }; +enum { JOINT_HIT=0, JOINT_MISS=1, JOINT_INSERTED=2, JOINT_ERROR=3 }; +static void joint_inc(unsigned long long *value) { + if (*value==ULLONG_MAX) { + if (joint_protocol_errorsphase]; + if (timer->eligible) { + JointClock end=joint_clock(); + if (!end.valid) joint_inc(&joint_clock_failures); + if (end.valid && timer->start.valid) { + double wall=joint_delta(end.wall,timer->start.wall); + double cpu=joint_delta(end.cpu,timer->start.cpu); + if (wall<0 || cpu<0) joint_inc(&joint_protocol_errors); + else { phase->wall+=wall;phase->cpu+=cpu; } + } + if (!joint_key_depth) joint_inc(&joint_protocol_errors); + else joint_key_depth--; + } + joint_inc(&phase->closed); + if (outcome==JOINT_HIT) joint_inc(&phase->hits); + else if (outcome==JOINT_MISS) joint_inc(&phase->misses); + else if (outcome==JOINT_INSERTED) joint_inc(&phase->inserted); + else joint_inc(&phase->errors); +} +static PyObject *joint_integer_enter(PyObject *self, PyObject *unused) { + (void)self;(void)unused; + if (joint_key_depth) joint_inc(&joint_integer_overlaps); + joint_inc(&joint_integer_enters);joint_inc(&joint_integer_depth); + Py_RETURN_NONE; +} +static PyObject *joint_integer_leave(PyObject *self, PyObject *unused) { + (void)self;(void)unused; + joint_inc(&joint_integer_leaves); + if (!joint_integer_depth) joint_inc(&joint_protocol_errors); + else joint_integer_depth--; + Py_RETURN_NONE; +} +static PyObject *joint_phase_dict(JointPhase *p) { + return Py_BuildValue("{s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:d,s:d}", + "entries",p->entries,"closed",p->closed,"timed",p->timed, + "excluded_callback",p->excluded_callback,"hits",p->hits, + "misses",p->misses,"inserted",p->inserted,"errors",p->errors, + "wall_seconds",p->wall,"cpu_seconds",p->cpu); +} +static PyObject *joint_diagnostics(PyObject *self, PyObject *unused) { + (void)self;(void)unused; + PyObject *lookup=joint_phase_dict(&joint_phases[JOINT_LOOKUP]); + PyObject *after=joint_phase_dict(&joint_phases[JOINT_AFTER]); + if (!lookup || !after) {Py_XDECREF(lookup);Py_XDECREF(after);return NULL;} + PyObject *result=Py_BuildValue("{s:O,s:O,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K,s:K}", + "lookup",lookup,"after_callback",after, + "key_depth",joint_key_depth,"integer_depth",joint_integer_depth, + "callback_depth",joint_callback_depth,"clock_failures",joint_clock_failures, + "protocol_errors",joint_protocol_errors,"nested_key_intervals",joint_nested_intervals, + "integer_overlap_intervals",joint_integer_overlaps, + "integer_enters",joint_integer_enters,"integer_leaves",joint_integer_leaves); + Py_DECREF(lookup);Py_DECREF(after);return result; +} +static PyObject *joint_clock_calibration(PyObject *self, PyObject *unused) { + (void)self;(void)unused; + unsigned long long failures=0; + JointClock start=joint_clock(); + for (int i=0;i<512;i++) { + JointClock a=joint_clock(),b=joint_clock(); + if (!a.valid || !b.valid) failures++; + } + JointClock end=joint_clock(); + if (!start.valid || !end.valid || failures) { + PyErr_SetString(PyExc_RuntimeError,"joint diagnostic calibration clock failure");return NULL; + } + return Py_BuildValue("{s:i,s:i,s:d,s:d,s:O}", + "empty_intervals",512,"clock_gettime_calls_per_interval",4, + "wall_seconds",joint_delta(end.wall,start.wall), + "cpu_seconds",joint_delta(end.cpu,start.cpu), + "subtracted_from_envelope",Py_False); +} +static PyMethodDef joint_module_methods[]={ + {"_joint_integer_enter",joint_integer_enter,METH_NOARGS,"Diagnostic activity marker only."}, + {"_joint_integer_leave",joint_integer_leave,METH_NOARGS,"Diagnostic activity marker only."}, + {"_joint_diagnostics",joint_diagnostics,METH_NOARGS,"Separate diagnostics; existing cache statistics unchanged."}, + {"_joint_clock_calibration",joint_clock_calibration,METH_NOARGS,"Record clock overhead; never subtract it."}, + {NULL,NULL,0,NULL} +}; diff --git a/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/prepare_source.py b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/prepare_source.py new file mode 100644 index 0000000000..db30b21035 --- /dev/null +++ b/research/verification-key-headroom/evidence/source/joint-cost-screen-v1/prepare_source.py @@ -0,0 +1,92 @@ +"""Reproducible text/hash/file preparation only; imports no scientific module.""" +from hashlib import sha256 +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ORIGINAL = HERE.parent / 'baseline-public' +COPY = HERE / 'baseline-public' +BASE_NATIVE_SHA = '78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb' +raw = (ORIGINAL / 'native_cache.c').read_bytes() +if sha256(raw).hexdigest() != BASE_NATIVE_SHA: + raise ValueError('exact original PR5864 native source') +source = raw.decode() +start = 'static PyObject *contribution(Event *e, PyObject *old, PyObject *v, Py_ssize_t i) {\n' +end = 'static int begin_event(Event *e) {\n' +if source.count(start) != 1 or source.count(end) != 1: + raise ValueError('unique original contribution region') +begin, finish = source.index(start), source.index(end) +original_function = source[begin:finish] +replacement = (HERE / 'contribution_diagnostic.c').read_text() +# Remove only the declared diagnostic statements and require exact original +# bytes. This verifies original statement/control/numeric order was preserved. +neutral = replacement +for statement in ( + ' JointTimer timer=joint_start(JOINT_LOOKUP);\n', + ' joint_stop(&timer,JOINT_MISS);\n', + ' joint_inc(&joint_callback_depth);\n', + ' if (!joint_callback_depth) joint_inc(&joint_protocol_errors);else joint_callback_depth--;\n', + ' timer=joint_start(JOINT_AFTER);\n', + ' joint_stop(&timer,JOINT_INSERTED);\n'): + if neutral.count(statement) != 1: + raise ValueError('unique diagnostic contribution statement: ' + statement) + neutral = neutral.replace(statement, '') +for statement in ('joint_stop(&timer,JOINT_ERROR);', 'joint_stop(&timer,JOINT_HIT);'): + if not neutral.count(statement): + raise ValueError('required diagnostic exit statements') + neutral = neutral.replace(statement, '') +if neutral != original_function: + raise ValueError('instrumented contribution neutralizes to exact original bytes') +header = '#define PY_SSIZE_T_CLEAN\n#include \n#include \n' +new_header = ('#ifndef _POSIX_C_SOURCE\n#define _POSIX_C_SOURCE 200809L\n#endif\n' + + header + '#include \n#include \n#include \n\n' + + (HERE / 'joint_diag.inc').read_text()) +module_line = 'static struct PyModuleDef module={PyModuleDef_HEAD_INIT,"_fraction_native","Bounded cache; exact Python arithmetic.",-1,NULL};' +new_module = module_line.replace(',-1,NULL};', ',-1,joint_module_methods};') +edits = [dict(label='diagnostic-clocks-markers-and-separate-module-methods', before=header, after=new_header), + dict(label='timed-original-contribution-with-callback-gap', before=original_function, after=replacement), + dict(label='expose-only-separate-diagnostic-module-methods', before=module_line, after=new_module)] +changed = source +for edit in edits: + if changed.count(edit['before']) != 1: + raise ValueError('one exact diagnostic seam: ' + edit['label']) + changed = changed.replace(edit['before'], edit['after']) +restored = changed +for edit in reversed(edits): + if restored.count(edit['after']) != 1: + raise ValueError('one reversible diagnostic seam: ' + edit['label']) + restored = restored.replace(edit['after'], edit['before']) +if restored.encode() != raw: + raise ValueError('all diagnostic edits reverse to exact original C source') +original_inventory = {} +for path in sorted(ORIGINAL.rglob('*')): + if path.is_symlink(): + raise ValueError('no baseline symlinks') + if not path.is_file(): + continue + relative = str(path.relative_to(ORIGINAL)) + target = COPY / relative + if not target.is_file() or target.is_symlink(): + raise ValueError('complete copied baseline file: ' + relative) + original_inventory[relative] = dict(sha256=sha256(path.read_bytes()).hexdigest(), mode=path.stat().st_mode & 0o777) + if relative not in ('native_cache.c', 'NATIVE-SOURCE.json'): + if target.read_bytes() != path.read_bytes() or (target.stat().st_mode & 0o777) != original_inventory[relative]['mode']: + raise ValueError('unchanged copied baseline file: ' + relative) +new_digest = sha256(changed.encode()).hexdigest() +for name, data in [('native_cache.c', changed.encode()), + ('NATIVE-SOURCE.json', (json.dumps(dict(sha256=new_digest), indent=2) + '\n').encode())]: + path = COPY / name + mode = original_inventory[name]['mode'] + path.chmod(mode | 0o200) + path.write_bytes(data) + path.chmod(mode) +receipt = dict(status='SOURCE_ONLY_DIAGNOSTIC_PREPARED', + original_native_sha256=BASE_NATIVE_SHA, diagnostic_native_sha256=new_digest, + exact_original_contribution_restored=True, + exact_original_complete_c_source_restored=True, + changed_baseline_files=['native_cache.c', 'NATIVE-SOURCE.json'], + baseline_file_count=len(original_inventory), + original_inventory=original_inventory, edits=edits, + numerical_execution=False, compilation=False) +(HERE / 'SOURCE-EDITS.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') +print(json.dumps({key: value for key, value in receipt.items() if key not in ('edits', 'original_inventory')}, sort_keys=True)) diff --git a/research/verification-key-headroom/evidence/synthetic/RESULT.json b/research/verification-key-headroom/evidence/synthetic/RESULT.json new file mode 100644 index 0000000000..5961cb89c8 --- /dev/null +++ b/research/verification-key-headroom/evidence/synthetic/RESULT.json @@ -0,0 +1,302 @@ +{ + "automatic_retries": 0, + "build": { + "command": [ + "x86_64-linux-gnu-gcc", + "-O3", + "-std=c11", + "-fPIC", + "-shared", + "-Wall", + "-Wextra", + "-Werror", + "-I", + "/usr/include/python3.12", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/cache-key-pilot-v1-artifacts/build/keypilot.c", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/runtime/cache-key-pilot-v1-artifacts/build/_keypilot.cpython-312-x86_64-linux-gnu.so" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/c-verification-all-opportunities-20261027/stages/cache-key-pilot-v1", + "executable": "/usr/bin/python3.12", + "extension_sha256": "3f7af5c42da7a9c5287488227fbb3027761b700657e18c4cc532f067f3609b0d", + "platform": "linux", + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "returncode": 0, + "source_manifest": { + "files_sha256": { + "PLAN.md": "18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5", + "REPRODUCE.md": "167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9" + }, + "frozen_plan": { + "automatic_retries": 0, + "calls_per_sample": 2621440, + "capacity": 16384, + "construction_admitted": false, + "events": 32768, + "evictions_per_sample": 311296, + "hits_per_sample": 2293760, + "integer_residual_assumed_for_rejection_only": 0, + "lookups_per_event": 80, + "misses_per_sample": 327680, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "performance_publication": false, + "provisional_new_bill_reserve_seconds": 0.5, + "reserve_measured": false, + "samples": 4 + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "JOINT-DIAGNOSTIC-REVIEW.md": "6374ac5865a7fc12000a264e632181a49a0f70d1ab20e222537aa77322d77bab", + "REMAINING-ROUTE-REASSESSMENT.md": "caddd8fb6c8128ac907a668b491c9aab981362d9f1b66377084271e10f8f1289", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_PREPARED_UNEXECUTED" + }, + "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "stderr_bytes": 0, + "stdout_bytes": 0 + }, + "calls_per_sample": 2621440, + "capacity": 16384, + "child_cold_through_final_receipt_boundary": { + "cpu_including_compiler_children": 6.340759, + "excludes_process_startup_exit_and_this_final_write": true, + "wall": 6.351428891997784 + }, + "construction_admitted": false, + "corpus_sha256_little_endian_i64_fields": "80f0c7747bb486160afbe4e50d873ba90bd10751b6437105453459ca7bff25a5", + "events": 32768, + "finite_controls": "PASS_FINITE_KEY_ONLY", + "frozen_order": [ + "B1", + "C1", + "C2", + "B2" + ], + "lookups_per_event": 80, + "optimistic_screen": { + "actual_calls_for_illustration": 2579750, + "complete_new_validation_build_bill": "UNPRICED_NONZERO", + "construction_admitted": false, + "cpu": { + "diagnostic_integer_gross_region": 4.683428714999984, + "illustrative_key_saving_at_actual_calls": 0.12811002245883943, + "necessary_15pct_threshold_seconds": 5.1705, + "necessary_threshold_met": false, + "optimistic_budget_seconds": 4.311538737458823, + "paired_gross_seconds": [ + 0.130180342, + 0.17491264699999998 + ], + "provisional_new_bill_reserve": 0.5, + "smaller_paired_gross_seconds": 0.130180342, + "synthetic_gross_seconds_per_call": 4.9659859466552736e-08 + }, + "diagnostic_integer_regions_include_clock_overhead": true, + "integer_residual_assumed_seconds": 0, + "interpretation": "ILLUSTRATIVE_OPTIMISTIC_SCREEN_ONLY", + "measured_complete_saving": false, + "new_bill_reserve_measured": false, + "real_integer_residual": "UNPRICED_NONZERO", + "status": "REJECT_THIS_OPTIMISTIC_NOMINATION", + "wall": { + "diagnostic_integer_gross_region": 4.684712576272432, + "illustrative_key_saving_at_actual_calls": 0.1281700749812126, + "necessary_15pct_threshold_seconds": 5.199267808800505, + "necessary_threshold_met": false, + "optimistic_budget_seconds": 4.312882651253644, + "paired_gross_seconds": [ + 0.130241365, + 0.17497556999999997 + ], + "provisional_new_bill_reserve": 0.5, + "smaller_paired_gross_seconds": 0.130241365, + "synthetic_gross_seconds_per_call": 4.968313789367676e-08 + } + }, + "oracle_output": { + "calls": 2621440, + "flags": "oracle-flags.u8", + "flags_sha256": "15ad3ec5eb89a2936e34fefeb265c9afe4cb0da964390d2a89ed05522c58461d", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "oracle-ids.u64", + "ids_sha256": "af0a2ccfaf7998bd0cc858d6a40b82ecdcbe24f0dc3e4b7a64e0ba55a628dfde", + "prefixes": "oracle-prefixes.json", + "stats": { + "calls": 2621440, + "capacity": 16384, + "evictions": 311296, + "hits": 2293760, + "misses": 327680, + "resident": 16384 + } + }, + "parent_outer_guard_receipt_required": true, + "performance_publication": false, + "samples": [ + { + "calls": 2621440, + "cpu": 0.487164264, + "full_output_equality": true, + "mode": 0, + "name": "B1", + "output": { + "calls": 2621440, + "flags": "B1-flags.u8", + "flags_sha256": "15ad3ec5eb89a2936e34fefeb265c9afe4cb0da964390d2a89ed05522c58461d", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "B1-ids.u64", + "ids_sha256": "af0a2ccfaf7998bd0cc858d6a40b82ecdcbe24f0dc3e4b7a64e0ba55a628dfde", + "prefixes": "B1-prefixes.json", + "stats": { + "calls": 2621440, + "capacity": 16384, + "evictions": 311296, + "hits": 2293760, + "misses": 327680, + "rehashes": 0, + "resident": 16384 + } + }, + "wall": 0.487316342 + }, + { + "calls": 2621440, + "cpu": 0.356983922, + "full_output_equality": true, + "mode": 1, + "name": "C1", + "output": { + "calls": 2621440, + "flags": "C1-flags.u8", + "flags_sha256": "15ad3ec5eb89a2936e34fefeb265c9afe4cb0da964390d2a89ed05522c58461d", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "C1-ids.u64", + "ids_sha256": "af0a2ccfaf7998bd0cc858d6a40b82ecdcbe24f0dc3e4b7a64e0ba55a628dfde", + "prefixes": "C1-prefixes.json", + "stats": { + "calls": 2621440, + "capacity": 16384, + "evictions": 311296, + "hits": 2293760, + "misses": 327680, + "rehashes": 26, + "resident": 16384 + } + }, + "wall": 0.357074977 + }, + { + "calls": 2621440, + "cpu": 0.338782096, + "full_output_equality": true, + "mode": 1, + "name": "C2", + "output": { + "calls": 2621440, + "flags": "C2-flags.u8", + "flags_sha256": "15ad3ec5eb89a2936e34fefeb265c9afe4cb0da964390d2a89ed05522c58461d", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "C2-ids.u64", + "ids_sha256": "af0a2ccfaf7998bd0cc858d6a40b82ecdcbe24f0dc3e4b7a64e0ba55a628dfde", + "prefixes": "C2-prefixes.json", + "stats": { + "calls": 2621440, + "capacity": 16384, + "evictions": 311296, + "hits": 2293760, + "misses": 327680, + "rehashes": 26, + "resident": 16384 + } + }, + "wall": 0.338865159 + }, + { + "calls": 2621440, + "cpu": 0.513694743, + "full_output_equality": true, + "mode": 0, + "name": "B2", + "output": { + "calls": 2621440, + "flags": "B2-flags.u8", + "flags_sha256": "15ad3ec5eb89a2936e34fefeb265c9afe4cb0da964390d2a89ed05522c58461d", + "id_byteorder": "little", + "id_itemsize": 8, + "ids": "B2-ids.u64", + "ids_sha256": "af0a2ccfaf7998bd0cc858d6a40b82ecdcbe24f0dc3e4b7a64e0ba55a628dfde", + "prefixes": "B2-prefixes.json", + "stats": { + "calls": 2621440, + "capacity": 16384, + "evictions": 311296, + "hits": 2293760, + "misses": 327680, + "rehashes": 0, + "resident": 16384 + } + }, + "wall": 0.513840729 + } + ], + "scope": "finite synthetic key-only comparator", + "source_manifest": { + "files_sha256": { + "PLAN.md": "18e9528867b4b72c3a8834deacda559c7fef7c4d514695d829d35c08b81f16f5", + "REPRODUCE.md": "167111998682babc725092257dd47038395b4a6e2ff420fb3de30460c8e85941", + "keypilot.c": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", + "load_pilot.py": "d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968", + "run_pilot.py": "e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e", + "stage_entry.py": "3784002e1299e038f848ff591101c056114901571f44a09ec1c3b6b1056779b9" + }, + "frozen_plan": { + "automatic_retries": 0, + "calls_per_sample": 2621440, + "capacity": 16384, + "construction_admitted": false, + "events": 32768, + "evictions_per_sample": 311296, + "hits_per_sample": 2293760, + "integer_residual_assumed_for_rejection_only": 0, + "lookups_per_event": 80, + "misses_per_sample": 327680, + "order": [ + "B1", + "C1", + "C2", + "B2" + ], + "performance_publication": false, + "provisional_new_bill_reserve_seconds": 0.5, + "reserve_measured": false, + "samples": 4 + }, + "reference_files_sha256": { + "JOINT-COST-DIAGNOSTIC-RESULT.json": "364eea36276acc74ab579238aafff71ab9845e66ca6945ee5a872132b0d4d70f", + "JOINT-DIAGNOSTIC-REVIEW.md": "6374ac5865a7fc12000a264e632181a49a0f70d1ab20e222537aa77322d77bab", + "REMAINING-ROUTE-REASSESSMENT.md": "caddd8fb6c8128ac907a668b491c9aab981362d9f1b66377084271e10f8f1289", + "baseline-public/native_cache.c": "78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb", + "guard.py": "7540f8cc4ae4d12ed86c844ef0837a74184d3ada653979608c295c09f200a751", + "run_guarded.py": "59b13f93c493de297173c82986593f97cb687660579d32a6bf2ce1de323aaa0b" + }, + "status": "SOURCE_ONLY_PREPARED_UNEXECUTED" + }, + "source_only_preparation_precedes_parent_run": true, + "status": "PASS_FINITE_KEY_COMPARISON_ONLY" +} diff --git a/research/verification-key-headroom/evidence/synthetic/RESULTS.md b/research/verification-key-headroom/evidence/synthetic/RESULTS.md new file mode 100644 index 0000000000..7de0fde116 --- /dev/null +++ b/research/verification-key-headroom/evidence/synthetic/RESULTS.md @@ -0,0 +1,30 @@ +# Cache-key pilot: finite comparison passed; optimistic nomination rejected + +The parent executed the frozen pilot once on 2026-10-28. The guarded command passed, and the driver returned `PASS_FINITE_KEY_COMPARISON_ONLY`. Its predeclared budget screen returned **`REJECT_THIS_OPTIMISTIC_NOMINATION`** for both wall time and CPU. The complete PR5864 >=15% target was not achieved or admitted. + +Evidence: [outer guard receipt](../runtime/runs/cache-key-pilot-v1/receipt.json), [driver result](../runtime/cache-key-pilot-v1-artifacts/RESULT.json), [finite controls](../runtime/cache-key-pilot-v1-artifacts/FINITE-CONTROLS.json), and [frozen source manifest](../stages/cache-key-pilot-v1/FROZEN-SOURCE.json). This report interprets those retained receipts; it performs no rerun or independent numerical replay. + +The complete cold command, including compilation, loading, finite checks, oracle construction, four samples, comparisons and output persistence, cost **6.573198422 seconds wall and 6.51 seconds CPU**. Sampled peak process-group RSS was **303,071,232 bytes**. The compiler returned zero with empty stdout and stderr; the guarded command had empty stderr, no termination condition, and unchanged inventoried source bytes and modes. The reported CPU is the guard's rounded user-plus-system measurement, including compiler children. + +The driver retained all four samples in the frozen B,C,C,B order. Each used fresh cache state and 2,621,440 synthetic lookups: 2,293,760 hits, 327,680 misses, 311,296 FIFO evictions and 16,384 final residents. Each complete ordered ID sequence, hit/miss/eviction flag sequence and 80-operation prefix transcript matched the separate literal Python dict/deque oracle. Both custom samples paid for 26 natural rehashes; baseline custom-rehash counters were zero. The 82 finite-control receipts passed and exercised 50 natural rehashes, including broad numeric/collision/FIFO cases, type rejections, and the declared success/failure reference checks. These are finite checks, not exhaustive allocator-failure or general GC proofs. + +| Sample | Wall seconds | CPU seconds | +|---|---:|---:| +| B1 | 0.487316342 | 0.487164264 | +| C1 | 0.357074977 | 0.356983922 | +| C2 | 0.338865159 | 0.338782096 | +| B2 | 0.513840729 | 0.513694743 | + +The fixed rule takes the smaller of B1−C1 and B2−C2 separately for wall and CPU. Those synthetic gross savings were **0.130241365 seconds wall / 0.130180342 CPU**. Multiplying their per-call rates by the actual 2,579,750 contribution calls gives only an illustrative transfer of **0.128170075 wall / 0.128110022 CPU seconds**; it is not a measured saving on the actual trace. + +| Conditional budget | Wall seconds | CPU seconds | +|---|---:|---:| +| Diagnostic integer gross region + illustrative key saving − provisional 0.5-second reserve | 4.312882651 | 4.311538737 | +| Same generous calculation with the reserve reduced to zero | 4.812882651 | 4.811538737 | +| Necessary 15% saving against the fixed complete baseline | 5.199267809 | 5.170500000 | + +Both calculations fail even while assigning **zero retained integer runtime**. The diagnostic integer gross regions include clock overhead and are not measured removable work. The 0.5-second reserve was provisional, not a measured complete future bill; the separate 6.573198422-second cold pilot bill above is real and must remain charged. Actual retained integer cost and complete construction/build/validation costs remain unpriced and nonzero. + +This result rejects **this synthetic conditional nomination**. It supplies neither an actual complete-runtime saving nor an upper bound on actual-trace key savings, and it does not establish global impossibility. The pilot omits Fraction arithmetic and descriptors from both inner loops, uses opaque miss IDs, and has no arbitrary callback or general Cache/Event GC interface. Consequently it does not prove literal Fraction-cache API compatibility, callback/GC behavior, or production integration correctness. Private cache cleanup is included in the inner measurements; destruction of returned outputs is paid outside those clocks by the cold command. + +No source was changed after execution, no favorable repeat replaced any sample, and no retry, integer-owner construction, GMP provisioning, or new route investigation was performed for this report. The frozen sources and manifest retain their original pre-execution provenance labels; this separate report records the subsequent parent-owned execution. diff --git a/research/verification-key-headroom/publication/HEADROOM-CONTEXT-EARLY-REVIEW.json b/research/verification-key-headroom/publication/HEADROOM-CONTEXT-EARLY-REVIEW.json new file mode 100644 index 0000000000..45403ee121 --- /dev/null +++ b/research/verification-key-headroom/publication/HEADROOM-CONTEXT-EARLY-REVIEW.json @@ -0,0 +1,9 @@ +{ + "status": "PASS", + "actual_stage_files": 177, + "measured_inventory_files": 177, + "baseline_files": 164, + "all_original_bytes_modes_and_stored_stage_bytes_equal": true, + "issues": [], + "scope": "Parent static source-only copy check; no imports/compiler/corpus/replay" +} diff --git a/research/verification-key-headroom/publication/HEADROOM-EARLY-ANCESTRY.json b/research/verification-key-headroom/publication/HEADROOM-EARLY-ANCESTRY.json new file mode 100644 index 0000000000..5fe4fddc7f --- /dev/null +++ b/research/verification-key-headroom/publication/HEADROOM-EARLY-ANCESTRY.json @@ -0,0 +1,25 @@ +{ + "status": "PASS", + "head": "f901e992a3846ff0351bfb0caf75b6167788cd74", + "commits": [ + { + "commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810", + "ancestor_of_current_input_commit": true, + "returncode": 0, + "stderr": "" + }, + { + "commit": "f901e992a3846ff0351bfb0caf75b6167788cd74", + "ancestor_of_current_input_commit": true, + "returncode": 0, + "stderr": "" + }, + { + "commit": "ccb92b752ab31df4220780a580cc14d9e86ffeca", + "ancestor_of_current_input_commit": true, + "returncode": 0, + "stderr": "" + } + ], + "scope": "Early static Git ancestry check before final publication commit; formal committed preflight remains required" +} diff --git a/research/verification-key-headroom/publication/HEADROOM-METADATA-CHECK.json b/research/verification-key-headroom/publication/HEADROOM-METADATA-CHECK.json new file mode 100644 index 0000000000..c13f8001e9 --- /dev/null +++ b/research/verification-key-headroom/publication/HEADROOM-METADATA-CHECK.json @@ -0,0 +1,14 @@ +{ + "status": "PASS_PACKAGE_METADATA_AND_PINS", + "command": [ + "python3", + "-B", + "outputs/c-verification-all-opportunities-20261027/headroom-repo/scripts/research_package.py", + "--package", + "research/verification-key-headroom", + "--check-only" + ], + "exit": 0, + "stdout": "PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)\n", + "scope": "metadata and source pins only; no mathematical/performance acceptance" +} diff --git a/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-FREEZE.json b/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-FREEZE.json new file mode 100644 index 0000000000..0f93bdce31 --- /dev/null +++ b/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-FREEZE.json @@ -0,0 +1,11 @@ +{ + "status": "PASS", + "source_manifest_sha256": "9b3c05b97f926c2c767ad394a399554cd4034a86526dead247251e0921c697d5", + "protected_files": 252, + "copied_package_files": 254, + "issues": [], + "stage": "outputs/c-verification-all-opportunities-20261027/stages/headroom-publication-v1", + "readonly_files": "0444", + "readonly_directories": "0555", + "external_runtime_only": true +} diff --git a/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-REVIEW.md b/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-REVIEW.md new file mode 100644 index 0000000000..34fb73937d --- /dev/null +++ b/research/verification-key-headroom/publication/HEADROOM-PUBLICATION-REVIEW.md @@ -0,0 +1,168 @@ +# Verification-key headroom: independent publication source review + +Status: PASS_PUBLICATION_SOURCE_REVIEW_ONLY at the exact manifest below. +No remaining source blocker within the declared serial, stable-checkout scope. +Parent-owned execution and committed publication checks remain separate gates. + +Reviewer: OpenAI Codex / Astra, separately from the publication-wrapper author. +The reviewer performed only source reading and standalone standard-library +file/hash/JSON/metadata comparisons. No package or scientific module was imported, +no compiler or corpus parser was run, and no numerical/timing, Git, or browser +operation was performed. This report is outside the proposed package; no measured +source, package source, data, prior receipt, or other agent's file was changed. + +## Confirmed source and evidence findings + +The independently checked `MEASURED-CONTEXT.json` census equals all 164 files in +the original frozen baseline and all 177 files in the measured actual-key stage, +including each byte count, SHA-256 and mode. Every file needed by the sparse +publication reconstruction is present with identical bytes. All original +baseline files use mode 0644; measured stage files use 0644 or 0664. Git's +executable-bit representation cannot retain the latter distinction, so the new +external reconstruction explicitly restores measured stage modes before checking +the complete census. It never changes the source checkout's modes. + +All 47 `ARCHIVE-MAP.json` copied-file rows equal the corresponding original local +files by complete bytes, size and SHA-256. Reversing every declared capture edit +in reverse order, with unique seam checks, recovers the complete original +`native_cache.c` SHA-256 +`78ed2e240ee40ce4989a4718e77e8b3967b092d2bf8c900124a26942c98a14cb`. +Only the capture C file and its native-loader hash are baseline overlays. + +The finite wrapper calls the byte-identical historical `finite_controls` helper +from `run_pilot.py`; it does not call the timing/corpus entrypoint. That helper's +checks use explicit conditionals and exceptions, so normal and `-O` registered +commands can exercise the same 82 finite receipts and 50 natural rehashes. +Compilation uses a fresh external build directory, unchanged source loader, +existing Linux CPython 3.12 headers/compiler, warnings as errors, and no install. +Actual successful normal/optimized execution remains a parent-runner obligation. + +The new data verifier implements a separate ordinary dict/deque FIFO oracle. +For all 2,579,750 seven-exact-int keys it checks every little-endian uint64 result +ID, every hit/miss/eviction flag, all 80-operation and final-partial cumulative +prefixes, and the final original counters. It compares full ordered values; +hashes do not replace the item comparisons. Transport hashes authenticate +immutable compressed inputs, while uncompressed hashes and complete values +are authoritative for regenerated output equality. The source-specific replay +preserved object identities only in the original in-memory timing run; the +archived block transport explicitly does not preserve cross-block identity. + +The parent-owned `HEADROOM-EARLY-ANCESTRY.json` records successful ancestry checks +for base `19fdb086ea96af9a9f87936a2b888e10af4ed810`, own input commit +`f901e992a3846ff0351bfb0caf75b6167788cd74`, and official archive input commit +`ccb92b752ab31df4220780a580cc14d9e86ffeca` against the input head. This reviewer +read that receipt and did not perform Git operations. Final committed-byte and +source-history preflight remains separate and required before publication. + +## Findings sent to the author before freeze + +1. The initial `corpus_blocks` implementation attempted one extra pickle load and + accepted `EOFError`. That does not establish exact absence of trailing bytes: + an incomplete trailing pickle can terminate in EOFError. A strict raw-byte + EOF check and safe opcode validation are required before final clearance. + The initial `find_class` override alone also did not establish the claimed + rejection of every unsafe pickle mechanism, particularly cached extension + opcodes. The requested repair is confined to the new archive wrapper; + historical measured source is retained verbatim. +2. The parent separately identified that an unconditional `TemporaryDirectory` + cleanup discards finite-control compiler logs on failure. The new wrapper + must preserve its external build directory on failure before registration. + +The repaired wrapper now scans each bounded object with an explicit plain-only +opcode allowlist before unpickling, uses a fresh memo per object, and checks raw +decompressed EOF after the final expected object. GLOBAL, STACK_GLOBAL, REDUCE, +BUILD, OBJ, INST, NEWOBJ and EXT mechanisms are excluded before deserialization. +Because the scanner consumes exactly through STOP, an unpickler cannot hide +trailing bytes through source-stream read-ahead. This resolves finding 1 by +source inspection; parser execution remains with the parent. The finite wrapper +now uses an external mkdtemp directory, retains it plus FAILURE.json and an +exception evidence note on failure, and deletes it only on success, resolving +finding 2. + +The parent also found that a fully read-only export leaves copied baseline modes +at 0444. The repaired reconstruction makes only its fresh external directories +writable, restores all original baseline file modes, and then restores all +measured stage modes. This resolves the read-only-source issue by source +inspection without chmod or writes to the source checkout. + +## Final source and metadata clearance + +The independent static check rehashed all 252 protected rows in the final +`CODE-SOURCES.json`, verified their byte lengths and Git executable-bit +semantics, and found no discrepancy. Its source census covers all 52 `.py`, +`.c` and `.inc` files. The 254 package files differ from that manifest only by +its own file and the explicitly excluded `VALIDATION.json` receipt. The latter +is a pending-status record, not a proof-relevant numerical/source input or +substitute for actual execution receipts. New wrappers, unchanged scientific +context, DATA/FORMAT/MEASURED metadata, original evidence and all immutable +corpus/canonical streams are protected. Registered entrypoints authenticate +those inputs before decoding or source loading and again before success. + +All eight SOURCES rows match retained local file bytes by SHA-256 and a separately +computed Git blob SHA-1 (standard-library hashing, no Git invocation). All six +live input paths appear in VERIFY; those input sets are equal. The recorded base, +own input commit, official archive head pin and early ancestry receipt agree. +The original task card equals the full card in the exact pinned local catalogue. +These static comparisons do not replace the parent's final committed-byte and +source-history checks against the actual publication commit. + +VERIFY registers exactly four commands: fresh finite controls under normal +Python, the same controls under deliberate `-O`, the complete streaming data +oracle, and exact context reconstruction. Their per-command bounds are 60, 60, +180 and 60 seconds. There are no required package installations and no timing or +capture rerun in registered checks or CI. Optional `replay_capture.py` is separate, +explicit, single-shot and guarded; its new timings cannot replace the retained +samples. It compares all regenerated key values/order rather than requiring new +gzip container bytes to match. + +README and TASK explicitly preserve the negative conditional result and unmet +complete target, scope the task's completed outcome to the archive/cost audit, +and keep the separate matrix result outside this performance claim. They retain +the zero-reserve sensitivity result, cross-run/clock-overhead limitations, +nonzero unpriced retained work and complete future bill, original callback/Fraction +integration obligations, predecessor attribution and Apache-2.0/AI disclosure. +The original nested NOTICE is byte-identical. Their open question requires new +source/cost evidence before any further construction or scientific run. + +The parent-owned freeze receipt records all 254 package files plus the official +archive in a Git-free stage with files 0444 and directories 0555. Source review +confirms that fresh external reconstruction restores destination-only modes, +finite build failures retain external evidence, and no registered source writes +or historical benchmark execution are required. Actual read-only-export success, +finite normal/optimized controls, full data equality and context execution are +not claimed by this reviewer; they remain parent-runner checks. + +### Exact reviewed publication identities + +| File | SHA-256 | +|---|---| +| CODE-SOURCES.json | `9b3c05b97f926c2c767ad394a399554cd4034a86526dead247251e0921c697d5` | +| verify.py | `e6218ee4d0dc1154c5d6cc90a20405dbbf0d753ba39ddffeeb29b4f9fda0b39e` | +| archive_support.py | `5d9db9496e040adac339bcbfdaf97e3561592a6f814b11a455bf700e64406fec` | +| replay_capture.py | `226aa76079545339cdc72ac65483628db8e7a42a071bbae21bf17baad5fc9126` | +| MEASURED-CONTEXT.json | `c0586ccf6b21ee92015ea7d6a3d88a672f21d556b09332cd6d4502730b074789` | +| FORMAT.json | `baf52afe2d0446706cd3c415ad59b603fb1f4f42b7b7d5c518dfe5d9693fda33` | +| SOURCES.json | `2806dd664a5af54719fc41f648025e231de5cf917f464393dffe276fdb40e559` | +| VERIFY.json | `1ffed66e98ce509f3b06e07aa6ab5f437ca9a3fea17f29870cf2fbce7b58596f` | +| TASK.json | `29a16369f5762f07e98df4ea91816232545744751610e262453f6528d417eab7` | +| README.md | `910241eb8d4968a97f168f4b54832b1dc66e8fa3fb230a5020a823e5455b81b3` | +| NOTICE | `5745bd98e57fa8bed84dc589cabbe34a23541c88aa6c9877633ee37bc923ad0d` | +| VALIDATION.json (pending receipt) | `e527f5abd9fa9a3d1e42c8e14751484b28d97ec3038b99f704ea868e5eb1ee83` | + +The measured comparator remains `ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6`, +its loader `d6912e01fafa7a79a635812e4884d776757f2e24996850b692f0eb8825bf7968`, +and its finite helper `e02ebb21c4985001f57d947414c52366de77e8db5dfe713440a921e5f4cb1c8e`. +The unchanged captured corpus remains `660e3f8d6dcd147c97a5691feab301e558cc70097c7d4c3d00e4f116482d2699`. +No claim here supplies a new execution result or independent full C memory-safety +proof. A proof-relevant edit after these pins requires renewed review of that edit. + +## Admission boundary + +The retained actual-key conditional nomination remains rejected in both wall +and CPU, including its zero-reserve sensitivity calculation. The earlier integer +gross anchor is from another run and is not an achieved saving; residual integer +work and the complete integration/build/validation bill remain unpriced and +nonzero. Publication cannot admit the further complete PR5864 15% target, a GMP +or private-integer construction, full Fraction/API/GC integration, a new kappa, +or a universal impossibility claim. The separately qualified matrix result does +not contribute to this target. diff --git a/research/verification-key-headroom/publication/headroom-publication-context-v1/receipt.json b/research/verification-key-headroom/publication/headroom-publication-context-v1/receipt.json new file mode 100644 index 0000000000..3ff4e6344f --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-context-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "headroom-publication-context-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": "02e3e062c0e4bb2af352c7f76697ffad7a3bbe0d9e8be2cfa0247eb06ebbd245", + "sampled_process_group_rss_bytes": 27918336, + "script": "stages/headroom-publication-v1/context.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "29b3d3020bc7de74564748f3654fa7aee3cbb96325042a307b47a35da620400e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 432, + "stdout_sha256": "aea7a19d153145b4e60ccca9d5aebbd4b3d01c10f77969185fc11af91ee8c4ae", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 25984, + "system_seconds": 0.06, + "user_seconds": 0.41 + }, + "wall_seconds": 0.5080786359903868 +} diff --git a/research/verification-key-headroom/publication/headroom-publication-context-v1/stderr.txt b/research/verification-key-headroom/publication/headroom-publication-context-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/publication/headroom-publication-context-v1/stdout.txt b/research/verification-key-headroom/publication/headroom-publication-context-v1/stdout.txt new file mode 100644 index 0000000000..81afe0e872 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-context-v1/stdout.txt @@ -0,0 +1 @@ +{"context": {"all_bytes_and_modes_equal": true, "exact_C_inverse": true, "measured_stage_files": 177, "original_baseline_files": 164}, "no_scientific_import_or_execution": true, "official_input": {"head": "3f15c943e4ad6479f03e674c80fff1269a16ccfe", "official_export_files": 163, "retained_export_receipt": true, "sha256": "7b142567acacac5182045bf8daa8780e916661c2cf343dbf81b13c88ead85d64"}, "status": "PASS_EXACT_MEASURED_CONTEXT"} diff --git a/research/verification-key-headroom/publication/headroom-publication-context-v1/usage.json b/research/verification-key-headroom/publication/headroom-publication-context-v1/usage.json new file mode 100644 index 0000000000..c3a78cec83 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-context-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.41,"system_seconds":0.06,"kernel_max_rss_kib":25984,"exit":0} diff --git a/research/verification-key-headroom/publication/headroom-publication-data-v1/receipt.json b/research/verification-key-headroom/publication/headroom-publication-data-v1/receipt.json new file mode 100644 index 0000000000..19706d9175 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-data-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "headroom-publication-data-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": "02e3e062c0e4bb2af352c7f76697ffad7a3bbe0d9e8be2cfa0247eb06ebbd245", + "sampled_process_group_rss_bytes": 41033728, + "script": "stages/headroom-publication-v1/data.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "29b3d3020bc7de74564748f3654fa7aee3cbb96325042a307b47a35da620400e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 354, + "stdout_sha256": "69fb3db17a6af42772389c2aa2903fc05a0969c0b73e324d431dcfe54b0d339e", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 38620, + "system_seconds": 0.05, + "user_seconds": 42.91 + }, + "wall_seconds": 43.02619857201353 +} diff --git a/research/verification-key-headroom/publication/headroom-publication-data-v1/stderr.txt b/research/verification-key-headroom/publication/headroom-publication-data-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/publication/headroom-publication-data-v1/stdout.txt b/research/verification-key-headroom/publication/headroom-publication-data-v1/stdout.txt new file mode 100644 index 0000000000..5fa830ec95 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-data-v1/stdout.txt @@ -0,0 +1 @@ +{"all_ordered_items_checked": true, "no_C_capture_or_timing": true, "prefixes": 32247, "regenerated_compression_is_not_mathematical_identity": true, "statistics": {"bypasses": 0, "calls": 2579750, "capacity": 16384, "evictions": 310400, "hits": 2252966, "misses": 326784, "resident": 16384}, "status": "PASS_COMPLETE_ACTUAL_KEY_DATA", "streaming": true} diff --git a/research/verification-key-headroom/publication/headroom-publication-data-v1/usage.json b/research/verification-key-headroom/publication/headroom-publication-data-v1/usage.json new file mode 100644 index 0000000000..6eb90da546 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-data-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":42.91,"system_seconds":0.05,"kernel_max_rss_kib":38620,"exit":0} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/receipt.json b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/receipt.json new file mode 100644 index 0000000000..6a11370466 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "headroom-publication-finite-O-v1", + "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": "02e3e062c0e4bb2af352c7f76697ffad7a3bbe0d9e8be2cfa0247eb06ebbd245", + "sampled_process_group_rss_bytes": 75513856, + "script": "stages/headroom-publication-v1/finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "29b3d3020bc7de74564748f3654fa7aee3cbb96325042a307b47a35da620400e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 218, + "stdout_sha256": "dab14578649bbe383cc42aa0f28a5a9ed2c6236063f52c51dacf0a032b7a83fa", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 46660, + "system_seconds": 0.05, + "user_seconds": 0.68 + }, + "wall_seconds": 0.7695385620172601 +} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/stderr.txt b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/stdout.txt b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/stdout.txt new file mode 100644 index 0000000000..9df56f3c2e --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/stdout.txt @@ -0,0 +1 @@ +{"natural_rehashes": 50, "no_capture_or_benchmark": true, "optimized": 1, "receipts": 82, "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", "status": "PASS_ARCHIVED_FINITE_CONTROLS"} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/usage.json b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/usage.json new file mode 100644 index 0000000000..bf87a2a848 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-O-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.68,"system_seconds":0.05,"kernel_max_rss_kib":46660,"exit":0} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-v1/receipt.json b/research/verification-key-headroom/publication/headroom-publication-finite-v1/receipt.json new file mode 100644 index 0000000000..7bc8adda30 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-v1/receipt.json @@ -0,0 +1,26 @@ +{ + "exit": 0, + "label": "headroom-publication-finite-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": "02e3e062c0e4bb2af352c7f76697ffad7a3bbe0d9e8be2cfa0247eb06ebbd245", + "sampled_process_group_rss_bytes": 75530240, + "script": "stages/headroom-publication-v1/finite.py", + "source_bytes_and_modes_unchanged": true, + "source_inventory_sha256": "29b3d3020bc7de74564748f3654fa7aee3cbb96325042a307b47a35da620400e", + "status": "PASS", + "stderr_bytes": 0, + "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout_bytes": 218, + "stdout_sha256": "f89be3ef436371edccddd3a2ca52c7fc4eb85b16e17b6dd0c19907814dc8f1ae", + "termination": null, + "usage": { + "exit": 0, + "kernel_max_rss_kib": 46408, + "system_seconds": 0.07, + "user_seconds": 0.68 + }, + "wall_seconds": 0.785633888997836 +} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-v1/stderr.txt b/research/verification-key-headroom/publication/headroom-publication-finite-v1/stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-v1/stdout.txt b/research/verification-key-headroom/publication/headroom-publication-finite-v1/stdout.txt new file mode 100644 index 0000000000..319a7b7825 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-v1/stdout.txt @@ -0,0 +1 @@ +{"natural_rehashes": 50, "no_capture_or_benchmark": true, "optimized": 0, "receipts": 82, "source_sha256": "ee3fb2af131878fa2065d1b50d02f2f865c0ac61c9ec0a3d66b15c910f3d9cf6", "status": "PASS_ARCHIVED_FINITE_CONTROLS"} diff --git a/research/verification-key-headroom/publication/headroom-publication-finite-v1/usage.json b/research/verification-key-headroom/publication/headroom-publication-finite-v1/usage.json new file mode 100644 index 0000000000..de55e47405 --- /dev/null +++ b/research/verification-key-headroom/publication/headroom-publication-finite-v1/usage.json @@ -0,0 +1 @@ +{"user_seconds":0.68,"system_seconds":0.07,"kernel_max_rss_kib":46408,"exit":0} diff --git a/research/verification-key-headroom/replay_capture.py b/research/verification-key-headroom/replay_capture.py new file mode 100644 index 0000000000..92007fcfad --- /dev/null +++ b/research/verification-key-headroom/replay_capture.py @@ -0,0 +1,66 @@ +"""Optional fresh capture reproduction, only when explicitly requested. + +Not registered for publication/CI. New timings never replace archived samples. +""" +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_capture.py','archive_support.py'): + raw=(ROOT/name).read_bytes() + if sha256(raw).hexdigest()!=PINS[name]['sha256']:raise ValueError('protected replay wrapper source: '+name) +S=types.ModuleType('_headroom_capture_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def main(): + import argparse + import subprocess + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--evidence',required=True,type=Path) + args=parser.parse_args();destination=args.evidence.resolve() + S.need(sys.platform=='linux' and sys.version_info[:2]==(3,12),'original Linux CPython 3.12 replay environment required') + S.need(not destination.exists() and not destination.is_relative_to(S.REPO),'fresh external evidence directory required') + S.authenticate();destination.mkdir(parents=True) + reconstructed=S.reconstruct(destination/'context') + source_check=S.validate_context(reconstructed);S.official_baseline(reconstructed) + command=[sys.executable,'-B',str(reconstructed/'run_guarded.py'),'actual-key-pilot-v1','stages/actual-key-pilot-v1/stage_entry.py'] + report=dict(status='STARTED_OPTIONAL_REPRODUCTION',command=command,source_check=source_check, + automatic_retries=0,historical_nomination='REJECT_THIS_ACTUAL_KEY_CONDITIONAL_NOMINATION', + new_timings_supersede_historical=False,construction_admitted=False) + result_path=destination/'REPLAY-RESULT.json' + def write():result_path.write_text(json.dumps(report,indent=2,sort_keys=True)+'\n') + write() + try: + with (destination/'guard.stdout.txt').open('wb') as out,(destination/'guard.stderr.txt').open('wb') as err: + completed=subprocess.run(command,cwd=reconstructed,stdout=out,stderr=err,check=False) + report['returncode']=completed.returncode + S.need(completed.returncode==0,'single guarded capture failed; all evidence retained, no retry') + guard=json.loads((reconstructed/'runtime/runs/actual-key-pilot-v1/receipt.json').read_text()) + fresh_root=reconstructed/'runtime/actual-key-pilot-v1-artifacts' + fresh=json.loads((fresh_root/'RESULT.json').read_text()) + S.need(guard['status']=='PASS' and fresh['status']=='PASS_ACTUAL_KEY_COMPARISON_ONLY','complete fresh guarded capture/replay') + committed=json.loads((ROOT/'data/DATA.json').read_text())['actual_corpus'] + left=S.corpus_blocks(ROOT/'data'/committed['file'],committed['sha256']) + right=S.corpus_blocks(fresh_root/fresh['corpus']['file'],fresh['corpus']['sha256']) + count=0 + for a,b in zip(left,right,strict=True): + S.need(a==b,'every regenerated key value/order equals committed corpus') + count+=len(a) + S.need(count==S.CALLS,'complete regenerated corpus equality') + S.validate_context(reconstructed);S.authenticate() + report.update(status='PASS_FRESH_CAPTURE_VALUES_ONLY',all_regenerated_key_values_equal=True,calls=count, + new_corpus_container_sha256=fresh['corpus']['sha256'],guard_receipt=guard, + compression_hash_equality_required=False) + except BaseException as error: + report.update(status='FAIL_OPTIONAL_REPRODUCTION_RETAINED',error_type=type(error).__name__,error=str(error)) + raise + finally:write() + print(json.dumps(dict(status=report['status'],result=str(result_path),new_timings_supersede_historical=False))) + + +if __name__=='__main__':main() diff --git a/research/verification-key-headroom/verify.py b/research/verification-key-headroom/verify.py new file mode 100644 index 0000000000..2c806e1e9b --- /dev/null +++ b/research/verification-key-headroom/verify.py @@ -0,0 +1,104 @@ +"""Bounded archive checks; never run the historical benchmark/capture entrypoint.""" +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'): + raw=(ROOT/name).read_bytes() + if sha256(raw).hexdigest()!=PINS[name]['sha256']:raise ValueError('protected verifier source: '+name) +S=types.ModuleType('_headroom_archive_support');S.__file__=str(ROOT/'archive_support.py') +exec(compile((ROOT/'archive_support.py').read_bytes(),S.__file__,'exec'),S.__dict__) + + +def finite(): + import struct + import tempfile + import shutil + S.need(sys.implementation.name=='cpython' and sys.version_info[:2]==(3,12) and sys.platform=='linux' and struct.calcsize('P')==8,'Linux 64-bit CPython 3.12 with existing cc/headers') + stage=ROOT/'context'/S.STAGE + loader=S.source_module('load_pilot',stage/'load_pilot.py') + approved=S.source_module('_headroom_approved_pilot',stage/'run_pilot.py') + temporary=Path(tempfile.mkdtemp(prefix='key-headroom-finite-')) + try: + module,build=loader.compile_and_load(temporary) + result=approved.finite_controls(module) + S.need(result['status']=='PASS_FINITE_KEY_ONLY' and len(result['receipts'])==82 and result['natural_rehashes']==50,'all unchanged finite controls executed') + S.need(build['returncode']==0 and build['stdout_bytes']==build['stderr_bytes']==0,'clean compiler with warnings as errors') + answer=dict(status='PASS_ARCHIVED_FINITE_CONTROLS',receipts=82,natural_rehashes=50,optimized=sys.flags.optimize, + source_sha256=build['source_sha256'],no_capture_or_benchmark=True) + except BaseException as error: + error.add_note('Finite build/control evidence retained at '+str(temporary)) + (temporary/'FAILURE.json').write_text(json.dumps(dict(type=type(error).__name__,message=str(error),evidence=str(temporary)),indent=2)+'\n') + raise + else: + shutil.rmtree(temporary) + return answer + + +def data(): + from collections import deque + from hashlib import sha256 as new_hash + import gzip + import struct + payload=json.loads((ROOT/'data/DATA.json').read_text()) + formatting=json.loads((ROOT/'FORMAT.json').read_text()) + S.need(formatting['ids']==dict(byteorder='little',item_bytes=8,type='unsigned 64-bit integer'),'explicit canonical ID format') + outputs=payload['canonical_outputs'];directory=ROOT/'data' + prefixes=json.loads(S.read_plain_gzip(directory/outputs['prefixes']['file'],outputs['prefixes'])) + S.need(type(prefixes) is list and len(prefixes)==(S.CALLS+79)//80,'complete prefix count') + for prefix in prefixes:S.need(type(prefix) is list and len(prefix)==5 and all(type(x) is int for x in prefix),'exact prefix fields') + for name in ('ids','flags'): + pin=outputs[name];S.need(S.digest_file(directory/pin['file'])==pin['transport_sha256'],'committed output transport pin') + cache={};fifo=deque();calls=hits=misses=evictions=prefix_index=0 + id_hash=new_hash();flag_hash=new_hash();id_bytes=flag_bytes=0 + corpus=payload['actual_corpus'] + with gzip.open(directory/outputs['ids']['file'],'rb') as ids,gzip.open(directory/outputs['flags']['file'],'rb') as flags: + for block in S.corpus_blocks(directory/corpus['file'],corpus['sha256']): + raw_ids=ids.read(8*len(block));raw_flags=flags.read(len(block)) + S.need(len(raw_ids)==8*len(block) and len(raw_flags)==len(block),'complete ordered ID/flag block') + id_hash.update(raw_ids);flag_hash.update(raw_flags);id_bytes+=len(raw_ids);flag_bytes+=len(raw_flags) + for offset,key in enumerate(block): + calls+=1;value=cache.get(key);flag=0 + if value is not None:hits+=1 + else: + misses+=1;value=misses;flag=1 + if len(fifo)==16384: + del cache[fifo.popleft()];evictions+=1;flag=3 + cache[key]=value;fifo.append(key) + S.need(struct.unpack_from('