diff --git a/research/complex-pooled-full-admission/AUDIT-EVIDENCE.json b/research/complex-pooled-full-admission/AUDIT-EVIDENCE.json new file mode 100644 index 000000000..d110d7cef --- /dev/null +++ b/research/complex-pooled-full-admission/AUDIT-EVIDENCE.json @@ -0,0 +1,46 @@ +{ + "schema_version": 1, + "status": "RECORDED_BOUNDED_CHECKS_AND_WRITTEN_SOURCE_RELATIVE_PROOFS", + "scope": "Fresh local/global source bindings, exact outer coefficient/recovery checks, constructor/cohort scope controls and lossless receipt/canonical-input transport. Optional B2 is separated. No production numerical payload, unconditional theorem, formal kernel or independent human review. The complete heavy finite release has its separate unchanged EVIDENCE.json.", + "source_sha256": { + "physical_bridge.py": "590c928e290fe8d7cbaa08bcd73fcac4fee6fe21aca193f5c41e3d612f57fd9a", + "physical_global_bridge.py": "b9075451d35480be6252b95105b0d9456845bfc62b3f43df9b822b492ad40172", + "PHYSICAL-PINS.json": "2ea958a9c87c5202113d84f176972de662fd87b45e5fde57c33a3251c7eeab53", + "PHYSICAL-GLOBAL-PINS.json": "66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b", + "PHYSICAL-BRIDGE.md": "2fa75b9af51d31f68b818aeca7f2cb9e9f9d940ebe509fdb29d77053e05f8218", + "PHYSICAL-GLOBAL.md": "1d1f06c714f0f3e5e6ab660084191a080ce4a86c0dfef8022b57c00778085b97", + "outer_factory.py": "d61f7637c8235904c5be4dcab54d28f451168f7cdbaae681d034000ee92e8a5d", + "outer_domain.py": "7296c03c5d90c464eee59515bd8b3eb81380d62d946c3713bf79ffa8c3f0fe9b", + "outer_check.py": "45c3f1255e58ab8ed37c9c1c14defa0f2d59a3ffc57c4823bb80d06bf9b73002", + "OUTER-PINS.json": "5cd7e6c92aa5be34cb4f9fd2db475e90954c4bff0f9a2a980d319d2079086dc9", + "OUTER-FACTORY-PINS.json": "6e066a1b7f5aa26ce2915ea67186a167614c87ca444c46c25e4a5c57d4c032c5", + "OUTER-DOMAIN-PINS.json": "f35c851e78f4eba0df41fb937940acdfcae8048b74c9938eb6a9172f2253fe8d", + "OUTER-DOMAIN.md": "280be120c31c88c7d9d906d040f0d851227dd06dc8657773455b0b42d6dddc55", + "OUTER-CHECK.md": "f44591b102fd618b0fbe171c9b571f4e109735713beb5b29b9887a6f4fddea9b", + "OUTER-JOIN.md": "bfb4677ee82ffc070be880eca87af05fd096686b464dfd5268cee1b27afa453e", + "outer_suite.py": "93119ca9ad83eedde376ce9f1b0979ed9020bcd45fb4f6dac6cb9901694777df", + "verify.py": "b9de9917f1242c2e3cef20c59b114430d76b8bfbc24185c0a223554bb7bfe386", + "INPUT-PINS.json": "fda470ee2346bb4febcc4df088bf82dd32db3b68f69e4eb6daee6467a65f521a", + "receipt_transport.py": "572d47cf4d2125b62b6f4ab147d6474908166213d6fb71a123a4e4f739eed4cb", + "joint_bound_inputs.py": "0141b3ef68c6bfc669f8a1f5d0a62eef04609d725051ae15f2e10f5604d11dd2", + "PACKAGING.json": "4622a5da4353421a67ba46c59293e65dec56190b0beb6cf3e8acd4591b5c50da", + "PACKAGING.md": "9960275e39920f30247c8a45c73a0c054d586bf719c963d5b7a658e9a68d41c5" + }, + "receipt_sha256": { + "evidence/PHYSICAL-LOCAL.json": "27359fe1d4fa0823a372b85c889fb6ace05d514ee3fb31dc4742fecdfa8a6a2d", + "evidence/PHYSICAL-GLOBAL.json": "782ef40f6e1a4fa5e88c3d8757ba064508d184aff6989aab6f1c57de7282897e", + "evidence/OUTER-CHECK.json": "68a6906522377502c07552cb74877f0fc8dd8134a1b95d9d75ca086e867d3816", + "evidence/OUTER-DOMAIN.json": "8258b918fc549a1e6554e80cba4f27edaf09dd7066e0e39a099efcefee009ff5", + "evidence/CRT-3935-COMPATIBILITY.json": "c539b3292ae425282e79ea2cacfbf82263ac6a3b9d0c9370e33ff8b386b4f2e6", + "evidence/GAUSSIAN-PHYSICAL-COHORT.json": "b609b81c7937b02263ba1abc254cef369b07813f443f7b2fdbe5b156dcba30e1", + "evidence/OUTER-CHECK-PORTABLE.json": "c3606f99d68fdef705d512341c65f1758eff3e4ec2b9f34f28d5f047192724a6" + }, + "review": { + "contexts": "Separate specialist contexts within the author/AI process", + "global": "Independent review checked all-owner/chart binding, stock, grid, stopped recurrence and production-factory scope. An unhashed local-module loader was fixed and re-reviewed.", + "outer": "Independent exact normalization, recovery, CRT format and carry controls; separate asymptotic/domain and physical lifetime reviews. Catalogue metadata storage corrected to polynomial(t_max,p), absorbed by the explicit outer shape.", + "remaining": "Inherited native/hosting, completed primitive/refinement and Gaussian/prime analytic hypotheses require scientific admission. Bounded controls do not prove these universal contracts.", + "factory": "Separate read-only review confirmed actual constructor argument types, Count/Tape and native ownership, authenticated bridge loading, CRT token sharing and teardown; normal/optimized nine-control receipts agree.", + "scope": "Historical specialist reviews of the unchanged proof/bridge sources. Review of the current packaging is separate; this record does not retroactively attribute the historical complete release to new packaging code." + } +} diff --git a/research/complex-pooled-full-admission/EVIDENCE.json b/research/complex-pooled-full-admission/EVIDENCE.json new file mode 100644 index 000000000..2aaa35ffc --- /dev/null +++ b/research/complex-pooled-full-admission/EVIDENCE.json @@ -0,0 +1,98 @@ +{ + "all_size_admission": false, + "bounded_replay_scope": "Fresh mathematical operator/arithmetic and semantic regressions; preserved complete-run integrity is not another full release.", + "execution_source_sha256": { + "INPUT-PINS.json": "07d6c095d5ed6d45fec6d9a83732ffcefd5eb785e3d7c05234440a9e74c0b284", + "common.py": "3f102ae694b0fe55fd9d1638ae3e21d6ba2b564c37481e89ac7f98e3cdba5f8f", + "joint_bound.py": "c4740234bee2bab8292aeef7fb561246cff8a060ea6e96f0bc14a7b69c62042c", + "operator_admission.py": "75e56e806d7d6a2e90db2039865c2285a0d3d4980dbc1f8d900709b03bf0e63c", + "replay.py": "91eef8b82679de027b79f41d69e532818dc884ac93f8c18b70ce976af235b952" + }, + "full_replay_scope": "Complete finite ordinary/strict/outer admission with assertions, 21 exact source adaptations, actual pooled fill and exact active registry. Uniform source-specific physical realization remains conditional.", + "independent_review": "Separate Codex contexts audited mathematical obligations and source/invoice bindings; not independent human or formal-kernel verification.", + "inherited_scope_string_note": "The unchanged inherited admission result retains an old descriptive phrase Both native providers. Its actual registry, source receipt, invoice and controls contain the three providers listed above; that phrase is not used as evidence.", + "native": { + "authenticated_retained": [ + "gauge44", + "extra" + ], + "coverage": "All active providers, both orientations, native source/stage and eleven scientific products each; inactive gauge44-four is not admitted as an active call.", + "fresh": [ + "extra-four" + ] + }, + "preflight": { + "coverage": "Freshly reconstructed and checked earlier in this same run; original check_preflight authenticates exact engine, source closure and retained non-source inputs before reuse.", + "receipt_sha256": "4577bfb2c70e7ad4e88ba13ed11ca724032606ba8433e0f6fbfdc10f725da1f5", + "reused": true, + "source_closure_files": 676 + }, + "receipt_sha256": { + "evidence/ADMISSION-RESULT.json": "90378c981ca4def5ea12432ef54cdf66324ec301fa8d489264a48923e89d478b", + "evidence/ASSEMBLY.json": "d766b9c5fe811d73a937bd1399ab3581992c6e054eb46522c0a7dee394f812be", + "evidence/CHALLENGES-normal.json": "65c402405b6c5b2d96046e953011a4808a7ca0ed3d02b02df6398d4df90af48b", + "evidence/CHALLENGES-optimized.json": "65c402405b6c5b2d96046e953011a4808a7ca0ed3d02b02df6398d4df90af48b", + "evidence/INHERITED-RESULT.json": "0d2bf59210f6d037e1e064937d1cb8bdafb493c4492888c7fe49dcb21904e927", + "evidence/JOINT-BOUND.json": "606fe0627e847443df451222c2e4756a21343cfc8753b6e7d7aa0220b8c2b893", + "evidence/MIXED-CONTRACT.json": "d26c9f6b12750c0422bf4616e0f5452c681bb36c5d2e0da2ec1871be1a9f5088", + "evidence/OPERATOR.json": "d5cb2582e5b108e2072468e49f1c14b1bcc74be96a5127fbb8bcf06a0a3db571", + "evidence/OUTER-LEDGER.json": "5b4ca44b7d8ed5a6b55d192aa1a2157dd78c4aafb521da3921eb47bfa7b09275", + "evidence/PREFIX-AND-INVOICE.json": "d600e6c533f3a3d470a3fbb514c0c9cd9d8a8fc3684370d1afb5afa26ba15bdd", + "evidence/RELEASE-RECEIPT.json": "5995008c26c103912feeacd7bfdf1fb6abbe75555ed349b902f075b0f12231f4", + "evidence/RESULT.json": "66f3a353aeb51411241b2c594a6e1b22f0165a3b39dfe14abcfaa0e014c9037f", + "evidence/SPEC.json": "98bb37ad3ae3c6598530120243381ebbe4b04bea785c86ee55f4416f95e628ce", + "evidence/STRICT-RESULT.json": "a5f625661cd34af433c07e1bc25f2d3c08d52f6df5fba8feab6bed739c940469" + }, + "recorded_utc": "2026-10-20T22:06:00.635599+00:00", + "runtime": { + "dependencies": { + "mpmath": "1.3.0", + "numpy": "2.3.5", + "scipy": "1.17.0", + "sympy": "1.14.0" + }, + "platform": "darwin", + "python": "3.12.12" + }, + "scientific_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "selected_frontier_changed": false, + "stages": [ + { + "exit_code": 0, + "log_sha256": "a6bde715fdaa3bac87dde33c570b772e528df26379ad515588a0ed4d335b4c5b", + "name": "pr4088-verify", + "seconds": 6.426478790992405 + }, + { + "exit_code": 0, + "log_sha256": "85a8931a0fc074835179df714d712bb73adabfac21ec5b756d4ef52d955902fa", + "name": "pr4088-owner_verify", + "seconds": 2.118935375008732 + }, + { + "exit_code": 0, + "log_sha256": "c2f2fbe53751b5e552b8198903f2b93f2656d2960780928fe458c4b268171f79", + "name": "pr4088-operator_verify", + "seconds": 4.410793874994852 + }, + { + "exit_code": 0, + "log_sha256": "fc7ff0769f6d0b6697c9f884e5483931a4b6e053a6a2203d3017503e6367a853", + "name": "pooled-exact-operator", + "seconds": 7.955982082989067 + }, + { + "exit_code": 0, + "log_sha256": "8a110a26ea85a943f4566de70b18191c776fcc280aba4960d896bce8b0680788", + "name": "native-four-extra", + "seconds": 32.073826417006785 + }, + { + "exit_code": 0, + "log_sha256": "8acfbd54604590a5a0a2c0c9d895a8e68fa2aa663aaf4f049cd24eed22e323cc", + "name": "inherited-admission", + "seconds": 994.7890521659865 + } + ], + "status": "RECORDED_COMPLETE_FINITE_REPLAY" +} diff --git a/research/complex-pooled-full-admission/INPUT-PINS.json b/research/complex-pooled-full-admission/INPUT-PINS.json new file mode 100644 index 000000000..f2f7efd4d --- /dev/null +++ b/research/complex-pooled-full-admission/INPUT-PINS.json @@ -0,0 +1,1119 @@ +{ + "base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "sources": { + "4180": "15a4153e734a8d1d485c6d3bea9b1a8201328a4c", + "4181": "4ed92bed95dd483f5662e98ef246b258c3cfe64f" + }, + "files": [ + { + "path": "research/kappa-adaptive-continuation/admission/receiver_share.py", + "sha256": "6ef3255e91f42cb78eb194c761c02568e0230a9cfab40387f257d7a4bd38ccc4", + "kind": "repository" + }, + { + "path": "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "sha256": "bbf28e17a657b8d1eaf63f33d811682720afb393ee2ab9a4bb46661fef1ed996", + "kind": "repository" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "sha256": "4f6185125ddb38b7ab02a349829aae434e7707e804ca8c6c4ab8c086cd63635e", + "kind": "repository" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "sha256": "30a39a3612efde96a0db189c14053afe5e012e56de1a89863596a078a8b64381", + "kind": "repository" + }, + { + "path": "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "sha256": "e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "sha256": "e0a3f13504304147f4049757016a494c15beda82ed751439f05039f88a0dd891", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "sha256": "31896a06049f951fc25db1338888a743c1c73cf1a6c44212dbc21789ceaefeb0", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "sha256": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "sha256": "1b9167ef68707cddad4b781e37858cfb5205d377670365019b8de26fceeb1891", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "sha256": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "sha256": "23163ff2f94a4920e5fca35fb6f0de108f710e7b09cc13e7c2796ad693a2b497", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "sha256": "7e3bb0f46320f243cd89c97c60af5b29ac82a79293463afae5a178f8938ebda0", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "sha256": "0bad75c89a69637a1c9b98824da183243c584e07e0eb76ce986420384a7246c8", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "sha256": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "sha256": "753c950d3273bba4e7ff560000d84aaf928d24448e899e6f75e0166b7989f508", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "sha256": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "sha256": "9100f0387118988d81fa47740d4bd47892b13400c36ea63d43cbe4aeba38a4a1", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "sha256": "e037ea86e1e2902d6c03885ae8e332e4afe48d27d6200923b9c71498b12953d3", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/run_release.py", + "sha256": "262e914eca3d0e97567786fe94cb25fb1698c52e08785fd4a2581020c4af26dc", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "sha256": "6f6b5adccb29d29a4b7890c91180a7ecd9f54ee04007cf9e0ea06fbea42b5c0e", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "sha256": "727691274be6f91059c763dfa8206f7bca4516c5acf4703da403789a49b5e1e7", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "sha256": "4b6b1ac15742264f1d6d8047d975fd5d05fc63db61358b3bacf1c1c47ee71428", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "sha256": "8bdda4822009d6e5f1d6bd948a8f89154780a5721dca366c56deb75019bb268b", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "sha256": "69bbfc0414324593e98112af7a8db6549315badb8aa7adb5ca05419214849c56", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "sha256": "fff028de30e9fb06d6d75efc6fdd6e94ead6a88823efa07d3e7cd177dcd94acd", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "sha256": "8159c67d29ab58efe546ebc4ce20872421996cc71b5f17737ff8b36cbc76d148", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "sha256": "0147e6b30ef328e227e89113323eb0d02d116e125b0e7c99a00ea4f2652dcc80", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "sha256": "00071bc2e54bf5fd05a6aac9292a3861087e72898d86d1f6f7bbda65b07cfbda", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "sha256": "6e2f3ef76d90086784db92a7e3b0ac23893dd60750effe79287fa59c48b6bc99", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "sha256": "e92568c62db0f220096870c2a01cd8c313497953bc9cff5f2c087fe9a6875109", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "sha256": "70030e184e9c3d41169cabf5f6a07d6ec10590ce384ebfeabbeba7253d85404b", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661", + "kind": "repository" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "sha256": "dd104d15719ae181fde3d6c93f210b09ddffe0e0ca16b07c85b4ebaf75641d91", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/.gitattributes", + "sha256": "04e5e0efa0141765d3c58422bbc347caf588ab7e70c3429e63f78d892038a1d7", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "sha256": "59b692adb4ed3c8caed033d380c23e2e2cf2a1547323b88f97b4a4ad7453141b", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/INPUTS.json", + "sha256": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/MANIFEST.json", + "sha256": "f2f52b40e4b0dda45777fdeecf2267679da0d36be69daf467adc1740f4951b9d", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/NOTICE.md", + "sha256": "1ba00cad41d7a1333da420bd23f078d09e28b7aa17cf5a8a89e54dd207123971", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/PROOF.md", + "sha256": "3aa03a9ba64422474890c137d2b10ef830464712830fd469fe1b0e9538b24ebb", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/README.md", + "sha256": "98b53ad6e6ee7ef7ba106e68e7a2a77d8f5a9823202cb3725cf101f5901e2d6f", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/RESULT.json", + "sha256": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/SOURCES.json", + "sha256": "53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/TASK.json", + "sha256": "8c34b11a10f0317dd4a4dc765b036a2231cee55cb44fc0e1e59fb64e11326a13", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/VERIFY.json", + "sha256": "2814773f90ee84a1c367dfec1ee85ec4f001ed100469f354d0464e7952303e9d", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "sha256": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "sha256": "bff67890d0d350646d11f45aa1b098d6a415b1850b4982e8a05b4c146d247eda", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "sha256": "e0c473d62127a09cb3cbf451564dbdd19c0c10f1674dab0575e65251aa5e1e3c", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "sha256": "e273538de7957b959c40f593c4aad5e8e3d81d83d662fe2895c17770c5fad8bd", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "sha256": "c8f744c62670ad7d76faf4dee65e2f708f4036953041e72383929c7d0b32ec38", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "sha256": "c422d41b5b316fe6823012ca31a13bd3c2c4a4a17c3712c36ce0156f311e5ce9", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "sha256": "2b6f90f3d00e7b2723fa12c6bd8e8f0d2881854b3ef625b0fd37ed6f51e2bfa4", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "sha256": "b00f1665c7096ca292079668bac86e25ca7552c57cbe62c8c45ea40aa8708ecf", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "sha256": "a65bcb4624a96204b1d30ec8c82080fbcdda2c1a30349643b60db579f339c75c", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "sha256": "817c39b155892ab3ea89b6e2bf04480c45e1ebb9a8f87e2bb9a48c715a7eee9e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/LICENSE", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/PINS.json", + "sha256": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "sha256": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/common.py", + "sha256": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/run_native.py", + "sha256": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/stage.py", + "sha256": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/operator_verify.py", + "sha256": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner_verify.py", + "sha256": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/price.py", + "sha256": "89b7c623befd880a163baabc52f8ca576281ad0d8b71685e2ee37c9709edb335", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "sha256": "221b56acc02ceeee35000f26f7098426421c0c90a075d81f9629170284f4aa25", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "sha256": "b1963fba45032238f773f3b375412d7db5f6e184edb59dcd05be15f6f70116f2", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "sha256": "91f7f723bb616aca757812f940f6b893559e64e441d6158c907155a79b3b15a7", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "sha256": "864b2857f200a37b37f939b78887484f5230be0b68ab7755705713e2e2d45d3e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "sha256": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "sha256": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "sha256": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-fourth-entry/verify.py", + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "kind": "repository" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "kind": "repository" + }, + { + "path": "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553", + "kind": "repository" + }, + { + "path": "frozen/pr4180/COVERAGE.md", + "sha256": "62831c49a38a3705d8a0ce40280ed9278754fc10d5a21c362d1a1b0d066da1de", + "kind": "package" + }, + { + "path": "frozen/pr4180/EVIDENCE.json", + "sha256": "bde93c6154c96eb8e862d44b4c30622dd716551a551409b4cab819e371e41851", + "kind": "package" + }, + { + "path": "frozen/pr4180/EVIDENCE.md", + "sha256": "636bf46bef23e89b4c1a39ee5157788c4b104a3592b205d9cbcd9c10c8bff2b8", + "kind": "package" + }, + { + "path": "frozen/pr4180/NATIVE-OUTPUTS.json", + "sha256": "7a231d9782297d36c5666860003e9b29a8260312c257820b488c8abd17780fc5", + "kind": "package" + }, + { + "path": "frozen/pr4180/README.md", + "sha256": "2c981e161616452eeabe437aecefa6849b9188137159b5c85d56da34da53ebf3", + "kind": "package" + }, + { + "path": "frozen/pr4180/REPLAY.log", + "sha256": "ad67d6bb3a5fc9c651fb322c5417cc0208adb35a1d644007487f636de6af8951", + "kind": "package" + }, + { + "path": "frozen/pr4180/SOURCES.json", + "sha256": "dc14323136206ceee2bbe56b848effd7cffcae07ab680055beb09ed10bef5113", + "kind": "package" + }, + { + "path": "frozen/pr4180/TASK.json", + "sha256": "5fc1b70e122b44b4e64df26d5ef3d01829cd18742a8dd2fa07ac485e18a40675", + "kind": "package" + }, + { + "path": "frozen/pr4180/VERIFY.json", + "sha256": "3923565863dfcb6fbe481e38ab110938f601a8893dc376374d2614b8fd99a899", + "kind": "package" + }, + { + "path": "frozen/pr4180/adapt.py", + "sha256": "3739cbeb4f0e75a475cf95f47ccfca5aee2f0a55abfcd2d0e502e411fad96a1d", + "kind": "package" + }, + { + "path": "frozen/pr4180/binding.py", + "sha256": "5a63b937ffc6533a2b8d858d441c210a35a33895242881c5d996459bb2210977", + "kind": "package" + }, + { + "path": "frozen/pr4180/challenge.py", + "sha256": "99d3f2c2b628e3eec0fc9fd0397f2ab822ef7230f37c42944e915fe38cd8f9fb", + "kind": "package" + }, + { + "path": "frozen/pr4180/independent_ledger.py", + "sha256": "4262571439a845ad93bc4dc119adfe0b1fe8654992653cc56f4c4e3232ce13c3", + "kind": "package" + }, + { + "path": "frozen/pr4180/native_outputs.py", + "sha256": "dfc9ae9f651dbf3e248896ee328d0968ee868fd5532252cb5217f04b0de6a5e3", + "kind": "package" + }, + { + "path": "frozen/pr4180/replay.py", + "sha256": "25576ade4839c1c0ece1ecd2e9f70ccedd04ed601a4aa28a715286176b8ef096", + "kind": "package" + }, + { + "path": "frozen/pr4180/sources.py", + "sha256": "a0c3a7cdbf0a889d1f47fb124209494fc17209d90992f4c12ce154fb786accd0", + "kind": "package" + }, + { + "path": "frozen/pr4180/test_binding.py", + "sha256": "5abfc37a6d256951f11f0ac5dd2f1066390d0bdebac984758afc2bcf7348c966", + "kind": "package" + }, + { + "path": "frozen/pr4180/verify.py", + "sha256": "e6cf84816fcfdb3bd1b66510539c7b30a08cc15b8e18e3f1715746d73d1826bc", + "kind": "package" + }, + { + "path": "frozen/pr4181/README.md", + "sha256": "1a9b633b0f11d5a351dc39382992e84bf38408cd3491d06480029d6c0ab85171", + "kind": "package" + }, + { + "path": "frozen/pr4181/RESULT.json", + "sha256": "d823509ea38e545db6c287a85c00bc4257825fb2710728dfc776c8801d2becd9", + "kind": "package" + }, + { + "path": "frozen/pr4181/SOURCES.json", + "sha256": "67057b36488f91d833df674770d4cf181343ff8e73363b6fc01b8639a21c9466", + "kind": "package" + }, + { + "path": "frozen/pr4181/TASK.json", + "sha256": "4b753e9ab52638e04b89bc79315e8bc8fab408daec9ecb78c11399fcfa7f2467", + "kind": "package" + }, + { + "path": "frozen/pr4181/VERIFY.json", + "sha256": "51910d1d36b23b49cc954a6a8e00fc2440f6ed12fc7ba933d124952024fb22a4", + "kind": "package" + }, + { + "path": "frozen/pr4181/construction/build_mixed.py", + "sha256": "c87a74d630a231ed078d57d0ead71c8d9ad42adffc9020b0a2bba9ebc6e65521", + "kind": "package" + }, + { + "path": "frozen/pr4181/construction/hall_mixed.py", + "sha256": "d850f31b16c6ef111e9410f659f37d32f9823fb68f7471bfe12954f9d2c30757", + "kind": "package" + }, + { + "path": "frozen/pr4181/owner/FILL.json.gz", + "sha256": "5455c120a121a7ec70897fb2c58e1988ce01d7172d6a5622519bea6b25efe8fe", + "kind": "package" + }, + { + "path": "frozen/pr4181/owner/MIXED-DISPATCH.json", + "sha256": "ab8c774b614730701435c0f5dc1bfba4a46d980690a1b6bc09225555ff9be6f4", + "kind": "package" + }, + { + "path": "frozen/pr4181/verify.py", + "sha256": "e89870761ddefe0a7f983512c6ae884ccff26235085238624e00f75a31cd6e76", + "kind": "package" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "kind": "repository" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "kind": "repository" + } + ] +} diff --git a/research/complex-pooled-full-admission/OPERATOR-PROOF.md b/research/complex-pooled-full-admission/OPERATOR-PROOF.md new file mode 100644 index 000000000..88153a733 --- /dev/null +++ b/research/complex-pooled-full-admission/OPERATOR-PROOF.md @@ -0,0 +1,141 @@ +# Exact operator admission of the pooled fill + +Prepared by Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. This proof reuses Cinna Davis's PR4088 owner/operator walkers and +David Ganz's PR4085 exact phase normalizer. It is not an independently written +operator algorithm or a formal-kernel proof. Rohan Arun supplies the PR4181 +selector and literal fill. Their unchanged source notices remain authoritative. + +## Exact inputs and the active provider set + +The source words, nine-stage order, original phase-axis lists and template are +PR4088 at `72d7efc181edb21806a878f174847c96dd410ab0`. The new fill and selector +are PR4181 at `4ed92bed95dd483f5662e98ef246b258c3cfe64f`. The wrapper pins every +executed source and consumed data file by SHA256. Immediately before each +mathematical module executes, it reads the source bytes, checks their fixed +digest, compiles those same bytes and executes the resulting code object. +Every nonstandard-library transitive import is preloaded through that same +exact-source procedure. The original module aliases and search path are restored +after the audit. Existing bytecode caches cannot substitute different code; +disabling bytecode writes alone would not guarantee this. The data pins are +checked again afterwards. No historical artifact is edited. + +The selector chooses FOUR exactly at ticks `t < 1080`. On this particular +unchanged clock its active provider counts are + +``` +gauge44: 1568; extra: 592; extra-four: 1080; gauge44-four: 0. +``` + +Thus a four-word authenticated catalogue has only **three active providers**. +The caller must distinguish catalogue authentication from its active registry; +it must bind every actual call to the selected width vector and orientation +program. Requiring all four catalogue entries to occur is false for this fill. + +`operator_admission.py` loads the exact frozen PR4181 `context` function and +changes only its predecessor-directory variable to the actual PR4088 path. +The `t < 1080` rule and context construction remain unchanged. It runs the +unchanged PR4088 `owner_verify.walk` on all 1,321,920 rows and all 725,760 bins. +It then runs the unchanged `phase_checks`, `exact_windows` and `scan` code. +Only the final expected `RESULT.json` read inside `scan` is bound to PR4181's +actual result. There is no predicate deletion or receipt substitution. + +## Arbitrary-input endpoint and exact phases + +The retained local interface has arbitrary live sources, targets and helpers. +PR4088's separate complete symbolic word check includes all 632 live inputs and +91 independent buffer symbols, both orientations, both cleanup boundaries and +reverse pullback. Its actual native contract separately allocates and clears +private work and retains its paid compiler and precision obligations. The +present operator binding does not rerun or strengthen that local theorem. + +Let `X_v f(x)=f(x+v)` and + +`C_v=((1+i)I+(1-i)X_v)/2`. + +On a Boolean Fourier character `z`, this multiplier is `i^(v dot z mod 2)`. +The exact exponent modulo four is its linear form minus twice every quadratic +cross term. The source normalizer represents all 73 linear coefficients in +Z/4 and all quadratic coefficients in Z/2. It discards no global phase. + +For each of the 112 ordered ports `q`, put + +`D[-1,X]=C_q`, `D[-1,Y]=I`, + +`D[s,X]=C_[0,9+8s)`, `D[s,Y]=D[s,X] C_q^(-1)`. + +The four data pairs have the signed forward or backward scalar transvection +between their declared entrance and exit gauges. The checked invariant is + +`P_t = D_t M_t D_initial^(-1)`. + +At every local boundary the declared phases are checked; at each bridge its +two mixed phases must agree. Each original idle child includes its literal +translation. The terminal Y translations and signed exchanges give +`M_final=I_8` and `D_final=C_all D_initial`, hence `P_final=C_all I_8`. +The normalizer verifies 10,416 exact polynomial identities over all 112 ports. +This is an all-character equality, not sampling of coordinate characters. +Tensor products add these Z/4 exponents; the equality therefore holds for +every positive tensor multiplicity in the declared operator model. + +## Why the changed owner fill implements the original child factors + +For every owner and original child slot, `exact_windows` derives the pair +`(last scalar observation, original idle endpoint)` directly from the retained +execution events. A hosted call at tick `t` must lie strictly between those +events, using `(t,-1)` for the whole-call boundary. The scan verifies all of: + +* exactly one row for every chronological call and helper identity; +* distinct physical helper families within a call and no productive-data alias; +* the actual selected helper width, compact offset and capacity; +* disjoint cells of that child's **original** ordered phase-axis list; +* every unused axis charged by its exact complementary residual. + +Within this observer-free interval, completed helper endpoint factors act +only on their physical stream and may be commuted to the original idle slot. +Their disjoint axis factors and the complementary residual multiply to the +original full child, including its phase. The argument permits arbitrary +correlated dirty inputs; it is not a clean-helper calculation. There is no +transfer of axes between different child slots. + +The new idle profile is + +`22788 H3 + 1620 H5 + 138492 H48`. + +The complete paid profile is + +`8060040 H1 + 2310120 H2 + 751788 H3 + 327240 H4 + 66420 H5 + 25920 H8 + 138492 H48`, + +with rank mass `23431680 = 65088*360`. The operator scan independently of +stored profile metadata recomputes the original-axis complement and checks +that it agrees with the owner walk and PR4181 result. Both scans are reused +predecessor algorithms; their agreement is not claimed as new independent +implementation evidence. + +## Controls and unresolved implications + +The audit preserves the inherited wrong-global-phase, wrong-signed-controller +and crossing-a-scalar-observation mutations. It additionally rejects PR4088's +old selector on PR4181's new fill and a stale PR4088 idle complement even when +the expected complete profile is left correct. The checks use explicit +exceptions, so the wrapper's controls also execute in optimized Python. + +A separate source-execution control builds an unchecked-hash `.pyc` in a +temporary directory, then replaces its source with a pinned harmless witness. +The ordinary loader demonstrably executes the stale cached witness; the audit's +exact-source loader executes the authenticated source instead. An incorrect +source digest is rejected before execution. The temporary fixture is removed. + +This finishes the exact finite operator/chronology implication for the changed +fill, assuming the unchanged local native endpoints and common-cover owner +embeddings. A common cover map conjugates the whole operator identity; the +retained final all-live translation supplies the claimed common-cover endpoint. +Uniform source generation, compatible recursive children, approximate-child +conditioning and cleanup, physical fixed-tape realization, precision/recovery, +and the analytic outer transfer remain separate inherited hypotheses. + +The unchanged four-word maximum local prefix and the unchanged physical stock +do not by themselves admit the new caller: complete ordinary admission separately +recomputes the actual active-provider scalar bill, all owner charts, block-norm +premises, residual profile and recursive/outer inequalities, as recorded in +EVIDENCE.json. The physical and outer arguments are separate companion notes. diff --git a/research/complex-pooled-full-admission/OUTER-CHECK.md b/research/complex-pooled-full-admission/OUTER-CHECK.md new file mode 100644 index 000000000..eea9bc486 --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-CHECK.md @@ -0,0 +1,291 @@ +# Independent normalization, recovery and cost audit + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. The Gaussian tensor and physical Fourier arguments remain credited +to Jose Manuel and their retained contributors; the CRT implementation and +argument remain credited to Tekalign. This note checks their proposed outer +composition, under their stated contracts. + +The proposed normalization and eventual recovery margin are correct. Three +details are essential: the final factor is S²; repeated target sizes need a +distinct prime for every source axis; and scaled coefficients cannot remain +in the Gaussian disk format. The root recurrence must also use a strict +exponent above both the complex-moment endpoint and the ordinary routing +exponent. None of those obligations is discharged by a finite numerical +example. + +## Exact source boundary + +The default checker authenticates all 35 unique regular files in the immutable +outer proof-reference bundle, its archive and its manifest. It checks literal +source facts for TensorPlan, the CRT width override, normalized Fourier maps, +the scalar continuation and the retained prime-gap premise. No source module +is imported. The source review uses PR3935 at +f687fa171ef760fa98a4be1289717b47dd4ee0b3 and canonical +12fa8c5c844be21bfefb38a19503fbd867a11244. The nine cited source blobs and their +SHA-256 values are listed in outer_check.py and its receipt. These are source +references, not a claim to freeze or execute their complete import closure. +Seven of these independently pinned blobs also occur in the 35-file bundle; +the optional Git comparison additionally checks the tensor word adaptation +and arithmetic note. + +The actual TensorPlan API in tensor_plan.py, lines 112–128, has +axes=D−1, dimensions=D and d=D+1, with restoration exponent +gamma=D(2u+ceil(log2(32p))+1). Its final target axis is always the long axis. +The tensor engine's boundary procedure takes the half-disk input, restores +by the exact gamma shift, and checks the complete disk-grid output. Its +opposite flag conjugates both boundaries. The cited tensor proof gives +the endpoint R F± with both Fourier maps divided by S. + +The CRT source, PROOF.md lines 8–25 and crt_converter.py lines 263–266, maps +coefficient k to coordinates mu_i k mod s_i, where +mu_i=(product of preceding s_j)^(-1) mod s_i. This is a group isomorphism, +so it carries cyclic convolution to tensor convolution. The converter accepts +an explicit opaque record_bits override on the inverse. Passing its default +Gaussian record width after changing the coefficient representation is not +an admissible implicit conversion. + +The synthetic Fourier source explicitly uses two normalized transforms, +F+F−=I/M, and gives an exact whole-transform rounded endpoint. The new root +must be bound at that actual exact-grid interface. Merely replacing its +printed exponent does not replace the retained ComposedRoot implementation. +The separate global binding and outer construction own that replacement. + +## Shape and distinct source primes + +For sufficiently large input bit length n, put b=ceil(log2 n), p=6b and +m=ceil(n/b). Choose the power of two T with + + 4n/b <= T < 8n/b. + +Write L_T=log2 T, D=floor(p^(997/1000)), d=D+1 and +ell=ceil(L_T/D). Choose D target widths in {ell−1,ell}, summing to L_T, +with the final width ell. This is possible: D ell−L_T is an integer between +zero and D−1, and specifies the number of short axes among the first D−1. +Eventually ell−1 is positive and exceeds every required logarithmic +microbox/halo width. These are eventual statements, not admissions at small p. + +For every axis choose a distinct prime + + (1−1/(2d)) t_i < s_i < (1−1/(4d)) t_i. + +This stricter interval implies both actual TensorPlan ratio guards: +4d(t_i−s_i)>s_i and (2d−1)(t_i−s_i) (1−1/(2d))^D >= 1−D/(2d) > 1/2. + +Thus S>T/2>=2n/b>2m−2, so the product of the two m-digit polynomials has +no cyclic alias. The source lengths are odd, pairwise coprime and below +their target lengths. + +One short-interval prime is not enough when a target size repeats. Retain +the Baker–Harman–Pintz exponent 21/40 as an analytic prime-gap premise. +Subdivide each required interval into D disjoint pieces of comparable +length Theta(t_i/(dD)). Eventually each piece is longer than the permitted +prime gap, because + + t_i^(19/40)/(dD) -> infinity. + +Indeed log2(t_i)=Theta(p^(3/1000)), whereas log(dD)=O(log p). This provides +at least D distinct primes for each repeated target size. The two intervals +for t and t/2 are disjoint. Trial division, interval scanning and selection +use poly(t_max,p) bit operations and storage; that is 2^o(p). The analytic +prime-gap constant and the other production conditions give an unspecified +finite cutoff. This note does not claim an effective practical cutoff. + +## The three normalized endpoints + +Use the tensor group G=product_i Z/s_i Z, of order S. Define + + F±x(k) = S^(-1) sum_j exp(±2pi i sum_i j_i k_i/s_i) x(j), + R x(j) = x((t_i j_i mod s_i)_i), + A± = R F±. + +Each t_i is a unit modulo s_i. Substitution in the Fourier sum gives +F+ R=R^(-1) F+. Pointwise multiplication commutes with R. Therefore + + A+((A−x)(A−y)) + = R F+ R ((F−x)(F−y)) + = F+((F−x)(F−y)) + = (x * y)/S². + +The final step follows from character orthogonality: the three normalized +maps contribute S^(-3), and the character sum contributes S. No additional +R or reflection remains. Interchanging the signs everywhere gives the +same convolution identity. + +The checker evaluates every bilinear input/output coefficient for four +finite groups, using exact integer arithmetic in cyclotomic quotient rings. +It has 12,788 coefficient cases. Mutants using S rather than S², omitting +the final R, or using the wrong final Fourier sign are distinguished. +This finite check supplements the displayed all-group derivation. + +## Error, format and exact integer recovery + +Scale each base-2^b input digit by 2^(−b−2); each input has complex norm +strictly below 1/4 and lies on the p grid. Write h=2^(−p) and retain the +source-bound three-call Gaussian error + + E = 2^gamma (D p² + 4 sqrt(2) M + 22 + 2D) h, + M=T/r, r=2^ell. + +The exact normalized transforms contract sup norm. If the first two +computed transforms have errors at most E, their rounded pointwise product +w=Q_p(tilde a tilde b) obeys + + ||w|| <= (1/4+E)² + 2h, + ||w−ab|| <= E/2 + E² + 2h. + +The term 2h safely dominates the complex error of componentwise p-grid +truncation. When the first displayed bound is below 1/2, the third tensor +call is admitted. Applying its error bound and the contraction of A+ gives + + ||tilde z − (x*y)/S²|| <= 3E/2 + E² + 2h. + +Consequently sufficient exact-recovery conditions are + + E <= 1/256, + (1/4+E)²+2h < 1/2, + S² 2^(2b+4) (3E/2+E²+2h) < 1/2. + +After exact multiplication by S² 2^(2b+4), round each component to its +nearest integer. The real component is the exact digit convolution; the +imaginary component is zero. The strict inequality avoids all tie choices. +Then apply inverse CRT with the declared integer record format and perform +ordinary base-2^b carries in coefficient order. + +For clarity, a safe implementation widens before scaling. Since +S=8, T<=2^b and E<=1/256 imply + + S²2^(2b+4) (3E/2+E²+2h) + < S²2^(2b+4)(2E+2h) + < 64 H 2^(gamma−b). + +Thus b>=gamma+ceil(log2 H)+9 makes the recovered error strictly below 1/8. +It also gives E<1/256 and p>=gamma+A+ceil(log2 H)+8, the actual tensor +error admission, since A=log2(T/r)<=b and p=6b. The checker checks the exact +algebra and three finite instances of this gate; those instances likewise +are not production tensor plans. + +Here is an explicit sufficient eventual arithmetic bound. For +alpha_G=floor(p^(1/1000)), u=alpha_G² and D=floor(p^(997/1000)), + + gamma/p <= 2p^(−1/1000) + (log2 p+7)p^(−3/1000). + +For p>=2^7000, divide the logarithm into intervals +1000q<=log2 p<1000(q+1), q>=7. The right side is at most + + 2/2^7 + 8007/2^21 = 40775/2097152 < 1/12. + +Both terms decrease from one interval to the next. Hence gamma<=b/2. +For b>=32, + + D p²+22+2D <=216b³+12b+32<=2^b, + M<=T<8*2^b/b<=2^b, + E<7*2^(gamma−5b), + S²2^(2b+4)<2^(4b+10)/b². + +The exact checker verifies the recovery inequalities for b=32 and 33 +under this sufficient gamma cap. For b increasing by two, the three +positive scaled error terms decrease by factors at most 1/2, 1/1024 +and 1/16, before the additional b^(-2) decrease. Thus the bound holds for +all larger b. These two arithmetic witnesses are not production tensor +plans. The enormous p threshold here addresses this error estimate only; +prime supply and every other retained production admission still apply. + +## Complete outer bill and strict exponent gaps + +Put V=T Theta(p)=Theta(n). Charge three full Gaussian tensors and three +CRT conversions, including their padded boxes, all gathers, coefficient +catalogues, numerical validation, parent copies, child-return consumption, +scratch erasure and head return. The CRT bill includes three full-support +router calls and six padding passes, not two conversions or two routes. +Source setup and fixed native compilation/storage remain charged once per +fixed constructed instance. + +The root recurrence uses + + C=0.001730980255989036959962, + tau=332353/332929, + sigma=0.99826995, eta=10^(−6), alpha_H=0.99827. + +One has 1−C 0, + +the extra loglog n fits within the strict power gap, giving the conditional +target O(n (log n)^(1−1/580)). This is a source-relative written implication, +not a finite-execution proof of a new multiplication theorem. + +## Reproduction and limits + +Run the checker with the standard library: + + python3 -I -B research/complex-pooled-full-admission/outer_check.py + python3 -I -O -B research/complex-pooled-full-admission/outer_check.py + +Optionally pass --source-repo /path/to/checkout to authenticate the nine +cited blobs through their exact Git commits, and --out /path/to/receipt to +save the result. The published evidence was generated with that additional source +check. All mathematical checks use explicit guards that remain active under +optimization. + +The finite certificate covers the stated groups, exact rational cost gaps, +the sufficient recovery bounds, interval-ratio fixtures and thirteen rejecting +controls. It does not execute the Gaussian tensor, prime selection at +production sizes, an integer tape wrapper, or the replacement root. The +all-width primitive, common-cohort construction, source-faithful coefficient +pages, precision, physical restoration and cutoff contracts remain the +explicit premises of the written outer join. + +## Recorded Git and portable scopes + +`evidence/OUTER-CHECK.json` additionally records nine exact Git-blob comparisons +from the original source checkout. `evidence/OUTER-CHECK-PORTABLE.json` records +the default Git-free check against the complete 35-file reference bundle. +The registered outer suite compares its freshly generated portable receipt in +full; it does not claim to repeat the optional historical Git-object checks. +All coefficient, recovery, exponent and rejection checks are identical. diff --git a/research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json b/research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json new file mode 100644 index 000000000..1998af6f9 --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json @@ -0,0 +1,8 @@ +{ + "receipts": { + "CRT-3935-COMPATIBILITY.json": "c539b3292ae425282e79ea2cacfbf82263ac6a3b9d0c9370e33ff8b386b4f2e6", + "GAUSSIAN-PHYSICAL-COHORT.json": "b609b81c7937b02263ba1abc254cef369b07813f443f7b2fdbe5b156dcba30e1" + }, + "role": "Retained complete archive-comparison observations; bounded checks replay source-contract/member comparisons and token lifecycle only.", + "schema": 1 +} diff --git a/research/complex-pooled-full-admission/OUTER-DOMAIN.md b/research/complex-pooled-full-admission/OUTER-DOMAIN.md new file mode 100644 index 000000000..58886ad27 --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-DOMAIN.md @@ -0,0 +1,291 @@ +# Cost and domain audit for the physical outer composition + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. The physical root, support, Fourier, chirp and Gaussian components +are Jose Manuel's retained constructions with their credited dependencies. +The CRT converter is Tekalign's. This note supplies the changed cost and +source-compatibility audit; it does not reprove their analytic inputs. + +Under the physical and analytic contracts stated in [OUTER-JOIN.md](OUTER-JOIN.md), +the new complete complex supplier supports the ordinary retained B1 backend +and the integer target `kappa=1/580`. B2 is unnecessary for this target. +The completed source contraction, restoration, all three CRT conversions, +all three Gaussian transforms and the final scalar arithmetic remain paid. +This is a conditional all-size construction, not a production payload run. + +## 1. The admissible stopped-tree exponent + +Use the complete new complex histogram and `W=322560`, as authenticated by +the full release and the physical global binding. Put + +``` +C = .001730980255989036959962, +tau = 332353/332929, +sigma = .99826995, +alpha_root = .99827, +eta = 10^-6. +``` + +The exact positive margins are + +``` +sigma - tau = 323671/6658580000000, +sigma - (1-C) = 465127994518479981/500000000000000000000000. +``` + +Every positive child rank is less than 73. Thus the complete moment at +`sigma` is strictly smaller than the already certified moment at `1-C`. +This includes every restoration and idle child; no child is removed to +obtain the inequality. The physical global checker also evaluates that +moment directly. + +The ordering `tau=g^eta`, + +``` +e^tau <= g^(-eta(sigma-tau)) e^sigma. +``` + +The weighted-node sum pays all internal work by +`O(V g^(sigma-eta(sigma-tau)) (log p)^tau)`. Frontier weights and the actual +elementary leaves pay `O(V g^(sigma+eta(1-sigma)))`. The exact gaps below +`alpha_root` are respectively + +``` +332929323671/6658580000000000000, +965399/20000000000000. +``` + +The unchanged reserved-leaf power `.998` has gap `27/100000`. +For failed root guards, `500(1-alpha_root)=173/200<1`, so the complete +literal root also fits `O(V g^alpha_root log p)`. Fixed constants may be +large and depend on the source, stock and moment slack. No practical +threshold or source-independent constant is asserted. + +Retain `d_root=g`, `K=floor(g^(1/500))`, the encoded stopping power `10^6`, +the full-depth stock, and `g<=floor(p^.997)`. The new family count changes +the fixed row-divisor constant and its logarithm; it does not change any +of these exponents. The physical bridge must supply the exact common-grid +height and bank/parking contracts for the new binding. A histogram alone +would not establish those contracts. + +## 2. Complete Fourier, Gaussian and CRT tariffs + +The support caller preserves the complete sparse-router rate `tau`. Its +completed invoice is + +``` +O(V [g^alpha_root log p + (g+1)^tau (log p)^(1+tau)]). +``` + +The synthetic Fourier caller batches at the actual cap `p^.997`. For +`D=Theta(p^.997)`, `ell=Theta(p^.003)` and total address width `Theta(p)`, +all rounds, signed diagonals and endpoint reversal therefore cost + +``` +O(V p^Phi log p), Phi = 1-.997(1-alpha_root) = .99827519. +``` + +The cap is retained. Replacing it by one would discard a real outer loss. +The complete full-support router has + +``` +beta = 41544341/41616125, +Phi-beta = 3273151/33292900000000 > 0. +``` + +Its additional `log^tau p` is absorbed by this particular positive gap. +It is not charged against the much larger Gaussian allowance. + +Each complete physical chirp costs three full Fourier calls plus +`O(Nc(ell+1)p^(8/5)+2^ell p^3+poly(p))`, where `Nc` is its coefficient +count. Since `V=Theta(Nc p)`, its extra online power is `.603`. +The physical Gaussian tensor additionally pays all short-field moves, +halos, catalogue scans and coefficient setup. Its Gaussian payload power +is at most `.9981`, and the four canonical gathers use `beta`. Both are +strictly below `Phi`. The producer's `poly(t_max,p)` cost is retained: +`t_max=2^Theta(p^.003)` makes it `2^o(p)`, which the complete tensor volume +`2^Theta(p)` pays. Catalogue construction is not repeated per input line. + +Each CRT conversion has the full invoice + +``` +O(V p^beta (log p)^(1+tau) + D V + C T(n_address+R) + + C D T poly(n_address)/t_min + poly(p)) + F_q + F_source. +``` + +Here `n_address,R=Theta(p)` and `t_min=2^Theta(p^.003)`. Thus padding costs +`O(V)`, the offset term is `o(V)`, and `D V` has power `.997 0. +``` + +This gap absorbs the remaining `log p` when `p=Theta(log n)` and `V=Theta(n)`. +The old physical root exponent `.99827101` would give +`Phi_old=.99827619697>1-1/580`; it does not certify this target. The new +complex saving is used in the changed root bound. + +## 3. The production parameter domain is nonempty + +Use the exact packed-box construction in OUTER-JOIN, with +`p=6 ceil(log2 n)`. It has actual scalar-axis count +`D=Theta(p^.997)`, target exponent `ell=Theta(p^.003)`, and target lengths +in `{2^ell,2^(ell-1)}`, with a final `2^ell` axis. Its constructor arguments +are `axes=D-1`, `dimensions=D`, and `d=D+1`. The latter is the Gaussian +parameter, not the root's selected width `d_root=g`. + +Retain the source-prime interval + +``` +(1-1/(2d)) t_i < s_i < (1-1/(4d)) t_i. +``` + +It gives the exact strict production ratio +`1/(4d)<(t_i-s_i)/s_i<1/(2d-1)`. The product satisfies +`S/T>(1-1/(2d))^D>=1-D/(2d)>1/2`. The retained Baker-Harman-Pintz +prime-interval theorem and the source's packing argument supply `D` distinct +primes once `12d^2=101`, `a>=2`, `u=ceil(log2(8p))` | `p^.002` exceeds `log p` | +| `u d<=p` | `u d=Theta(p^.999)=o(p)` | +| `d>4w+2` | `d=Theta(p^.997)` and `w=Theta(p^.499)` | +| `L>=64dH` | `L>=p^8` and `dH=Theta(p^3.997)` | +| `s>2(L+2H+2w)` | Each source axis is superpolynomial in `p` | +| target width exceeds `inner_bits` | `ell=Theta(p^.003)` exceeds `8log2 p+O(1)` | +| strict source-core clearances | `H=Theta(p^3)` dominates `512p^2 w=Theta(p^2.499)` | +| complete signed descriptors fit | `log2 t_max=o(p)` and all halo lengths are polynomial | +| restored-error guard | `gamma=O(p^.999+p^.997 log p)=o(p)` and `p-A=Omega(p)` | + +The last row uses the actual `gamma=D(2u+ceil(log2(32p))+1)`, including the +new inverse normalizers. The input scaling and exact recovery inequalities +are independently checked in OUTER-CHECK. All metadata and coefficients +come from the original-axis production producers; a finite fixture or a +declared count is not substituted for the required physical packets. + +These are eventual inequalities for one fixed parameter family. For the +finite prefix below their combined thresholds, use a fixed elementary +integer multiplier and enlarge the constant. No numerical cutoff is inferred +from an asymptotic `Theta` expression, and no run at those enormous production +parameters is asserted. + +## 4. Exact source compatibility and the constructor adapter + +The eight PR3935 files pinned by the canonical CRT converter at +`240597ed313fc2854c0462b23c89dc3bae72aaf5` are byte-identical at the newer +`f687fa171ef760fa98a4be1289717b47dd4ee0b3`. This includes the actual +`TensorPlan`, full router, source loader, proof, fixture and three archives. +The retained comparison receipt records the complete archive byte checks; +the bounded package check rechecks the included constructor/proof bytes and +that receipt. The 19 MB runtime archives are not duplicated in the small +proof-reference bundle. + +Inspection of both actual Gaussian archives also found the exact same +`active_sources`, `ActiveWidthRoot`, `RetunedMachine`, `retuned_native`, +`ScalarProgram`, `ComposedRoot`, `Fourier`, `Convolution`, `Cyclic` and +`Chirp` source bytes. Their nested archive paths are retained in the cohort +receipt. The source comparison supports a precise constructor composition; +it is not a production execution receipt. + +[`outer_factory.py`](outer_factory.py) exposes `production_consumers` inside +an **already open** authenticated `tensor_sources.opened()` context. Its +explicit source-root arguments supply the full retained runtime packages. +It authenticates and stages only declared source files, checks the already +loaded constructor bytes and common `Count`/`Tape` classes, then constructs + +``` +root = physical_global_bridge.production_layer() +support = ComposedRoot(Router(build_native()), root) +fourier = Fourier(support) +convolution = Convolution(fourier) +cyclic = Cyclic(convolution) +chirp = Chirp(cyclic) +tensor = Tensor(chirp, FullRouter(build_native())) +converter = Converter(FullRouter(build_native())) +``` + +The pooled root factory already requires the current `active_sources` +context; it opens no second cohort. Its ordinary instance is at +`root.machine.monomial.compact.binary.native`. The adapter checks this +instance and the three others are distinct. `FullRouter` takes an ordinary +native object and constructs its own `Router`; passing a `Router` to that +constructor would be incorrect. + +The local pooled global bridge is compiled directly from authenticated source +bytes under a fresh private module name. Its local bridge uses the same direct +compilation rule. Neither load consults a bytecode cache. Both aliases are +removed on exit only when they still name the modules created in that scope; +pre-existing foreign aliases are rejected. The already opened physical cohort +is an explicit precondition: file-byte checks are not a claim to authenticate +arbitrary mutated objects in an unrelated Python interpreter. + +The unchanged CRT cold opener cannot be nested inside an active tensor +opener. The adapter instead authenticates the CRT sources and all eight +network-pinned tensor inputs, then temporarily assigns its loader's `_active` +token to the existing tensor state, exactly as the retained tensor/chirp +adapter shares a state. It requires a fresh CRT module namespace, restores +the token and module paths on every exit, and checks complete output +consumption on successful exit. It does not replace numerical methods, +native constructors, profiles, tape classes or cleanup functions. + +The bounded checks execute the real CRT authentication/token functions on +their pinned small sources and inspect the actual constructor graph. They +do not invoke the four production native constructors or run a production +numerical packet. The written all-size proof remains conditional on the +retained primitive, refinement, hosting, coefficient, analytic and prime +theorems; their implementation interfaces are now identified precisely. + +## 5. Bounded reproduction + +Run from the repository root, placing the receipts outside the published +package: + +``` +python3 -B research/complex-pooled-full-admission/outer_domain.py --output /tmp/outer-domain.json +python3 -O -B research/complex-pooled-full-admission/outer_domain.py --output /tmp/outer-domain-optimized.json +``` + +The checked-in `evidence/OUTER-DOMAIN.json` is the matching normal/optimized +receipt. `OUTER-DOMAIN-PINS.json` authenticates the retained complete archive +comparison receipts. `OUTER-FACTORY-PINS.json` records the exact runtime package +files and local bridge source commitment required by the production adapter. +The small frozen outer archive contains proof and constructor references; +these commands do not pretend it is the complete runtime closure. The checks +include exact exponent margins, actual constructor signatures and graph, +unchanged CRT authentication and token restoration, direct compilation of both +bridge definitions in two fresh scopes, and decisive rejection controls. They +execute no production ordinary constructor or numerical packet. diff --git a/research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json b/research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json new file mode 100644 index 000000000..dd5670e98 --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json @@ -0,0 +1,264 @@ +{ + "local_bridges": { + "physical_global_bridge.py": "b9075451d35480be6252b95105b0d9456845bfc62b3f43df9b822b492ad40172" + }, + "packages": { + "research/crt-address-streams": { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": { + "NETWORK-SOURCES.json": { + "bytes": 2322, + "git_blob": "efd965ec0f01c8ba176c0a7fdffb9494fdda704b", + "sha256": "c843e86f64902c63cfbac72b7d743ae628abd430ba3987a0b8c6254de3b9b22b" + }, + "SOURCES.json": { + "bytes": 823, + "git_blob": "47203dc21d58da7a844aa43f3f5ba72ece13c41f", + "sha256": "96b3228ee210e10c9f6c597061eec79917d28c1dc31173842d803b72b672493b" + }, + "check_crt_cost.py": { + "bytes": 545, + "git_blob": "bbee94cc1d43046d95506c90517b97fdb1b56b94", + "sha256": "ba01ba42c5cbce8b8fd0ee9adedaf80a8ae3a17656e1a6c6555bb80b3a8dcb1e" + }, + "check_crt_runtime.py": { + "bytes": 14797, + "git_blob": "9651a3ca380db72ab7298274d1c51997432d3588", + "sha256": "96a0136758b701b4b547b8c852b8d1cd95f098d0df7001c9794d206351fc7913" + }, + "crt_converter.py": { + "bytes": 11706, + "git_blob": "eec21ef3e629abb5d9b21f9ea09a1cbd3655daa4", + "sha256": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea" + }, + "crt_descriptor.py": { + "bytes": 4005, + "git_blob": "867505afc59f8037ccf13e48353122397770484e", + "sha256": "4bd7674ea79693fb0617378a9de600eab6da2b8c15afd55a969c5e741a198b2e" + }, + "crt_offsets.py": { + "bytes": 2753, + "git_blob": "efb054733b8bfff89e229f5f1e9c223b9aafb6d3", + "sha256": "3b130990f37a844c39722eeed3de7af45aeca6640972333c762e96e6d0df7cd7" + }, + "crt_padding.py": { + "bytes": 3844, + "git_blob": "3bffe1415679869fff37118fd596d6c972a98555", + "sha256": "a827e88a57fbd96e1b61cbc105fe24233f07c7cef71527f495819c8f9fb245f3" + }, + "crt_shape.py": { + "bytes": 7013, + "git_blob": "23b6cd3fecdb8c5ec1bd7ec2637679efcf20c22a", + "sha256": "4073253569e5941de30e26b9ed83b9f1fcdb2c186b20123c7757f2edd7e2153a" + }, + "crt_shear.py": { + "bytes": 2973, + "git_blob": "229e3a42decd7088019240f4f8f8578a3d20424b", + "sha256": "2ab51279388abceeb8a1e4a335c207236da60d9c62c7e0f633b39cca11abee46" + }, + "crt_sources.py": { + "bytes": 7176, + "git_blob": "fa0effe0bc5c34ae560bc045fdf4470840b028a7", + "sha256": "6a7e28fb2b3584a382ddec57902fcdd963d3af7c241a4541023666aba7f3d140" + }, + "crt_streams.py": { + "bytes": 1129, + "git_blob": "61d10d7e998f4d7362b66fe991d23eb199dda9e2", + "sha256": "21147240ab87d5662b0b8219ab3b51d95bc9766cd52e1ec458e5cc015a38fea8" + }, + "encoded_crt.py": { + "bytes": 3993, + "git_blob": "054270cd827d664adaf8eb115b61b423a03d8c88", + "sha256": "10ebb779490ecb21e11a441db60272e825f328f08ae9cb55b4ee88c37b8027ed" + }, + "verify.py": { + "bytes": 3730, + "git_blob": "e69ebb71d4e54238347398efe77483bab7eabd82", + "sha256": "c5e49d21f7352ee45c6580a81211bc5b56f71dbcf6df1505b0df5df5538ce9e3" + } + } + }, + "research/physical-gaussian-tensor": { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "files": { + "SOURCES.json": { + "bytes": 4289, + "git_blob": "d4c2f56c7417874a3ddc3eaab7a528589a6c30f7", + "sha256": "d37382a6a63dcf96625a7d59489abd52a25fa539a8d7e9007667d93b85d5bd54" + }, + "tensor_arithmetic.py": { + "bytes": 5308, + "git_blob": "0fbcaafb04b4785c511185ea309548370c77348b", + "sha256": "5e82e32f3afe8e91d4bb9ca531ecc30c836fed951c594e9482af96a472ab130a" + }, + "tensor_catalogue.py": { + "bytes": 13868, + "git_blob": "a1300e66aa005b4478452ec1857f0086475b03f9", + "sha256": "1c22cbfe62f644d500a00cccf6f9dbd16b1c659fcb3b9f70d51770bc9b092d20" + }, + "tensor_check_arithmetic.py": { + "bytes": 9350, + "git_blob": "d21260a7cad7f93d04eeaf9962afedb542d9a37d", + "sha256": "3899e1734723b7ba9cb1331f8fb61c0a5bd3b4540af45831323a587101df759f" + }, + "tensor_check_budget.py": { + "bytes": 2448, + "git_blob": "469c84b739b385ebead526845da20dfd4f47513b", + "sha256": "5088866fc0762b3ca9caa97e0b681ad29912fdd001393584233bd9d7bba265db" + }, + "tensor_check_catalogue.py": { + "bytes": 6539, + "git_blob": "1947616b7cf1eed138b480522228bdf0070e4087", + "sha256": "f9edaca382a499c2293c3e6ca13d118d7938f4b919bd7c6227d64b74b5768a4a" + }, + "tensor_check_counts.py": { + "bytes": 2988, + "git_blob": "f51bd353a64d01e835ff8c8f2395fa4adf0f8ddb", + "sha256": "2c9577752dbad52232e15ad4e1dbd7e3cc556642651a769161cf1cc67b296057" + }, + "tensor_check_division.py": { + "bytes": 8140, + "git_blob": "a305ad22a26cbc55c65bd7535869e4eef18c0e58", + "sha256": "8930941cbdd00042e5272860d831bb5d27c27547b09880b5a8bb09314ae02e46" + }, + "tensor_check_full.py": { + "bytes": 7627, + "git_blob": "3c57f539354e06c530d9fecc6d534df2b19b9997", + "sha256": "b3448653ed845e174e37f616793983b8a23f0f82fa1c02cf038cfba1e405a9ba" + }, + "tensor_check_gather.py": { + "bytes": 4980, + "git_blob": "ee6aea0b37f3d4112b1fccbf9b51da37ddb0c791", + "sha256": "038acf5beb847a31d51df795c4bc173dc45092fc747a09eda9bcb5f28a785d70" + }, + "tensor_check_moves.py": { + "bytes": 5093, + "git_blob": "296521382bad1ab4dca6c1e267bb5e99418051b3", + "sha256": "63b584d06bcd2a3f935f8e53389c2a0a3e05bd66d86a4dd0e9f1fae6690bf11f" + }, + "tensor_check_plan.py": { + "bytes": 6976, + "git_blob": "bee8084ce9b0f78d78050e2eabb47a3c0b3c9caa", + "sha256": "68480a2195d76d8d4e32252629429ffd4702f1df5380918c1cfa69d939010431" + }, + "tensor_check_records.py": { + "bytes": 24051, + "git_blob": "87872d9f496c9f78b4850917763873212cf60bc1", + "sha256": "992132d09f84d343e131b4d40909e276aa4af00e0e0b3e16e53aacf98093f12a" + }, + "tensor_check_router.py": { + "bytes": 6717, + "git_blob": "175b1509635dee22fa76e906b0eda15d303cfd06", + "sha256": "65b6ce689ce0ff4fa6037a81922cf582b7fab5b5f42921ffeb67cddecd7f51eb" + }, + "tensor_check_sources.py": { + "bytes": 4405, + "git_blob": "14eec11943205392b3405314ed0cf0e3f4cd91cc", + "sha256": "fc637a849a20ffec369a9d29693535e0c7c2edbba233a6c10595391f831c6da5" + }, + "tensor_check_twiddles.py": { + "bytes": 5097, + "git_blob": "131f07a2ac2f4d6a5e6299ea55fd1f781cafbcc5", + "sha256": "a2fdbcc7a3787239a74427b4e2c1804a5d0b7fbd2285b442fd6c4bedb58ffe46" + }, + "tensor_check_windows.py": { + "bytes": 9365, + "git_blob": "6aeeb54a36c8bdc6ec7fad7b16d4eb09b7ff5a84", + "sha256": "86e2c3742de5b53d9e85d5d4b865cd7be0dae06acfbf7a1ceca5aa68d41d9f51" + }, + "tensor_check_word.py": { + "bytes": 10391, + "git_blob": "af3adc04288e3b2349665402081f7f48d4d3e9e9", + "sha256": "60f7a1ec734c8e511ee486360e1de156ef7324db394768ee214116c53ec92c8d" + }, + "tensor_counts.py": { + "bytes": 3456, + "git_blob": "48ccd496dc7c7973089782a272ec6d3b125e6c56", + "sha256": "01a2e0a836d71e899f3129b47c5923a6c525ee5d20f6679e2930692242cb5eea" + }, + "tensor_division.py": { + "bytes": 4393, + "git_blob": "d5830becd01aa82aa12fa078e5d2453f4a1d1d56", + "sha256": "ff1ee517fab590219d569f96696a85f085c7b0a46871372b4b0a55ed8180259a" + }, + "tensor_engine.py": { + "bytes": 13918, + "git_blob": "779023d7e2c82f5dcf0d78c32ffd067e923572f7", + "sha256": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1" + }, + "tensor_fixture.py": { + "bytes": 3429, + "git_blob": "83a40a9ada87ae94cadc1ed2ddaa11c482c1d318", + "sha256": "f699d1c52334f42fe548b71c199a79381a980fb351c77515acd107f848cf100b" + }, + "tensor_gather.py": { + "bytes": 8186, + "git_blob": "5e96dd76424d4171b93e540aa04ad0a829e79618", + "sha256": "47c33983ed41b484836bb4ba3831c4f6506d48c7c23bd948c55906622a55ded0" + }, + "tensor_lines.py": { + "bytes": 12633, + "git_blob": "c59be26feb3f9d09b6a6f9b0f00e93f223669cfa", + "sha256": "66bac95bdcdf788978d185e2f7508cd74152801f1513c4e5af978ff5983fc511" + }, + "tensor_model.py": { + "bytes": 9773, + "git_blob": "71d8489e72f855c2848e18e7982acac93b5b2387", + "sha256": "2de4aaf4e13d1c711bd7ba5bb10b361454867dfb5384fd34883efbb09897f42c" + }, + "tensor_moves.py": { + "bytes": 7127, + "git_blob": "842da60d989cd3a2e3e1ca60cccde396ead0f9e0", + "sha256": "65fedbf5aad4922cd4ba24a6f2aef339d7428dba3f051bf8e647800ab1c1818d" + }, + "tensor_plan.py": { + "bytes": 12079, + "git_blob": "239caba2d2ccf2640c36d377949df3fb6a920cf0", + "sha256": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3" + }, + "tensor_records.py": { + "bytes": 5964, + "git_blob": "4b06c9d85165b9e7e2dce20d24527f02844ec3b4", + "sha256": "a450cbee0b899c0e14dbd43147e73138786846ac009c6626dbcb96292458bb6b" + }, + "tensor_router.py": { + "bytes": 7709, + "git_blob": "6f5177cfa1bd03f145527c6ad5ca1ddef74716fd", + "sha256": "cf6d7c58396517d15a28f836676d1da679b68796b48b0f780f6131c8a1d2b2fa" + }, + "tensor_signed.py": { + "bytes": 4340, + "git_blob": "8b5b2d758f3a8d46a80508aae62afadab53113b9", + "sha256": "1cf33e9ff482a19ec808be33ebd29166895faa70e9dd770dc02da313fe448644" + }, + "tensor_sources.py": { + "bytes": 9250, + "git_blob": "00edf5a03fad4ed69891dd0ca4a6909bd68ef4cf", + "sha256": "cba69b2bc93b7dabbffdbdf07fb41130fde5d65a8f4d344ade52d3a326e30ac0" + }, + "tensor_twiddles.py": { + "bytes": 5817, + "git_blob": "485baf3ca625589fd414b6354e285dce305c0cfe", + "sha256": "bd19438b8e261eb9e82029115e2e66e83a5cde161ef9d82a626acd862dfc092f" + }, + "tensor_windows.py": { + "bytes": 14697, + "git_blob": "b8287a35d4d72dc811143fa7b58ec9afc8146ae5", + "sha256": "c6554a2d07754af2bf562dc63259bcc57c8d518f3259d0a536b2468af7b4122d" + }, + "tensor_word.py": { + "bytes": 8235, + "git_blob": "084f89d5ded7e76df8c575aa7d5eb9af6de2ea3a", + "sha256": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26" + }, + "verify.py": { + "bytes": 2853, + "git_blob": "df6cf3189215bfd2fc115784cbb9ac4827f81fde", + "sha256": "9a6cf1edcadee4b411644a880149937b76fb40df942ea7a6562aa380993dfbe5" + } + } + } + }, + "role": "Exact source identities for a constructor adapter inside an already authenticated full tensor cohort; no runtime source archive or payload execution is supplied.", + "schema": 1 +} diff --git a/research/complex-pooled-full-admission/OUTER-JOIN.md b/research/complex-pooled-full-admission/OUTER-JOIN.md new file mode 100644 index 000000000..50cf3eefd --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-JOIN.md @@ -0,0 +1,355 @@ +# A conservative complete conditional integer transfer + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. This composition uses Jose Manuel's physical root, support, +Fourier, ring/chirp and Gaussian constructions; Tekalign's encoded CRT +conversion; the original integer-assembly and analytic sources; and the +credited pooled supplier lineage. Their source-relative premises remain +explicit. The new result is the source-specific composition and complete +cost/error comparison, not authorship of those components. + +## Statement and proof boundary + +Under the completed physical and analytic contracts specified below, the +pooled supplier admits a fixed finite-tape integer multiplication construction +with exact output and + +``` +T(n) = O(n (log n)^(1-1/580)), +space O(n)+F_q, +kappa = 1/580 = 0.0017241379310344827586... . +``` + +This is a conditional all-parameter composition, separate from the exact +finite release and the more aggressive legacy arithmetic candidate +`0.001727989140903569`. The conservative value includes the physical root's +actual stopping rule, both support-routing directions, the full Fourier and +Gaussian calls, three CRT conversions, normalization, integer recovery, +all child-return copies, restoration and fixed compiled inventories. + +The required contracts are the pooled arbitrary-input native/common-cover +identities and whole-call hosting; the retained completed BIT/ordinary, +Compact and fixed-tape primitives; the source-relative physical root and +Gaussian refinement/locality/rounding arguments; and the stated analytic +Gaussian and prime theorems. These are mathematical premises, not conclusions +of a bounded replay. The construction does not use a rounded recursive C +child. Exact children run on one guarded grid; truncation occurs only at +the complete normalized interfaces prescribed by their source. + +`OUTER-PINS.json` freezes exact proof and constructor references. It is not +an executable export of every transitive Gaussian source. PR3935 is pinned +at `f687fa171ef760fa98a4be1289717b47dd4ee0b3`; canonical references are pinned +at `12fa8c5c844be21bfefb38a19503fbd867a11244`. The source-specific global +binding and its physical proof are in `physical_global_bridge.py` and +`PHYSICAL-GLOBAL.md` (with the local refinement in `PHYSICAL-BRIDGE.md`). +The constructor/cohort comparison and exact margins +are separated in `OUTER-DOMAIN.md`; exact normalization/error controls are +in `OUTER-CHECK.md`. No complete production-prime payload, end-to-end +Gaussian integer program, human review or formal-kernel theorem is claimed. + +## 1. The physical layer rate actually used + +Retain PR3599's completed ordinary backend and its exact encoded coupling +`1/577`; no B2 backend is needed for this theorem. Put + +``` +tau = 332353/332929, +sigma_star = 0.99826995, +alpha_layer = 0.99827, +theta_stop = 1/1000000. +``` + +The pooled complete moment is less than one at `1-C`, where +`C=0.001730980255989036959962`. Since every child ratio is strictly below +one and `sigma_star>1-C`, it is also less than one at `sigma_star`. +Moreover `tau=4n/b, +N=log2 T, +D=floor(p^(997/1000)), d=D+1, +ell=ceil(N/D), r=2^ell, +alpha_G=floor(p^(1/1000)), u=alpha_G^2. +``` + +Eventually `D>=2`, `D=2` and `T<2^b`, while +`4n/b<=T<8n/b`. Choose exactly `N-D(ell-1)` of the D target lengths to +be `r`, the remainder `r/2`, and put a long axis last. Their product is +exactly T. The actual TensorPlan parameters are `axes=D-1`, +`dimensions=D` and `d=D+1`; these names must not be interchanged. + +For each target length t choose a distinct odd prime in + +``` +((1-1/(2d))*t, (1-1/(4d))*t). +``` + +The required multiplicity is at most D for each of the two target sizes. +Baker--Harman--Pintz Theorem 1 gives a prime in each sufficiently large +interval `[x-x^(21/40),x]`. As in the retained rad20 prime argument, pack +at least D disjoint such intervals inside each required interval. The +sufficient comparison `12d^2=ceil(log2(8p))`, +`ud<=p`, `d>4w+2` for `w=ceil(sqrt(16p/u))+2`, +`L=2^ceil(log2(p^8))>=64dH` for `H=4096p^3`, and +`s_i>2(L+2H+2w)`. The target lengths have more than one complete L tile. +All descriptors have O(p) bits. The required source windows, period margins +and signed origins are those computed by the original-axis producer; no +unverified arbitrary coefficient page is accepted instead. + +All eventual conditions are fixed before numerical input. They can be +tested by encoded integer arithmetic, including the final error gate below. +Use schoolbook multiplication if a finite-size admission fails. Each +condition eventually holds; this branch therefore covers only a fixed +bounded range of n and fits the final bound after enlarging its constant. + +## 3. Complete interfaces and normalization + +Write `F_-` and `F_+` for the tensor Fourier maps on the prime box, both +normalized by `1/S`. Let `R_i x(j)=x(t_i j mod s_i)` and `R=tensor_i R_i`. +The actual Gaussian endpoint is `A_-=R F_-`; conjugating its input and +output gives `A_+=R F_+`. Since `F_+ R=R^-1 F_+`, + +``` +A_+(A_-x * A_-y) = (x cyclic-convolve y)/S^2. +``` + +Here `*` is coordinatewise multiplication. Omitting R from either source +contract, treating two normalized maps as unscaled inverses, or retaining +only one factor S would change the result. + +Initially scale each radix digit by `2^(-b-2)`, producing p-grid values +of modulus less than 1/4. Pad through S coefficients. Execute two complete +forward CRT conversions to natural prime-box order, then two completed +Gaussian calls. Copy and consume each protected output before reusing its +owner. Multiply corresponding returned Gaussian values exactly with four +signed integer word products, then truncate each component toward zero to +the p grid. Execute the opposite Gaussian call on that complete packet. + +Every Gaussian packet uses signed least-significant-bit-first components of +width `p+2`, real before imaginary. The CRT conversion treats these as +opaque complete records of width `2(p+2)`. It preserves the complete rows +and performs its actual padding, global field permutation, triangular shifts +and cropping. It checks every discarded padding bit. There are three full +CRT conversions in total, including the final inverse below. + +The synthetic Fourier maps used inside the chirp both normalize by their +polynomial-address volume M and compose to `I/M`. PR3763's completed chirp +already restores its required factors. The Gaussian theorem then supplies +`R F_s` with its exact global scale `2^gamma`. We neither add nor delete a +second normalization at these internal interfaces. + +## 4. A complete error and recovery budget + +Let `h=2^-p`, `M=T/r=2^A`, and + +``` +gamma=D(2u+ceil(log2(32p))+1), +H_err=Dp^2+32+2D. +``` + +PR3935 gives each completed Gaussian call, on any admitted half-disk input, +error below + +``` +E=2^gamma (Dp^2+4sqrt(2)M+22+2D) h + < 2^gamma T H_err h. +``` + +This includes coefficient generation, expansion, the complete chirp, +principal-core compression, all local rounding, exact `2^gamma` restoration +and final width reduction. We assume the source's analytic locality and +conditioning estimates at their stated production domain. Its reduced +p48 fixture is not evidence that this asymptotic domain was executed. + +Apply the additional encoded gate + +``` +b >= gamma+ceil(log2 H_err)+9. (1) +``` + +It holds eventually since `gamma=O(p^.999+p^.997 log p)=o(p)`. +It also implies the source guard +`p>=gamma+A+ceil(log2 H_err)+8`. Thus returned values remain in the +required disk and the retained Gaussian narrowing is valid. + +For the first two exact transforms the norm is at most 1/4. Their computed +values have norm at most `1/4+E`, eventually below .26. The product's +componentwise p-grid truncation changes its Gaussian value by less than +`2h`. Its error from the product of exact transforms is at most +`E/2+E^2+2h<=E+2h`. Its norm is below `.26^2<1/2`, so the third Gaussian +call is admissible. The exact normalized map is a contraction; the complete +three-call result therefore has error below `2E+2h` from the desired +scaled cyclic convolution. + +Now multiply each numerator exactly by `S^2`, restore the scale +`2^(2b+4)`, and round the real component to its unique nearest integer. +The resulting coefficient error is strictly less than + +``` +S^2 2^(2b+4) (2E+2h) + < 64 H_err 2^(gamma-b) + <= 1/8 (by (1)). +``` + +This uses `S 1/580, +``` + +the strict positive difference absorbs the remaining fixed logarithm. +Using `p=Theta(log n)` proves the stated conditional exponent. The target +`1/580` is above the selected `0.001672660197076918`. The old physical +Fourier rate `.00172380303` does not itself reach `1/580`; the changed +complex layer supplies the additional margin. We make no measured-runtime +claim and no uniform claim as any of these fixed margins tends to zero. + +## 6. What this does and does not close + +This written construction joins explicit completed source contracts and +accounts for every outer invocation, format, normalization, error and paid +restoration term. The finite all-provider release, global source binding, +bounded exact controls and constructor evidence support different parts of +that argument and must remain separately labelled. + +The inherited universal native/hosting, physical primitive/refinement and +Gaussian analytic hypotheses still require scientific admission. The source +code is a fixed-controller realization argument, not an emitted universal +transition table. The new integer wrapper is specified by the complete +encoded sequence above; an end-to-end production execution is not claimed. +The selected frontier remains unchanged pending independent review. diff --git a/research/complex-pooled-full-admission/OUTER-PINS.json b/research/complex-pooled-full-admission/OUTER-PINS.json new file mode 100644 index 000000000..d3495e13e --- /dev/null +++ b/research/complex-pooled-full-admission/OUTER-PINS.json @@ -0,0 +1,11 @@ +{ + "archive": "frozen/outer-source/SOURCE-CONTRACTS.tar.gz", + "archive_sha256": "a93f3e4df06a8ee18c69f68697cec463bbb86ddff642cc1df652d87ba642f046", + "attribution": "Retained contracts and physical components by Jose Manuel with credited contributors; CRT conversion by Tekalign; original integer assembly and analytic lineage retained. This composition is prepared for Ross Richardson with substantial OpenAI Codex assistance. Original source notices remain in the retained bytes.", + "bytes": 116428, + "files": 35, + "manifest": "frozen/outer-source/MANIFEST.json", + "manifest_sha256": "cc5c879b5c28c9d2d4191c1ac2c5563213c1b58ffd1e4d25a3e6c0a6a6dbeb18", + "role": "Exact proof and constructor references; not an executable runtime closure or a completed payload replay", + "schema": 1 +} diff --git a/research/complex-pooled-full-admission/PACKAGING.json b/research/complex-pooled-full-admission/PACKAGING.json new file mode 100644 index 000000000..5c73541a5 --- /dev/null +++ b/research/complex-pooled-full-admission/PACKAGING.json @@ -0,0 +1,48 @@ +{ + "canonical_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "historical_input_pins": { + "bytes": 8564, + "path": "frozen/RECORDED-INPUT-PINS.json.gz", + "payload_bytes": 48722, + "payload_sha256": "07d6c095d5ed6d45fec6d9a83732ffcefd5eb785e3d7c05234440a9e74c0b284", + "sha256": "fba0146f62fec7da7d66196802c506c34790406f58c3a87c94c146c6cf8d419f" + }, + "receipts": { + "evidence/MIXED-CONTRACT.json": { + "bytes": 10482, + "path": "evidence/MIXED-CONTRACT.json.gz", + "payload_bytes": 174337, + "payload_sha256": "d26c9f6b12750c0422bf4616e0f5452c681bb36c5d2e0da2ec1871be1a9f5088", + "sha256": "5195747668ae17eb3656396b984c6bda44b907e286cdd758636219cc6d45c289" + }, + "evidence/PREFIX-AND-INVOICE.json": { + "bytes": 21898, + "path": "evidence/PREFIX-AND-INVOICE.json.gz", + "payload_bytes": 1526088, + "payload_sha256": "d600e6c533f3a3d470a3fbb514c0c9cd9d8a8fc3684370d1afb5afa26ba15bdd", + "sha256": "0dbef8438d59d985679af8dc82d2a31c979c516cfb6f6e3b31ac8b1e9c595d86" + }, + "evidence/SPEC.json": { + "bytes": 23878, + "path": "evidence/SPEC.json.gz", + "payload_bytes": 298334, + "payload_sha256": "98bb37ad3ae3c6598530120243381ebbe4b04bea785c86ee55f4416f95e628ce", + "sha256": "4b92e37e79b60a5505b0839510e2e142eb8978743ac6fc0c86ce2c1db5ba358f" + } + }, + "schema_version": 1, + "scientific_head": "46965e30a34af44499a1442daeb94cd3b68fa67a", + "scope": "Lossless storage and equivalent source addresses only. EVIDENCE.json and its full scientific receipt payloads remain unchanged; this does not claim a new historical full release.", + "selected_inputs": { + "frozen/selected/ASSEMBLY.json": { + "bytes": 85147, + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + "frozen/selected/BIT-EXPECTED.json": { + "bytes": 5987, + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + } + } +} diff --git a/research/complex-pooled-full-admission/PACKAGING.md b/research/complex-pooled-full-admission/PACKAGING.md new file mode 100644 index 000000000..da4be5305 --- /dev/null +++ b/research/complex-pooled-full-admission/PACKAGING.md @@ -0,0 +1,69 @@ +# Lossless receipt storage and pinned input reuse + +This packaging change does not alter a mathematical proof, interval engine, +primitive tariff, rejection predicate or retained premise. The optional B2 +ordinary-bootstrap calculation is a separate draft contribution. The main +`kappa=1/580` composition continues to use B1. + +## Receipt bytes and history + +`evidence/PREFIX-AND-INVOICE.json.gz`, `evidence/SPEC.json.gz` and +`evidence/MIXED-CONTRACT.json.gz` contain the complete original JSON bytes. +No field, coefficient, owner entry or rejection case is dropped. +[PACKAGING.json](PACKAGING.json) commits both the stored container and the +decompressed byte count and SHA256. The decompressed hashes must equal the +original commitments in the unchanged [EVIDENCE.json](EVIDENCE.json). +Regenerated scientific products still compare by their complete JSON values, +rather than requiring a particular gzip encoding. + +For example, this reads every original invoice entry: + +```sh +python3.12 -c 'import gzip,json; print(json.loads(gzip.decompress(open("research/complex-pooled-full-admission/evidence/PREFIX-AND-INVOICE.json.gz","rb").read())))' +``` + +`EVIDENCE.json` records the historical complete finite release. It does not +claim that the new packaging code executed that historical run. Its original +`INPUT-PINS.json` bytes are retained in `frozen/RECORDED-INPUT-PINS.json.gz`; +the other four recorded execution sources remain byte-for-byte unchanged. +The verifier authenticates all five historical source commitments, all fourteen +receipt commitments and the complete recorded release chain. + +## Reused canonical inputs + +Two redundant local copies have been replaced by their identical pinned files +at canonical base `12fa8c5c844be21bfefb38a19503fbd867a11244`: + +| Former package address | Declared repository input | +| --- | --- | +| `frozen/selected/ASSEMBLY.json` | `research/community-frontier1094-audit/ASSEMBLY.json` | +| `frozen/selected/BIT-EXPECTED.json` | `research/e8-bit-p111-tuned/tune/EXPECTED.json` | + +The current `INPUT-PINS.json` must equal the historical document with exactly +these two path/kind substitutions. Their SHA256 commitments stay unchanged. +Both are explicit `VERIFY.json` inputs with canonical `SOURCES.json` bindings, +so a Git-free export includes them without network or predecessor Git objects. + +`joint_bound.py` remains the exact recorded interval engine. Its direct readers +retain the historical addresses. Use `joint_bound_inputs.py` to run its complete +CLI with the two canonical addresses: the adapter compiles the authenticated +engine bytes, changes only those two reader addresses, and retains every +arithmetic function and predicate. All other paths, including `--release-work`, +use the original readers. The physical/global and successor admission checks +continue to compile the unchanged engine for its pure interval arithmetic. + +## Checks and scope + +The normal and optimized registered regressions authenticate containers and +original payloads, compare the complete current and historical input sets, +recompute all original operator/arithmetic controls, and reject missing or +changed containers, payload commitments and symlinked inputs. Local/global +physical, outer and successor admission checks retain their existing domains. +All registered commands also run from an isolated committed export without Git. + +These fresh bounded checks are distinct from the preserved historical complete +release. The packaging change supplies no new production multiplication run, +formal-kernel proof, premise admission or selected-frontier update. + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0; retained source notices continue to apply. diff --git a/research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md b/research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md new file mode 100644 index 000000000..e7166dfac --- /dev/null +++ b/research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md @@ -0,0 +1,215 @@ +# Pooled local words in the existing physical instruction language + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Jose Manuel authored the retained physical compiler, controller and +primitive arguments; the frozen texts retain their complete attribution. +Cinna Davis's borrowing/warp construction and Rohan Arun's pooled fill retain +their original credit. This contribution binds those constructions to each +other at their stated interfaces. + +## Result and evidence boundary + +The older R480-only interpreter is not the strongest available predecessor. +The canonical `research/t74-physical-layer/compile_word.py` already supports +exactly the persistent/centre/Z layout used here. Its **unchanged** `Compiler` +successfully lowers all three active pooled providers in both orientations. +No warp or Z operation introduces a positive-rank child. + +`physical_bridge.py` pins all twelve actual native files from the completed +pooled release and the retained compiler/scalar/affine sources. Its immutable +26-member closure is in `frozen/physical-t74/SOURCE-BUNDLE.tar.gz`; every raw +member and the archive itself are authenticated before use. Python source is +compiled from authenticated bytes, without a bytecode-cache lookup. The +archive is checked for a complete unique regular-file inventory and contained +paths before temporary extraction. This check needs only the standard library +and does not need Git objects or network access. + +The finite result is: + +| Provider | Source events per orientation | Lowered instructions per orientation | Positive children per orientation | +| --- | ---: | ---: | ---: | +| gauge44 | 22,807 | 29,915 | 3,554 | +| extra | 22,807 | 29,915 | 3,554 | +| extra-four | 22,808 | 29,920 | 3,556 | + +Each orientation contains 240 warp events and 182 Z allocation/release events. +The six programs use 3,848 distinct monomial literals and 36 scalar literals. +The largest affine word has 61 gates. Each scalar recipe has at most ten +instructions, prefix denominator at most eight and affine row l1 norm at most +nine. These scalar-prefix figures are local lowerer facts; the complete caller +still needs the already invoiced whole-word guard. + +The private map is explicit: `L0..L631 -> 0..631`, `C0..C7 -> 632..639`, and +the provider's sorted 91 Z labels map to `640..730`. There are 731 local packet +roles, including 99 owned private packets. Z allocation is distinct from +clearing an arbitrary dirty input. Each provider has one complete Z lifetime. + +The checker additionally proves every compiled affine map and its inverse on +all `2^73` addresses by exact symbolic affine rows. It exhausts all 512 native +addresses for every phase polynomial. The higher 64 coordinates have explicit +identity affine action and zero phase coefficients. The separate native +operator admission establishes that these serialized recipes implement the +intended frame/warp products; recompiling a serialized recipe alone would not +establish that semantic claim. + +Nine controls reject missing or premature Z release, the wrong warp entrance +frame, a positive-rank warp, an omitted or inverted lowered warp, a misbound +warp recipe, unchecked clearing in place of Z release, and release of the +wrong private packet. The latter controls test the independently checked +event-to-instruction binding, including the required `inverse=False` flag. +The inherited runtime's actual zero check is source-pinned separately. + +## All-width local refinement lemma + +The following is a written compositional proof under named primitive +contracts. It is not inferred by enumerating numerical packet sizes. + +Fix one of the six authenticated local programs. Let `f>=1`, `K>=1`, +`0<=rho=1`. Supply complete aligned Gaussian packets, arbitrary +complete prefix/suffix spectators, and the retained three compact fields. +Each of the 73 vector fields has exactly `fK` bits. Each of the three compact +fields has exactly `(f-1)G` bits in the retained earlier/later placement, +including width zero at `f=1`. Any additional complete capacity is represented +by separately named prefix/suffix spectator fields. Outer +row count and the number of coefficients per record are positive integers. +Components have one common dyadic grid and signed width `h>=2`. Assume the +caller guard covers every exact half and signed arithmetic prefix. Persistent +inputs may be arbitrarily correlated and dirty. Private C/Z packets are owned +work, initially blank. Borrowed source and descriptor ports have canonical +heads and the inherited complete-word markers. + +Assume the existing all-width scalar, monomial, copying and ordered child +contracts, including their source/spectator preservation, work erasure and +head returns. A positive-rank child is the exact completed tensor on the full +prescribed `rf` axes, not one child per coefficient or unused row. + +For a warp event, select its exact `(sign,operator,old,new)` record. The emitted +monomial is the rank-zero physical product + +``` +Gamma_new K_operator^(sign) Gamma_old^-1. +``` + +Apply its columnwise lift once. Each column retains the serialized affine +map and quadratic/linear phase; a constant phase `i^a` becomes `i^(fa)`. +Role-level ADD/SCALE coefficients occur once and are not tensor-powered. +The separately supplied backward scalar word uses the same physical warp +record under the retained free-operator convention. Replacing that record +by its complex conjugate or inverse changes the specified contract. + +The retained monomial lowerer implements each fixed affine gate with the +completed Compact routine; its phase pass evaluates the phase on the source +address and, on an inverse invocation, on the recovered source address. +Its encoded phase accumulator keeps a residue modulo four. Induction on the +`f` column iterations gives the sum of the `f` phase polynomials, including +`fa`. Thus the construction works on the entire tensor space, including +correlations between columns and helpers. + +For a Z allocation, fill the declared owned packet with exactly the encoded +packet extent of zero bits and return its head. For a Z release, scan that +entire extent and require every bit to be zero before erasing it and returning +the head. The pinned `T74Machine.release_zero_step` performs this check before +`clear()`. The native free-operator cleanup proves that the required zero is +reached for every persistent input; it is not an assumption that the original +dirty helper was zero. Live Z packets exist only in the FULL-frame cleanup. +The original centre CLEAR remains owned-work disposal with its separate +source-word semantics. + +At an ADD/SCALE, the exact three-word scalar lowering preserves its source and +returns its scratch to logical zero; the physical scalar interpreter consumes +complete components and erases owned work. At a positive child, apply the +right monomial, the completed exact child, then the left monomial. The literal +frame and lifetime checks ensure that these contracts compose at every event. +Induction over the finite instruction sequence establishes the native local +endpoint for every admitted `f`, width and complete payload. All 632 persistent +packets return under their specified endpoints; all private work is blank and +all primitive interfaces have returned their heads. The local endpoint alone +does not assert a global physical owner map or an enclosing multiplication +algorithm. + +## Paid tariff for the new macros + +Write `C_rows` for the number of complete outer rows, `a` for the within-row +address width, `R` for the record width in bits, `M=C_rows*2^a`, `V=MR`, and +`A=2+a+ceil(log2(R+1))`. For `f>1`, put `b=(f-1)G` and + +``` +delta = min(1,(f-1)*(2*2^-G + 8*2^(G-K))). +``` + +The retained Compact theorem charges, for each affine gate, four completed +ordinary calls per row for an earlier source/toggle or twelve for a later +source, plus + +``` +O(V + M A^6 + delta M A(R+A)). +``` + +The phase pass additionally costs `O(V+M A^2)`. Summing the actual affine word, +each of our monomials therefore costs at most + +``` +s_R * sum_(row=1)^C_rows T_ordinary(V/C_rows,b) + + O(61*(V+M A^6+delta M A(R+A)) + V+M A^2), +``` + +where the exact source-order sum satisfies `s_R<=524`. This is a bound on +ordinary primitive calls, not on recursive complex children. The `f=1` branch +uses the retained direct bit-permutation/phase routines and has no Compact +call at width zero. It retains the displayed preparation/scan charges. + +Each Z allocation and checked release costs `O(V+log(V+1)^2)` symbol steps, +including extent arithmetic, encoded counters, terminal probes, writes, +checks, erasure and rewind. Hence it is `O(V)` for positive complete packets. +This is a uniform asymptotic bound with fixed primitive constants, not an +unmeasured numerical microtransition count. Allocation uses one owned packet; +release returns it to blank. All 91 Z packets remain charged throughout their +literal lifetimes. No scan or disposal is treated as free. + +Consequently the 240 added monomial events and 182 Z events contribute no new +positive-rank recursive call and a fixed multiple of the paid primitive bill. +Under the retained long-record/compact guard and a completed ordinary bound +`T_ordinary(v,b)=O(v(1+b^tau))`, this is +`O(V(1+(f log p)^tau))`, with `O(V)` local workspace plus fixed compilation +storage. Without those input-domain hypotheses the unabsorbed terms above +remain part of the tariff. + +## Finite control and separate global binding + +All local event, role, recipe and program-counter labels range over fixed +finite sets determined before input. The largest local code has 29,920 +instructions, below the inherited 65,536 bound. Component widths, packet +extents and row counts remain encoded on tapes. This permits the retained +local finite-state composition of the primitive controllers; it does not +license a host integer, seek, stack or Python event loop as a free operation. +No literal universal transition table or formal-kernel proof is supplied. + +This result resolves the **local opcode/lifetime** part of the gap: the new +warps and private buffers fit an already available physical instruction +language, with exact source binding and a paid all-width local argument. +The companion PHYSICAL-GLOBAL.md supplies the separate new global owner +dispatcher, actual cover charts/translations, bank and recursive root binding. +Its main layer rate uses the existing PR3599 completed ordinary B1 contract; +it does not assume the optional B2 bootstrap. Root/outer domain compatibility +remains separate from this local lowering certificate. Any further ordinary +bootstrap must construct its actual backend noncircularly; changing a `Profile` +constant alone does not replace C0's primitive calls. + +## Reproduction + +``` +python3 -I -B research/complex-pooled-full-admission/physical_bridge.py +python3 -I -O -B research/complex-pooled-full-admission/physical_bridge.py +``` + +To additionally compare every frozen native input with an actual fresh release, +pass `--release-providers /absolute/path/to/global/base/providers`. `--out` +may name a receipt outside this package. Normal and optimized runs perform the +same exact checks; the output distinguishes local lowering from global machine +admission. + +The immutable local bundle also includes the exact `scalar_words.require_zero`, +`ScalarEngine.run` and `FullScalarEngine` bodies reached by the described scalar +and Z-release macros. This is a source pin, not a new execution of their physical +tape cohort. The all-width statement retains the scalar-stream theorem and its +encoded Count/Tape, signed-arithmetic, scratch and source-cohort contracts. diff --git a/research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json b/research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json new file mode 100644 index 000000000..f824a30ca --- /dev/null +++ b/research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json @@ -0,0 +1,98 @@ +{ + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "bundle": { + "bytes": 4705664, + "files": { + "data/ACTUAL-SIGMAS.json": { + "bytes": 6336476, + "sha256": "1258d0eeba7692334646bd245d3953d7ebdabb009617a902780b12412cef8cc3" + }, + "data/DATA-PHASES.json": { + "bytes": 814141, + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "data/PHYSICAL-PROJECTION.json": { + "bytes": 46129608, + "sha256": "63ebf89bc0e874fc2021ff7407a39877426d8352a20032b34209098bfac1e8f0" + }, + "source/research/physical-complex-controller/PROOF.md": { + "bytes": 15528, + "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e" + }, + "source/research/physical-complex-controller/cover.py": { + "bytes": 4996, + "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da" + }, + "source/research/physical-complex-controller/selected_binding.py": { + "bytes": 11214, + "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985" + }, + "source/research/t74-physical-layer/binding.py": { + "bytes": 9991, + "sha256": "bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057" + }, + "source/research/t74-retuned-physical-layer/PROOF.md": { + "bytes": 14261, + "sha256": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f" + }, + "source/research/t74-retuned-physical-layer/active_plan.py": { + "bytes": 5202, + "sha256": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e" + }, + "source/research/t74-retuned-physical-layer/active_root.py": { + "bytes": 1424, + "sha256": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7" + }, + "source/research/t74-retuned-physical-layer/active_sources.py": { + "bytes": 8835, + "sha256": "599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49" + }, + "source/research/t74-retuned-physical-layer/retuned_machine.py": { + "bytes": 3939, + "sha256": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a" + }, + "source/research/t74-retuned-physical-layer/retuned_native.py": { + "bytes": 890, + "sha256": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc" + } + }, + "path": "frozen/physical-t74/GLOBAL-BINDING.tar.xz", + "sha256": "511ef8e6f9d1519886a8a531d788af6ef51bfcf684172a15890895f66dbcf308" + }, + "projection_sha256": "5731ce226b0d741d99e3707f0a6b071e202bd6a0448ce990ff346eb80b1001d8", + "release_inputs": { + "base/work/complex-nine-native/DATA-PHASES.json": { + "bytes": 814141, + "canonical_bytes": 814140, + "canonical_sha256": "26b10fbdc7a78542ed32d36aab685e60c3f0384c2c85cdb2282a4a72bffe324d", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + "hosted/ACTUAL-SIGMAS.json.gz": { + "bytes": 375537, + "canonical_bytes": 6336476, + "canonical_sha256": "6ebe29463a27adfa3b26c9e4327cd37c69ec25558cd53c3add82ec9d660a203e", + "sha256": "91f9cc167ab0664f46986da40dd491664e394e0128059fcc81d46a5b50bb61eb" + }, + "hosted/GLOBAL-TEMPLATE.json.gz": { + "bytes": 27378930, + "canonical_bytes": 251418003, + "canonical_sha256": "26aa499f91a2b50daa65579859ca00629161e25ea5d0ee23d9ce89f2bb138f04", + "sha256": "efb1e73b7e08849d47e3bd2149d652eaa9d7305c1f7fdf896027ed5d84106c1a" + } + }, + "role": "Complete global physical dispatch rebinding, preserving primitive and root contracts", + "route_count": 1146, + "schema": 1, + "source_sha256": { + "research/physical-complex-controller/PROOF.md": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "research/physical-complex-controller/cover.py": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "research/physical-complex-controller/selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "research/t74-physical-layer/binding.py": "bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057", + "research/t74-retuned-physical-layer/PROOF.md": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f", + "research/t74-retuned-physical-layer/active_plan.py": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e", + "research/t74-retuned-physical-layer/active_root.py": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7", + "research/t74-retuned-physical-layer/active_sources.py": "599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49", + "research/t74-retuned-physical-layer/retuned_machine.py": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a", + "research/t74-retuned-physical-layer/retuned_native.py": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc" + } +} diff --git a/research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md b/research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md new file mode 100644 index 000000000..d7a349cc4 --- /dev/null +++ b/research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md @@ -0,0 +1,317 @@ +# Pooled physical binding and the retained actual-width root + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +The underlying controller, scalar, Compact and actual-width root arguments are +Jose Manuel's credited source work. The borrowing words and pooled owner fill +retain their native-source attribution. This note supplies a changed-source +binding and its quantified extension; it does not independently reprove every +retained primitive theorem. + +## Claim and precise premises + +Under the retained completed ordinary, Compact, scalar, Gaussian-leaf and +physical controller contracts, and this package's admitted native all-column +operators and complete chronological whole-family allocation, the pooled +supplier has a source-relative fixed-tape realization with the actual-width +root bound + +``` +time O_(q,b,B,source)(V g^0.99827 log p), +occupied/visited space O_(q,b,B,source)(V)+F_q. +``` + +Here `q=213*2^80+1` is the retained source-admissible prime; `p>=2`; +`1<=g<=floor(p^(997/1000))`; `K=floor(g^(1/500))`; `0<=rho(Y,-X)`, and the final correction computed from output-coordinate row +weights. The complete event inventory has 3,240 local, 3,600 idle, 3,240 bridge, +360 terminal-Y and 360 terminal events, plus the empty bank-padding sweep and +one final live-family correction. There are 1,575,720 subgroups per cover. +Six corruption controls reject duplicate owners, a wrong provider width, +a misbound private Z family, missing/duplicate call dispatch, wrong provider +dispatch and a missing pending idle axis. + +## All cover labels and all widths + +Put `Gamma=|O(73,2)|` and `L=322560 Gamma`. The source's exact cover rank/unrank +is a finite-control function: dimension 73 and the entire cover are fixed +before an input. A Python loop is not being charged as a free machine action. +The retained proof compiles these bounded labels and source tables into +finite control and pays all encoded width, extent and payload operations. + +For common cover element `d` and owner chart `sigma`, the physical family key +is `g=d sigma^-1`. The class stores the inverse chart as `sigma_columns` and +uses exactly `rank(d sigma_columns)`. Each chart is orthogonal: helper charts +are permutations of the complete orthogonal port basis; data charts are +checked finite orthogonal matrices. Right multiplication by `sigma^-1` is a +bijection of the full cover. Thus every whole family is addressed exactly +once during its complete cover sweep, and distinct owner families never +alias. This is a proof for every cover element, not an enumeration of Gamma. + +The unchanged local group enters the common view by `P_d^-1`, applies the +actual data Pauli alignments, runs the correct source provider/orientation, +then applies exit alignment and `P_d`. The local all-width refinement in +PHYSICAL-BRIDGE.md and the admitted native operator theorem identify this +complete group with the desired caller operation, including every helper +residual. The retained idle and terminal formulas then identify the entire +chronological global sweep. This substitution uses completed child endpoints +and the admitted whole-family availability intervals; a child invoice alone +would not justify it. + +At a node of width `e`, the unchanged PR3599 transition stops at `e<73` or +`e^(10^6)Q0` still implies `K>3G` and +`3H= s+E. +``` + +It also verifies that a coarse full subgroup/instruction/scalar allowance, +including all common-view adapters, is below E. Monomials, zero checks and +copying add no Gaussian coefficient height. The retained prefix induction +therefore gives `A(e)<=8e` at leaves, +`A(e)<=A(48f)+sf+E` internally and `A(e)<=2B0 e`. The original working grid +`Delta=2^210000 g`, `h=p+2Delta+3` still covers all exact halves and signed +prefixes. Since `g<=p`, this is a fixed constant precision expansion. No child +is rounded. The retained normalization and final truncation give the endpoint +and error stated above. + +The local inventory remains 632 persistent plus 99 private packets, hence +731 local roles and the same fixed `2q^2+100696842` tape inventory as PR3477, +plus its borrowed caller ports. The larger global constants increase the +encoded finite header from 2691 to 2695 bits, not the number of tape roles. +Each local group has at most 31,632 instructions including view/Pauli adapters, +within the unchanged 65,536 program-counter limit. There are still 751 role +delimiters per saved frame plus its frame delimiter and 18 encoded descriptors. +The parked-payload sum is bounded by + +``` +4 (1+731/L) V/(1-1/L), +``` + +before the fixed current/replacement/output copies. The full one-active-branch +proof and the long-record payment give occupied/visited space `O(V)+F_q`. +Blanking an emulator tape does not assert deallocation of its historical host +list capacity. + +## Strict moment and the improved physical layer rate + +Use the exact rational choice + +``` +sigma=0.99826995, alpha=0.99827, eta=10^-6. +``` + +`rate_certificate` re-evaluates the full histogram with the independently +written rational logarithm/exponential enclosures in this package's pinned +`joint_bound.py`. It obtains a strict negative interval for + +``` +mu_sigma - 1 = sum_r N_r (r/73)^sigma / 322560 - 1. +``` + +It verifies `tau=g^eta`, its total bill is + +``` +O(V g^(sigma-eta*(sigma-tau)) (log p)^tau). +``` + +Stopped leaves cost +`O(V g^(sigma+eta*(1-sigma)))`; their exponent is exactly +`0.998269951730051/580`, leaving a positive margin +for the remaining logarithm. The complete integer proof pays three Gaussian +calls, three CRT conversions, ordinary word products and all recovery work. + +The stronger legacy arithmetic candidate `0.001727989140903569` is preserved +in [RECURSION.md](RECURSION.md), under its separate uniform-interface premises. +It is not the bound proved by this physical outer composition. The optional B2 +ordinary-stage calculation is maintained separately; this package and `1/580` +use B1 and do not depend on B2. + +## Reproduction and evidence + +The recorded full finite run passed all active-provider, operator, +ordinary/strict/outer and source-reuse gates. Its strict controls covered 160 +admission, 34 controller, 12 BIT, eight independent-owner and six geometry +cases, plus fourteen reuse challenges in each Python mode. Fresh FOUR-extra +native execution and inherited admission took about 32 and 995 seconds. +Those are verifier timings, not multiplication speed measurements. + +Registered bounded checks require only Python 3.12's standard library: + +```sh +python3.12 -B scripts/research_package.py --package research/complex-pooled-full-admission +``` + +The manifest runs normal and optimized checks of the finite adapter, +source/evidence bindings, local/global physical programs, exact outer +normalization/recovery and constructor/cohort adapter. +It does not repeat the heavy complete release, instantiate a production-size +native tape inventory or certify an all-parameter theorem by enumeration. +[PACKAGING.md](PACKAGING.md) describes lossless receipt decompression, the +unchanged historical commitments and reuse of canonical pinned inputs. +Direct commands in `VERIFY.json` also work in the committed Git-free export; +the generic metadata runner itself requires Git provenance. + +To reproduce the complete finite admission, use Python 3.12 with +`numpy==2.3.5`, `scipy==1.17.0`, `sympy==1.14.0`, `mpmath==1.3.0`, and a fresh +output directory outside the checkout: + +```sh +python3.12 -B research/complex-pooled-full-admission/replay.py --work /tmp/pooled-complex-full +python3.12 -B research/complex-pooled-full-admission/joint_bound_inputs.py \ + --release-work /tmp/pooled-complex-full/replay --output /tmp/pooled-joint.json +``` + +`replay.py` derives the registry adapter with 21 checked literal replacements. +It preserves every inherited scientific predicate and executes the unchanged +local-word, owner and all-character gates, changed-fill operator check, source +reconstruction, active FOUR native execution and full admission engine. +Retained THREE products use authenticated scientific-output commitments. +No historical pass flag substitutes for the new complete release. + +The complete engine requires assertions and refuses optimized execution. +New bounded checkers use explicit exceptions and have optimized replays. +Optional `--checked-preflight PATH` and `--four-native-extra PATH` reuse must +pass the same complete source, stage, output and semantic commitments; default +execution performs those stages fresh. Keep scientific source and reuse trees +stable throughout execution. Import hardening is not a concurrent-filesystem +security guarantee. + +Local/global bundles are complete for their bounded checks. The outer source +bundle contains exact proof/constructor references, not all transitive runtime +archives. `outer_factory.production_consumers()` requires the complete pinned +PR3935 Gaussian package and canonical CRT package plus an already active, +authenticated Gaussian cohort. [OUTER-DOMAIN.md](OUTER-DOMAIN.md) specifies that +interface and the observed archive compatibility. Its bounded checks exercise +source/class/token contracts; they do not instantiate or execute the full +production construction. Pending-source bytes needed for bounded verification +are retained locally; their recorded commit IDs do not require an unmerged +Git object to be available in a fresh checkout. + +## Open next questions + +* **Independent scientific admission of the complete conditional proof.** + Review the actual native/hosting, physical refinement and analytic premises, + then follow the global root through `OUTER-JOIN.md`. Start with the exact + source contracts and recorded full release. The blocker to selected-frontier + promotion is independent mathematical admission, not another root enclosure. +* **Production implementation evidence.** Exercise the explicit factory and + integer wrapper on a source-admitted instance if feasible. Begin with the + exact record formats and complete output-consumption contract; do not replace + the eventual production domain with the Gaussian p48 diagnostic. The fixed + compiled inventory and enormous asymptotic crossover limit practical replay. +* **Tighter physical saving.** Admit a faster ordinary backend, then repeat + the actual stopped-tree and complete outer costs. Stronger finite/legacy + arithmetic values do not supply that construction. + +Structured next steps and their blockers are retained in [TASK.json](TASK.json). diff --git a/research/complex-pooled-full-admission/RECURSION.md b/research/complex-pooled-full-admission/RECURSION.md new file mode 100644 index 000000000..898eae117 --- /dev/null +++ b/research/complex-pooled-full-admission/RECURSION.md @@ -0,0 +1,395 @@ +# Joint bound and the exact conditional boundary + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. + +This note prices Rohan Arun's PR4181 pooled fill using Cinna Davis's PR4088 +words and yssite's PR4180 admission architecture. It supplies a complete +profile comparison, a source-bound joint arithmetic certificate and the +conditional recurrence implication. It does not turn finite admission into +an unconditional multiplication theorem. The completed release and its actual +invoice must be bound separately; `joint_bound.py` reports that distinction. + +This note preserves the finite and legacy arithmetic branch. The later +source-specific physical binding and conservative `kappa=1/580` composition +are proved separately in [PHYSICAL-GLOBAL.md](PHYSICAL-GLOBAL.md) and +[OUTER-JOIN.md](OUTER-JOIN.md). They retain explicit source/analytic premises +and do not certify the stronger legacy number in this note. Statements below +about gaps left by finite arithmetic refer to that arithmetic, not a claim +that the companion physical work is absent. + +The scientific base is `12fa8c5c844be21bfefb38a19503fbd867a11244`. +The consumed PR4181 head is `4ed92bed95dd483f5662e98ef246b258c3cfe64f`; +PR4180 is `15a4153e734a8d1d485c6d3bea9b1a8201328a4c` and PR4088 is +`72d7efc181edb21806a878f174847c96dd410ab0`. Frozen files retain their +original attribution. Historical statements below keep their original +compiler, exact-return and cost assumptions. + +## 1. All local returns and idle children + +The complete local profiles, including the rederived inverse cleanup, are + +``` +L3 = 2487 H1 + 713 H2 + 224 H3 + 102 H4 + 20 H5 + 8 H8, +L4 = 2489 H1 + 713 H2 + 227 H3 + 99 H4 + 20 H5 + 8 H8. +``` + +The pooled selector uses FOUR at chronological ticks `t < 1080`, then THREE. +It uses three active provider IDs, with counts +`gauge44:1568, extra:592, extra-four:1080`. The fourth local word +`gauge44-four` is available in the inherited four-word catalogue but has no +call in this selector. An active registry must reflect this actual dispatch; +the four-word catalogue is not four positive provider multiplicities. + +The literal fill supplies every one of 1,321,920 helper roles in 725,760 bins, +with complete idle profile + +``` +I = 22788 H3 + 1620 H5 + 138492 H48. +``` + +Thus `H = 2160 L3 + 1080 L4 + I` is exactly + +``` +{1:8060040, 2:2310120, 3:751788, 4:327240, + 5:66420, 8:25920, 48:138492}. +``` + +Its rank mass is 23,431,680 = 65,088*360. The ambient dimension is 73, +the live stock is `W=896*360=322560`, and the deficit is +`73W - sum rH[r] = 115200 = 320*360`. Every child has rank at most 48; +`73^2=5329 > 2*48^2=4608` supplies the inherited two-level halving guard. + +These identities do not replace the chronology or operator proof. The owner +walk must use the selected width at each call, and the all-character phase +and observer audit must run on this new fill. The old arithmetic selector's +operator receipt cannot certify changed owner axes. Completed local calls +restore arbitrary ordinary helper inputs; the 91 allocated private work +buffers, eight centers and coefficient workspace also need their explicit +return/clear contracts. Private owned-zero work is a distinct resource from +arbitrary dirty helper input. + +## 2. Strict profile improvement for every relevant power + +Against PR4088/PR4180's complete profile, the old cost minus the new cost is + +``` +20 H1 + 25 H3 - 30 H4 + 5 H5. +``` + +This is the difference after including idle compensation. It has rank mass +zero and removes 20 complete children; a local rank calculation alone would +not establish it. For `p=1-a`, its power bill is + +``` +5 * 4^p * F(p), +F(p) = 4 * 4^(-p) + 5 * (3/4)^p + (5/4)^p - 6. +``` + +The sum of exponentials is strictly convex, `F(1)=0`, and + +``` +F'(1) = (15 log 3 + 5 log 5 - 24 log 4)/4 < 0, +``` + +because the exact integer inequality `3^15*5^5 < 4^24` holds. Hence for +every `p<1`, strict convexity gives `F'(p)F(1)=0`. +In particular the new complete profile has strictly smaller moment for +every `0 10^-24`: the old BIT supplier is +strictly above even the new complex root's upper endpoint. No replacement +by PR4183 is needed. Its newer logical `p=1` result does not automatically +satisfy the stronger primitive, physical and outer hypotheses used here. +Replacing only BIT while keeping the selected complex endpoint leaves the +selected assembly unchanged; the certificate includes that rejection control. + +## 4. The full recursive implication and its costs + +Assume the completed native complex supplier acts on arbitrary full payloads, +with exact restored source and spectator coordinates, and that its dispatcher +realizes every rank-r call once on `1/W` of the parent volume. At integer +width `e=73f+t`, first handle `0<=t<73` remainder axes with paid elementary +operations, then recurse on widths `rf`. There are no same-width children. +The finite depth bound + +``` +D(e)=0 for e<73; otherwise D(e)=1+D(48 floor(e/73)) +``` + +is monotone and `O(log(2e))`. Supplying rows divisible by `W^D(e)` permits +all branches, including unequal leaf depths. The inherited full cover/physical +implementation must supply the corresponding group and private reserves. +Rows are padded once at the outer boundary and may be removed only after +their pointwise return. The normalization by live `W` is not permission to +omit the larger physical stock. + +For elementary local toll, `F(e)<=sum_r H[r]F(r floor(e/73))/W+K` and +`mu_c(a)<1` imply `F(e)=O(e^(1-a))` by strong induction. Floors only shrink +the power majorant; monotonicity of the actual running time is unnecessary. +This elementary recurrence is not the whole outer layer. With compact +operations supplied by ordinary BIT at exponent `tau`, complex moment +exponent `sigma=1-b`, and stop width `d^theta`, the unequal-width weighted +tree argument gives + +``` +internal exponent chi = tau+(1-theta)*max(sigma-tau,0), +leaf exponent = sigma+theta*(1-sigma). +``` + +Complete cost retains both terms, compact field/row preparation, finite +routers, all scalar and coefficient work, source access, descriptors, rewinds, +COPY/CLEAR, parent bridges, private work, stock and precision. The inherited +strict layer inequalities require both exponents and the preprocessing +exponents below the chosen layer exponent. An exact finite child word alone +does not establish this input-size recurrence. + +For this source family the complete physical inventory is +`322560+408+8+91+2=323069`. The expected bound is a 2,646-bit complete +physical stock, actual local prefix 95, block depth 18 and stock l2 exponent +1323. Therefore the full prefix is `95+37+18+1323+1+4=1478`, charged at +2048 bits. The physical row coefficient is 19549, below 20161. These are +source-bound invariants to be freshly checked on the pooled release, not +automatically inherited receipts. The finite invoice also retains `G=2^30000`, +`E=2^100000` and `C0=2^210000`, with the actual scalar, coefficient, wrapper, +adapter and router counts. The parent driver executes their original guards; +the optional receipt binder cross-checks the actual new invoice and sums all +3,240 selected calls independently. + +An exact completed child preserves the required return lattice. Substituting +rounded children requires a separate error/cleanup theorem: approximate +subtraction does not prove an exact private ERASE or exact helper return. +Likewise a finite group cardinality and a finite invoice do not construct a +uniform physical address generator or prove its tape tariff. These remain +the explicit all-size hypotheses. + +## 5. Two different outer maps + +For a comparison using the selected PR1094 parameter convention, let + +``` +eta=beta=10^-24, +s=min(B,(1-beta)C)-10^-27, +a0=384599/10^10, +a_(j+1)=s(1-s)+s a_j, j=0,...,6, +q=(1-2 eta)a7. +``` + +The largest `10^-18` grid point strictly below `(1-eta)q/(1+q)` is + +``` +kappa_legacy = 0.001727989140903569. +``` + +The exact ceiling is approximately +`0.0017279891409035694232259263143154912346868927440763`. +The same independent formula reproduces the selected +`0.001672660197076918` from its actual complex endpoint and BIT endpoint. +The candidate's gain is `0.000055328943826651` over that selected number, +and `0.000000001136380736` over PR4088 under the same map. This comparison +requires the new supplier to pass the original finite invoice and a fresh +instantiation of the inherited all-size contract. The named contract is the +same, but the selected review does not establish it for the changed source. +Section 7 makes this quantifier distinction explicit. + +The modern PR1786/1758/2180 lineage uses a different analytic construction: +fine source-prime padding, gauge-free interiors, a radix-distributed union +schedule with paid per-visit tags, and the explicit Strassen boundary +`tau=45/16`. It retains additional proof premises beyond the selected map. +For endpoint precision 24, its exact parameter algebra is + +``` +r=10^-104, delta=(1025/1024)r, +epsilon=1-delta, beta_outer=1-3delta, +b=C-r, q=C-2r, a=(b+q)/2. +``` + +Since `0=36`, `L_j gap_j>=2(4+ell_j)`, and propagate +`ell_(j+1)>=max(PAYLOAD,ell_j+ceil(L_j(a_(j+1)-a_j)))+1`. +For finitely many positive gaps those cutoffs exist. This is a conditional +existence argument, not a claim that the retained twelve-stage executable +receipt is a 38-stage replay. It relies on the same uniform-cost theorem. + +The parent release must run all 63 modern strict ledger inequalities and its +17 controls, together with the ordinary admission and all 47 retained legacy +rows. Arithmetic cannot prove the fine-prime, conditioning or physical +implementation lemmas. Root-as-kappa is valid only under these named modern +premises and its strict margins; it is not the selected `a/(1+a)` map. + +## 6. Evidence and permitted conclusion + +Without `--release-work`, the certificate reports +`PASS_JOINT_CONDITIONAL_ARITHMETIC_NOT_SUPPLIER_ADMISSION`. +Its six controls reject missing idle children, using the root as the legacy +kappa, omitting modern padding, a BIT-only joint gain, omitting the BIT +fallback, and the old profile claimed at the new root. + +With `--release-work WORK`, it requires the completed ordinary and release +statuses in `WORK/admission`, exact new selector and profile, complete native +surcharge models, both outer ledgers, actual restored columns, complete call +cost sums, stock and precision reserves. It records hashes of those actual +files and reports that they are bound. This extra check does not re-execute +the parent engine or replace its source/log/product authentication. + +After the parent driver completes and binds the full new release, the +permitted result is a **fully invoiced finite conditional kappa improvement** +at the stated historical mathematical interfaces. The new integration credit +is admission of PR4181's already-published fill; its root and construction +remain attributed to PR4181 and its predecessors. No selected-frontier +change, unconditional multiplication exponent, formal-kernel proof of the +whole algorithm, or independent human review follows. + +The finite calculation itself leaves uniform native/source generation and +common-label lifting; arbitrary-input whole-call hosting with exact return; +the common fine-grid precision and exact cleanup contract; physical tape +routing, stock and live-storage bounds; the original BIT H1-H5/ordinary +bootstrap; and the chosen legacy or modern analytic transfer theorem as +separate proof obligations. +PR4183's logical BIT admission alone closes none of the missing complex/outer +obligations. A rounded-child implementation would need a further theorem; +the exact recursive-return model used here does not assume one. + +## 7. Inherited hypotheses versus their new source instance + +The selected review is specific about its scope. In +[`community-batch1099-review.md`](../../docs/research/community-batch1099-review.md), +the construction review admits twelve owner refinements on the **same** +seven-slot local word with the unchanged strict T16 compiler. Its independent +owner and pricing audits extend their tested input, not their inherited +interface scope. The final paragraph leaves all-size compilation, +common-label/mutable-source realization, whole-call hosting, precision/tape, +exact recovery, analytic transfer and BIT H1-H5 conditional. The selected +construction already permits mutable-source cells; allowing such cells is +therefore not by itself a new hypothesis here. + +Let `S0` be that selected source and `S1` the present pooled source. Separate +the following obligations: + +* `F(S)` is the finite word, native operator, chronological owner, controller, + complete profile, stock and invoice certificate for that actual source. +* `U(S)` says that, for every recursive width and admissible full payload, + the emitted source and its common-cover charts have the declared exact + completed-child action, pointwise source/spectator/helper return, legal + private work, and uniform physical implementation within those invoices. + It includes the address generation, routing, copying, storage lifetime, + common-grid precision and tape costs needed to realize the recurrence. +* `B` is the unchanged selected BIT/ordinary-primitive and H1-H5 contract; + `L` is the retained legacy analytic and exact-recovery transfer. + +The inference used in Sections 4 and 5 has the form + +``` +F(S1) and U(S1) and B and L + imply T(n) = O(n (log n)^(1-0.001727989140903569)). +``` + +The full release establishes the finite evidence `F(S1)`. It does not prove +`U(S1)`. In particular, `U(S0)` is not logically `U(S1)`: a theorem only about +the selected word cannot be transferred by changing its profile argument. +If the inherited compiler hypothesis is stated universally for every legal +finite source in this class, `U(S1)` is an application of that same unresolved +hypothesis. If it is stated only for the selected source, its scope must +explicitly be extended to `S1`. These are the same *kinds* of mathematical +interfaces, with a newly required source-specific instantiation, rather than +a proof that every unresolved obligation is byte-for-byte unchanged. + +The changed instance includes the three active provider programs and their +fixed 3,240-entry selector, the new owner-axis embeddings, the 91 allocated +private buffers and their exact clear/return rules, and the larger complete +physical stock. PR4088's +[`PROOF.md`](../staged544-mixed-fourth-entry/PROOF.md), Section 3, explicitly +requires its uniform implementation hypothesis to cover the finite mixed +selector and all four catalogue words. The pooled selector uses only three; +this does not remove the implementation obligation. The native/all-character +identities and [operator proof](OPERATOR-PROOF.md) establish the declared +algebra and tensor-phase lift, while their common-cover physical embeddings +and recursive invocation contract remain conditional. The fixed selector +adds no width-dependent exceptional residue class; the pure complex moment +still requires PR559's uniform exact-cover premise. + +There is no additional rounded-child premise hidden in the legacy conclusion. +[`three-stage-cover-assembly.tex`](../../notes/three-stage-cover-assembly.tex) +requires every completed child to be the exact Gaussian-dyadic tensor on all +roles, preserves the incoming odd-denominator exponent and explicitly forbids +rounding at recursive returns. The borrowing lineage's +[`PROOF-LOCAL.md`](../selective-borrowing-outer-retune/vendor/pr2260-selective-borrowing-kappa/PROOF-LOCAL.md) +retains that contract: tensor phases scale with multiplicity, dyadic Horner +arithmetic is exact, and only the completed outer layer truncates. Its +active-depth bound is + +``` +A(e) <= A(48 floor(e/73)) + s floor(e/73) + E, +A(e) <= 2(s+E)e, +A_layer(d) < 32*73*(s+E)^2*d. +``` + +Here `s` and `E` must be the freshly invoiced complete quantities for `S1`. +The release checks the finite guard against `C0=2^210000`; uniform realization +of that common grid and its cost remains in `U(S1)`. Replacing exact children +with rounded approximations would require a separate conditioning and exact +cleanup argument and would not follow from this conditional saving. + +Thus the legacy comparison needs no new BIT theorem and no modern +fine-prime/union-schedule transfer. After full finite admission it gives a +strictly larger conditional exponent under the inherited contract schema, +explicitly applied to the new source. It does not complete the unresolved +uniform recursive implementation or establish an unconditional kappa gain. diff --git a/research/complex-pooled-full-admission/SOURCES.json b/research/complex-pooled-full-admission/SOURCES.json new file mode 100644 index 000000000..af0322f7a --- /dev/null +++ b/research/complex-pooled-full-admission/SOURCES.json @@ -0,0 +1,1794 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "notes/three-stage-cover-assembly.tex", + "usage": "provenance", + "git_blob": "983ffb6ac8fb9117360cd0797c00c05dfa071c9d", + "sha256": "ccf34a6d37c4af14bebeab15be50ab204eb1caebe546385520050ec30089441d" + }, + { + "path": "references/semantic-bulk/rad20/LICENSE", + "usage": "provenance", + "git_blob": "0e259d42c996742e9e3cba14c677129b2c1b6311", + "sha256": "a2010f343487d3f7618affe54f789f5487602331c0a8d03f49e9a7c547cf0499" + }, + { + "path": "references/semantic-bulk/rad20/NOTICE", + "usage": "provenance", + "git_blob": "544634f5f3001c50330413f22dc0070e07c46738", + "sha256": "82fc72aff49769ae82a8ce886846d9bd0601827a09c955042d26a61177d14369" + }, + { + "path": "references/semantic-bulk/rad20/reports/review-reusable-banded-inverse.md", + "usage": "provenance", + "git_blob": "de7a916369cc36737fd96b9b0172e2ef453c6b03", + "sha256": "801359569c92f9d5ddd128b694993a5ac22a468e87bfea478cecc0ee413d058b" + }, + { + "path": "research/bit2234-stock-threshold/README.md", + "usage": "provenance", + "git_blob": "ede0d322c477af91d4c2cc33db0fd10958f45eab", + "sha256": "1e050c9f963421d751d9208092f9a15321ed77810e03912df8eb5eb56bbb06e7" + }, + { + "path": "research/bootstrap-depth-audit/sources/pr387/PROOF.md", + "usage": "provenance", + "git_blob": "915d08efd81fa304e1974e26d8212803e03e6623", + "sha256": "15997b908604d124d688482db46e58da3117ecf1c176597afb1556a767c073d8" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL-TEMPLATE.json.gz", + "usage": "provenance", + "git_blob": "9eafb8776cbf78c72124f833534469ddfa5e98ec", + "sha256": "0357b7cfbd7c29b4983982baf153c8a9f1e1e412690cd7fa9fc3d23d7963b20f" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/hosted/GLOBAL.json", + "usage": "provenance", + "git_blob": "1f648db9e63e7bfcaa6d5b1dd9fa6503caac47d2", + "sha256": "8de008a7978d4b7189cbec2470443619149a2b7b2f0f862540eeee4b23d3a819" + }, + { + "path": "research/community-hyperplane599-audit/pr589/bit589/v9/nine/GEOMETRY.json", + "usage": "provenance", + "git_blob": "44006542202ca6037533a754f0bcd00549d7e088", + "sha256": "0058c491d839142aa99ef86a5ec697ce99857632228531512ea3fa74fb24d734" + }, + { + "path": "research/community-round8-audit/pr185-proof-reviewed.md", + "usage": "provenance", + "git_blob": "93a588a73a38050dfa0a383cb44f228aff6f243e", + "sha256": "bbac6ec77f315dd76324f4595b8c7a9b0ec719f3903d0c56c61f23990326e8fa" + }, + { + "path": "research/complex-multicold/vendor/pr559/PROOF.md", + "usage": "provenance", + "git_blob": "9adf304048b62c6db9250a611a8d4b0b60ed8276", + "sha256": "d5d498edc56fdef8c5798af7f5ec66948bd2f66c553b9efe366cdaab01bd3453" + }, + { + "path": "research/crt-address-streams/NETWORK-SOURCES.json", + "usage": "provenance", + "git_blob": "efd965ec0f01c8ba176c0a7fdffb9494fdda704b", + "sha256": "c843e86f64902c63cfbac72b7d743ae628abd430ba3987a0b8c6254de3b9b22b" + }, + { + "path": "research/crt-address-streams/PROOF.md", + "usage": "provenance", + "git_blob": "479a2b727b67b88efc8bdc64bde340a1c0d95ec3", + "sha256": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4" + }, + { + "path": "research/crt-address-streams/SOURCES.json", + "usage": "provenance", + "git_blob": "47203dc21d58da7a844aa43f3f5ba72ece13c41f", + "sha256": "96b3228ee210e10c9f6c597061eec79917d28c1dc31173842d803b72b672493b" + }, + { + "path": "research/crt-address-streams/crt_converter.py", + "usage": "provenance", + "git_blob": "eec21ef3e629abb5d9b21f9ea09a1cbd3655daa4", + "sha256": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea" + }, + { + "path": "research/crt-address-streams/crt_shape.py", + "usage": "provenance", + "git_blob": "23b6cd3fecdb8c5ec1bd7ec2637679efcf20c22a", + "sha256": "4073253569e5941de30e26b9ed83b9f1fcdb2c186b20123c7757f2edd7e2153a" + }, + { + "path": "research/crt-address-streams/crt_sources.py", + "usage": "provenance", + "git_blob": "fa0effe0bc5c34ae560bc045fdf4470840b028a7", + "sha256": "6a7e28fb2b3584a382ddec57902fcdd963d3af7c241a4541023666aba7f3d140" + }, + { + "path": "research/e8-bit-p111-tuned/tune/EXPECTED.json", + "usage": "input", + "git_blob": "e293ddc557742637f9f679f083a1a282d87b1b13", + "sha256": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4" + }, + { + "path": "research/e8-bit-p111-tuned/tune/bitE8mut-p111-tuned.json.gz", + "usage": "provenance", + "git_blob": "85a4499bf9e4911a705d50567a2c2ef6cf23739a", + "sha256": "e3e301e62bc2b41dbf1ceac0acf3d35824ebeab1848c5a2142d4577b109da52f" + }, + { + "path": "research/idle-axis-hosting/PROOF.md", + "usage": "provenance", + "git_blob": "4468a00349b4f68dce103e785a8392099435e1d6", + "sha256": "cfe34bf0b64259661312dae22c3a23adc5bf6f6326951eee5c1488ccfc347542" + }, + { + "path": "research/kappa-adaptive-continuation/admission/receiver_share.py", + "usage": "input", + "git_blob": "0f1491d8c6df7b59e55ba71230daa2d54447e9b3", + "sha256": "6ef3255e91f42cb78eb194c761c02568e0230a9cfab40387f257d7a4bd38ccc4" + }, + { + "path": "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "usage": "input", + "git_blob": "dcc11d429ce0aef7aa9700a9c31994c8a77e1dfe", + "sha256": "bbf28e17a657b8d1eaf63f33d811682720afb393ee2ab9a4bb46661fef1ed996" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "usage": "input", + "git_blob": "ded4702868432d304851486f602a8db0d57f6fbc", + "sha256": "4f6185125ddb38b7ab02a349829aae434e7707e804ca8c6c4ab8c086cd63635e" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "usage": "input", + "git_blob": "086fb580b25d533570b50dfd1f806e8309d5e4ea", + "sha256": "30a39a3612efde96a0db189c14053afe5e012e56de1a89863596a078a8b64381" + }, + { + "path": "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "usage": "input", + "git_blob": "5e45113fdc6eaf8d4a07aa1f7c0f9b3b6991ca1c", + "sha256": "e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "usage": "input", + "git_blob": "1614c1c40d4804cf70d3c4a90896d20c261f59a1", + "sha256": "e0a3f13504304147f4049757016a494c15beda82ed751439f05039f88a0dd891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "usage": "input", + "git_blob": "9d585f31444582f3254f8e10e8f76ba5224b4508", + "sha256": "31896a06049f951fc25db1338888a743c1c73cf1a6c44212dbc21789ceaefeb0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "9dcdc26825cf00d00ab7420156a747d4279c3bb3", + "sha256": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "7f9a60816cdc2717d0c392de4496b28e675d50c4", + "sha256": "1b9167ef68707cddad4b781e37858cfb5205d377670365019b8de26fceeb1891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "8eaa8cd45ee42162008586bc72e3ca8164f16be1", + "sha256": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "04d1e367f4e96770b5bde9b84fd5369633a6f5a1", + "sha256": "23163ff2f94a4920e5fca35fb6f0de108f710e7b09cc13e7c2796ad693a2b497" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "9e3afae3bc1dff0b5a12a87ba8b13aa003cb1219", + "sha256": "7e3bb0f46320f243cd89c97c60af5b29ac82a79293463afae5a178f8938ebda0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "usage": "input", + "git_blob": "c93596421fdbf2c41e524eb1c0c7660f58cc362d", + "sha256": "0bad75c89a69637a1c9b98824da183243c584e07e0eb76ce986420384a7246c8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "3a8e83134093221f7e7676ae4d432ef858856885", + "sha256": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "0b69f5f67e2e26f531c6685db8da43ee911eb347", + "sha256": "753c950d3273bba4e7ff560000d84aaf928d24448e899e6f75e0166b7989f508" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "5ecdb02d3da25d5854be7574cdd53bed2d286ac6", + "sha256": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "4dde678a2fd312ed567404cb21f757a248217acb", + "sha256": "9100f0387118988d81fa47740d4bd47892b13400c36ea63d43cbe4aeba38a4a1" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "077da2ebaac823cd7b69568d265652496cf2fbd1", + "sha256": "e037ea86e1e2902d6c03885ae8e332e4afe48d27d6200923b9c71498b12953d3" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/run_release.py", + "usage": "input", + "git_blob": "a14a26a95e02899b05d61a510e86ee461614e2d5", + "sha256": "262e914eca3d0e97567786fe94cb25fb1698c52e08785fd4a2581020c4af26dc" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "usage": "input", + "git_blob": "492998766fc9aedfa1f1c0c337b2d4abe10ab707", + "sha256": "6f6b5adccb29d29a4b7890c91180a7ecd9f54ee04007cf9e0ea06fbea42b5c0e" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "usage": "input", + "git_blob": "1c96d298a534aa98325592a9487fea79aebec596", + "sha256": "727691274be6f91059c763dfa8206f7bca4516c5acf4703da403789a49b5e1e7" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "usage": "input", + "git_blob": "e45a06597117509656383c7ac3c49c1c0620b93b", + "sha256": "4b6b1ac15742264f1d6d8047d975fd5d05fc63db61358b3bacf1c1c47ee71428" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "usage": "input", + "git_blob": "fda8edb01adffae448457341f10ea0a73848079c", + "sha256": "8bdda4822009d6e5f1d6bd948a8f89154780a5721dca366c56deb75019bb268b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "usage": "input", + "git_blob": "ee1f16607ca4b5dc29321483e9a5dc63371085be", + "sha256": "69bbfc0414324593e98112af7a8db6549315badb8aa7adb5ca05419214849c56" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "usage": "input", + "git_blob": "5ea426d4983e1f70b23f451d7d3f29a93aabcf56", + "sha256": "fff028de30e9fb06d6d75efc6fdd6e94ead6a88823efa07d3e7cd177dcd94acd" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "usage": "input", + "git_blob": "dcc0374b5c822d544a4ecf19d00635c7117d82c9", + "sha256": "8159c67d29ab58efe546ebc4ce20872421996cc71b5f17737ff8b36cbc76d148" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "usage": "input", + "git_blob": "990c54caeeb4fb344de622de98d97e107ec67ed5", + "sha256": "0147e6b30ef328e227e89113323eb0d02d116e125b0e7c99a00ea4f2652dcc80" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "usage": "input", + "git_blob": "f67031d3e12f7ca91075ba2b2fdeeb99a3de5873", + "sha256": "00071bc2e54bf5fd05a6aac9292a3861087e72898d86d1f6f7bbda65b07cfbda" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "64bcb35908f140bec80c73a2f4ba429be14ae225", + "sha256": "6e2f3ef76d90086784db92a7e3b0ac23893dd60750effe79287fa59c48b6bc99" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "faf479d61f57b88ced9b434d188a31f6ca5c3f2c", + "sha256": "e92568c62db0f220096870c2a01cd8c313497953bc9cff5f2c087fe9a6875109" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "usage": "input", + "git_blob": "7dfaaaa1b084e5971e03ce2586fc5d5ddd21c760", + "sha256": "70030e184e9c3d41169cabf5f6a07d6ec10590ce384ebfeabbeba7253d85404b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "usage": "input", + "git_blob": "3ee17a1e5fbdfcdf14a481e35c69ab0a0615e5d9", + "sha256": "dd104d15719ae181fde3d6c93f210b09ddffe0e0ca16b07c85b4ebaf75641d91" + }, + { + "path": "research/lean-common-label-tensor-lift/README.md", + "usage": "provenance", + "git_blob": "d868d426b2d7ebed48cbb0058490626c4ec3ce3f", + "sha256": "5571d08c779eda12ad2871185d5869f3b1dd293e28300f52efb5fabb36c6abf9" + }, + { + "path": "research/physical-chirp-middle/PROOF.md", + "usage": "provenance", + "git_blob": "56b12bd4f0727f333b368ac59839fd4e423b9b9a", + "sha256": "92cccf922e0e79fcffc5b6883812c6c5f162565c926f9d807791f6b850ac0951" + }, + { + "path": "research/physical-chirp-middle/chirp_engine.py", + "usage": "provenance", + "git_blob": "801c8e0ce13ec5aea504004f15f847ecf37add25", + "sha256": "95c74ed419a1d525755542f5d951dc73c841055e018b25c546901b10fc21bd1a" + }, + { + "path": "research/physical-chirp-middle/cyclic_engine.py", + "usage": "provenance", + "git_blob": "4670745b77c117128821160b41863ad9a160b215", + "sha256": "38c37e1176160607f2e0e6912242e65de2a59afbc1ba909acabf099c59fb34c1" + }, + { + "path": "research/physical-complex-compact/PROOF.md", + "usage": "provenance", + "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb", + "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48" + }, + { + "path": "research/physical-complex-controller/PROOF.md", + "usage": "provenance", + "git_blob": "c505caecc7ced19a4efc35c423efedda9427bea5", + "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e" + }, + { + "path": "research/physical-complex-controller/bank_packets.py", + "usage": "provenance", + "git_blob": "defda707199e8eba83ee483daf5ae7acb642c43c", + "sha256": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477" + }, + { + "path": "research/physical-complex-controller/cover.py", + "usage": "provenance", + "git_blob": "2b9b9df832a747bcb02505d5495f79d38deffa43", + "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da" + }, + { + "path": "research/physical-complex-controller/machine.py", + "usage": "provenance", + "git_blob": "92f9467ffd3346d672a0e2c56f2508e33ed21689", + "sha256": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855" + }, + { + "path": "research/physical-complex-controller/native_program.py", + "usage": "provenance", + "git_blob": "7d1c54c7d1394de28585d48b1a703d4b00069e98", + "sha256": "177d87445659d7ddbef11370d0b4cdc0596732147ed26c1fa11bad16ae53c93b" + }, + { + "path": "research/physical-complex-controller/scalar_packets.py", + "usage": "provenance", + "git_blob": "66ea778399423005695bdea1e43ef9dcde903402", + "sha256": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35" + }, + { + "path": "research/physical-complex-controller/scalar_program.py", + "usage": "provenance", + "git_blob": "30ba678c7b828285d549e923b34e315e439b8452", + "sha256": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a" + }, + { + "path": "research/physical-complex-controller/selected_binding.py", + "usage": "provenance", + "git_blob": "5fe097ff688f5304a45945054e9d4a4af05f13d8", + "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985" + }, + { + "path": "research/physical-complex-controller/selected_source.py", + "usage": "provenance", + "git_blob": "6bdc133472e85d2230d59c91813390b3547caf8d", + "sha256": "02601c9e7d88e58e62d63509ff709c6498a40fbbc0f95fab328379ae6acaa87a" + }, + { + "path": "research/physical-gaussian-core/PROOF.md", + "usage": "provenance", + "git_blob": "883c8d4a6f0eead888fb3532b60db41596940889", + "sha256": "e909026dd3f455c35ff28210a0c4ffa232ad8d7633174e481094fd09e2469d7a" + }, + { + "path": "research/physical-gaussian-expansion/PROOF.md", + "usage": "provenance", + "git_blob": "89642f4740c62460835380a3bfa00f63808009a8", + "sha256": "5452f3e2191824b4a8451c83fbdf58b3b2228f4e1966a6f22c3e60bd152e56b0" + }, + { + "path": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "usage": "provenance", + "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd", + "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53" + }, + { + "path": "research/physical-ring-product/PROOF.md", + "usage": "provenance", + "git_blob": "2bc9926799296bb348193e68e55aed60ec6ce96d", + "sha256": "a2e43fe5f77350958c2d7d66a50389e5ec6b439a7f9620e94862b969e88fb500" + }, + { + "path": "research/physical-ring-product/convolution_engine.py", + "usage": "provenance", + "git_blob": "02e4dd8e612d5d782a7b260b817b25ffd54348a8", + "sha256": "3d9941f986ad27e8b7ae8f46df2dc3a9ae7a2b119a69195735a5c735dc5aba65" + }, + { + "path": "research/physical-ring-product/word_product.py", + "usage": "provenance", + "git_blob": "67e09e91103535fd1eb0b2d7d6db1fdc13de07d2", + "sha256": "12020ed0571fa756c2d19942b6ccdd6dc5627fdaadb388051417a618c14417d6" + }, + { + "path": "research/physical-scalar-stream/scalar_engine.py", + "usage": "provenance", + "git_blob": "aea19253f6a772047f22d2f0e1927b9bf319aba9", + "sha256": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6" + }, + { + "path": "research/physical-scalar-stream/scalar_words.py", + "usage": "provenance", + "git_blob": "36919dc569678656a1696f23454cba2d1fb0f393", + "sha256": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00" + }, + { + "path": "research/physical-synthetic-fourier/PROOF.md", + "usage": "provenance", + "git_blob": "aa3c20a49eac7ec7406cf3ee3bab827181aeba09", + "sha256": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7" + }, + { + "path": "research/physical-synthetic-fourier/fourier_engine.py", + "usage": "provenance", + "git_blob": "b62324aefc18fc5b90c1693a751662e08f5b7cd4", + "sha256": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9" + }, + { + "path": "research/pr589-five-helper-hosting/PROOF.md", + "usage": "provenance", + "git_blob": "bbd3f12b9a32b3ad3cba85a2d5a1b3054214fa02", + "sha256": "59cae781bfbe1a01ed9e66a8efeeb5a2b995e5ecdf908586b23ecc39f2b8d647" + }, + { + "path": "research/pr589-five-helper-hosting/verify.py", + "usage": "provenance", + "git_blob": "dbc71f56bb4205ebe378ada1f9f4ea88630d1d39", + "sha256": "cf90e19ae9991b0698be03d395a8cc29061ecb307eb7fea19adfb2d23c25a367" + }, + { + "path": "research/recursive-parking-boundary/README.md", + "usage": "provenance", + "git_blob": "251f335ebaccc11d69393ee7aeb5a2e84526d0bb", + "sha256": "491aa208391ee4c2936510b1a5c5c018dd5509d9a0e88687c72ab8406cd77b18" + }, + { + "path": "research/retuned-ordinary-coupling/EVIDENCE.md", + "usage": "provenance", + "git_blob": "b370d63711733f6eb9685a96d09ca1964f685c51", + "sha256": "3cea6f279f0ae302f3432e1c67955ed009d2a9e569192b690f68627c62c2c3cb" + }, + { + "path": "research/retuned-ordinary-coupling/PROOF.md", + "usage": "provenance", + "git_blob": "8a0f47a1541a0b8e67866df4f65928de31073651", + "sha256": "3e554832c38b4b801f55b20868679f3283bc90cd5a9d8ce1960f828ed2655f22" + }, + { + "path": "research/retuned-ordinary-coupling/README.md", + "usage": "provenance", + "git_blob": "21a248de1d9ea63c88ed596554af307a36360383", + "sha256": "b342b26f131e67cd6e5bc143a41845e40eaec349af19648a6f76bc2c43ec0983" + }, + { + "path": "research/retuned-ordinary-coupling/SOURCES.json", + "usage": "provenance", + "git_blob": "2d346515fb715a1e6d91371e89aa6727ef25d3d9", + "sha256": "d4208b2d236c6055cc86c1d8ba8ce5cf54263ec5034556b0d70fbab3fbd7796e" + }, + { + "path": "research/retuned-ordinary-coupling/TASK.json", + "usage": "provenance", + "git_blob": "dc1ca38c3b0758bde1d7bf0f035014021e1e3c2a", + "sha256": "cf0749a2e4c805b28e5284f519fdcb43f203d77c3fd227d8581cb1079454fb1e" + }, + { + "path": "research/retuned-ordinary-coupling/VERIFY.json", + "usage": "provenance", + "git_blob": "7fe1448397d60577fe8445c64f6424cb8bb80422", + "sha256": "a46e323a04b959c76ceea82e738e66489639f4189b7b2b93f5e8111fb5b85b38" + }, + { + "path": "research/retuned-ordinary-coupling/certificate.py", + "usage": "provenance", + "git_blob": "03a5942a7b35e5c22b2f9993589be4167d477759", + "sha256": "461aabd741d12e97278968dece22cc5435293e55d744808838865988856b0b2e" + }, + { + "path": "research/retuned-ordinary-coupling/check_runtime.py", + "usage": "provenance", + "git_blob": "dc4a415d78f2de81332a0b7e4256dd9f01fc3c9d", + "sha256": "82de942e6c609cf46533f8746cfd67ae55714cd39e808af3ebf00eed4f71a16b" + }, + { + "path": "research/retuned-ordinary-coupling/check_setup.py", + "usage": "provenance", + "git_blob": "3a196ed2ae7030a75f4fadc423e15f0c4fb23193", + "sha256": "5ccea0216b701e3e1adb6bb0890ba3db179b1d7b3d1a6e9913ac1fdc4d56bfca" + }, + { + "path": "research/retuned-ordinary-coupling/inputs/pr2899-export.tar.gz", + "usage": "provenance", + "git_blob": "5c07cf429005658400d7a64e229162ea845e5bf7", + "sha256": "0fef1707c6460418fd01fd49faf0d8ff7945907fa57284765c852a12d2674d3c" + }, + { + "path": "research/retuned-ordinary-coupling/interface.py", + "usage": "provenance", + "git_blob": "6479a08fe78f7f4fe93d144cec26ac84aebcf9d3", + "sha256": "25707c61b9fc6c1f09388c7cc72d269be0f8f8cae4dbc7cd5c2d00ce7fadf839" + }, + { + "path": "research/retuned-ordinary-coupling/predecessor.py", + "usage": "provenance", + "git_blob": "31c08659c843dc114ae84d9c431bd749919c40bc", + "sha256": "4733b33a6a840f73ebc87f0c3f9e9f1aee95438b10eae7f8dbbf20d5b11b2306" + }, + { + "path": "research/retuned-ordinary-coupling/test_controls.py", + "usage": "provenance", + "git_blob": "d5cf4133d53a8bbbd95561df90b8f21ebcaea1cc", + "sha256": "06f3ee0b77e8c9cf8c031b1f1c7590c6dc7b627ccf7d67fa17b7a79a0ba477b9" + }, + { + "path": "research/retuned-ordinary-coupling/verify.py", + "usage": "provenance", + "git_blob": "9a21f9e08c5264abfd9d50968691f32a8c526484", + "sha256": "887e878fd78f27b0029de651c94728f4e71314f08e562272dc9e52d66328fcb7" + }, + { + "path": "research/selected-bit-fast-primitives/PROOF.md", + "usage": "provenance", + "git_blob": "6522e6ec84ed91bce98056456a88698b1cbfe1ad", + "sha256": "c6912c307304b71ab51a5b9647df19a3e2c85efaca5bb3f1b635e918a62b5978" + }, + { + "path": "research/selected-bit-fast-primitives/README.md", + "usage": "provenance", + "git_blob": "22280ad31392300f4c2934800aa82a1fabf299b7", + "sha256": "46136a36462163003cecf93a78d4a435d170948676e9015bae22620589e9d57e" + }, + { + "path": "research/selected-bit-fast-primitives/RESULT.json", + "usage": "provenance", + "git_blob": "25bd73fd36d150c020a28d8ba3751c2320c2e11f", + "sha256": "2af1012f3e3467588397bd5ba581d419442477caf0407ba48f8ee7e6137d1992" + }, + { + "path": "research/selected-bit-fast-primitives/SOURCES.json", + "usage": "provenance", + "git_blob": "bba64765508e3d293e40243b40409b671a3d0c2c", + "sha256": "12878f05f1cbc1ff4a0db76d5d39f4f991c1fe3b5d14865340bf75d5df79c6d5" + }, + { + "path": "research/selected-bit-fast-primitives/TASK.json", + "usage": "provenance", + "git_blob": "dba96083fefb88573d7388bea80f9c2b87e197d2", + "sha256": "b415aee0f8d9bfded525cb47d3aa04ea97680abf16a02a89888ac0dc5ab2ecbd" + }, + { + "path": "research/selected-bit-fast-primitives/VERIFY.json", + "usage": "provenance", + "git_blob": "606bf32c4fc154f9ace0fcd51ec9857a51e1876a", + "sha256": "fee812dbe7905c31c39bf97920c88deb442b152a2cfb261c86c169fbad4d1edc" + }, + { + "path": "research/selected-bit-fast-primitives/check_caller.py", + "usage": "provenance", + "git_blob": "c3085e1d648ff2ba8d774d1739854306b84e5798", + "sha256": "75808ef9a1b65d620109717ab4af88598777a39cfc4d4bc2e42d3788233f029b" + }, + { + "path": "research/selected-bit-fast-primitives/check_catalogue.py", + "usage": "provenance", + "git_blob": "7368d63e1a7c54c29d622324e35f4115884adc10", + "sha256": "f7cc1c7907fd1877e310ba41904110a40e52f091ad38442ab2398c798afd3644" + }, + { + "path": "research/selected-bit-fast-primitives/check_complete.py", + "usage": "provenance", + "git_blob": "d4db3439979d347a1ab6a96b978c8d3dbfa5cb7e", + "sha256": "0751dd27a129823894cd7ade7ba73fcc84c825ecf5fcdd1fedac11ca08526d9d" + }, + { + "path": "research/selected-bit-fast-primitives/check_controls.py", + "usage": "provenance", + "git_blob": "bee3f603c989358b8e6169bd7770ebf9280b3a00", + "sha256": "d0b41aec46462f6b351935efdd8b200eb4de72fa2f8784cfa672fe3607711d91" + }, + { + "path": "research/selected-bit-fast-primitives/check_handoff.py", + "usage": "provenance", + "git_blob": "96051d7ca03bd38541d86289cdb6ec5fed98e707", + "sha256": "be1436e32bfad474330b69905aa6e4bfdb1a3538c295ace0f0ef96f40a34661a" + }, + { + "path": "research/selected-bit-fast-primitives/check_kernels.py", + "usage": "provenance", + "git_blob": "f4525ca47b90151f5461b01ed33ff80d64931ffe", + "sha256": "dd35d535e6986687bee112cef2003569252fc473acbce98f1a64b66e84083cc2" + }, + { + "path": "research/selected-bit-fast-primitives/check_outer.py", + "usage": "provenance", + "git_blob": "013b959cc9fc4a37f0c109cda4ffc37d639a5473", + "sha256": "b303f94091b1a09333532c57182808e5e049ad8b00dc77d491c664f5c5351ee3" + }, + { + "path": "research/selected-bit-fast-primitives/check_routes.py", + "usage": "provenance", + "git_blob": "0b05ab1e4de1e10fe651c72da883887cb44a643d", + "sha256": "28803eb270202e2742c713bf14ead47f44c8b5341a380c156bce7392ebed642d" + }, + { + "path": "research/selected-bit-fast-primitives/compile_routes.py", + "usage": "provenance", + "git_blob": "37263fdc327b4a300ccfaa0b7ad650012ab3d59c", + "sha256": "1bfef464dfb3e33d9d57f53b657b2d1fe3598bc453be49000a5e782b622e8585" + }, + { + "path": "research/selected-bit-fast-primitives/high_route.py", + "usage": "provenance", + "git_blob": "ec7481f890147be7763f4da729fd879a88a87e8e", + "sha256": "13d9c706e7bad2fa3b7d2a97d19b58f2c4efac06d2bb76b613b40069c38b1cd2" + }, + { + "path": "research/selected-bit-fast-primitives/inputs/pr2157.tar", + "usage": "provenance", + "git_blob": "9504807466071f56519f8663ccb532076a42a273", + "sha256": "db202c7b91b5b8b9340f96f870d54e275854f0b73839451c7c15bd7895ac3639" + }, + { + "path": "research/selected-bit-fast-primitives/inputs/pr2899.tar", + "usage": "provenance", + "git_blob": "e85ce82745879141e416ac6d9e3551ff959871aa", + "sha256": "fc4a2e07423835737c8fb3872664b16ff12aa4cf83b1e26e49878debef40c531" + }, + { + "path": "research/selected-bit-fast-primitives/kernels.py", + "usage": "provenance", + "git_blob": "de9fb08c35e92c8354ae622276866385fd07e3d2", + "sha256": "c4b91333817f7fcea44b1d32e01095cd71aeb673ed3608d2e25f4c06d56bb420" + }, + { + "path": "research/selected-bit-fast-primitives/stage.py", + "usage": "provenance", + "git_blob": "765ae9e11af3acb9458d7a1444a9e79112b72d96", + "sha256": "44e334162d12868ce6bb50c501cd2eba8c527f59ce7a144614edd8cd6f533647" + }, + { + "path": "research/selected-bit-fast-primitives/stage_sources.py", + "usage": "provenance", + "git_blob": "27383dd1553672f9c82139f80b628b2a094628d8", + "sha256": "55c6631cce4f76e14b66b6195468c36b544e2374cc6c59702135c664bff10822" + }, + { + "path": "research/selected-bit-fast-primitives/verify.py", + "usage": "provenance", + "git_blob": "a2f602c15cd413638116b4ea9bcffe613e4e3a7d", + "sha256": "90760db1526f73cfffc34eb8af3f2e5ec83f8f1015a780caa61d156f0d850c68" + }, + { + "path": "research/selected-bit-local-ring-sweeps/PROOF.md", + "usage": "provenance", + "git_blob": "4330de85dd9862ed15d84ab917887d249753df99", + "sha256": "846c59440cc99e28bae93ad2af99525bc769de29368080071b8427141215b4f7" + }, + { + "path": "research/selected-bit-recursive-closure/PROOF.md", + "usage": "provenance", + "git_blob": "6c410cab5713979214a45835091fbeb9ee9b8531", + "sha256": "74cc8de20f21acb5123fe2d20996fe0925ea6e51b3dec633bd5221fb719b3344" + }, + { + "path": "research/selected-conservative-outer/PROOF.md", + "usage": "provenance", + "git_blob": "f26af67ae1ee4d9886d4e4b28d5332994f492bc2", + "sha256": "4afeb1708cf9568a9cd25afc72b159d5b06d151a6a6aba567a50970b38a1f513" + }, + { + "path": "research/selective-borrowing-outer-retune/vendor/pr2260-selective-borrowing-kappa/PROOF-LOCAL.md", + "usage": "provenance", + "git_blob": "d16c7549ce7c2a27fde57c36c1b959e8da8fcc43", + "sha256": "eb8a083f2ef5348a24e9f8873092eecdc2f5a95b5e86f09d6fb10e2dcf398960" + }, + { + "path": "research/staged544-mixed-fourth-entry/.gitattributes", + "usage": "input", + "git_blob": "fc06868c3d5cb57faf9146b154cb3961d5660360", + "sha256": "04e5e0efa0141765d3c58422bbc347caf588ab7e70c3429e63f78d892038a1d7" + }, + { + "path": "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "usage": "input", + "git_blob": "5d27e2d4f864e6d4a26be3af2d2131bd3000545a", + "sha256": "59b692adb4ed3c8caed033d380c23e2e2cf2a1547323b88f97b4a4ad7453141b" + }, + { + "path": "research/staged544-mixed-fourth-entry/INPUTS.json", + "usage": "input", + "git_blob": "5898f7e11f827baa4122fa17d4aa251b990efff6", + "sha256": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98" + }, + { + "path": "research/staged544-mixed-fourth-entry/MANIFEST.json", + "usage": "input", + "git_blob": "768091ef74f2212027222b3e5af84365694e4780", + "sha256": "f2f52b40e4b0dda45777fdeecf2267679da0d36be69daf467adc1740f4951b9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/NOTICE.md", + "usage": "input", + "git_blob": "56c36d6f5900b2d6cd3169c8996b7b2018649fe9", + "sha256": "1ba00cad41d7a1333da420bd23f078d09e28b7aa17cf5a8a89e54dd207123971" + }, + { + "path": "research/staged544-mixed-fourth-entry/PROOF.md", + "usage": "input", + "git_blob": "9c665b0442774b8c84116f51c3261d50dd5f8d2c", + "sha256": "3aa03a9ba64422474890c137d2b10ef830464712830fd469fe1b0e9538b24ebb" + }, + { + "path": "research/staged544-mixed-fourth-entry/README.md", + "usage": "input", + "git_blob": "29aac74f7ba382aad85189e5e297bf356414e2f9", + "sha256": "98b53ad6e6ee7ef7ba106e68e7a2a77d8f5a9823202cb3725cf101f5901e2d6f" + }, + { + "path": "research/staged544-mixed-fourth-entry/RESULT.json", + "usage": "input", + "git_blob": "1174e25e2ef8f8bc9a0815c43ba5d64c8af08349", + "sha256": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d" + }, + { + "path": "research/staged544-mixed-fourth-entry/SOURCES.json", + "usage": "input", + "git_blob": "a604c6a640acd80f08b7378a00739eff45ac0830", + "sha256": "53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43" + }, + { + "path": "research/staged544-mixed-fourth-entry/TASK.json", + "usage": "input", + "git_blob": "77f24f0c846cb00a702cb7aa06c31c02a29198fd", + "sha256": "8c34b11a10f0317dd4a4dc765b036a2231cee55cb44fc0e1e59fb64e11326a13" + }, + { + "path": "research/staged544-mixed-fourth-entry/VERIFY.json", + "usage": "input", + "git_blob": "f8b3c9ab743525816d1a2f35ca437b7d3674d07a", + "sha256": "2814773f90ee84a1c367dfec1ee85ec4f001ed100469f354d0464e7952303e9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "usage": "input", + "git_blob": "a87dde507358dd3b60c0d80d6216ef16123c56ca", + "sha256": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "77ee265be3cc15d76054c023d825578d9c62fa5c", + "sha256": "bff67890d0d350646d11f45aa1b098d6a415b1850b4982e8a05b4c146d247eda" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "bc6433bbf5c355d53eec218448fa49c5f4d45346", + "sha256": "e0c473d62127a09cb3cbf451564dbdd19c0c10f1674dab0575e65251aa5e1e3c" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "usage": "input", + "git_blob": "22fd191b74aadd219bc4095633ac552244b1083b", + "sha256": "e273538de7957b959c40f593c4aad5e8e3d81d83d662fe2895c17770c5fad8bd" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "usage": "input", + "git_blob": "f99019e597d38749594b06c7a47847bb78a40bc8", + "sha256": "c8f744c62670ad7d76faf4dee65e2f708f4036953041e72383929c7d0b32ec38" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "usage": "input", + "git_blob": "f6b24b3310609e9a862e6877a1412ce5d4d23120", + "sha256": "c422d41b5b316fe6823012ca31a13bd3c2c4a4a17c3712c36ce0156f311e5ce9" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "usage": "input", + "git_blob": "fe667708d7c878e80a6efdb6874496864ca67136", + "sha256": "2b6f90f3d00e7b2723fa12c6bd8e8f0d2881854b3ef625b0fd37ed6f51e2bfa4" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "usage": "input", + "git_blob": "4bdbe9682413329415782da9ee9c33ec34bb2a21", + "sha256": "b00f1665c7096ca292079668bac86e25ca7552c57cbe62c8c45ea40aa8708ecf" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "usage": "input", + "git_blob": "a0485940af5330dc64a962937d8f3465074a7224", + "sha256": "a65bcb4624a96204b1d30ec8c82080fbcdda2c1a30349643b60db579f339c75c" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "usage": "input", + "git_blob": "d110afeaeecc8df7ccf1730eae63a8e124516b65", + "sha256": "817c39b155892ab3ea89b6e2bf04480c45e1ebb9a8f87e2bb9a48c715a7eee9e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "usage": "input", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/PINS.json", + "usage": "input", + "git_blob": "7c83dc543292205bc65abd332f77215b58feebf7", + "sha256": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "usage": "input", + "git_blob": "07cd8a78808413a4a2e58cd5d43e448ab50ac34b", + "sha256": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/common.py", + "usage": "input", + "git_blob": "9ed8d88b97bda87a30bcb01cb9fd81339cbc15ab", + "sha256": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/run_native.py", + "usage": "input", + "git_blob": "64ef0eb83f214c2a922e446fa079e7d2568f73ef", + "sha256": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/stage.py", + "usage": "input", + "git_blob": "9ecc54bca4173b732e3f030fadee0a3b7f54f686", + "sha256": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/staged544-mixed-fourth-entry/operator_verify.py", + "usage": "input", + "git_blob": "60295d1c4622819c1bb2f514b885b952376e52bd", + "sha256": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner_verify.py", + "usage": "input", + "git_blob": "a74d1ee0b5d45feb4c87cc034ae49069d654467c", + "sha256": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72" + }, + { + "path": "research/staged544-mixed-fourth-entry/price.py", + "usage": "input", + "git_blob": "5b702b6fd94327f502fd9ef58594e1031dfa9db9", + "sha256": "89b7c623befd880a163baabc52f8ca576281ad0d8b71685e2ee37c9709edb335" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "d1c13c2ea786f790e96d45f18f58ec1ef2be7507", + "sha256": "221b56acc02ceeee35000f26f7098426421c0c90a075d81f9629170284f4aa25" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "8d5a8d22ddb5450abf414f9ec814077d16033111", + "sha256": "b1963fba45032238f773f3b375412d7db5f6e184edb59dcd05be15f6f70116f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "usage": "input", + "git_blob": "9ccffcfb7da1e36b158752ffed293dc95797e68e", + "sha256": "91f7f723bb616aca757812f940f6b893559e64e441d6158c907155a79b3b15a7" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "usage": "input", + "git_blob": "eb65f87966b1b8b61c5f9abad508a3f0cd6d689b", + "sha256": "864b2857f200a37b37f939b78887484f5230be0b68ab7755705713e2e2d45d3e" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "usage": "input", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462", + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "usage": "input", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491", + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "usage": "input", + "git_blob": "96dab46ab3404adc92c4b004481759db0c71dfdf", + "sha256": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "usage": "input", + "git_blob": "b2b50c0847c811248031ef14e0b9adc8010d0127", + "sha256": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "usage": "input", + "git_blob": "ca3e3effb97f46485ab7ac8c15ce4a92e1f93fbe", + "sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "usage": "input", + "git_blob": "266a2e541edc82c77a77e9c403bfe79a7392b950", + "sha256": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329" + }, + { + "path": "research/staged544-mixed-fourth-entry/verify.py", + "usage": "input", + "git_blob": "816a7786a3570976ac86baf3b19ee798e6098895", + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-idle-rebind/vendor/rebind.py", + "usage": "provenance", + "git_blob": "a0453d3e956d80c2088b9f69650095dcae800343", + "sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af" + }, + { + "path": "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + }, + { + "path": "research/t74-physical-layer/PROOF.md", + "usage": "provenance", + "git_blob": "2a8bfe5d6d1599b859da9836ce4c2ff1de5d9036", + "sha256": "1054f13f3e370a2e5d5f5cbc0e767e84927d4879f4c7be54cccb9b9a6a58e8ba" + }, + { + "path": "research/t74-physical-layer/binding.py", + "usage": "provenance", + "git_blob": "468c0724ee950d91754045af67b5b980e6adbdb2", + "sha256": "bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057" + }, + { + "path": "research/t74-physical-layer/compile_word.py", + "usage": "provenance", + "git_blob": "345e7820ea0351e3801ffbb93050473213ec045f", + "sha256": "1ae8eeedd1a3e8fea68762550d6f7c9495112785ed82bf824d8f82eba21f64a2" + }, + { + "path": "research/t74-physical-layer/t74_machine.py", + "usage": "provenance", + "git_blob": "27146d9f3961835afdf732aeb1f858ea16035ce6", + "sha256": "3bc4c40f275852cea82dbdcf41b8e586bae2e599112ee073a367acc66f37ce83" + }, + { + "path": "research/t74-retuned-physical-layer/PROOF.md", + "usage": "provenance", + "git_blob": "728ff53e7217e34b463cfcf86cc81624ea9b1dd2", + "sha256": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f" + }, + { + "path": "research/t74-retuned-physical-layer/active_plan.py", + "usage": "provenance", + "git_blob": "c3a01cd8c4f52cab478aefacad60f64f60f1453a", + "sha256": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e" + }, + { + "path": "research/t74-retuned-physical-layer/active_root.py", + "usage": "provenance", + "git_blob": "8f63fc094432692b7fd81aad14d937320fda4354", + "sha256": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7" + }, + { + "path": "research/t74-retuned-physical-layer/active_sources.py", + "usage": "provenance", + "git_blob": "4f7f8d1aa8ea37aa7e66f6887606821a0b48bbba", + "sha256": "599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49" + }, + { + "path": "research/t74-retuned-physical-layer/retuned_machine.py", + "usage": "provenance", + "git_blob": "f01b69888e53a81be986fd59f3e5e05f7a4e4087", + "sha256": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a" + }, + { + "path": "research/t74-retuned-physical-layer/retuned_native.py", + "usage": "provenance", + "git_blob": "7f51e925db0e4e6885107ad51e09f90b95757900", + "sha256": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc" + }, + { + "path": "research/t74-support-composition/PROOF.md", + "usage": "provenance", + "git_blob": "c0c7c9df28e2ac7afc51d40fd3e31de668e01703", + "sha256": "7c12a3ba5617b2bcbf5d2614db4fdc297fc619cd430366137386a70e9698f925" + }, + { + "path": "research/t74-support-composition/composed_engine.py", + "usage": "provenance", + "git_blob": "646c451a4cbdf0244c7782d958f257f6606b962f", + "sha256": "e6fb1b83f301027fe0f80732817b96d662bd365c9d5279e8949c20b1186ced4f" + }, + { + "path": "upstream/build/sections/02-streams.tex", + "usage": "provenance", + "git_blob": "088fceea1867abc76271d7efe7532b779fee9039", + "sha256": "606c80db61cad13aa0c3b6060dc4b88dbbe7ac60cdd831aa93f28d908fd09dab" + }, + { + "path": "upstream/build/sections/08-assembly.tex", + "usage": "provenance", + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + } + ] +} diff --git a/research/complex-pooled-full-admission/TASK.json b/research/complex-pooled-full-admission/TASK.json new file mode 100644 index 000000000..32c148be8 --- /dev/null +++ b/research/complex-pooled-full-admission/TASK.json @@ -0,0 +1,102 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Complete PR4181 pooled-fill finite admission, bind its local/global source to the retained physical recursive root, and prove a conservative conditional integer kappa=1/580 with every restoration, recursive, routing, Gaussian, CRT and recovery cost.", + "scope_change_reason": "The user explicitly requested a real kappa improvement after complete costs. The finite release alone left a source-specific physical gap, so this successor adds the retained T74/retuned-root binding and complete outer construction rather than promoting a root calculation.", + "bottleneck_link": "The complex supplier is the joint limiter. A better root has no multiplication consequence until arbitrary-input restoration, actual owner/controller calls and the complete recursive/outer invoice are admitted.", + "budget_minutes": 240, + "stop_rule": "Complete one source-bound finite integration and independent conditional cost proof, or preserve a decisive blocked obligation. Retain the original UTC deadline2026-10-21T01:28:34Z and begin closeout20minutes earlier.", + "outcome": "completed", + "evidence": "EVIDENCE.json retains the complete finite release. PHYSICAL-BRIDGE.md and PHYSICAL-GLOBAL.md give source-specific local/global refinement and recurrence. OUTER-JOIN.md, OUTER-DOMAIN.md and OUTER-CHECK.md give the conditional all-parameter integer join with separate bounded evidence. No production payload or unconditional/formal theorem is claimed.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance. Separate specialist contexts derived the operator and joint-bound obligations and reviewed the adapter. This is author/AI evidence, not independent human or formal-kernel verification.", + "open_questions": [ + { + "question": "Can the complete conditional kappa=1/580 proof receive independent scientific admission?", + "why_it_matters": "The new all-parameter composition retains universal native/hosting, physical and analytic hypotheses; finite checks and author/AI review do not certify a frontier.", + "first_step": "Review the pinned contracts and complete release, then trace PHYSICAL-GLOBAL.md through OUTER-JOIN.md including actual support/domain and exact recovery.", + "blocked_by": "Independent mathematical review and admission; selected frontier remains unchanged." + }, + { + "question": "Can the explicit cohort and integer wrapper be exercised on a source-admitted production instance?", + "why_it_matters": "The factory, written encoded sequence and bounded controls do not constitute an end-to-end production payload run.", + "first_step": "Acquire the complete pinned runtime source packages, open the authenticated tensor cohort, and audit actual records and output-consumption gates before allocating the native inventory.", + "blocked_by": "Production parameter scale, fixed compiled inventory, and practical execution resources; diagnostic p48 is not a substitute." + }, + { + "question": "Can an admitted B2 ordinary backend improve the conservative physical saving?", + "why_it_matters": "The optional noncircular arithmetic alone does not construct the faster production callee or reprice the whole caller.", + "first_step": "Implement and admit the proposed bootstrap factory, then repeat actual stopped-tree and complete outer cost comparisons.", + "blocked_by": "An implemented and scientifically admitted B2 physical backend; it is not required by the current bound." + } + ] +} diff --git a/research/complex-pooled-full-admission/UNIFORM-GAP.md b/research/complex-pooled-full-admission/UNIFORM-GAP.md new file mode 100644 index 000000000..5bf4d1cd4 --- /dev/null +++ b/research/complex-pooled-full-admission/UNIFORM-GAP.md @@ -0,0 +1,60 @@ +# Uniform physical proof boundary + +The finite ledger alone does not establish the uniform premise `U(S1)` in +[RECURSION.md](RECURSION.md). This package now supplies a source-specific +physical extension and complete conservative outer join, rather than leaving +that premise as an unconstructed inference from the moment calculation. + +## Resolved obligations + +The old selected R480 controller has no `warp` or `zero_buffer` instruction and +cannot consume these pooled words unchanged. The retained T74 compiler does +support them. [PHYSICAL-BRIDGE.md](PHYSICAL-BRIDGE.md) binds all six actual local +programs to that compiler and includes each warp/inverse, private allocation, +zero check, cleanup, scalar tariff and exact compact field. + +[PHYSICAL-GLOBAL.md](PHYSICAL-GLOBAL.md) binds the actual 3,240-call selector, +all complete owner families, helper/data charts, idle suffixes and terminal +correction to the T74 physical binding. Its all-cover argument uses the +bijection `d -> d sigma^-1`; the all-width proof uses the actual retained root, +new complete row divisor, enlarged finite header, exact coefficient guard, +stock recurrence and saved-parent lifetimes. It charges every restoration and +child return. The existing retuned B1 backend is fast enough for a layer +exponent `.99827` with the actual stop `e^10000000\nassert m==73 and W==896*T and W==BJ['live']" + ] + ] + }, + { + "after_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "before_sha256": "08ca58abff11bdfba721dc56ab8acf06ec1b7c48a8699a0955cf35324680aca7", + "path": "code/witness.py", + "replacements": [ + [ + " with open(os.environ['WITNESS_RECORD'],'a')as f:f.write(json.dumps([key,got],default=str)+chr(10))", + " import time as _wr_time\n _wr_path=Path(os.environ['WITNESS_RECORD'])\n _wr_lock=_wr_path.with_name(_wr_path.name+'.append.lock')\n _wr_deadline=_wr_time.monotonic()+60\n _wr_fd=None\n while _wr_fd is None:\n try:_wr_fd=os.open(_wr_lock,os.O_CREAT|os.O_EXCL|os.O_WRONLY)\n except FileExistsError:\n if _wr_time.monotonic()>=_wr_deadline:raise TimeoutError('discovery record lock timeout; existing lock preserved')\n _wr_time.sleep(.005)\n try:\n with _wr_path.open('a',encoding='utf-8',newline='\\n')as _wr_out:\n _wr_out.write(json.dumps([key,got],default=str)+chr(10))\n _wr_out.flush()\n finally:\n os.close(_wr_fd)\n _wr_lock.unlink()" + ] + ] + }, + { + "after_sha256": "b12cd2b6b7fc902f591c9e08b41caaa4601593a1ae38cde224bd86ec8e062bfb", + "before_sha256": "248649d4415a359c2b52ba6f5dd9a6b01ce109654b0dae91c9f71d8c02b26fb3", + "path": "verify.py", + "replacements": [ + [ + "run('lift-parent',P/'lift_parent.py','--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')", + "run('lift-parent',P/'lift_parent.py','--package',P,'--owners',work/'rebuilt-owners','--out',work/'rebuilt-parent')" + ] + ] + }, + { + "after_sha256": "0d8cc021d2401d047aaec79060ec2ea28ba06f12eca8dbf4c60c78bb31975c4e", + "before_sha256": "ebaf637f1f818dac9c0fce0ee3f18df300873105818cea29a8ae9e8b737b5c7d", + "path": "code/witness.py", + "replacements": [ + [ + "PAYLOAD==1<<(192+(GEO['dimension']+1)//2+2*CALLS+4).bit_length()", + "PAYLOAD==1<<(128+(GEO['dimension']+1)//2+18+1330+1+4).bit_length()" + ] + ] + }, + { + "after_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "before_sha256": "bb213d0af12218ff7c9c572717e522d8bbeeb2856b87a253f4a7f44e0fd71f15", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " required_prefix=localbits+input_l2_bits+call_count+bridge_sweeps+4", + " from blocknorm_certificate import certify\n blocknorm=certify(template, {pid:base/'providers'/pid for pid in template['local_providers']})\n assert blocknorm['status'] == 'PASS_TENSOR_BLOCK_NORM_CERTIFICATE'\n assert localbits <= 128, 'actual native scalar/Horner prefix exceeds charged local reserve'\n required_prefix=localbits+input_l2_bits+blocknorm['max_active_depth']+blocknorm['stock_l2_bits']+1+4" + ] + ] + }, + { + "after_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "before_sha256": "02502a217fe8c9e10229075b50745518beac512c48db20e64c3e06514a4da5b5", + "path": "independent_core.py", + "replacements": [ + [ + " payload = 1 << (192 + (M+1)//2 + 2*len(c['order']) + 4).bit_length()", + " require(localbits <= 128, 'measured native prefix exceeds local reserve')\n payload = 1 << (128 + (M+1)//2 + 18 + 1330 + 1 + 4).bit_length()" + ] + ] + }, + { + "after_sha256": "d598a2ac1e2e8eaee14a8c285e0277a7ae44ca6a15bd2b5cfc67fb40844fb387", + "before_sha256": "c5106e0d7a97382677fa228fbade989262347968a0e54acfcf6712aa37e02f47", + "path": "code/invoice_allcold.py", + "replacements": [ + [ + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,", + " complete_invocation_sweeps=call_count,bridge_sweeps=bridge_sweeps,row_prefix_extra=2*payload,blocknorm=blocknorm," + ], + [ + " primitive_arithmetic_margin_bits=4,controller_audit_sha256=", + " tensor_block_norm=blocknorm,partial_cover_margin_bits=1,physical_stock_l2_bits=blocknorm['stock_l2_bits'],primitive_arithmetic_margin_bits=4,controller_audit_sha256=" + ], + [ + "Sum every actual invocation and bridge sweep and take the maximum local scalar/Horner prefix over both orientations of the fixed provider.", + "All invocations and bridge sweeps remain charged. Bound completed-boundary energy by at most eighteen active steps per owner replica, using exact tensor-isomorphic whole-family helper unitaries. Add the full group-indexed physical-stock sup-to-l2 factor and one partial-cover margin, then the maximum local scalar/Horner prefix." + ] + ] + }, + { + "after_sha256": "e051aaa166e01263780d5ae03699690670b597fed6593af4c37a7e978825eb85", + "before_sha256": "0d522b09c7fe6a5e62fe80c28f3eefe733557a82d77c6212e5d4b91ffb7e3421", + "path": "independent_core.py", + "replacements": [ + [ + " prefix = localbits + (M + 1) // 2 + len(c['order']) + c['bridges'] + 4", + " bn=c['blocknorm']\n require(bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['max_active_depth']==18 and bn['stock_l2_bits']<=1330, 'independent tensor block certificate')\n prefix = localbits + (M + 1) // 2 + bn['max_active_depth'] + bn['stock_l2_bits'] + 1 + 4" + ], + [ + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], margin=4)", + "prefix_formula=dict(local_scalar=localbits, input_l2=(M + 1) // 2, invocations=len(c['order']), bridges=c['bridges'], active_block_depth=18,stock_l2=bn['stock_l2_bits'],partial_cover=1,margin=4),blocknorm=bn" + ] + ] + }, + { + "after_sha256": "393323f150d0bb686419804d51cf43d0f58450d2a1e7929725acdd26fdbb3640", + "before_sha256": "2286f00e462ff28abbb3f396095463482a1e063213b9526a7225275980c77eaf", + "path": "audit_mixed.py", + "replacements": [ + [ + "pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)", + "import blocknorm_certificate as BN;ctx['blocknorm']=BN.certify_context(ctx,roles,dirs,source_parent=parent);pending=A.check_pending_axes(ctx);receipt=A.check_roles(ctx,roles)" + ] + ] + }, + { + "after_sha256": "0542dde915af8902324db2f59136da078d5256bfaa8f1510f3e59336be7e2680", + "before_sha256": "f25e1e870df5d5a16a1e367b3df8843cb01644ab4b75895d7939af81e4fcb833", + "path": "code/assemble.py", + "replacements": [ + [ + " assert invoice['global_prefix_bits']==max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())+37+CALLS+CALLS+4", + " bn=invoice['blocknorm']\n assert bn['status']=='PASS_TENSOR_BLOCK_NORM_CERTIFICATE' and bn['replicas']==REPLICAS\n assert bn['max_active_depth']==bn['boundary_depth_bits']==18 and bn['active_calls_per_block']==bn['bridges_per_block']==9\n assert bn['block_width_families']==896 and bn['physical_families']==invoice['physical'] and bn['live_families']==invoice['live']\n assert bn['partial_cover_bits']==1 and bn['input_l2_bits']==37 and bn['local_reserve_bits']==128 and bn['retained_payload_bits']==PAYLOAD\n localbits=max(z['prefix_bits']for p in invoice['providers'].values()for z in p['local'].values())\n assert bn['local_actual_prefix_bits']==localbits and localbits<=128\n assert invoice['global_prefix_bits']==bn['actual_prefix_bits']==localbits+37+18+bn['stock_l2_bits']+1+4\n assert bn['required_reserve_bits']==128+37+18+bn['stock_l2_bits']+1+40 for p=1-a<1. See RECURSION.md.", + "covered_domain": "0 < a < 1", + "exact_integer_witness": [ + 44840334375, + 281474976710656 + ], + "previous_minus_new": { + "1": 20, + "3": 25, + "4": -30, + "5": 5 + } + } +} diff --git a/research/complex-pooled-full-admission/evidence/MIXED-CONTRACT.json.gz b/research/complex-pooled-full-admission/evidence/MIXED-CONTRACT.json.gz new file mode 100644 index 000000000..4d2318a55 Binary files /dev/null and b/research/complex-pooled-full-admission/evidence/MIXED-CONTRACT.json.gz differ diff --git a/research/complex-pooled-full-admission/evidence/OPERATOR.json b/research/complex-pooled-full-admission/evidence/OPERATOR.json new file mode 100644 index 000000000..9639dcb69 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/OPERATOR.json @@ -0,0 +1,103 @@ +{ + "active_provider_counts": { + "extra": 592, + "extra-four": 1080, + "gauge44": 1568 + }, + "all_characters": true, + "all_positive_tensor_multiplicities": true, + "authenticated_word_catalogue": [ + "extra", + "extra-four", + "gauge44", + "gauge44-four" + ], + "calls": 3240, + "controls": [ + { + "name": "wrong_global_phase", + "reason": "idle exact phase including translation" + }, + { + "name": "wrong_signed_controller", + "reason": "full signed scalar controller identity" + }, + { + "name": "cross_scalar_observation", + "reason": "strict exact observation window" + }, + { + "name": "pr4088_dispatch_on_pr4181_fill", + "reason": "exact native axis capacity" + }, + { + "name": "stale_pr4088_idle_complement", + "reason": "exact phase residual" + } + ], + "exact_Z4_identities": 10416, + "exact_observation_windows": 7200, + "global_phase_retained": true, + "hosted_rows": 1321920, + "hosted_width_mass": 10694160, + "idle": { + "3": 22788, + "5": 1620, + "48": 138492 + }, + "original_axis_mass": 17418240, + "paid_rank_mass": 23431680, + "physical_bins": 725760, + "ports": 112, + "profile": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "5": 66420, + "8": 25920, + "48": 138492 + }, + "residual_rank_mass": 6724080, + "scope": "Exact phase/chronology binding of the PR4181 fill under the retained local native endpoint and common-cover embedding interfaces. Source-bound interpreter reuse; not an independent algorithm, native rerun, ordinary/outer release, or an all-size multiplication theorem.", + "source_execution_control": { + "exact_loader_executes_authenticated_source": true, + "unchecked_hash_pyc_fixture_exposes_stock_loader": true, + "wrong_source_digest_rejected": true + }, + "source_head_pr4088": "72d7efc181edb21806a878f174847c96dd410ab0", + "source_head_pr4181": "4ed92bed95dd483f5662e98ef246b258c3cfe64f", + "source_pins": { + "complex-pooled-full-admission/frozen/pr4181/RESULT.json": "d823509ea38e545db6c287a85c00bc4257825fb2710728dfc776c8801d2becd9", + "complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz": "5455c120a121a7ec70897fb2c58e1988ce01d7172d6a5622519bea6b25efe8fe", + "complex-pooled-full-admission/frozen/pr4181/owner/MIXED-DISPATCH.json": "ab8c774b614730701435c0f5dc1bfba4a46d980690a1b6bc09225555ff9be6f4", + "complex-pooled-full-admission/frozen/pr4181/verify.py": "e89870761ddefe0a7f983512c6ae884ccff26235085238624e00f75a31cd6e76", + "staged544-mixed-fourth-entry/INPUTS.json": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98", + "staged544-mixed-fourth-entry/RESULT.json": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d", + "staged544-mixed-fourth-entry/checks/inherited_frames.py": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04", + "staged544-mixed-fourth-entry/inputs/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95", + "staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a", + "staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "staged544-mixed-fourth-entry/inputs/THREE-base.json.gz": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "staged544-mixed-fourth-entry/operator_verify.py": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564", + "staged544-mixed-fourth-entry/owner/DISPATCH.json": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a", + "staged544-mixed-fourth-entry/owner/ORDER.json": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44", + "staged544-mixed-fourth-entry/owner/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6", + "staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448", + "staged544-mixed-fourth-entry/owner_verify.py": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72", + "staged544-mixed-fourth-entry/vendor/audit_core.py": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "staged544-mixed-fourth-entry/vendor/audit_verify.py": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "staged544-mixed-fourth-entry/vendor/exact_root.py": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe", + "staged544-mixed-fourth-entry/vendor/full_operator.py": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3", + "staged544-mixed-fourth-entry/vendor/staged_entries_applier.py": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661", + "staged544-mixed-fourth-entry/vendor/staged_pair.py": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "staged544-mixed-fourth-entry/vendor/t360_admission.py": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329", + "staged544-mixed-fourth-entry/verify.py": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8" + }, + "status": "PASS_POOLED_ALL_CHARACTER_OPERATOR_ADMISSION", + "unused_catalogue_provider": "gauge44-four" +} diff --git a/research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json b/research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json new file mode 100644 index 000000000..fecd414f5 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json @@ -0,0 +1,249 @@ +{ + "arithmetic": { + "Phi": "99827519/100000000", + "alpha": "99827/100000", + "beta": "41544341/41616125", + "complex_rate_lower": "865490127994518479981/500000000000000000000000", + "controls": [ + "sigma_without_router_slack", + "old_root_target_kappa", + "omitted_inverse_normalization", + "axes_dimensions_off_by_one" + ], + "encoded_recovery_gate_cases_not_production_plans": [ + { + "H": 256, + "b": 32, + "ceil_log2_H": 8, + "coarse_recovery_upper": "1/1024", + "gamma": 8 + }, + { + "H": 4096, + "b": 48, + "ceil_log2_H": 12, + "coarse_recovery_upper": "1/16384", + "gamma": 16 + }, + { + "H": 1048575, + "b": 64, + "ceil_log2_H": 20, + "coarse_recovery_upper": "1048575/17179869184", + "gamma": 24 + } + ], + "eta": "1/1000000", + "gamma_ratio_upper_for_p_ge_2_pow_7000": "40775/2097152", + "internal": "6647060323670676329/6658580000000000000", + "kappa": "1/580", + "leaf": "19965399034601/20000000000000", + "router_gap": "3273151/33292900000000", + "saving_gap": "1949/2900000000", + "sigma": "19965399/20000000", + "sufficient_margin_base_cases_not_production_plans": [ + { + "E_upper": "7/22300745198530623141535718272648361505980416", + "b": 32, + "gamma_cap": 16, + "scaled_error_upper": "234157824584571701442450070391482982900695089/1461501637330902918203684832716283019655932542976", + "third_input_norm_upper": "31082702275611665134711390509176302506278587477442427197368450255864951507735694802993/497323236409786642155382248146820840100456150797347717440463976893159497012533375533056" + }, + { + "E_upper": "7/713623846352979940529142984724747568191373312", + "b": 33, + "gamma_cap": 16, + "scaled_error_upper": "2497683462235430636952400598689550819805276859/33157818396944859956746099642250671008443969568768", + "third_input_norm_upper": "31828687130226345097944463881396533766429196148713716151622021674363110804221618110332977/509258994083621521567111422102344540262867098416484062659035112338595324940834176545849344" + } + ], + "tau": "332353/332929" + }, + "checker_sha256": "45c3f1255e58ab8ed37c9c1c14defa0f2d59a3ffc57c4823bb80d06bf9b73002", + "controls": [ + "omitted_final_R", + "wrong_final_Fourier_sign", + "S_instead_of_S_squared", + "sigma_without_router_slack", + "old_root_target_kappa", + "omitted_inverse_normalization", + "axes_dimensions_off_by_one", + "disk_width_after_scaling", + "cyclic_alias_without_padding", + "non_strict_half_unit_margin", + "duplicate_CRT_prime", + "omitted_source_manifest_row", + "changed_source_bytes" + ], + "immutable_source_references": { + "archive_sha256": "a93f3e4df06a8ee18c69f68697cec463bbb86ddff642cc1df652d87ba642f046", + "controls": [ + "omitted_source_manifest_row", + "changed_source_bytes" + ], + "manifest_sha256": "cc5c879b5c28c9d2d4191c1ac2c5563213c1b58ffd1e4d25a3e6c0a6a6dbeb18", + "reference_files": 35, + "scope": "Exact proof/constructor references; no source imports or physical execution", + "source_contract_checks": [ + "TensorPlan_dimensions_and_gamma", + "CRT_explicit_record_width", + "normalized_Fourier_pair", + "scalar_Karatsuba_continuation", + "BHP_21_over_40" + ] + }, + "normalization": [ + { + "S": 3, + "bilinear_coefficients": 27, + "cyclotomic_polynomial": [ + 1, + 1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": false, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3 + ], + "target_axes": [ + 4 + ] + }, + { + "S": 5, + "bilinear_coefficients": 125, + "cyclotomic_polynomial": [ + 1, + 1, + 1, + 1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 5 + ], + "target_axes": [ + 8 + ] + }, + { + "S": 15, + "bilinear_coefficients": 3375, + "cyclotomic_polynomial": [ + 1, + -1, + 0, + 1, + -1, + 1, + 0, + -1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3, + 5 + ], + "target_axes": [ + 4, + 8 + ] + }, + { + "S": 21, + "bilinear_coefficients": 9261, + "cyclotomic_polynomial": [ + 1, + -1, + 0, + 1, + -1, + 0, + 1, + 0, + -1, + 1, + 0, + -1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": false, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3, + 7 + ], + "target_axes": [ + 4, + 8 + ] + } + ], + "normalization_controls": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "prime_interval_fixture": { + "d": 5, + "dimensions": 4, + "scope": "finite interval and ratio fixture, not a production TensorPlan", + "source_axes": [ + 1847, + 1861, + 3691, + 3697 + ], + "target_axes": [ + 2048, + 2048, + 4096, + 4096 + ] + }, + "recovery": { + "complete_round_scale_CRT_carry_cases": 27, + "controls": [ + "disk_width_after_scaling", + "cyclic_alias_without_padding", + "non_strict_half_unit_margin", + "duplicate_CRT_prime" + ] + }, + "scope": "Complete bilinear coefficient checks only on four stated finite groups; exact rational exponent and sufficient-margin certificates. Written eventual prime supply, Gaussian/CRT/Fourier source contracts, replacement-root binding, tape execution and all-size restoration are not proved by this checker.", + "source_blob_checks": [], + "source_blob_checks_performed": false, + "source_pins": { + "12fa8c5c844be21bfefb38a19503fbd867a11244": { + "research/crt-address-streams/PROOF.md": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4", + "research/crt-address-streams/crt_converter.py": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea", + "research/physical-synthetic-fourier/PROOF.md": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7", + "research/physical-synthetic-fourier/fourier_engine.py": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9" + }, + "f687fa171ef760fa98a4be1289717b47dd4ee0b3": { + "research/physical-gaussian-tensor/ARITHMETIC.md": "bf809380781faf39227b363aa1abd388694a4c26cac48548a3595d1aa0673440", + "research/physical-gaussian-tensor/PROOF.md": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e", + "research/physical-gaussian-tensor/tensor_engine.py": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1", + "research/physical-gaussian-tensor/tensor_plan.py": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3", + "research/physical-gaussian-tensor/tensor_word.py": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26" + } + }, + "status": "PASS_EXACT_OUTER_ALGEBRA_AND_ARITHMETIC_NOT_PHYSICAL_EXECUTION" +} diff --git a/research/complex-pooled-full-admission/evidence/OUTER-CHECK.json b/research/complex-pooled-full-admission/evidence/OUTER-CHECK.json new file mode 100644 index 000000000..ab947564c --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/OUTER-CHECK.json @@ -0,0 +1,295 @@ +{ + "arithmetic": { + "Phi": "99827519/100000000", + "alpha": "99827/100000", + "beta": "41544341/41616125", + "complex_rate_lower": "865490127994518479981/500000000000000000000000", + "controls": [ + "sigma_without_router_slack", + "old_root_target_kappa", + "omitted_inverse_normalization", + "axes_dimensions_off_by_one" + ], + "encoded_recovery_gate_cases_not_production_plans": [ + { + "H": 256, + "b": 32, + "ceil_log2_H": 8, + "coarse_recovery_upper": "1/1024", + "gamma": 8 + }, + { + "H": 4096, + "b": 48, + "ceil_log2_H": 12, + "coarse_recovery_upper": "1/16384", + "gamma": 16 + }, + { + "H": 1048575, + "b": 64, + "ceil_log2_H": 20, + "coarse_recovery_upper": "1048575/17179869184", + "gamma": 24 + } + ], + "eta": "1/1000000", + "gamma_ratio_upper_for_p_ge_2_pow_7000": "40775/2097152", + "internal": "6647060323670676329/6658580000000000000", + "kappa": "1/580", + "leaf": "19965399034601/20000000000000", + "router_gap": "3273151/33292900000000", + "saving_gap": "1949/2900000000", + "sigma": "19965399/20000000", + "sufficient_margin_base_cases_not_production_plans": [ + { + "E_upper": "7/22300745198530623141535718272648361505980416", + "b": 32, + "gamma_cap": 16, + "scaled_error_upper": "234157824584571701442450070391482982900695089/1461501637330902918203684832716283019655932542976", + "third_input_norm_upper": "31082702275611665134711390509176302506278587477442427197368450255864951507735694802993/497323236409786642155382248146820840100456150797347717440463976893159497012533375533056" + }, + { + "E_upper": "7/713623846352979940529142984724747568191373312", + "b": 33, + "gamma_cap": 16, + "scaled_error_upper": "2497683462235430636952400598689550819805276859/33157818396944859956746099642250671008443969568768", + "third_input_norm_upper": "31828687130226345097944463881396533766429196148713716151622021674363110804221618110332977/509258994083621521567111422102344540262867098416484062659035112338595324940834176545849344" + } + ], + "tau": "332353/332929" + }, + "checker_sha256": "45c3f1255e58ab8ed37c9c1c14defa0f2d59a3ffc57c4823bb80d06bf9b73002", + "controls": [ + "omitted_final_R", + "wrong_final_Fourier_sign", + "S_instead_of_S_squared", + "sigma_without_router_slack", + "old_root_target_kappa", + "omitted_inverse_normalization", + "axes_dimensions_off_by_one", + "disk_width_after_scaling", + "cyclic_alias_without_padding", + "non_strict_half_unit_margin", + "duplicate_CRT_prime", + "omitted_source_manifest_row", + "changed_source_bytes" + ], + "immutable_source_references": { + "archive_sha256": "a93f3e4df06a8ee18c69f68697cec463bbb86ddff642cc1df652d87ba642f046", + "controls": [ + "omitted_source_manifest_row", + "changed_source_bytes" + ], + "manifest_sha256": "cc5c879b5c28c9d2d4191c1ac2c5563213c1b58ffd1e4d25a3e6c0a6a6dbeb18", + "reference_files": 35, + "scope": "Exact proof/constructor references; no source imports or physical execution", + "source_contract_checks": [ + "TensorPlan_dimensions_and_gamma", + "CRT_explicit_record_width", + "normalized_Fourier_pair", + "scalar_Karatsuba_continuation", + "BHP_21_over_40" + ] + }, + "normalization": [ + { + "S": 3, + "bilinear_coefficients": 27, + "cyclotomic_polynomial": [ + 1, + 1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": false, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3 + ], + "target_axes": [ + 4 + ] + }, + { + "S": 5, + "bilinear_coefficients": 125, + "cyclotomic_polynomial": [ + 1, + 1, + 1, + 1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 5 + ], + "target_axes": [ + 8 + ] + }, + { + "S": 15, + "bilinear_coefficients": 3375, + "cyclotomic_polynomial": [ + 1, + -1, + 0, + 1, + -1, + 1, + 0, + -1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3, + 5 + ], + "target_axes": [ + 4, + 8 + ] + }, + { + "S": 21, + "bilinear_coefficients": 9261, + "cyclotomic_polynomial": [ + 1, + -1, + 0, + 1, + -1, + 0, + 1, + 0, + -1, + 1, + 0, + -1, + 1 + ], + "mutation_witnesses": { + "S_instead_of_S_squared": true, + "omitted_final_R": false, + "wrong_final_Fourier_sign": true + }, + "source_axes": [ + 3, + 7 + ], + "target_axes": [ + 4, + 8 + ] + } + ], + "normalization_controls": { + "S_instead_of_S_squared": true, + "omitted_final_R": true, + "wrong_final_Fourier_sign": true + }, + "prime_interval_fixture": { + "d": 5, + "dimensions": 4, + "scope": "finite interval and ratio fixture, not a production TensorPlan", + "source_axes": [ + 1847, + 1861, + 3691, + 3697 + ], + "target_axes": [ + 2048, + 2048, + 4096, + 4096 + ] + }, + "recovery": { + "complete_round_scale_CRT_carry_cases": 27, + "controls": [ + "disk_width_after_scaling", + "cyclic_alias_without_padding", + "non_strict_half_unit_margin", + "duplicate_CRT_prime" + ] + }, + "scope": "Complete bilinear coefficient checks only on four stated finite groups; exact rational exponent and sufficient-margin certificates. Written eventual prime supply, Gaussian/CRT/Fourier source contracts, replacement-root binding, tape execution and all-size restoration are not proved by this checker.", + "source_blob_checks": [ + { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "path": "research/physical-gaussian-tensor/PROOF.md", + "sha256": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e" + }, + { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "path": "research/physical-gaussian-tensor/tensor_plan.py", + "sha256": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3" + }, + { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "path": "research/physical-gaussian-tensor/tensor_engine.py", + "sha256": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1" + }, + { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "path": "research/physical-gaussian-tensor/tensor_word.py", + "sha256": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26" + }, + { + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "path": "research/physical-gaussian-tensor/ARITHMETIC.md", + "sha256": "bf809380781faf39227b363aa1abd388694a4c26cac48548a3595d1aa0673440" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "path": "research/crt-address-streams/PROOF.md", + "sha256": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "path": "research/crt-address-streams/crt_converter.py", + "sha256": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "path": "research/physical-synthetic-fourier/PROOF.md", + "sha256": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7" + }, + { + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "path": "research/physical-synthetic-fourier/fourier_engine.py", + "sha256": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9" + } + ], + "source_blob_checks_performed": true, + "source_pins": { + "12fa8c5c844be21bfefb38a19503fbd867a11244": { + "research/crt-address-streams/PROOF.md": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4", + "research/crt-address-streams/crt_converter.py": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea", + "research/physical-synthetic-fourier/PROOF.md": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7", + "research/physical-synthetic-fourier/fourier_engine.py": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9" + }, + "f687fa171ef760fa98a4be1289717b47dd4ee0b3": { + "research/physical-gaussian-tensor/ARITHMETIC.md": "bf809380781faf39227b363aa1abd388694a4c26cac48548a3595d1aa0673440", + "research/physical-gaussian-tensor/PROOF.md": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e", + "research/physical-gaussian-tensor/tensor_engine.py": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1", + "research/physical-gaussian-tensor/tensor_plan.py": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3", + "research/physical-gaussian-tensor/tensor_word.py": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26" + } + }, + "status": "PASS_EXACT_OUTER_ALGEBRA_AND_ARITHMETIC_NOT_PHYSICAL_EXECUTION" +} diff --git a/research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json b/research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json new file mode 100644 index 000000000..bef3f066a --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json @@ -0,0 +1,88 @@ +{ + "constructor_parameters": { + "Chirp": [ + "cyclic" + ], + "ComposedRoot": [ + "router", + "root", + "policy" + ], + "Converter": [ + "router" + ], + "Convolution": [ + "fourier" + ], + "Cyclic": [ + "convolution" + ], + "Fourier": [ + "layer" + ], + "FullRouter": [ + "native" + ], + "Tensor": [ + "chirp", + "router" + ] + }, + "controls_rejected": [ + "unbound_CRT_token", + "nested_CRT_token", + "changed_CRT_authenticated_input", + "changed_loaded_constructor_body", + "foreign_private_bridge_alias:pooled_outer_authenticated_global_bridge", + "foreign_private_bridge_alias:pooled_physical_local_bridge", + "original_sigma_below_tau", + "old_complex_layer_target", + "Router_passed_as_native" + ], + "exact_exponents": { + "C": "865490127994518479981/500000000000000000000000", + "Phi": "99827519/100000000", + "alpha": "99827/100000", + "beta": "41544341/41616125", + "final_log_gap": "1949/2900000000", + "internal": "6647060323670676329/6658580000000000000", + "internal_gap": "332929323671/6658580000000000000", + "kappa": "1/580", + "leaf": "19965399034601/20000000000000", + "leaf_gap": "965399/20000000000000", + "router_gap": "3273151/33292900000000", + "sigma": "19965399/20000000", + "target": "579/580", + "tau": "332353/332929" + }, + "global_bridge_definitions_compiled_from_authenticated_bytes": true, + "local_bridge_definitions_compiled_in_two_fresh_scopes": true, + "numerical_payload_executed": false, + "production_native_constructors_executed": false, + "real_CRT_loader_authentication_executed": true, + "runtime_package_pins": { + "research/crt-address-streams": 14, + "research/physical-gaussian-tensor": 35 + }, + "runtime_source_closure_supplied": false, + "scope": "Exact exponents, actual constructor source interfaces, retained archive comparison receipts and actual CRT loader token lifecycle on a small token-only fixture. The production adapter and conditional all-size proof are distinct from these bounded checks.", + "source_comparison": { + "receipt_sha256": { + "CRT-3935-COMPATIBILITY.json": "c539b3292ae425282e79ea2cacfbf82263ac6a3b9d0c9370e33ff8b386b4f2e6", + "GAUSSIAN-PHYSICAL-COHORT.json": "b609b81c7937b02263ba1abc254cef369b07813f443f7b2fdbe5b156dcba30e1" + }, + "replayed_CRT_contract_bodies": [ + "research/physical-gaussian-tensor/tensor_sources.py", + "research/physical-gaussian-tensor/tensor_router.py", + "research/physical-gaussian-tensor/tensor_fixture.py", + "research/physical-gaussian-tensor/tensor_plan.py", + "research/physical-gaussian-tensor/PROOF.md" + ], + "retained_full_CRT_inputs": 8, + "retained_nested_constructor_members": 10, + "whole_runtime_archive_comparison_replayed": false + }, + "source_contract_files": 35, + "status": "PASS_OUTER_COST_DOMAIN_SOURCE_AND_TOKEN_CHECKS", + "token_scope_success_and_exception_restoration": true +} diff --git a/research/complex-pooled-full-admission/evidence/OUTER-LEDGER.json b/research/complex-pooled-full-admission/evidence/OUTER-LEDGER.json new file mode 100644 index 000000000..e6156f420 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/OUTER-LEDGER.json @@ -0,0 +1,575 @@ +{ + "status": "PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC", + "scope": "Conditional fine-prime padding composition. Fresh native admission is required by verify.py. The cited prime theorem, written gauge-free theorem and inherited all-size interfaces are not proved by this arithmetic. No independent human review is claimed.", + "geometry_changes": { + "theta_power": { + "rational": "2", + "decimal": "2" + }, + "halo_power": 48, + "core_power": 128, + "matrix_exponent": { + "rational": "45/16", + "decimal": "2.8125" + } + }, + "halo_umbrella": { + "umbrella_power": 10, + "theta_power": { + "rational": "2", + "decimal": "2" + }, + "exponent_budget": { + "rational": "13/2", + "decimal": "6.5" + }, + "margin": { + "rational": "7/2", + "decimal": "3.5" + }, + "fails_from_theta_power": { + "rational": "15/4", + "decimal": "3.75" + } + }, + "complex_lower_short": { + "rational": "173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999" + }, + "complex_lower_pinned": { + "rational": "865490127994518479981/500000000000000000000000", + "decimal": "0.001730980255989036959962" + }, + "native_moment": [ + { + "rational": "54918381281044877719855165666034059059164261803751103273726525815494072443227902411252869952566690700919221960890480765179064643899326830395026129536246797317/54918381281044877719855206392651145738155482401146443275155707673484345467181248416980477125291636439818370491131846864296975903997733150500592226328920457216", + "decimal": "0.99999999999999999999999925841555893170844454405482831052901363220128536872555964566048985271909330097365406527182506214871926070906620068450550064593844358058796779749955931033402180591818062317345631364614820890609625824748" + }, + { + "rational": "439347050248359021758841325328272472473314094430008826189812206523952579545823219290022959620533525607353775687123846121432517151194614643160209036289974378641/439347050248359021758841651141209165905243859209171546201245661387874763737449987335843817002333091518546963929054774914375807231981865204004737810631363657728", + "decimal": "0.99999999999999999999999925841555893170844454405482831052901363220128536872555964566048985271909330097365406527182506214871926070906620068450550064593844358082695881824419484135378235222055124479349095449485509486145191772827" + } + ], + "profile": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "5": 66420, + "8": 25920, + "48": 138492 + }, + "m": 73, + "W": 322560, + "online_final_kappa": { + "rational": "1727989140903569/1000000000000000000", + "decimal": "0.001727989140903569" + }, + "rows": { + "struct_boundary_radix_union": { + "kind": "struct_boundary_radix_union", + "kappa": { + "rational": "17309802559890369599619999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017309802559890369599619999999999999999999998999999999999999999999999" + }, + "epsilon": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "xi": { + "rational": "185954504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999995898451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.9079809802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999799729076683360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "beta": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "q": { + "rational": "86549012799451847998099999999999999999999999999999999999999999999999999999999999999999999999999999999/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999998" + }, + "a": { + "rational": "346196051197807391992399999999999999999999999999999999999999999999999999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001730980255989036959961999999999999999999999999999999999999999999999999999999999999999999999999999999985" + }, + "r0": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-104" + }, + "zeta": { + "rational": "1/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-106" + }, + "slack": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-104" + }, + "margins": { + "main_transform": { + "rational": "354504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999995900451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017309802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999799826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "global_coordinate_router": { + "rational": "346196051197807391992399999999999999999999999999999999999999999999999999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001730980255989036959961999999999999999999999999999999999999999999999999999999999999999999999999999999985" + }, + "fused_gaussian": { + "rational": "354504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999997943354471425667422696233700000000000000000000000000000000000000000000000000000000000000000000000000000123/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017309802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999899577855050081417123839536132812500000000000000000000000000000000000000000000000000000000000000000000006005859375" + }, + "group_bit_router": { + "rational": "1418019025706219077600870399999999999999999999999999999999999999999999999999999999999999999999999999995869417885702669690784934800000000000000000000000000000000000000000000000000000000000000000000000000000369/819200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.001730980255989036959961999999999999999999999999999999999999999999999999999999999999999999999999999999994957785505008141712383953613281250000000000000000000000000000000000000000000000000000000000000000000000450439453125" + }, + "group_scans": { + "rational": "2047999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "boundary_algebraic_matrix": { + "rational": "354504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999997948451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0017309802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999899826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "sparse_union_movement": { + "rational": "83554504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999997948451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4079809802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999899826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "polynomial_products": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "microbox_face_corrections": { + "rational": "78848000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000041/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "77.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400390625" + } + }, + "strict_checks": { + "actual_bit_above_effective": { + "rational": "489356720161454957400000000000000000000000000000000000000000000000000000000000000000000000000000003/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000002446783600807274787000000000000000000000000000000000000000000000000000000000000000000000000000000015" + }, + "complex_above_effective": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-105" + }, + "q_positive": { + "rational": "86549012799451847998099999999999999999999999999999999999999999999999999999999999999999999999999999999/50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.00173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999998" + }, + "complex_endpoint": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-104" + }, + "q_below_effective": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-105" + }, + "stop_positive": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-110" + }, + "stop_below_one": { + "rational": "99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999" + }, + "leaf_saving_above_effective": { + "rational": "49999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "4.9999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001E-105" + }, + "q_below_internal": { + "rational": "1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "5E-105" + }, + "q_below_leaf": { + "rational": "99999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.9999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001E-105" + }, + "lambda_above_tau": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-105" + }, + "lambda_above_sigma": { + "rational": "3/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "7.5E-105" + }, + "lambda_above_internal": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-105" + }, + "lambda_prime_above_lambda": { + "rational": "1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.5E-105" + }, + "lambda_prime_above_leaf": { + "rational": "99999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.9999999826901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001E-105" + }, + "epsilon_positive": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999989990234375" + }, + "epsilon_below_one": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-104" + }, + "cap_above_band": { + "rational": "83554504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999995898451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4079809802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999799729076683360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "cap_below_cell": { + "rational": "18845495243573445230599782400000000000000000000000000000000000000000000000000000000000000000000000000002051548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0920190197440109630400380000000000000000000000000000000000000000000000000000000000000000000000000000000100173267066639527625386821289062499999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "group_positive": { + "rational": "4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "group_below_dimension": { + "rational": "41/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.001953125E-104" + }, + "support_router_span": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-104" + }, + "group_gauge_power_slack": { + "rational": "18845495243573445230599782400000000000000000000000000000000000000000000000000000000000000000000000000006152548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.184038039488021926080076000000000000000000000000000000000000000000000000000000000000000000000000000000060083481538327905525077364257812499999999999999999999999999999999999999999999999999999999999999999999999599609375" + }, + "actual_logarithmic_group_guard": { + "rational": "18845495243573445230599782400000000000000000000000000000000000000000000000000000000000000000000000000007176548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.184038039488021926080076000000000000000000000000000000000000000000000000000000000000000000000000000000070083481538327905525077364257812499999999999999999999999999999999999999999999999999999999999999999999999599609375" + }, + "global_gamma_power_slack": { + "rational": "1/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.765625E-108" + }, + "actual_logarithmic_gamma_guard": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-104" + }, + "alpha_logarithm_absorption": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-104" + }, + "group_key_fits_record": { + "rational": "41/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "2.001953125E-104" + }, + "membership_arithmetic_fits_record": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-104" + }, + "microbox_halo_volume": { + "rational": "323584000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "79.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000030029296875" + }, + "positive_layout_slack": { + "rational": "1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1E-104" + }, + "short_record_fallback": { + "rational": "102222747621786722615299891200000000000000000000000000000000000000000000000000000000000000000000000000000511/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.998269019744010963040038000000000000000000000000000000000000000000000000000000000000000000000000000000004990234375" + }, + "improvement_over_online_final": { + "rational": "29911150854679599619999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000029911150854679599619999999999999999999998999999999999999999999999" + }, + "improvement_over_previous_local_final": { + "rational": "576201505832589599619999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000576201505832589599619999999999999999999998999999999999999999999999" + }, + "complex_below_one_over_32": { + "rational": "2951901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.02951901974401096304003800000000000000000000000000000000000000000000000000000000000000000000000000000001" + }, + "strassen_integer_power_gap": { + "rational": "1951441519231", + "decimal": "1951441519231" + }, + "theta_positive_polynomial_power": { + "rational": "2", + "decimal": "2" + }, + "cap_below_phase_cell_power": { + "rational": "223645495243573445230599782400000000000000000000000000000000000000000000000000000000000000000000000000004101548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0920190197440109630400380000000000000000000000000000000000000000000000000000000000000000000000000000000200270923316639527625386821289062499999999999999999999999999999999999999999999999999999999999999999999997998046875" + }, + "halo_covers_generic_inverse_radius": { + "rational": "5", + "decimal": "5" + }, + "union_tag_work_per_visit_fits_record": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-104" + }, + "union_header_fits_record": { + "rational": "123/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "3.0029296875E-104" + }, + "source_axis_superpolynomial": { + "rational": "41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.0009765625E-104" + }, + "improvement_over_pr1786": { + "rational": "512254678389880511814521334999999999999999000000000000000001999998800001/10000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000512254678389880511814521334999999999999999000000000000000001999998800001" + }, + "improvement_over_pr1828": { + "rational": "102450599726984877252658012158594846003376922994839409079344959674200000000000000000000000004006719019826502178085342683975683/2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000512252998634924386263290060792974230016884614974197045396724798371000000000000000000000000020033595099132510890426713419878415" + }, + "improvement_over_pr1839": { + "rational": "256126499317462193131645030396487115008442307487098522698362399185177258698371805868475000000001001679754956625544521335670993920703/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000512252998634924386263290060792974230016884614974197045396724798370354517396743611736950000000002003359509913251089042671341987841406" + }, + "improvement_over_pr1875": { + "rational": "256126499317462193131645030396487115008442307487098522698362399185177258698371805868471719335776838627743415457068895139647759399172939286143496816535216421325187363046885361425772909502231218314437622205930116079297234806627210590217190600996553729143901162562581526621534715086055386213403722175000000001001679754956625544521335670993920703/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000051225299863492438626329006079297423001688461497419704539672479837035451739674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325" + }, + "improvement_over_pr1876": { + "rational": "25612649931746219313164503039648711500844230748709852269836239918517725869837180586847171933577683862774341545706889513964775939917293928614349681653521642132518736304688536142577290950223121831443762220593011607929723480662721059021719060099655372914390116256258152662153471508605538621340372217196657216794137380775174500330086462142358142864921147118845386980694114022172311249292673931726844600000000000000000001001679754956625544521335670993920702577/500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000051225299863492438626329006079297423001688461497419704539672479837035451739674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325" + }, + "improvement_over_pr1897": { + "rational": "51225299863492438626329006079297423001688461497419704539672479837035451739674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325442118043438120199310745828780232512516305324306943017211077242680744434393314433588274761550349000660172924284716285729842294237690773961388228044344622498585347863453689118814253082419197486359454032147189198319033143866021423837056207677317517847011467076188001061138620310116832610271556685687769184940440093096226243113127523863162928128796969576356494654526264864467/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000051225299863492438626329006079297423001688461497419704539672479837035451739674361173694343867155367725548683091413779027929551879834587857228699363307043284265037472609377072285154581900446243662887524441186023215859446961325" + }, + "improvement_over_pr1758": { + "rational": "51234747186737908415466314800026327686526480209199320247542619067115757027414399369818327775017/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000051234747186737908415466314800026327686526480209199320247542619067115757027414399369818327775017" + }, + "improvement_over_pr1699": { + "rational": "533385246456823957109417129363552509344314069999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000533385246456823957109417129363552509344314069999999999999999999999" + }, + "improvement_over_pr1712": { + "rational": "266692623228411978551362020680007884145726638632283638941299969772187285461029288600736779707649/5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000533385246456823957102724041360015768291453277264567277882599939544374570922058577201473559415298" + }, + "improvement_over_previous_package": { + "rational": "531603536746005263309448641223998986170597784229341400200650717282025923262102542077285802551153/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000531603536746005263309448641223998986170597784229341400200650717282025923262102542077285802551153" + }, + "improvement_over_pkg_k2": { + "rational": "52987648783754439229911225169191627777122002965890395790280701170094526587548469132116575062403/1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.000052987648783754439229911225169191627777122002965890395790280701170094526587548469132116575062403" + }, + "gaussian_above_main": { + "rational": "1021451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "9.975112211672094474922635742187500000000000000000000000000000000000000000000000000000000000000000000000400390625E-105" + }, + "main_transform_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999995900451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999799826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125E-46" + }, + "global_coordinate_router_above_kappa": { + "rational": "20000000000000000000000019999999999999999999999999999999997/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.00000000000000000000000099999999999999999999999999999999985E-46" + }, + "fused_gaussian_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999997943354471425667422696233700000000000000000000000000000000000000000000000000000000000000000000000000000123/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999899577855050081417123839536132812500000000000000000000000000000000000000000000000000000000000000000000006005859375E-46" + }, + "group_bit_router_above_kappa": { + "rational": "81920000000000000000000081919999999999999999999999999999995869417885702669690784934800000000000000000000000000000000000000000000000000000000000000000000000000000369/819200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.00000000000000000000000099999999999999999999999999999999994957785505008141712383953613281250000000000000000000000000000000000000000000000000000000000000000000000450439453125E-46" + }, + "group_scans_above_kappa": { + "rational": "2044454952435734452305997824000000000000000000204800000000000000000000204799999999999999999999999999999959/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.99826901974401096304003800000000000000000000010000000000000000000000009999999999999999999999999999999997998046875" + }, + "boundary_algebraic_matrix_above_kappa": { + "rational": "20480000000000000000000020479999999999999999999999999999997948451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "1.000000000000000000000000999999999999999999999999999999999899826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125E-46" + }, + "sparse_union_movement_above_kappa": { + "rational": "83200000000000000000000000000000000000000000020480000000000000000000020479999999999999999999999999999997948451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.4062500000000000000000000000000000000000000001000000000000000000000000999999999999999999999999999999999899826732933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + }, + "polynomial_products_above_kappa": { + "rational": "4088909904871468904611995648000000000000000000409600000000000000000000409599999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.998269019744010963040038000000000000000000000100000000000000000000000099999999999999999999999999999999989990234375" + }, + "microbox_face_corrections_above_kappa": { + "rational": "78846227476217867226152998912000000000000000000102400000000000000000000102400000000000000000000000000000041/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "76.9982690197440109630400380000000000000000000001000000000000000000000001000000000000000000000000000000000400390625" + } + } + } + }, + "rejecting_controls": { + "struct_boundary_radix_union": { + "endpoint_equality": { + "complex_endpoint": { + "rational": "0", + "decimal": "0" + }, + "q_below_effective": { + "rational": "-1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5E-105" + }, + "q_below_internal": { + "rational": "-1/200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5E-105" + }, + "q_below_leaf": { + "rational": "-173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.73098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999E-113" + }, + "lambda_above_tau": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-105" + }, + "lambda_above_internal": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-105" + }, + "lambda_prime_above_lambda": { + "rational": "-1/400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.5E-105" + }, + "lambda_prime_above_leaf": { + "rational": "-173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.73098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999E-113" + } + }, + "zero_layout_slack": { + "positive_layout_slack": { + "rational": "0", + "decimal": "0" + } + }, + "old_per_axis_scan": { + "old_per_axis_scan_above_kappa": { + "rational": "-7090095128531095388004351999999999999999999590399999999999999999999590399999999999999999999999999999959/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.001730980255989036959961999999999999999999999899999999999999999999999899999999999999999999999999999999989990234375" + } + }, + "full_cell_gauge": { + "unrecentered_group_gauge": { + "rational": "-204799999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999997949/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999979970703125" + } + }, + "full_key_sort": { + "unnecessary_full_key_sort_above_kappa": { + "rational": "-121599999999999999999999999999999999999999999979519999999999999999999979519999999999999999999999999999997951548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.5937499999999999999999999999999999999999999998999999999999999999999998999999999999999999999999999999999899977954566639527625386821289062499999999999999999999999999999999999999999999999999999999999999999999997998046875" + } + }, + "old_g_factor_union_row": { + "old_g_factor_union_row_above_kappa": { + "rational": "-121599999999999999999999999999999999999999999979519999999999999999999979519999999999999999999999999999995901548509524777525767922099999999999999999999999999999999999999999999999999999999999999999999999999999959/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.5937499999999999999999999999999999999999999998999999999999999999999998999999999999999999999999999999999799880298316639527625386821289062499999999999999999999999999999999999999999999999999999999999999999999997998046875" + } + }, + "old_theta_chirp_guard": { + "old_theta_chirp_guard": { + "rational": "-83554504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999994872451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/102400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.815961960511978073919923999999999999999999999999999999999999999999999999999999999999999999999999999999949926284086672094474922635742187500000000000000000000000000000000000000000000000000000000000000000000000400390625" + } + }, + "old_linear_guard": { + "old_linear_guard": { + "rational": "-185954504756426554769400217599999999999999999999999999999999999999999999999999999999999999999999999999991796451490475222474232077900000000000000000000000000000000000000000000000000000000000000000000000000000041/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.9079809802559890369599619999999999999999999999999999999999999999999999999999999999999999999999999999999599436107933360472374613178710937500000000000000000000000000000000000000000000000000000000000000000000002001953125" + } + }, + "old_union_tag_2beta": { + "old_union_tag_2beta": { + "rational": "-2047999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/2048000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999993994140625" + } + }, + "matrix_below_strassen": { + "strassen_integer_power_gap": { + "rational": "-423", + "decimal": "-423" + } + }, + "halo_too_short": { + "halo_covers_generic_inverse_radius": { + "rational": "-3", + "decimal": "-3" + } + }, + "core_too_small": { + "microbox_halo_volume": { + "rational": "-4095999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999877/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969970703125" + }, + "microbox_face_corrections_above_kappa": { + "rational": "-3073772523782132773847001087999999999999999999897599999999999999999999897599999999999999999999999999999959/1024000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-3.0017309802559890369599619999999999999999999998999999999999999999999998999999999999999999999999999999999599609375" + } + }, + "group_equals_dimension": { + "group_below_dimension": { + "rational": "0", + "decimal": "0" + }, + "group_key_fits_record": { + "rational": "0", + "decimal": "0" + }, + "membership_arithmetic_fits_record": { + "rational": "-41/4096000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1.0009765625E-104" + } + }, + "epsilon_equals_one": { + "epsilon_below_one": { + "rational": "0", + "decimal": "0" + }, + "global_gamma_power_slack": { + "rational": "-1/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-1E-104" + }, + "actual_logarithmic_gamma_guard": { + "rational": "0", + "decimal": "0" + }, + "source_axis_superpolynomial": { + "rational": "0", + "decimal": "0" + }, + "gaussian_above_main": { + "rational": "-10645528574332577303766299999999999999999999999999999999999999999999999999999999999999999999999999999877/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-5.19801199918582876160463867187499999999999999999999999999999999999999999999999999999999999999999999993994140625E-107" + } + }, + "epsilon_not_above_r0_slack": { + "global_gamma_power_slack": { + "rational": "0", + "decimal": "0" + } + }, + "beta_below_gaussian_window": { + "gaussian_above_main": { + "rational": "-430408157819490511777547899999999999999999999999999999999999999999999999999999999999999999999999999971341/204800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "-2.1016023331029810145388081054687499999999999999999999999999999999999999999999999999999999999999999998600634765625E-105" + } + }, + "beta_above_membership_window": { + "membership_arithmetic_fits_record": { + "rational": "0", + "decimal": "0" + } + } + } + }, + "pr1673_kappa": { + "rational": "1677160151714381/1000000000000000000", + "decimal": "0.001677160151714381" + }, + "improvement_over_pr1673": { + "rational": "538201042746559599619999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "decimal": "0.0000538201042746559599619999999999999999999998999999999999999999999999" + }, + "source_sha256": { + "new/SPEC.json": "98bb37ad3ae3c6598530120243381ebbe4b04bea785c86ee55f4416f95e628ce", + "CLAIM.json": "e3db58c2612402961820881cdc760d360301ae6f2f828551d00091394a6676bf" + } +} diff --git a/research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json b/research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json new file mode 100644 index 000000000..93042adff --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json @@ -0,0 +1,86 @@ +{ + "families": 322560, + "inventory": { + "calls": 3240, + "cover_bits": 2628, + "event_counts": { + "bank_padding_cover_sweep": 1, + "bridge": 3240, + "idle_cover_sweep": 3600, + "local_cover_sweep": 3240, + "terminal": 360, + "terminal_Y_translations": 360, + "translate_every_live_family": 1 + }, + "events": 10802, + "helper_charts": 6489, + "owner_entries": 2047680, + "scope": "Finite complete global dispatcher binding; numerical fixtures use reduced geometry.", + "subgroups_per_cover": 1575720 + }, + "local_bridge_sha256": "590c928e290fe8d7cbaa08bcd73fcac4fee6fe21aca193f5c41e3d612f57fd9a", + "local_packet_roles": 731, + "negative_controls": [ + "unowned_local_module_alias", + "changed_local_source_commitment", + "duplicate_complete_owner_family", + "misbound_actual_provider_width", + "private_Z_map_outside_declared_family", + "missing_or_duplicate_complete_call_dispatch", + "misbound_local_provider_dispatch", + "omitted_pending_idle_axis" + ], + "physical_layer_rate": { + "alpha": "99827/100000", + "cover_bits": 2628, + "exact_guard_exponent": 210000, + "fallback_log_power": "173/200", + "header_bits": 2695, + "internal_exponent": "6647060323670676329/6658580000000000000", + "internal_margin": "332929323671/6658580000000000000", + "joint_arithmetic_sha256": "c4740234bee2bab8292aeef7fb561246cff8a060ea6e96f0bc14a7b69c62042c", + "leaf_exponent": "19965399034601/20000000000000", + "leaf_margin": "965399/20000000000000", + "maximum_local_group_instructions": 31632, + "moment_minus_one": [ + "-33989562751811586763128131904117409800226978209787909368775448862027064463490500701933615095451456395537816144932191/12886032106468850481583737274350967458813277931013019678285809874924520848150447758356921635997562811169399617949941104640", + "-606956477710921192198716641144953746432624610889069810156704443964769008276616083963100269561633149920318144962697/230107716186943758599709594184838704621665677339518208540818033480795015145543709970659314928527907342310707463391805440" + ], + "rank_mass": 23431680, + "reserved_margin": "27/100000", + "sigma": "19965399/20000000", + "stopping_power": 1000000, + "tau": "332353/332929" + }, + "positive_children": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "5": 66420, + "8": 25920, + "48": 138492 + }, + "retained_binding_ast_sha256": "70034765430d25f66abe612045604b6b299107472fab639274c97374485c6159", + "schedule": { + "all_owner_entries": 2047680, + "data_charts": 1008, + "distinct_pending_suffixes": 896, + "pending_children": 162900 + }, + "scope": "All finite global owner/event/child bindings; all-cover and all-width endpoint and cost are written compositional proofs under the retained primitive/root contracts. No production physical payload execution or formal kernel proof.", + "source_bundle_sha256": "511ef8e6f9d1519886a8a531d788af6ef51bfcf684172a15890895f66dbcf308", + "source_sha256": { + "research/physical-complex-controller/PROOF.md": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "research/physical-complex-controller/cover.py": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "research/physical-complex-controller/selected_binding.py": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "research/t74-physical-layer/binding.py": "bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057", + "research/t74-retuned-physical-layer/PROOF.md": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f", + "research/t74-retuned-physical-layer/active_plan.py": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e", + "research/t74-retuned-physical-layer/active_root.py": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7", + "research/t74-retuned-physical-layer/active_sources.py": "599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49", + "research/t74-retuned-physical-layer/retuned_machine.py": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a", + "research/t74-retuned-physical-layer/retuned_native.py": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc" + }, + "status": "PASS_POOLED_GLOBAL_PHYSICAL_BINDING_WITH_RETAINED_PRIMITIVE_CONTRACTS" +} diff --git a/research/complex-pooled-full-admission/evidence/PHYSICAL-LOCAL.json b/research/complex-pooled-full-admission/evidence/PHYSICAL-LOCAL.json new file mode 100644 index 000000000..071696a02 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/PHYSICAL-LOCAL.json @@ -0,0 +1,785 @@ +{ + "affine_coverage": "Every 73-bit address by symbolic affine forms, both directions", + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "controls": [ + "missing_Z_release", + "Z_release_before_allocation", + "wrong_warp_source_frame", + "unpriced_positive_rank_warp", + "lowered_warp_omitted", + "lowered_warp_inverted", + "lowered_warp_wrong_recipe", + "Z_release_changed_to_unchecked_clear", + "Z_release_wrong_private_slot" + ], + "inherited_affine_source_sha256": "394f9a465ac9148af0c20844d375e4befbef17d92b2fcc840d83419480dd4740", + "local_packet_roles": 731, + "maximum_affine_gates": 61, + "maximum_ordinary_calls_per_outer_row_per_monomial": 524, + "maximum_quadratic_terms": 25, + "monomial_literals": 3848, + "native_phase_columns_per_literal": 512, + "native_sha256": { + "extra": { + "CANONICAL-WORD.json.gz": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379", + "CLIFFORD-RECIPES.json": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06", + "LOCAL-PROGRAMS.json.gz": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "RESIDUAL-ADAPTERS.json": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d" + }, + "extra-four": { + "CANONICAL-WORD.json.gz": "06168f8f432aa153a0605177e95239261d093894f1c3cc826fcd98fc5671c2f3", + "CLIFFORD-RECIPES.json": "d259754558d9616665069423644a71535b5c331a565c77211b9719f0a319d29d", + "LOCAL-PROGRAMS.json.gz": "d1f91c2d18262e4aff221fa0daa8441a968ececc4fd53ae3b52b4db9afb5aaba", + "RESIDUAL-ADAPTERS.json": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d" + }, + "gauge44": { + "CANONICAL-WORD.json.gz": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542", + "CLIFFORD-RECIPES.json": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2", + "LOCAL-PROGRAMS.json.gz": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "RESIDUAL-ADAPTERS.json": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76" + } + }, + "persistent_roles": 632, + "private_Z_roles": 91, + "private_centre_roles": 8, + "programs": { + "extra": { + "backward": { + "instruction_counts": { + "child": 3554, + "identity": 754, + "marker": 10, + "monomial": 7962, + "release_zero": 91, + "scalar": 17437, + "zero": 107 + }, + "instructions": 29915, + "local_code_sha256": "872bff599b525188359f38fe75a7cb0eff2d278983b26890a2e7b2200720d768", + "paid_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62993, + "source_events": 22807, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + }, + "forward": { + "instruction_counts": { + "child": 3554, + "copy": 8, + "identity": 754, + "marker": 10, + "monomial": 7962, + "release_zero": 91, + "scalar": 17429, + "zero": 107 + }, + "instructions": 29915, + "local_code_sha256": "6c444a31ca41ba7ebb4105af3957bc115161ad7525126747819c9f0664511078", + "paid_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62977, + "source_events": 22807, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + } + }, + "extra-four": { + "backward": { + "instruction_counts": { + "child": 3556, + "identity": 754, + "marker": 10, + "monomial": 7966, + "release_zero": 91, + "scalar": 17436, + "zero": 107 + }, + "instructions": 29920, + "local_code_sha256": "10e8a58cb019895a9aac37554e59d90f028e1fb3b06b6bc2033cd2bd03743795", + "paid_profile": { + "1": 2489, + "2": 713, + "3": 227, + "4": 99, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62983, + "source_events": 22808, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + }, + "forward": { + "instruction_counts": { + "child": 3556, + "copy": 8, + "identity": 754, + "marker": 10, + "monomial": 7966, + "release_zero": 91, + "scalar": 17428, + "zero": 107 + }, + "instructions": 29920, + "local_code_sha256": "914dadeb7a70d906dcdfb5b5aab239e7934defe5b03372c1208fda70db3e01ef", + "paid_profile": { + "1": 2489, + "2": 713, + "3": 227, + "4": 99, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62967, + "source_events": 22808, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + } + }, + "gauge44": { + "backward": { + "instruction_counts": { + "child": 3554, + "identity": 754, + "marker": 10, + "monomial": 7962, + "release_zero": 91, + "scalar": 17437, + "zero": 107 + }, + "instructions": 29915, + "local_code_sha256": "5dbad741fb84da0cd0e158e5bc9ad976ffdb70093f67804419adcf2417474038", + "paid_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62993, + "source_events": 22807, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + }, + "forward": { + "instruction_counts": { + "child": 3554, + "copy": 8, + "identity": 754, + "marker": 10, + "monomial": 7962, + "release_zero": 91, + "scalar": 17429, + "zero": 107 + }, + "instructions": 29915, + "local_code_sha256": "1096096adaf8bfa3baaddc38ddbd91ed07b428d0c352cf51fa8f91673af64c85", + "paid_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "scalar_recipe_instructions_plus_packet_zero_copy_release": 62977, + "source_events": 22807, + "source_warps": 240, + "source_zero_events": 182, + "zero_map": { + "226": 640, + "228": 641, + "230": 642, + "249": 643, + "251": 644, + "265": 645, + "267": 646, + "277": 647, + "282": 648, + "293": 649, + "298": 650, + "299": 651, + "304": 652, + "307": 653, + "309": 654, + "311": 655, + "314": 656, + "320": 657, + "323": 658, + "325": 659, + "327": 660, + "330": 661, + "331": 662, + "337": 663, + "339": 664, + "341": 665, + "346": 666, + "353": 667, + "355": 668, + "357": 669, + "362": 670, + "363": 671, + "369": 672, + "371": 673, + "373": 674, + "378": 675, + "385": 676, + "387": 677, + "389": 678, + "394": 679, + "395": 680, + "408": 681, + "412": 682, + "424": 683, + "428": 684, + "448": 685, + "449": 686, + "450": 687, + "451": 688, + "452": 689, + "453": 690, + "454": 691, + "455": 692, + "482": 693, + "483": 694, + "494": 695, + "495": 696, + "496": 697, + "497": 698, + "503": 699, + "504": 700, + "505": 701, + "506": 702, + "507": 703, + "508": 704, + "525": 705, + "526": 706, + "527": 707, + "537": 708, + "548": 709, + "549": 710, + "550": 711, + "551": 712, + "560": 713, + "561": 714, + "566": 715, + "567": 716, + "568": 717, + "569": 718, + "574": 719, + "575": 720, + "576": 721, + "577": 722, + "578": 723, + "579": 724, + "580": 725, + "581": 726, + "582": 727, + "583": 728, + "584": 729, + "585": 730 + } + } + } + }, + "recipe_sha256": "5224d98a1a81f87adeda4942bc1d8fcbe7def39c8e5ddeeb152d7dd64ddd9cc9", + "scalar_literals": 36, + "scalar_maximum_instructions": 10, + "scalar_prefix_denominator_bits": 3, + "scalar_prefix_l1": "9", + "scope": "Unchanged retained compiler on all six exact current programs; independent symbolic affine check; complete finite native phase table; source-preserving scalar prefix identities. All-width primitive, complete global owner binding, physical ordinary B2 and outer transfer are separate written contracts. No physical payload execution or formal-kernel proof.", + "source_bundle_sha256": "91226b99943069f21d845c3242b54ba492418d1194422d04cf2569fd14cbb9ea", + "source_sha256": { + "research/physical-complex-compact/PROOF.md": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48", + "research/physical-complex-controller/bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "research/physical-complex-controller/machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "research/physical-complex-controller/scalar_packets.py": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "research/physical-complex-controller/scalar_program.py": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "research/physical-gaussian-leaf/inputs/pr3087.tar": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "research/physical-scalar-stream/scalar_engine.py": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "research/physical-scalar-stream/scalar_words.py": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "research/t74-physical-layer/PROOF.md": "1054f13f3e370a2e5d5f5cbc0e767e84927d4879f4c7be54cccb9b9a6a58e8ba", + "research/t74-physical-layer/compile_word.py": "1ae8eeedd1a3e8fea68762550d6f7c9495112785ed82bf824d8f82eba21f64a2", + "research/t74-physical-layer/t74_machine.py": "3bc4c40f275852cea82dbdcf41b8e586bae2e599112ee073a367acc66f37ce83" + }, + "status": "PASS_POOLED_SIX_PROGRAM_LOCAL_LOWERING_NOT_GLOBAL_MACHINE_ADMISSION" +} diff --git a/research/complex-pooled-full-admission/evidence/PREFIX-AND-INVOICE.json.gz b/research/complex-pooled-full-admission/evidence/PREFIX-AND-INVOICE.json.gz new file mode 100644 index 000000000..539f9d11e Binary files /dev/null and b/research/complex-pooled-full-admission/evidence/PREFIX-AND-INVOICE.json.gz differ diff --git a/research/complex-pooled-full-admission/evidence/RELEASE-RECEIPT.json b/research/complex-pooled-full-admission/evidence/RELEASE-RECEIPT.json new file mode 100644 index 000000000..116eced51 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/RELEASE-RECEIPT.json @@ -0,0 +1,7 @@ +{ + "status": "PASS_RELEASE", + "kappa_decimal": "0.0017309802559890369599619999999999999999999998999999999999999999999999", + "manifest_sha256": "f1aa401c875cd3549e11e05e835b5209a26ccd7b56d0d5de138c34c25b6c2f9e", + "proof": "Supplier: the package's own unchanged `verify.py` (retained PR1297 provider and parent admission, owner reconstruction, parent lift, strict T74 admission, geometry controls): `PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION`, native reuse {'base': 'e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e', 'extra': '7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905'}; its complex endpoint 865490127994518479981/50000000... brackets the ledger's b = 173098025598903695996199999999999999999999999999999999999999999999999999999999999999999999999999999999/100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000. Outer (PR1673 capped phase-cell fusion): regenerated exact ledger (63 strict inequalities: the 62 retained rows plus the explicit main-binding row gaussian_above_main, the fixed-grid maximum kappa = C - 1/F - B asserted, 17 rejecting controls incl. the old g-factor union row, the old linear and old-theta chirp guards, the old 2*beta tag test, epsilon at 1 or at the r0 slack and beta outside its window, larger endpoint rejected by the native moment), independent balance derivation, the exact union-schedule simulation, the (retained, not used for kappa) structured-boundary displacement-rank check, the gauge-free identity/symbol/circuit checks, PR1786's finite prime/underflow controls and 19 exact evidence replays all pass. Conditional kappa 0.0017309802559890369599619999999999999999999998999999999999999999999999 (union schedule outer/UNION-SCHEDULE.md; explicit Strassen boundary tau=45/16 (the structured boundary of outer/STRUCTURED-BOUNDARY.md is not used); gauge-free interiors outer/GAUGEFREE-INTERIORS.md; fine source-prime padding PR1786 at the free point epsilon=1-(1025/1024)e-104, outer/FINE-PADDING-COMPOSITION.md; fixed-grid maximum of PR2180/PR2161 (dataisfire), outer/PROOF-GRID-MAX.md; exact-integer coarse exponential PR2168/PR2184 (dataisfire) at the one 24-digit rejection call).", + "seconds": 627.74 +} diff --git a/research/complex-pooled-full-admission/evidence/RESULT.json b/research/complex-pooled-full-admission/evidence/RESULT.json new file mode 100644 index 000000000..0e3892b55 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/RESULT.json @@ -0,0 +1,30 @@ +{ + "active_providers": { + "extra": "extra", + "extra-four": "extra-four", + "gauge44": "base" + }, + "adaptation_sha256": "bf8cbdebfc860b594035a235e7713716b39b73ec966c753391bcf8c296c04d67", + "call_counts": { + "extra": 592, + "extra-four": 1080, + "gauge44": 1568 + }, + "candidate_profile": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "48": 138492, + "5": 66420, + "8": 25920 + }, + "inherited_result_sha256": "0d2bf59210f6d037e1e064937d1cb8bdafb493c4492888c7fe49dcb21904e927", + "inherited_source_loading": "Clean scientific source trees before and after; bytecode writes disabled.", + "inherited_status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "mathematical_scope": "Finite complete conditional admission; uniform physical and analytic hypotheses remain.", + "operator_receipt_sha256": "d5cb2582e5b108e2072468e49f1c14b1bcc74be96a5127fbb8bcf06a0a3db571", + "selected_frontier_changed": false, + "source_pins": "07d6c095d5ed6d45fec6d9a83732ffcefd5eb785e3d7c05234440a9e74c0b284", + "status": "PASS_POOLED_COMPLETE_FINITE_ADMISSION" +} diff --git a/research/complex-pooled-full-admission/evidence/SPEC.json.gz b/research/complex-pooled-full-admission/evidence/SPEC.json.gz new file mode 100644 index 000000000..f1267baf6 Binary files /dev/null and b/research/complex-pooled-full-admission/evidence/SPEC.json.gz differ diff --git a/research/complex-pooled-full-admission/evidence/STRICT-RESULT.json b/research/complex-pooled-full-admission/evidence/STRICT-RESULT.json new file mode 100644 index 000000000..74ed38aa4 --- /dev/null +++ b/research/complex-pooled-full-admission/evidence/STRICT-RESULT.json @@ -0,0 +1,164 @@ +{ + "status": "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", + "kappa": "1727989140903569/1000000000000000000", + "kappa_decimal": "0.001727989140903569", + "manifest_sha256": "f1aa401c875cd3549e11e05e835b5209a26ccd7b56d0d5de138c34c25b6c2f9e", + "native_reuse": { + "base": true, + "extra": true + }, + "provider_verification": "PASS_GLOBAL_MIXED_X54_FUSIONS_NATIVE_AND_STRICT_ADMISSION", + "roles": 1321920, + "prefix_bits": 1478, + "charged_prefix_bits": 2048, + "physical_row_coefficient": 19549, + "row_limit": 20161, + "controls": { + "admission": 160, + "bit": 12, + "controller": 34, + "independent_owner": 8, + "geometry": 6 + }, + "stages": [ + { + "name": "fine-engine-oracle", + "exit_code": 0, + "seconds": 2.039413250022335, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3" + }, + { + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "exit_code": 0, + "seconds": 0.2685183749999851 + }, + { + "name": "rebuild-words-566", + "exit_code": 0, + "seconds": 1.928434000001289, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f" + }, + { + "name": "reconstruct-owners", + "exit_code": 0, + "seconds": 19.160808082990116, + "log_sha256": "8f599e72eea369fbec0dc30b289b860a9d32cb6ba7519c13fb2348701d0dd145" + }, + { + "name": "lift-parent", + "exit_code": 0, + "seconds": 37.538473083026474, + "log_sha256": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab" + }, + { + "name": "rebuild-borrow-words", + "exit_code": 0, + "seconds": 147.21461962501053, + "log_sha256": "53b627a9024754ea246d38de7431581695e4dae3374bdec5d73e645ba46dcd91" + }, + { + "name": "shared-kernel-independent-review", + "exit_code": 0, + "seconds": 8.299192875012523, + "log_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3" + }, + { + "name": "preload-move-independent-review", + "exit_code": 0, + "seconds": 10.25467187500908, + "log_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda" + }, + { + "name": "two-sided-helper408-review", + "exit_code": 0, + "seconds": 3.555892708012834, + "log_sha256": "feebe0765e4823eb7f92609ffc1e62b5cdf0ca4f35b639755f948eec94f7564c" + }, + { + "name": "paired-extension-review", + "exit_code": 0, + "seconds": 20.731732042011572, + "log_sha256": "ee208f9dc4a8bcae7be12e5701e3b5989882af2b1b6d6a553994c798e3cda51f" + }, + { + "name": "declared-edit-review", + "exit_code": 0, + "seconds": 14.503815665986622, + "log_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13" + }, + { + "name": "staged3605-review", + "exit_code": 0, + "seconds": 0.28857941599562764, + "log_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8" + }, + { + "name": "delayed-release-independent-review", + "exit_code": 0, + "seconds": 8.829953375010518, + "log_sha256": "344f6429f27bce1ca4cb114d45937919a595f738fdf71d74db3e90599bc1ee7f" + }, + { + "name": "staged544-independent-word-review", + "exit_code": 0, + "seconds": 2.7439597499906085, + "log_sha256": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0" + }, + { + "name": "terminal-width5-independent-word-review", + "exit_code": 0, + "seconds": 2.2960841250023805, + "log_sha256": "be24d67b25305edbd7007e3d66204ea332b0589d2e68e8dc9c3ea7b6bf0afe16" + }, + { + "name": "staged-entries-independent-word-review", + "exit_code": 0, + "seconds": 6.319684625021182, + "log_sha256": "6b584a0cb534d19f4683dde3a32ccc826ba405344ef267b2a91507b6ae49d513" + }, + { + "name": "receiver-sharing-independent-word-review", + "exit_code": 0, + "seconds": 2.5042128749773838, + "log_sha256": "4598a833dda6247b7f0f2ac377a4e584254615ac8677745b0cc9e68385c1facf" + }, + { + "name": "audit-local-566-base", + "exit_code": 0, + "seconds": 0.6592982909933198, + "log_sha256": "d3eb4bb3395b8c430f0b6ed0b9188862b5afbf50815cb8d06f02105e01e86324" + }, + { + "name": "audit-local-566-extra", + "exit_code": 0, + "seconds": 0.6505022500059567, + "log_sha256": "6bff40d6258efbe166b279461dbc7230550fea4c96fa57da69f118246c88871c" + }, + { + "name": "rebind-566", + "exit_code": 0, + "seconds": 7.3599830840248615, + "log_sha256": "139b3330e688d87f2056c7547ef8dfc7601024bf2dbb5251d11c81fc911b16e8" + }, + { + "name": "lemmag-labels", + "exit_code": 0, + "seconds": 24.7274164170085, + "log_sha256": "d9a788a3f7d6cc290807e45c92328b3092fb831f552d0d6bd2cae29f90d1274e" + }, + { + "name": "strict-t74", + "exit_code": 0, + "seconds": 359.59552404200076, + "log_sha256": "27776975bd52dbd1829f046bd79cc60f4a0f7dcf9d11d93769bcd2c0f987dfa5" + }, + { + "name": "geometry-controls", + "exit_code": 0, + "seconds": 0.43546212499495596, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9" + } + ], + "scope": "Conditional finite construction only. All-size compiler, common-label/mutable-source realization, whole-call hosting, precision/tape, exact recovery, analytic transfer, PR559 recurrence correction and PR589 bit H1-H5 assumptions remain. No unconditional theorem, full Lean certification, or global packing claim." +} diff --git a/research/complex-pooled-full-admission/frozen/RECORDED-INPUT-PINS.json.gz b/research/complex-pooled-full-admission/frozen/RECORDED-INPUT-PINS.json.gz new file mode 100644 index 000000000..65560b2e2 Binary files /dev/null and b/research/complex-pooled-full-admission/frozen/RECORDED-INPUT-PINS.json.gz differ diff --git a/research/complex-pooled-full-admission/frozen/outer-source/MANIFEST.json b/research/complex-pooled-full-admission/frozen/outer-source/MANIFEST.json new file mode 100644 index 000000000..19171f1ae --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/outer-source/MANIFEST.json @@ -0,0 +1,254 @@ +{ + "canonical_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "bytes": 7048, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "0e259d42c996742e9e3cba14c677129b2c1b6311", + "path": "references/semantic-bulk/rad20/LICENSE", + "sha256": "a2010f343487d3f7618affe54f789f5487602331c0a8d03f49e9a7c547cf0499" + }, + { + "bytes": 1470, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "544634f5f3001c50330413f22dc0070e07c46738", + "path": "references/semantic-bulk/rad20/NOTICE", + "sha256": "82fc72aff49769ae82a8ce886846d9bd0601827a09c955042d26a61177d14369" + }, + { + "bytes": 11235, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "de7a916369cc36737fd96b9b0172e2ef453c6b03", + "path": "references/semantic-bulk/rad20/reports/review-reusable-banded-inverse.md", + "sha256": "801359569c92f9d5ddd128b694993a5ac22a468e87bfea478cecc0ee413d058b" + }, + { + "bytes": 2322, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "efd965ec0f01c8ba176c0a7fdffb9494fdda704b", + "path": "research/crt-address-streams/NETWORK-SOURCES.json", + "sha256": "c843e86f64902c63cfbac72b7d743ae628abd430ba3987a0b8c6254de3b9b22b" + }, + { + "bytes": 11035, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "479a2b727b67b88efc8bdc64bde340a1c0d95ec3", + "path": "research/crt-address-streams/PROOF.md", + "sha256": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4" + }, + { + "bytes": 823, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "47203dc21d58da7a844aa43f3f5ba72ece13c41f", + "path": "research/crt-address-streams/SOURCES.json", + "sha256": "96b3228ee210e10c9f6c597061eec79917d28c1dc31173842d803b72b672493b" + }, + { + "bytes": 11706, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "eec21ef3e629abb5d9b21f9ea09a1cbd3655daa4", + "path": "research/crt-address-streams/crt_converter.py", + "sha256": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea" + }, + { + "bytes": 7013, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "23b6cd3fecdb8c5ec1bd7ec2637679efcf20c22a", + "path": "research/crt-address-streams/crt_shape.py", + "sha256": "4073253569e5941de30e26b9ed83b9f1fcdb2c186b20123c7757f2edd7e2153a" + }, + { + "bytes": 7176, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "fa0effe0bc5c34ae560bc045fdf4470840b028a7", + "path": "research/crt-address-streams/crt_sources.py", + "sha256": "6a7e28fb2b3584a382ddec57902fcdd963d3af7c241a4541023666aba7f3d140" + }, + { + "bytes": 11024, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "56b12bd4f0727f333b368ac59839fd4e423b9b9a", + "path": "research/physical-chirp-middle/PROOF.md", + "sha256": "92cccf922e0e79fcffc5b6883812c6c5f162565c926f9d807791f6b850ac0951" + }, + { + "bytes": 5310, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "801c8e0ce13ec5aea504004f15f847ecf37add25", + "path": "research/physical-chirp-middle/chirp_engine.py", + "sha256": "95c74ed419a1d525755542f5d951dc73c841055e018b25c546901b10fc21bd1a" + }, + { + "bytes": 6337, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "4670745b77c117128821160b41863ad9a160b215", + "path": "research/physical-chirp-middle/cyclic_engine.py", + "sha256": "38c37e1176160607f2e0e6912242e65de2a59afbc1ba909acabf099c59fb34c1" + }, + { + "bytes": 20177, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "883c8d4a6f0eead888fb3532b60db41596940889", + "path": "research/physical-gaussian-core/PROOF.md", + "sha256": "e909026dd3f455c35ff28210a0c4ffa232ad8d7633174e481094fd09e2469d7a" + }, + { + "bytes": 12006, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "89642f4740c62460835380a3bfa00f63808009a8", + "path": "research/physical-gaussian-expansion/PROOF.md", + "sha256": "5452f3e2191824b4a8451c83fbdf58b3b2228f4e1966a6f22c3e60bd152e56b0" + }, + { + "bytes": 13933, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "0f59178830599efa2c689627664245f0ac04f959", + "path": "research/physical-gaussian-tensor/PROOF.md", + "sha256": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e" + }, + { + "bytes": 13918, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "779023d7e2c82f5dcf0d78c32ffd067e923572f7", + "path": "research/physical-gaussian-tensor/tensor_engine.py", + "sha256": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1" + }, + { + "bytes": 3429, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "83a40a9ada87ae94cadc1ed2ddaa11c482c1d318", + "path": "research/physical-gaussian-tensor/tensor_fixture.py", + "sha256": "f699d1c52334f42fe548b71c199a79381a980fb351c77515acd107f848cf100b" + }, + { + "bytes": 12079, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "239caba2d2ccf2640c36d377949df3fb6a920cf0", + "path": "research/physical-gaussian-tensor/tensor_plan.py", + "sha256": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3" + }, + { + "bytes": 7709, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "6f5177cfa1bd03f145527c6ad5ca1ddef74716fd", + "path": "research/physical-gaussian-tensor/tensor_router.py", + "sha256": "cf6d7c58396517d15a28f836676d1da679b68796b48b0f780f6131c8a1d2b2fa" + }, + { + "bytes": 9250, + "commit": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "git_blob": "00edf5a03fad4ed69891dd0ca4a6909bd68ef4cf", + "path": "research/physical-gaussian-tensor/tensor_sources.py", + "sha256": "cba69b2bc93b7dabbffdbdf07fb41130fde5d65a8f4d344ade52d3a326e30ac0" + }, + { + "bytes": 15716, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "2bc9926799296bb348193e68e55aed60ec6ce96d", + "path": "research/physical-ring-product/PROOF.md", + "sha256": "a2e43fe5f77350958c2d7d66a50389e5ec6b439a7f9620e94862b969e88fb500" + }, + { + "bytes": 6305, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "02e4dd8e612d5d782a7b260b817b25ffd54348a8", + "path": "research/physical-ring-product/convolution_engine.py", + "sha256": "3d9941f986ad27e8b7ae8f46df2dc3a9ae7a2b119a69195735a5c735dc5aba65" + }, + { + "bytes": 8118, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "67e09e91103535fd1eb0b2d7d6db1fdc13de07d2", + "path": "research/physical-ring-product/word_product.py", + "sha256": "12020ed0571fa756c2d19942b6ccdd6dc5627fdaadb388051417a618c14417d6" + }, + { + "bytes": 15276, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "aa3c20a49eac7ec7406cf3ee3bab827181aeba09", + "path": "research/physical-synthetic-fourier/PROOF.md", + "sha256": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7" + }, + { + "bytes": 9377, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "b62324aefc18fc5b90c1693a751662e08f5b7cd4", + "path": "research/physical-synthetic-fourier/fourier_engine.py", + "sha256": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9" + }, + { + "bytes": 18754, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "f26af67ae1ee4d9886d4e4b28d5332994f492bc2", + "path": "research/selected-conservative-outer/PROOF.md", + "sha256": "4afeb1708cf9568a9cd25afc72b159d5b06d151a6a6aba567a50970b38a1f513" + }, + { + "bytes": 14261, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "728ff53e7217e34b463cfcf86cc81624ea9b1dd2", + "path": "research/t74-retuned-physical-layer/PROOF.md", + "sha256": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f" + }, + { + "bytes": 5202, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "c3a01cd8c4f52cab478aefacad60f64f60f1453a", + "path": "research/t74-retuned-physical-layer/active_plan.py", + "sha256": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e" + }, + { + "bytes": 1424, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "8f63fc094432692b7fd81aad14d937320fda4354", + "path": "research/t74-retuned-physical-layer/active_root.py", + "sha256": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7" + }, + { + "bytes": 8835, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "4f7f8d1aa8ea37aa7e66f6887606821a0b48bbba", + "path": "research/t74-retuned-physical-layer/active_sources.py", + "sha256": "599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49" + }, + { + "bytes": 3939, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "f01b69888e53a81be986fd59f3e5e05f7a4e4087", + "path": "research/t74-retuned-physical-layer/retuned_machine.py", + "sha256": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a" + }, + { + "bytes": 890, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "7f51e925db0e4e6885107ad51e09f90b95757900", + "path": "research/t74-retuned-physical-layer/retuned_native.py", + "sha256": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc" + }, + { + "bytes": 12209, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "c0c7c9df28e2ac7afc51d40fd3e31de668e01703", + "path": "research/t74-support-composition/PROOF.md", + "sha256": "7c12a3ba5617b2bcbf5d2614db4fdc297fc619cd430366137386a70e9698f925" + }, + { + "bytes": 9081, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "646c451a4cbdf0244c7782d958f257f6606b962f", + "path": "research/t74-support-composition/composed_engine.py", + "sha256": "e6fb1b83f301027fe0f80732817b96d662bd365c9d5279e8949c20b1186ced4f" + }, + { + "bytes": 46444, + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_blob": "337810a1d9a58a2ecf14123420923c039ba322a6", + "path": "upstream/build/sections/08-assembly.tex", + "sha256": "763d7945b1e1ec4ebae9b799bcefcc45fa9bae6e2ffad799868a9c3d513dbd4a" + } + ], + "gaussian_head": "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "gaussian_pr": 3935, + "role": "Exact proof and constructor references; not an executable runtime closure or a completed payload replay", + "schema": 1 +} diff --git a/research/complex-pooled-full-admission/frozen/outer-source/SOURCE-CONTRACTS.tar.gz b/research/complex-pooled-full-admission/frozen/outer-source/SOURCE-CONTRACTS.tar.gz new file mode 100644 index 000000000..af213ec94 Binary files /dev/null and b/research/complex-pooled-full-admission/frozen/outer-source/SOURCE-CONTRACTS.tar.gz differ diff --git a/research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz b/research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz new file mode 100644 index 000000000..49283533a Binary files /dev/null and b/research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz differ diff --git a/research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz b/research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz new file mode 100644 index 000000000..d5a802e31 Binary files /dev/null and b/research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz differ diff --git a/research/complex-pooled-full-admission/frozen/pr4180/COVERAGE.md b/research/complex-pooled-full-admission/frozen/pr4180/COVERAGE.md new file mode 100644 index 000000000..12096f4d4 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/COVERAGE.md @@ -0,0 +1,55 @@ +# Admission coverage and invalidation + +This map describes the exact PR4088 words and literal fill carried through the +retained PR4085 engine. Paths in the caller column are in the reconstructed +source or runtime tree. `adapt.py` records exact preimages and hashes for every +change. A completed discovery run is not strict admission. + +| Obligation | Actual caller and input binding | Evidence or rejection control | +| --- | --- | --- | +| Four local provider definitions, both orientations, shared helper order | Retained PR4088 `verify.py --controls`; `adapt.extend_source`; native full/canonical word identity | Exact source words, widths and profiles; changed word and omitted provider reject | +| Complete native source and execution products | `replay.bind_cache`, `native_outputs.authenticate_native`, then inherited cache/generated-identity checks | Exact compiler closure; `native`, `ledgers`, `local-replay`, `wrappers`, `phases`; eleven fixed scientific products per provider | +| Literal selector and per-call mixed dispatch | Inherited reconstruction and parent lift; `new/rebind.py` calls `mixed_binding.validate_rebind`; provider arguments enter both discovery and strict replay | All 3,240 calls have the exact provider, orientation and program; selector `(109*t) % 324 < 109`; omitted/same-width-wrong-program/coherent-dispatch mutations reject | +| Width, owner capacity and chronology | Retained PR4088 owner/operator gates; independent parent lift; inherited controller audit; `binding.account` | Each of 1,321,920 rows uses the selected width and strict window; compact prefixes, per-call non-aliasing, capacity and physical owner identity; width 7/8 adversarial fixture | +| Recomputed idle and complete paid profile | `validate_rebind` compares its complement accounting to `CONSTRUCTION.json` and `PLAN.json`; downstream invoice consumes rebound plan | Mixed idle `{3:22783,5:1625,48:138492}`, total mass 23,431,680; stale idle and changed complete profile reject | +| Phase and native endpoint evidence | Retained PR4088 `operator_verify.py --controls`; native exact recipe/endpoint checks; inherited local and Lemma-G checks for each provider and orientation | 10,416 all-character identities over 112 ports; exact phase mutant, omitted phase stage and false private-work erasure reject | +| Full stock/reserve/depth cost | Inherited `extension_blocknorm.py`, `blocknorm_certificate.full_stock_l2`, invoice, assembly and `independent_core`; exact rebound native ABI and per-call profile | 632 arbitrary columns, 91 zero buffers, 8 centers; actual local prefix 95 with reserve 128, active boundary depth 18, actual stock l2 1323 with cap 1330; actual global prefix 1478, charged payload 2048, physical inventory 323,069, physical row coefficient 19,549 below 20,161 | +| Discovery and frozen certificates | Inherited `replay.py --discover` runs bind, emit, audit, invoice, assembly, freeze, independent | Records actual mixed certificate; discovery alone is not accepted as release | +| Ordinary strict verification | Inherited `verify.py` and its strict `replay.py`, with four provider directories propagated to both calls | All inherited predicates retained; four-provider control targets: 201 assembly, 43 controller, 12 bit, 8 independent owner and 6 geometry controls | +| Outer admission | Inherited `outer/check_ledger.py`, `outer/independent_check.py`, top-level `verify_release.py` | Rebound complete paid profile and all ordinary prerequisites; reproducing the headline moment root alone is insufficient | +| Uniform all-size mathematics | Outside this finite engine | General generation/lifting, conditioning, fixed-tape realization and analytic transfer remain unresolved here | + +## Two corrected draft reuse gaps + +The separate adversarial context found two failures in early versions of this +successor, before publication. These are not attributed to PR4088 or PR4165. + +First, an existing preflight's successful source reconstruction did not by +itself authenticate the cached admission driver. The final gate requires the +exact inherited engine SHA256 +`e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1`, +the exact 676-file source inventory, adapter bindings, three review stages and +all 95 retained engine/helper/native-cache inputs. A changed engine is rejected +before the source adaptation can consume it. + +Second, a native source hash and successful stage flags did not commit the +produced operators. The phase mutation changed a warp's left phase modulo 4 +and refreshed recipe references. The source's exact recipe checker rejected +the resulting operator. The final reuse gate compares every scientific product +to fixed commitments, including when all internal references are coherently +updated. It never derives an expected commitment from the supplied cache. + +The regression includes the latter mutation, missing-stage and endpoint +controls. The clean release records the actual native executions and inherited +controls separately; a regression success is not substituted for those runs. + +## Evidence categories + +* **Original authors' retained evidence:** unchanged THREE native results and + predecessor scientific input packages. +* **Campaign execution:** FOUR native replays, exact source reconstruction, + independent reviews and the extended inherited admission. +* **Separate AI checks:** an independent event/span accounting method and an + adversarial implementation review. These are not independent human review. +* **Not established here:** formal proof, a maintainer-reviewed new frontier, + or the complete integer-multiplication theorem. diff --git a/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.json b/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.json new file mode 100644 index 000000000..0e230402e --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.json @@ -0,0 +1,648 @@ +{ + "actual_inherited_controls": { + "admission": 201, + "bit": 12, + "controller": 43, + "geometry": 6, + "independent_owner": 8 + }, + "actual_output_challenges": [ + { + "name": "actual predecessor preflight", + "status": "PASS" + }, + { + "name": "gauge44 actual native products", + "status": "PASS" + }, + { + "name": "gauge44 wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "gauge44 skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "gauge44 equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "extra actual native products", + "status": "PASS" + }, + { + "name": "extra wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "extra skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "extra equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "gauge44-four actual native products", + "status": "PASS" + }, + { + "name": "gauge44-four wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "gauge44-four skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "gauge44-four equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "extra-four actual native products", + "status": "PASS" + }, + { + "name": "extra-four wrong phase with all recipe references rebound", + "reason": "native scientific output commitment", + "status": "REJECTED" + }, + { + "name": "extra-four skipped phase stage", + "reason": "actual native stage products coverage", + "status": "REJECTED" + }, + { + "name": "extra-four equivalent serialization and timing", + "status": "PASS" + }, + { + "name": "changed engine with rebound completion receipt", + "reason": "preflight admission engine", + "status": "REJECTED" + } + ], + "claim": "The exact retained PR4088 four-provider construction passes the extended inherited finite ordinary/outer release with source-bound per-call widths and a recomputed complete idle invoice.", + "development_release": { + "inherited_seconds": 1780.780658912, + "status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE" + }, + "discovery_stages": [ + { + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "name": "bind", + "seconds": 5.425385736999942 + }, + { + "exit_code": 0, + "log_sha256": "b8f4202fcfa93e19069e726c949b8eefee864eb8a22338dc60e9edce5f7997ba", + "name": "emit", + "seconds": 139.54207018600027 + }, + { + "exit_code": 0, + "log_sha256": "644a2e44045b134104bc7bb45fbda8642347168a8cf32f54fc7af79d5ac8e5a0", + "name": "audit", + "seconds": 396.46721273 + }, + { + "exit_code": 0, + "log_sha256": "a5319a1c6c21f33f7e7f3c4ba3c8b44edd00795f95bf2f457c1e9c13c2445968", + "name": "invoice", + "seconds": 17.163060288999986 + }, + { + "exit_code": 0, + "log_sha256": "7358a8a7e6ee53cd295162c695895ce04ea910655b119c7b64381ffd9395ce39", + "name": "assembly", + "seconds": 0.5220512509995388 + }, + { + "exit_code": 0, + "log_sha256": "fe7a44e785ab2226b2f52945f27fd0362c02f9e0d02c26e4e10f24ff96ddafd1", + "name": "freeze", + "seconds": 0.05886043000009522 + }, + { + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "name": "independent", + "seconds": 25.74216463099947 + } + ], + "driver_stages": [ + { + "exit_code": 0, + "log_sha256": "e2b3ca9377e03e9b25cfb7b5086dac5833f75526298c476409bc69f570594886", + "name": "owners", + "script_sha256": "5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15", + "seconds": 36.32757500799971 + }, + { + "exit_code": 0, + "log_sha256": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "name": "parent-lift", + "script_sha256": "66ed2b2287add939b30af2b9bac22570b93d0a74d902afb5de5fa65cba9d3cac", + "seconds": 71.65258922000021 + }, + { + "exit_code": 0, + "log_sha256": "d68f6853059855ffaa204aaf3d3132d04d69480db5fc7e955b06ac77171ae920", + "name": "rebind", + "script_sha256": "c00f769b29fa49e8b559a26287fbc815a25c51727410ca809f0d12532b07d095", + "seconds": 14.366808935000336 + }, + { + "exit_code": 0, + "log_sha256": "472ea53bfbf046f4844e9e95c460ad97370b660382040f0010b207075c72424c", + "name": "discovery", + "script_sha256": "fd11521257936734d8ac2a2c2c418a1e6b9c629b4d559a93f0ff5be5e0bf2705", + "seconds": 587.2045944200004 + }, + { + "exit_code": 0, + "log_sha256": "dc92e09c5b9dedab975e871b942bdc7ce997909d3c9bbb77c47f10951a11e78d", + "name": "outer-check_ledger.py", + "script_sha256": "1dd56009986eb14dd6603c9193c7ad71dd45c7d005bf71c9cd3f916e66f54d98", + "seconds": 0.04120386999966286 + }, + { + "exit_code": 0, + "log_sha256": "c27d3d0ba2a63a7f8db5da3c3820e3fc4b293b23f8cf8e171dd2940c85c83d62", + "name": "outer-independent_check.py", + "script_sha256": "a5a0361539ec7cae9eb6c0371f857919335a1720040f22af291aa3e34fc864c7", + "seconds": 0.03291257700038841 + }, + { + "exit_code": 0, + "log_sha256": "797cff0086ccefbb0c9bfc92136e5415892f0b43c5b8e4d605be3a585d2c7dba", + "name": "release", + "script_sha256": "6cfefe80c02a6c0f243f50ca9e146e1ab1440b84a033d8a71d42be5a5fa27f6b", + "seconds": 1118.443671162 + } + ], + "finite": { + "calls": 3240, + "charged_prefix_bits": 2048, + "idle": { + "3": 22783, + "48": 138492, + "5": 1625 + }, + "local_prefix_bits": 95, + "physical": 323069, + "physical_row_coefficient": 19549, + "physical_stock_bits": 2646, + "prefix_bits": 1478, + "prefix_formula": { + "active_block_depth": 18, + "bridges": 3240, + "input_l2": 37, + "invocations": 3240, + "local_scalar": 95, + "margin": 4, + "partial_cover": 1, + "stock_l2": 1323 + }, + "profile": { + "1": 8060060, + "2": 2310120, + "3": 751813, + "4": 327210, + "48": 138492, + "5": 66425, + "8": 25920 + }, + "provider_counts": { + "extra": 1110, + "extra-four": 562, + "gauge44": 1040, + "gauge44-four": 528 + }, + "roles": 1321920, + "row_limit": 20161 + }, + "fixed_inputs": { + "NATIVE-OUTPUTS.json": "7a231d9782297d36c5666860003e9b29a8260312c257820b488c8abd17780fc5", + "SOURCES.json": "dc14323136206ceee2bbe56b848effd7cffcae07ab680055beb09ed10bef5113" + }, + "implementation_commit": "b1eb3cec856e1f56a4ce70c583bce738223be6b2", + "independent_ledger_controls": [ + { + "control": "stamp-three-t0", + "detail": "row 29389: expected 8, got 7", + "rejection": "compact-prefix" + }, + { + "control": "offset-hole", + "detail": "row 0: expected 0, got 1", + "rejection": "compact-prefix" + }, + { + "control": "extra-rank-one", + "detail": "", + "rejection": "complete-profile" + } + ], + "isolated_export_files": 208, + "isolated_export_unchanged_after_replay": true, + "limitations": [ + "Finite source-bound admission, not an all-size or formal proof.", + "Author-produced evidence and separate AI checking; no independent human or maintainer review.", + "Unchanged THREE native and retained ancestry receipts authenticated and reused, not rebuilt cold.", + "Selected frontier unchanged; no new kappa claimed.", + "No hosted CI, Windows execution, dense backend or selected-frontier cold replay claimed." + ], + "native_execution": { + "base": { + "engine": "sparse", + "seconds": 74.37671391999993, + "stages": [ + { + "exit_code": 0, + "seconds": 1.0676890469999307, + "step": "native" + }, + { + "exit_code": 0, + "seconds": 1.2444967950000319, + "step": "ledgers" + }, + { + "exit_code": 0, + "seconds": 33.2658251339999, + "step": "local-replay" + }, + { + "exit_code": 0, + "seconds": 1.7386096579998593, + "step": "wrappers" + }, + { + "exit_code": 0, + "seconds": 37.05364620699993, + "step": "phases" + } + ], + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + "extra": { + "engine": "sparse", + "seconds": 65.27442802099995, + "stages": [ + { + "exit_code": 0, + "seconds": 1.0079365389997292, + "step": "native" + }, + { + "exit_code": 0, + "seconds": 1.2680895930002407, + "step": "ledgers" + }, + { + "exit_code": 0, + "seconds": 28.34220983100022, + "step": "local-replay" + }, + { + "exit_code": 0, + "seconds": 1.7045661110000765, + "step": "wrappers" + }, + { + "exit_code": 0, + "seconds": 32.946490324000024, + "step": "phases" + } + ], + "status": "PASS_COMPLETE_T74_NATIVE_REPLAY", + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + } + }, + "ordinary_stages": [ + { + "exit_code": 0, + "log_sha256": "ea6df7be568d6461ac54e0d56754797de0f70f2f1ecc335114791445b75795d3", + "name": "fine-engine-oracle", + "seconds": 2.7065371510007026 + }, + { + "exit_code": 0, + "name": "retained-provider-and-parent-admission", + "reused_receipt": "e0eefc96567fbb45e19e6de0ca295381dbe0e686c08ddc783639b065c7c791d4", + "seconds": 0.38355172199953813 + }, + { + "exit_code": 0, + "log_sha256": "dcbcbeda80423df29ef008bfac58409378f1fd0a3b9b23fc31ab9f03659dd86f", + "name": "rebuild-words-566", + "seconds": 3.0525175610000588 + }, + { + "exit_code": 0, + "log_sha256": "e2b3ca9377e03e9b25cfb7b5086dac5833f75526298c476409bc69f570594886", + "name": "reconstruct-owners", + "seconds": 40.22737005399995 + }, + { + "exit_code": 0, + "log_sha256": "2d738a7322c4303d36deb694e6d79b6b51bfe098642bf5cda8abc319f03d66ab", + "name": "lift-parent", + "seconds": 74.72428813200077 + }, + { + "exit_code": 0, + "log_sha256": "8db780424ae2b9a2cfe8b8ed2d6fb76b3db3580348b7b3dbbc6fd2e3fe168072", + "name": "rebuild-borrow-words", + "seconds": 261.0704355709995 + }, + { + "exit_code": 0, + "log_sha256": "3dc6eb8940cf8a4b993f80129c98b6c4846ad346ccf773a78af225cff3339cc3", + "name": "shared-kernel-independent-review", + "seconds": 14.209026573000301 + }, + { + "exit_code": 0, + "log_sha256": "c456d3e39c09e960ceebf80251d5e808fa9299991471fd86f4093d9bc4dd3eda", + "name": "preload-move-independent-review", + "seconds": 18.142910587999722 + }, + { + "exit_code": 0, + "log_sha256": "a580354334d31376297292b4cb3c4edb0b53496a27700dbce15079305dac7457", + "name": "two-sided-helper408-review", + "seconds": 6.344389111000055 + }, + { + "exit_code": 0, + "log_sha256": "675cf2d9e49433fd6345462a4eacff74f6c37fd5fa0c167bbd8135822ab2562c", + "name": "paired-extension-review", + "seconds": 37.63992583500021 + }, + { + "exit_code": 0, + "log_sha256": "9812aa8d08d4251d390eb0cea1e5731dc59d22e09e0c914823c77d3e2e233e13", + "name": "declared-edit-review", + "seconds": 25.923998927000866 + }, + { + "exit_code": 0, + "log_sha256": "de2fa433a259e21f69f10db63667ba6034e0cd35f102a989208e865d042c31c8", + "name": "staged3605-review", + "seconds": 0.5407488490000105 + }, + { + "exit_code": 0, + "log_sha256": "145c88b1dff898d6b482558ca13a21f539c7f81b5bd5f2e6857156473692c9c4", + "name": "delayed-release-independent-review", + "seconds": 15.87705145200016 + }, + { + "exit_code": 0, + "log_sha256": "2b3e72ac971d0d7eacd8277defcd85ff3d24771285681d1b99fb6fdc4c3cdbf0", + "name": "staged544-independent-word-review", + "seconds": 5.402585488000113 + }, + { + "exit_code": 0, + "log_sha256": "be24d67b25305edbd7007e3d66204ea332b0589d2e68e8dc9c3ea7b6bf0afe16", + "name": "terminal-width5-independent-word-review", + "seconds": 4.287232639000649 + }, + { + "exit_code": 0, + "log_sha256": "6b584a0cb534d19f4683dde3a32ccc826ba405344ef267b2a91507b6ae49d513", + "name": "staged-entries-independent-word-review", + "seconds": 12.144086363000497 + }, + { + "exit_code": 0, + "log_sha256": "4598a833dda6247b7f0f2ac377a4e584254615ac8677745b0cc9e68385c1facf", + "name": "receiver-sharing-independent-word-review", + "seconds": 4.907475904999956 + }, + { + "exit_code": 0, + "log_sha256": "11d2f7b0418ead7e3a3991c0aa3a6776ebd4e4eb9aff5a226129c5a12685f6a6", + "name": "audit-local-566-base", + "seconds": 1.1379442690003998 + }, + { + "exit_code": 0, + "log_sha256": "e78a2eb0b7e2772691ba95c5bd139f817956ac52f52220c6b249bf2078b2b7bc", + "name": "audit-local-566-extra", + "seconds": 1.2681380249996437 + }, + { + "exit_code": 0, + "log_sha256": "d68f6853059855ffaa204aaf3d3132d04d69480db5fc7e955b06ac77171ae920", + "name": "rebind-566", + "seconds": 16.021649397000147 + }, + { + "exit_code": 0, + "log_sha256": "6e9516482c37bb844030d73d01af22e27ccd2a105aebc3ddd8846a7ab45e8e63", + "name": "lemmag-labels", + "seconds": 69.08023641800082 + }, + { + "exit_code": 0, + "log_sha256": "9f9c864207f4f1f98139419bf73c72fa6e5ce8dc07b70d3835e5cdd0c4b5202e", + "name": "strict-t74", + "seconds": 612.8734909570003 + }, + { + "exit_code": 0, + "log_sha256": "0a3ecf05cfa2bebb61fffd2fbb4b244c03d742069e2705d02512699bbf4b01f9", + "name": "geometry-controls", + "seconds": 0.7877863670000806 + } + ], + "outer": { + "exact_evidence_replays": 19, + "independent_status": "PASS_INDEPENDENT_BALANCE_DERIVATION", + "ledger_status": "PASS_FINE_PRIME_PADDING_EXACT_ARITHMETIC", + "rejecting_controls": [ + "endpoint_equality", + "zero_layout_slack", + "old_per_axis_scan", + "full_cell_gauge", + "full_key_sort", + "old_g_factor_union_row", + "old_theta_chirp_guard", + "old_linear_guard", + "old_union_tag_2beta", + "matrix_below_strassen", + "halo_too_short", + "core_too_small", + "group_equals_dimension", + "epsilon_equals_one", + "epsilon_not_above_r0_slack", + "beta_below_gaussian_window", + "beta_above_membership_window" + ], + "status": "PASS_RELEASE", + "strict_positive_inequalities": 63 + }, + "providers": { + "extra": { + "execution": "retained_PR4085", + "native_result_sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce", + "word_sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + "extra-four": { + "execution": "executed_by_this_driver", + "native_result_sha256": "849bc74cdcf9d47a8b30376daab54002223a780c541e5bd0decb3cb26c4c0d18", + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + "gauge44": { + "execution": "retained_PR4085", + "native_result_sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e", + "word_sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + "gauge44-four": { + "execution": "executed_by_this_driver", + "native_result_sha256": "f4461bf354c92f672010d28b06540f36def41c88bd0c607c2db51e97d3e37055", + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + } + }, + "runtime": { + "dependencies": { + "mpmath": "1.3.0", + "numpy": "2.3.5", + "scipy": "1.17.0", + "sympy": "1.14.0" + }, + "platform": "linux", + "python": "3.12.14" + }, + "schema_version": 1, + "scientific_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_bound_receipt_hashes": { + "RESULT.json": "9d3c65bac0cd3ec566804dbd0afe988f087e99e750a78940184abc9daf9338a1", + "admission/RESULT.json": "ab509448ce5eb88035739fa9836b0eb33a8da6ebe79aa77c51f0617c47473835", + "admission/release/RELEASE-RECEIPT.json": "228dca1ce9cef5da86d4116e13f4782768a9828c033a16d1dd14d4928c32e0b9", + "admission/release/outer-tmp/outer/LEDGER.json": "73a236e238023f2d2216c44b19ad2765ee2ce45f46133967b40d1767fe9ba077", + "admission/release/verify/RESULT.json": "f76ad4dad609bfc4ce2259a0bbac201747c9957078a1f01081e76a8e3a5f4af1", + "admission/release/verify/strict/INDEPENDENT.json": "3032c25bb909fbfefcdbd6ef7b75776d22c91182668e6a6ba2a9469bad704fe4" + }, + "source_files": 680, + "source_manifest_sha256": "633c49d337b2053d294c2ef257b2e46f1ca2b4712ad5536747da05ddbcb71e73", + "status": "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "strict_stages": [ + { + "exit_code": 0, + "log_sha256": "71f679ce5a123fb58397fd6852ba64ce3832fd20e81a096bfda9a1cf3237237a", + "name": "bind", + "seconds": 5.3001343500000075 + }, + { + "exit_code": 0, + "log_sha256": "b8f4202fcfa93e19069e726c949b8eefee864eb8a22338dc60e9edce5f7997ba", + "name": "emit", + "seconds": 132.40401873000064 + }, + { + "exit_code": 0, + "log_sha256": "9a3e11fe30dbf47c5e0a54ef462b4b08a2fcafc52111f3082aa0ef5ba38d48e0", + "name": "audit", + "seconds": 414.7160506050004 + }, + { + "exit_code": 0, + "log_sha256": "a5319a1c6c21f33f7e7f3c4ba3c8b44edd00795f95bf2f457c1e9c13c2445968", + "name": "invoice", + "seconds": 19.95038905399997 + }, + { + "exit_code": 0, + "log_sha256": "7358a8a7e6ee53cd295162c695895ce04ea910655b119c7b64381ffd9395ce39", + "name": "assembly", + "seconds": 0.5276581799998894 + }, + { + "exit_code": 0, + "log_sha256": "90e2d631eb82a5edf69c7672e79cf6e261a5d4f4592b5dc09986f1aa6748611b", + "name": "admission", + "seconds": 7.6581824559998495 + }, + { + "exit_code": 0, + "log_sha256": "d54d260bf95bd8ae4ab8846314082b93b2e3d8f427eb35376691f2ce543a6b67", + "name": "bit", + "seconds": 1.3034140260006097 + }, + { + "exit_code": 0, + "log_sha256": "d2c176fb1b9778e4fb8b98b6272d5f713d676ea3fed84da20213eca036bb58fe", + "name": "independent", + "seconds": 28.85628553600054 + } + ], + "tested_python_sources": { + "adapt.py": "3739cbeb4f0e75a475cf95f47ccfca5aee2f0a55abfcd2d0e502e411fad96a1d", + "binding.py": "5a63b937ffc6533a2b8d858d441c210a35a33895242881c5d996459bb2210977", + "challenge.py": "99d3f2c2b628e3eec0fc9fd0397f2ab822ef7230f37c42944e915fe38cd8f9fb", + "independent_ledger.py": "4262571439a845ad93bc4dc119adfe0b1fe8654992653cc56f4c4e3232ce13c3", + "native_outputs.py": "dfc9ae9f651dbf3e248896ee328d0968ee868fd5532252cb5217f04b0de6a5e3", + "replay.py": "25576ade4839c1c0ece1ecd2e9f70ccedd04ed601a4aa28a715286176b8ef096", + "sources.py": "a0c3a7cdbf0a889d1f47fb124209494fc17209d90992f4c12ce154fb786accd0", + "test_binding.py": "5abfc37a6d256951f11f0ac5dd2f1066390d0bdebac984758afc2bcf7348c966", + "verify.py": "e6cf84816fcfdb3bd1b66510539c7b30a08cc15b8e18e3f1715746d73d1826bc" + }, + "wrapper_stages": [ + { + "exit_code": 0, + "log_sha256": "a6bde715fdaa3bac87dde33c570b772e528df26379ad515588a0ed4d335b4c5b", + "name": "pr4088-verify", + "seconds": 11.456949471000371 + }, + { + "exit_code": 0, + "log_sha256": "b33431cc08d680a861ca0a206dc264980ce46b66f6b27f352c7113ba434ae2a4", + "name": "pr4088-owner_verify", + "seconds": 4.37820875899979 + }, + { + "exit_code": 0, + "log_sha256": "1992e3d6debe5ad7688f1221842b4444a546053429167ba8bbba682b7598be21", + "name": "pr4088-operator_verify", + "seconds": 9.245831447 + }, + { + "exit_code": 0, + "log_sha256": "0a7fcecac4dcd5be8347adf0b221d1d7f1aef00973720fd78cc8a63a06dc676d", + "name": "predecessor-preflight", + "seconds": 26.3588124730004 + }, + { + "exit_code": 0, + "log_sha256": "9043965e7f35767772769856a15d4316f21fdc2a12b762da691a84c413b7c7e6", + "name": "native-four-base", + "seconds": 74.43039581699986 + }, + { + "exit_code": 0, + "log_sha256": "2300d8a9b4d84d3cbb588066528087922fb819d14b034b79eb1e579b2d336915", + "name": "native-four-extra", + "seconds": 65.3754942100004 + }, + { + "exit_code": 0, + "log_sha256": "131825ece051c1e45a30c36537235b943c1c4caf9b4d2c363f1355566249b2dd", + "name": "inherited-admission", + "seconds": 1829.7672280440001 + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.md b/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.md new file mode 100644 index 000000000..61efc2270 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/EVIDENCE.md @@ -0,0 +1,192 @@ +# Executed evidence and limits + +Scientific base: `12fa8c5c844be21bfefb38a19503fbd867a11244`. +Task: `supplier-boundary-audit`, priority revision 7, refined to the exact +PR4088/PR4165 four-provider admission handoff. The assignment and experiments +are deterministic; there was no randomized task lottery. + +## Baseline and bounded evidence + +The inexpensive `python3 -B scripts/research_baseline.py` passed +`PASS_RESEARCH_BASELINE_BINDINGS_ONLY`. This checks source bindings, not +mathematical acceptance. + +The retained PR4085 source preflight was executed freshly, redirecting only its +output location into a private external work directory. Its three independent +terminal, staged-entry and receiver reviews passed. It reconstructed exactly +676 source files, manifest SHA256 +`4116ef61479e509811b60b5fd4e84db8811dae079092f2f83bdcc2c80052c0da`, +and admission engine SHA256 +`e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1`. +All 95 non-source archive inputs matched their retained inventory. + +An unmodified inherited owner reconstruction on the real PR4085 THREE control +reproduced its old invoice, including idle +`{3:22842,5:1890,48:138438}`. The independent mixed scan and the new binding +then reproduced the distinct PR4088 invoice in the README. PR4165's existing +five rejection controls also passed; its idle finding is predecessor credit. + +The separate THREE baseline copied `PREFLIGHT/inputs/source` to +`BASELINE_CONTROL`, installed the unchanged retained +`PREFLIGHT/inputs/helpers/reconstruct_replica.py` as `reconstruct.py`, and +placed PR4076's `owner/FILL.json.gz` and `owner/inputs/{ORDER,DISPATCH}.json` +in `new/borrow-fill/`. Its executed command was: + +```sh +python3 -B BASELINE_CONTROL/reconstruct.py --out BASELINE_OWNERS +``` + +Those aliases denote fresh external directories. The source package is +`research/staged544-triple-entry-fill` at the scientific base. Its baseline +input hashes are `a8de70d8cc5e15914881dd4849e51014af261bdd215ced7222ceb111cc5baab9` +(fill), `743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44` +(order), and `5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a` +(dispatch). The unchanged helper hash is +`5472811c24aef3852dc7e189dff5060076a6c0b25bfde928da50dcfe9b5bdc15`. +This initial experiment used the full canonical checkout; the isolated export +contains the 192 inputs consumed by the successor's documented replay commands. + +Both FOUR native sources were freshly executed through all five stages: +`native`, `ledgers`, `local-replay`, `wrappers`, `phases`. Initial executions +took 63.145 and 68.423 seconds. These are observed wall times, not a speedup +claim. Unchanged THREE and parent-admission evidence is explicitly authenticated +reuse, not a fresh cold replay of the entire historical ancestry. + +Executed bounded commands: + +```sh +python3 -B scripts/research_package.py --package research/mixed-provider-admission +python3 -O -B research/mixed-provider-admission/independent_ledger.py --controls +python3 -B research/mixed-provider-admission/challenge.py --work REPLAY_WORK --preflight PREFLIGHT +python3 -O -B research/mixed-provider-admission/challenge.py --work REPLAY_WORK --preflight PREFLIGHT +``` + +`REPLAY_WORK` and `PREFLIGHT` above denote the actual external output directories, +not repository dependencies. The registered command passed the 192 live pins, +14 semantic test methods, all 1,321,920 real rows, the optimized unit controls +and the independent event/span checker. The independent checker also passed +separately under `-O`, with an identical result object. + +The public actual-output challenges passed 18 cases in normal and optimized +Python. They include all four providers, changed phase with coherently rebound +references, skipped native stage, equivalent serialization/timing positives, +and a changed predecessor engine with its completion receipt rebound. + +`python3 -O -B research/mixed-provider-admission/replay.py --work NEW_DIRECTORY` +was rejected before creating the directory, with +`inherited admission requires assertions`. An optimized full release is not +reported as passing. + +## Development failures and corrections + +The first mixed wrapper attempt reached the new rebind gate and failed because +the inherited reconstructor serializes dispatch rows chronologically, while the +literal input table has a different row order. The correction compares the +table as a sorted relation while separately requiring a bijection and checking +every chronological call, program, orientation and width. A permutation +positive control and changed-selector negative controls cover this distinction. +No owner or accounting predicate was removed. + +A separate adversarial AI context demonstrated two draft reuse gaps: an +unbound cached admission driver and native output phases authenticated only by +successful flags. The fixed engine commitment and fixed scientific output +commitments close those demonstrated gaps. That context's 17 bounded follow-up +cases passed before the public four-provider challenge script was added. +These were defects in this unpublished draft, not new allegations about +predecessor mathematics. + +A preliminary metadata-only check rejected the draft outcome string +`in-progress`; it was corrected to the schema's `partial` state. The registered +metadata and pin checks then passed. + +## Full release + +The development replay completed the inherited engine in 1,780.781 seconds: + +* `PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`; +* all seven outer-driver stages, including discovery and final release; +* all 23 ordinary stages, ending in strict replay and geometry controls; +* actual control counts: 201 assembly, 43 controller, 12 bit, + 8 independent owner and 6 geometry; +* `PASS_RELEASE`, 63 strict outer inequalities, 17 rejecting outer controls, + independent balance derivation, union schedule and 19 exact evidence replays. + +The counts above were inspected in the produced ordinary result, strict +receipts and nested outer ledger, rather than inferred from a PR title. +Source and native-cache inventories remained unchanged after admission. + +The implementation commit is +`b1eb3cec856e1f56a4ce70c583bce738223be6b2`. Its 208-file committed export +(16 package files and 192 declared inputs) passed archive integrity and +committed-byte checks. Extracting into a fresh directory without `.git` +passed the direct binding regression and optimized controls. The default full +replay then passed from that export, with fresh source reconstruction and fresh +FOUR native execution. Its seven wrapper stages totalled 2,021.013 seconds, +including 1,829.767 seconds in inherited admission. The fresh FOUR base/extra +native drivers reported 74.377 and 65.274 seconds respectively. These are +single-run wall measurements, not performance comparisons. + +The clean replay reproduced all the statuses and control counts above. +[EVIDENCE.json](EVIDENCE.json) records the actual stage results, receipt hashes, +provider provenance, exact invoice and semantic controls. +[REPLAY.log](REPLAY.log) contains actual executed stdout excerpts, with only +work, source and interpreter paths normalized. Raw receipt hashes identify +this execution; they are not cross-environment deterministic hash claims. +All 208 exported files remained unchanged after execution, and all nine tested +Python files remain byte-identical in the final package. Subsequent changes +only finalize documentation, metadata and these execution receipts. +The registered package check was then rerun on the final tree and returned +`PASS_REGISTERED_RESEARCH_PACKAGE` with outcome `completed`. + +The executed default command, with its external work path abbreviated, was: + +```sh +python3 -B research/mixed-provider-admission/replay.py --work ISOLATED_RELEASE +``` + +The ordinary release ran its 19 exact outer evidence replays. This does not +mean every historical native/parent receipt was rebuilt cold: unchanged THREE +and retained ancestry evidence use the authenticated reuse described above. + +## Review and overlap scope + +The 2026-10-20 08:54 UTC refresh still found canonical main at the scientific +base and priority revision 7. The helper covered all 295 open/draft PRs and +2,695 Discussion records with complete pagination and no warnings. The latest +50 updated PRs were also inspected for merged successors. +A final canonical fetch at 09:06 UTC still returned the same base SHA. + +PR4170's pooled-ceiling transfer and PR4171's independent moment/paid-power +arithmetic are complementary to this actual caller/ordinary/outer integration. +PR4169 audits a PR4100 CRT repair implication. The new Discussion4173 +claim concerns CRT reservoir placement, and PR4172 concerns QQ16 comparison. +No equivalent admission successor or active claim was found in that coverage. +This is an overlap check, +not a proof of novelty. Coordination remained local-only. + +## Checks outside this result + +No repository-wide historical suite, selected #1094 cold replay, Lean proof, +reference dense native backend, Windows execution, or hosted CI was run. +The selected construction is not changed. No complete all-size theorem, +independent human review or maintainer acceptance is established. + +The optional `--check-source-history` publication preflight was not run: +this workspace has shallow history and that check requires a full clone. +All declared source pins resolve at the canonical base, which is the +implementation commit's immediate parent; no unreachable PR-head object is +needed. Metadata, Git-blob pins, committed bytes and the Git-free export are +checked separately. A reviewer with full history can additionally run: + +```sh +python3 -B scripts/check_research_commit.py \ + --package research/mixed-provider-admission --check-source-history +``` + +The numerical environment is CPython 3.12.14 on Linux, NumPy 2.3.5, +SciPy 1.17.0, SymPy 1.14.0 and mpmath 1.3.0, all already installed. +The full driver checks these dependency versions before running. +The registered regression itself uses the Python standard library. + +Prepared for yssite with substantial OpenAI Codex assistance. Apache-2.0; +all predecessor credits and source-specific notices remain applicable. diff --git a/research/complex-pooled-full-admission/frozen/pr4180/NATIVE-OUTPUTS.json b/research/complex-pooled-full-admission/frozen/pr4180/NATIVE-OUTPUTS.json new file mode 100644 index 000000000..a9d1938dd --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/NATIVE-OUTPUTS.json @@ -0,0 +1,74 @@ +{ + "providers": { + "extra": { + "evidence": "retained PR4085 five-stage output", + "products": { + "CANONICAL-WORD.json.gz": "5fb702d44a4c8a785b1ee98e1c544756a9e821d0425d842cf8b882f10d445725", + "CLIFFORD-RECIPES.json": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06", + "CLIFFORD-REVIEW.json": "edeafd04c696d4465d8c415a6bf6484821373b36b3d1b6eaf98509aafb7ae9b0", + "FULL-WORD.json.gz": "ef1ca8b7d40346fc2b3261b93dab740322064e47ea194b7d989bac3650e37255", + "INDEPENDENT-LOCAL-REPLAY.json": "dc28e816c3dfd5541a851a94b7f4cc903c1492c2528dba093a9aaeef111ee931", + "LOCAL-CHECKS.json": "cd992cd4e5705767e703bf21cb0f490b7df69cdd9178410977d1a1b670bb5c21", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177", + "RESIDUAL-ADAPTERS.json": "ab58505fae0a0c50aeae5dfbfff4d949a7f11625b8d088cf133ca70c69a7ae72", + "SCALAR-FRAME-AUDIT.json": "aa950de74f09508ca1706f7213d9ca45a28ba58318b740a5e00ae1e822c4e945", + "WARP-RECIPE-CHECKS.json": "c389582fc10b1461ad7846bbf20f39fc342cffefc905f5c39139193eec5067eb", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + "extra-four": { + "evidence": "fresh five-stage campaign execution", + "products": { + "CANONICAL-WORD.json.gz": "6a3bbd63a229da14c5067fcf11f4abc99940651651e4567d870388dfe725e606", + "CLIFFORD-RECIPES.json": "d259754558d9616665069423644a71535b5c331a565c77211b9719f0a319d29d", + "CLIFFORD-REVIEW.json": "35e44002b64ce70766231eecb425864f746fbca40a797aa78c7f5e9d4a5ecd4c", + "FULL-WORD.json.gz": "c517eed7547e48ddc9f1f561e2fcc436b5999dab4aeb0cc634806c910d5444fc", + "INDEPENDENT-LOCAL-REPLAY.json": "90de0735f66c47134c12d72ff76acdc6f5796947dc581ed8bb626e9ae98551c2", + "LOCAL-CHECKS.json": "8e7857823c377bf9bfb246d8f29b5b79e6bc4547c10ab0901d07ab041103b5ec", + "LOCAL-PROGRAMS.json.gz": "a55f57ff6d2a9680c77930897372d0574c0222e29d9a88cfeadca4b023ee44f6", + "RESIDUAL-ADAPTERS.json": "ab58505fae0a0c50aeae5dfbfff4d949a7f11625b8d088cf133ca70c69a7ae72", + "SCALAR-FRAME-AUDIT.json": "4d3b08fd41116cbd8bb54aa3700dd9ac78dfde7b5ea053ef16f0f0dc64793e51", + "WARP-RECIPE-CHECKS.json": "8fd04798f9e526806d0b9e65ca6e30f042b06121ef5b389e59f4f37ec7aa90f5", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + "gauge44": { + "evidence": "retained PR4085 five-stage output", + "products": { + "CANONICAL-WORD.json.gz": "c3348706d4bbf01e7909a53efc677e51aa6ebc1286846c1fa72f3d6a85f2e5da", + "CLIFFORD-RECIPES.json": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2", + "CLIFFORD-REVIEW.json": "7cee799b7060f8b30e8415760770e8e73ca04cf6f966b0d008a897d7250b3d36", + "FULL-WORD.json.gz": "960867f94fe43489c5108eaff4cc159714a338a8a056837e5c497ded3d72c283", + "INDEPENDENT-LOCAL-REPLAY.json": "2ae9acb0162b4afedfa51bbfd1d7f6708009d76ad539907383ba10720c4382f7", + "LOCAL-CHECKS.json": "cd992cd4e5705767e703bf21cb0f490b7df69cdd9178410977d1a1b670bb5c21", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177", + "RESIDUAL-ADAPTERS.json": "f6e5a22cb2ee20196b4bd06510022dc65a63a7991f9bc46d2c27d2f97a2ffbdc", + "SCALAR-FRAME-AUDIT.json": "2d3794f1ad85bbfc1e1bf42d3b17f525d7856fb686557629c973636174b9f900", + "WARP-RECIPE-CHECKS.json": "e08d18d81ef1a425727d57f02046152d9c85dcc171073975d554758c4220658b", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + "gauge44-four": { + "evidence": "fresh five-stage campaign execution", + "products": { + "CANONICAL-WORD.json.gz": "6206d8d304264c476738ed9ccfc0d15ca93f25dbb7cfab6e54ba9ca9c5559b84", + "CLIFFORD-RECIPES.json": "f99fef8a175ff4952bc546d4b09c78d45d0bda5540c391eba82d539e477a78ba", + "CLIFFORD-REVIEW.json": "ab86e9840b746ea3cc601d65676337609732b9aecc6e630cd82165231990d75f", + "FULL-WORD.json.gz": "cc8e27b329defb34e5fe89bc18f886a4c9ff0f99a08bd4f686f4298b0eb39e04", + "INDEPENDENT-LOCAL-REPLAY.json": "19789adff8d0550fd3fe6ece9e467302b738cd00f1e08e678511906aadaed3dd", + "LOCAL-CHECKS.json": "8e7857823c377bf9bfb246d8f29b5b79e6bc4547c10ab0901d07ab041103b5ec", + "LOCAL-PROGRAMS.json.gz": "a55f57ff6d2a9680c77930897372d0574c0222e29d9a88cfeadca4b023ee44f6", + "RESIDUAL-ADAPTERS.json": "f6e5a22cb2ee20196b4bd06510022dc65a63a7991f9bc46d2c27d2f97a2ffbdc", + "SCALAR-FRAME-AUDIT.json": "b354613cd4fe79eb2bae8f2aa5b4df9f3112aa1c9d09b5b9bb02273428eecf2e", + "WARP-RECIPE-CHECKS.json": "8175edef5e833dce1071c1360cb631419ee659b97a1f1f3649ec189374cc17be", + "WRAPPER-CHECKS.json": "63372859a1b3f6c44a61797d5c035ca1ef51d87833ee1e2e8d83d6e8030ac835" + }, + "word_sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + } + }, + "schema_version": 1, + "scope": "Fixed scientific output commitments for the exact four source words; timings and JSON/gzip serialization are not mathematical evidence. Reproduce via the original five native stages." +} diff --git a/research/complex-pooled-full-admission/frozen/pr4180/README.md b/research/complex-pooled-full-admission/frozen/pr4180/README.md new file mode 100644 index 000000000..16f25a51e --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/README.md @@ -0,0 +1,221 @@ +# Four-provider ordinary admission for the retained PR4088 construction + +This successor connects the exact retained PR4088 mixed construction to the +PR4085 ordinary/outer admission engine. It extends the provider registry and +actual call dispatch, recomputes the idle invoice from each selected helper +width, and preserves the inherited release checks. It does not construct a new +supplier, change the selected frontier, or prove the all-size multiplication +theorem. + +The default full replay passed from an isolated committed export, including +ordinary, strict and outer release. [EVIDENCE.json](EVIDENCE.json) records its +actual receipts and [REPLAY.log](REPLAY.log) preserves the executed stdout +excerpts. These are author-produced finite evidence, pending independent +scientific review. + +The question is the revision-7 `supplier-boundary-audit` card's concrete missing +replay. The scientific baseline is +`12fa8c5c844be21bfefb38a19503fbd867a11244`; the exact consumed Git objects and +SHA256 pins are in [SOURCES.json](SOURCES.json). The task is refined to this +specific integration, as recorded in [TASK.json](TASK.json). + +## What changes + +The source adapter makes checked, literal substitutions in a fresh copy of the +inherited engine. Every preimage must match; it records each changed file's +before/after hash and each substitution's count in `ADAPTATION.json`. Frozen +predecessors are read without modification. + +* The registry contains `gauge44`, `extra`, `gauge44-four`, and `extra-four`, + with both orientations. The original literal selector and all 3,240 calls + remain bound to their actual native programs. +* The rebind gate checks all 1,321,920 owner rows against per-call widths and + programs. It requires the exact compact residual prefixes, chronology, + capacity and full provider set; it recomputes idle complements and the + complete paid profile. It does not use an averaged width vector. +* All four native closures enter the inherited provider, emission, audit, + invoice, assembly, independent, strict and outer paths. The coverage map is + [COVERAGE.md](COVERAGE.md). +* Optional reuse authenticates the exact predecessor engine and all 95 retained + non-source inputs, as well as its 676-file source inventory. Native reuse + authenticates the compiler, word, five-stage coverage and 11 scientific + output products per provider against [NATIVE-OUTPUTS.json](NATIVE-OUTPUTS.json). + +## Accounting boundary + +PR4165 already identified the different mixed idle invoice. We credit that +finding and carry it into the actual admission caller rather than claim it as +a new result. Original helper 601 (owner helper index 367, native register 591) +has width 8 for THREE and width 7 for FOUR, in both orientations. + +| Quantity | Exact value | +| --- | --- | +| Calls `(gauge44, extra, gauge44-four, extra-four)` | `(1040, 1110, 528, 562)` | +| Mixed idle profile | `{3: 22783, 5: 1625, 48: 138492}` | +| Complete paid profile | `{1: 8060060, 2: 2310120, 3: 751813, 4: 327210, 5: 66425, 8: 25920, 48: 138492}` | +| Profile mass | `23431680 = 65088 * 360` | +| Complete physical inventory | `896 * 360 + 408 + 8 + 91 + 2 = 323069` | +| Actual global prefix | `95 + 37 + 18 + 1323 + 1 + 4 = 1478` | +| Charged payload and physical row | `2048` bits; coefficient `19549 < 20161` | + +The first distinguishing owner row is index 367. If call zero is coherently +changed from FOUR to THREE, the later shared-owner row 29,389 has offset 7 but +requires 8. This is a useful negative control because counts and local program +metadata can be updated consistently while the real chronology still fails. + +PR4088's already published root enclosure is not a new result of this package. +The selected conditional kappa remains `0.001672660197076918` (#1094). +The actual native local prefix is 95, below the inherited reserve 128. +The stock l2 calculation gives 1323, below its cap 1330. The inherited block-norm +and independent invoice callers recompute these values on this physical +inventory; the caps do not replace the actual measurements. + +## Native evidence and invalidation + +Successful status flags and a source-word hash do not authenticate a native +output. During adversarial review of this draft, changing the first warp's +left phase modulo 4 while rebinding recipe references exposed that gap. The +original exact recipe checker rejects the changed operator; the final reuse +gate also rejects it against a fixed scientific product commitment. A missing +phase stage and a false private-work-erasure claim are rejected separately. + +The commitments canonicalize JSON and decompressed gzip payloads. They omit +only the root elapsed-time `seconds` fields in `SCALAR-FRAME-AUDIT.json` and +`CLIFFORD-REVIEW.json`; those fields must still be finite nonnegative numbers. +References to compressed words/programs and serialized recipes are checked +against the actual referenced bytes before normalization. All other scientific +fields, missing/extra products, compiler changes and word changes invalidate +reuse. Reformatting or recompression with corresponding valid references is +allowed. + +The FOUR products were executed afresh during this campaign. The unchanged +THREE products are authenticated retained PR4085 evidence. A run records +`executed_by_this_driver`, `explicitly_supplied_cache`, or `retained_PR4085` +for each provider. These labels distinguish fresh execution from reuse. + +## Reproduce + +From the repository root, the bounded standard-library regression is: + +```sh +python3 -B scripts/research_package.py --package research/mixed-provider-admission +``` + +Its three registered commands can also be run directly: + +```sh +python3 -B research/mixed-provider-admission/verify.py +python3 -O -B research/mixed-provider-admission/test_binding.py +python3 -B research/mixed-provider-admission/independent_ledger.py --controls +``` + +The first reports `PASS_FOUR_PROVIDER_BINDING_REGRESSION`, including the exact +source pins, semantic controls and all real owner rows. This bounded regression +does not run or claim the full admission. +The last reports `PASS_INDEPENDENT_MIXED_LEDGER`: a separate implementation +enumerates binary spans and reconstructs observation windows from schedule +events without importing the original owner walker or the new binder. + +The full replay requires Python 3.12 and the pinned numerical environment +used by the inherited engine: NumPy 2.3.5, SciPy 1.17.0, SymPy 1.14.0 and +mpmath 1.3.0. The driver installs nothing. Use a new directory outside the +checkout: + +```sh +python3 -B research/mixed-provider-admission/replay.py \ + --work /tmp/mixed-admission-fresh +``` + +The expected final status is +`PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE`. The driver first runs +the three retained PR4088 word/owner/operator gates, reconstructs the exact +PR4085 source through its independent reviews, runs both FOUR native replays, +and invokes the extended inherited engine. The inherited engine requires +assertions; the full driver explicitly rejects optimized Python. + +`--checked-preflight`, `--four-native-base`, and `--four-native-extra` accept +previous outputs only after the binding checks described above. They are useful +for continuing an interrupted replay, not an exemption from those checks. +`--prepare-only` deliberately reports a non-admitted preparation status. + +After a full or prepared run, the actual cache/engine challenges can be run +without repeating expensive admission: + +```sh +python3 -B research/mixed-provider-admission/challenge.py \ + --work /tmp/mixed-admission-fresh +python3 -O -B research/mixed-provider-admission/challenge.py \ + --work /tmp/mixed-admission-fresh +``` + +They report `PASS_ACTUAL_REPLAY_CHALLENGES` for 18 positive/negative cases. +Supply `--preflight PATH` if the replay used an external checked preflight. +Only temporary copies are mutated. The recorded environment is Linux; the driver +cleans its child process groups on POSIX. Windows execution is not claimed. + +Actual executed commands, outcomes, environments and unrun checks are recorded +in [EVIDENCE.md](EVIDENCE.md). Source commitments bind inputs, not proof truth +or authorship. + +## Scope and limitations + +This is author-produced finite verification with separate AI adversarial checks. +A second context used an event-based scanner and explicit small binary spans +to check the mixed owner widths and invoice independently of the original +owner walk. That corroboration is neither independent human review nor formal +verification. + +The inherited native and ordinary/outer predicates remain the acceptance +contract; this package does not replace them with a permissive new checker. +Their successful finite execution does not discharge uniform generation, +arbitrary-size lifting, conditioning/precision, fixed-tape realization, or the +complete analytic transfer theorem. It does not assess PR4100's separately +proposed written all-size argument. Archival source-retention merges and +author receipts are distinct from maintainer scientific review. + +## Open next questions + +1. **Independent scientific review of this finite integration.** A maintainer + can execute the full command on the committed tree, inspect the exact + adaptations and challenge the coverage map before considering selection. + Independent review is required beyond any author replay; this package makes no + selected-frontier change. +2. **One caller-bound all-size implication.** Finite admission leaves the + uniform compiler/precision/fixed-tape transfer question open. The first + feasible step is to consult the current `uniform-transfer-audit` card and + PR4100/PR4169 handoffs and Discussion4173's live CRT reservoir claim, then + pin one unclaimed real caller and quantified proposition. + A general argument, rather than another evaluation of this root, is needed. + +The structured questions and their blockers are also in [TASK.json](TASK.json). + +## Provenance and credit + +* PR4088, Cinna Davis (`1337isnot1337`): + `72d7efc181edb21806a878f174847c96dd410ab0`, the mixed construction, exact + selector, four local words, owner/operator evidence and published profile. +* PR4165, `unpaidmoon`: + `430072ee4130b58c1dd952cb37fd81759675a118`, mixed idle-rebind audit and + concrete admission handoff. +* PR4085, David Ganz (`zxv`): + `c5854c77620723aae6914c32122870519a6f820d`, repaired operator composition + and predecessor release/admission. +* PR4076, Rohan Arun: + `9744f9df268590295a9872b1952c695a678192b9`, triple-entry fill and source + reconstruction; PR3945, Dugongue: + `91f81d131252db704f945891da1ea54e29d46b8b`, predecessor release machinery. +* Tekalign (`tekuuu`), including PR2768's exact sparse native execution and + the retained owner/native checking tools. Their original notices, as well + as the credited Clifford and earlier supplier lineage, remain in the source. + +The retained archive SHA256 is +`e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041`. +All predecessor notices and licenses remain in their source packages and are +preserved by reconstruction. PR4170's pooled-ceiling transfer, PR4171's moment +arithmetic and Discussion4173's CRT reservoir audit address distinct +obligations. This does not repeat yssite's PR959, PR1558 or PR2377. + +Prepared for yssite with substantial OpenAI Codex assistance in investigation, +implementation, documentation and two separate AI checking contexts. +New work is Apache-2.0; predecessor attribution and source-specific notices +remain applicable. diff --git a/research/complex-pooled-full-admission/frozen/pr4180/REPLAY.log b/research/complex-pooled-full-admission/frozen/pr4180/REPLAY.log new file mode 100644 index 000000000..05fa331de --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/REPLAY.log @@ -0,0 +1,84 @@ +Executed stdout excerpts from the isolated committed export. +Only work/source/interpreter paths are normalized; these are local logs, not hosted CI or formal proof. + +== default full driver == +PASS pr4088-verify +PASS pr4088-owner_verify +PASS pr4088-operator_verify +PASS predecessor-preflight +PASS native-four-base +PASS native-four-extra +PASS inherited-admission +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE + +== fresh FOUR base == +PASS native +PASS ledgers +PASS local-replay +PASS wrappers +PASS phases +PASS_COMPLETE_T74_NATIVE_REPLAY sparse 74.377 + +== fresh FOUR extra == +PASS native +PASS ledgers +PASS local-replay +PASS wrappers +PASS phases +PASS_COMPLETE_T74_NATIVE_REPLAY sparse 65.274 + +== inherited admission == +PASS owners +PASS parent-lift +PASS rebind +PASS discovery +PASS outer-check_ledger.py +PASS outer-independent_check.py +PASS release +PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE 0.0017309791156707924727599999999999999999999998999999999999999999999999 + +== ordinary verification == +PASS fine-engine-oracle +PASS retained-provider-and-parent-admission (hash-checked receipt) +PASS rebuild-words-566 +PASS reconstruct-owners +PASS lift-parent +PASS rebuild-borrow-words +PASS shared-kernel-independent-review +PASS preload-move-independent-review +PASS two-sided-helper408-review +PASS paired-extension-review +PASS declared-edit-review +PASS staged3605-review +PASS delayed-release-independent-review +PASS staged544-independent-word-review +PASS terminal-width5-independent-word-review +PASS staged-entries-independent-word-review +PASS receiver-sharing-independent-word-review +PASS audit-local-566-base +PASS audit-local-566-extra +PASS rebind-566 +PASS lemmag-labels +PASS strict-t74 +PASS geometry-controls +PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION 0.001727988004522833 + +== strict replay == +PASS bind +PASS emit +PASS audit +PASS invoice +PASS assembly +PASS admission +PASS bit +PASS independent +PASS_STRICT_MIXED_T74_EXACT_FILL 0.001727988004522833 + +== outer execution == +case g=5 L=7: exact tensor product reproduced; sum|F|=28812 = sum|U_i|; g|U|=74035 (x2.57); moves=336140 <= 950796; rounds=5 +case g=4 L=6: exact tensor product reproduced; sum|F|=1944 = sum|U_i|; g|U|=4416 (x2.27); moves=18360 <= 58320; rounds=4 +case g=6 L=5: exact tensor product reproduced; sum|F|=40625 = sum|U_i|; g|U|=90834 (x2.24); moves=459375 <= 1340625; rounds=6 +case g=3 L=8: exact tensor product reproduced; sum|F|=512 = sum|U_i|; g|U|=1086 (x2.12); moves=5120 <= 15360; rounds=3 +PASS_UNION_SCHEDULE +PASS_EXACT_REPLAY 19 +PASS_OUTER diff --git a/research/complex-pooled-full-admission/frozen/pr4180/SOURCES.json b/research/complex-pooled-full-admission/frozen/pr4180/SOURCES.json new file mode 100644 index 000000000..163f13ee2 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/SOURCES.json @@ -0,0 +1,1176 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/kappa-adaptive-continuation/admission/receiver_share.py", + "usage": "input", + "git_blob": "0f1491d8c6df7b59e55ba71230daa2d54447e9b3", + "sha256": "6ef3255e91f42cb78eb194c761c02568e0230a9cfab40387f257d7a4bd38ccc4" + }, + { + "path": "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "usage": "input", + "git_blob": "dcc11d429ce0aef7aa9700a9c31994c8a77e1dfe", + "sha256": "bbf28e17a657b8d1eaf63f33d811682720afb393ee2ab9a4bb46661fef1ed996" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "usage": "input", + "git_blob": "ded4702868432d304851486f602a8db0d57f6fbc", + "sha256": "4f6185125ddb38b7ab02a349829aae434e7707e804ca8c6c4ab8c086cd63635e" + }, + { + "path": "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "usage": "input", + "git_blob": "086fb580b25d533570b50dfd1f806e8309d5e4ea", + "sha256": "30a39a3612efde96a0db189c14053afe5e012e56de1a89863596a078a8b64381" + }, + { + "path": "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "usage": "input", + "git_blob": "5e45113fdc6eaf8d4a07aa1f7c0f9b3b6991ca1c", + "sha256": "e74d545c18f77b7a9b8f0cc3d4901a87bb686888edaf3e41b30e5b2748751041" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "usage": "input", + "git_blob": "1614c1c40d4804cf70d3c4a90896d20c261f59a1", + "sha256": "e0a3f13504304147f4049757016a494c15beda82ed751439f05039f88a0dd891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "usage": "input", + "git_blob": "9d585f31444582f3254f8e10e8f76ba5224b4508", + "sha256": "31896a06049f951fc25db1338888a743c1c73cf1a6c44212dbc21789ceaefeb0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "9dcdc26825cf00d00ab7420156a747d4279c3bb3", + "sha256": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "7f9a60816cdc2717d0c392de4496b28e675d50c4", + "sha256": "1b9167ef68707cddad4b781e37858cfb5205d377670365019b8de26fceeb1891" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "8eaa8cd45ee42162008586bc72e3ca8164f16be1", + "sha256": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "04d1e367f4e96770b5bde9b84fd5369633a6f5a1", + "sha256": "23163ff2f94a4920e5fca35fb6f0de108f710e7b09cc13e7c2796ad693a2b497" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "9e3afae3bc1dff0b5a12a87ba8b13aa003cb1219", + "sha256": "7e3bb0f46320f243cd89c97c60af5b29ac82a79293463afae5a178f8938ebda0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "usage": "input", + "git_blob": "c93596421fdbf2c41e524eb1c0c7660f58cc362d", + "sha256": "0bad75c89a69637a1c9b98824da183243c584e07e0eb76ce986420384a7246c8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "usage": "input", + "git_blob": "3a8e83134093221f7e7676ae4d432ef858856885", + "sha256": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "usage": "input", + "git_blob": "0b69f5f67e2e26f531c6685db8da43ee911eb347", + "sha256": "753c950d3273bba4e7ff560000d84aaf928d24448e899e6f75e0166b7989f508" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "usage": "input", + "git_blob": "9e67bc42952b2c65ed8e070cf81582bd78a5f550", + "sha256": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "usage": "input", + "git_blob": "5ecdb02d3da25d5854be7574cdd53bed2d286ac6", + "sha256": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "usage": "input", + "git_blob": "4dde678a2fd312ed567404cb21f757a248217acb", + "sha256": "9100f0387118988d81fa47740d4bd47892b13400c36ea63d43cbe4aeba38a4a1" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "usage": "input", + "git_blob": "077da2ebaac823cd7b69568d265652496cf2fbd1", + "sha256": "e037ea86e1e2902d6c03885ae8e332e4afe48d27d6200923b9c71498b12953d3" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "usage": "input", + "git_blob": "04a12a3f688315ce6c76369223db11b7c5abd198", + "sha256": "c3c925cfe5a3e2e4cb21fba12a60d8ba2b84ab568d27bf26691f92bf48a0d681" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/kappa-operator-repair/late-staged-composition/run_release.py", + "usage": "input", + "git_blob": "a14a26a95e02899b05d61a510e86ee461614e2d5", + "sha256": "262e914eca3d0e97567786fe94cb25fb1698c52e08785fd4a2581020c4af26dc" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "usage": "input", + "git_blob": "492998766fc9aedfa1f1c0c337b2d4abe10ab707", + "sha256": "6f6b5adccb29d29a4b7890c91180a7ecd9f54ee04007cf9e0ea06fbea42b5c0e" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "usage": "input", + "git_blob": "1c96d298a534aa98325592a9487fea79aebec596", + "sha256": "727691274be6f91059c763dfa8206f7bca4516c5acf4703da403789a49b5e1e7" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "usage": "input", + "git_blob": "e45a06597117509656383c7ac3c49c1c0620b93b", + "sha256": "4b6b1ac15742264f1d6d8047d975fd5d05fc63db61358b3bacf1c1c47ee71428" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "usage": "input", + "git_blob": "fda8edb01adffae448457341f10ea0a73848079c", + "sha256": "8bdda4822009d6e5f1d6bd948a8f89154780a5721dca366c56deb75019bb268b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "usage": "input", + "git_blob": "ee1f16607ca4b5dc29321483e9a5dc63371085be", + "sha256": "69bbfc0414324593e98112af7a8db6549315badb8aa7adb5ca05419214849c56" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "usage": "input", + "git_blob": "5ea426d4983e1f70b23f451d7d3f29a93aabcf56", + "sha256": "fff028de30e9fb06d6d75efc6fdd6e94ead6a88823efa07d3e7cd177dcd94acd" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "usage": "input", + "git_blob": "dcc0374b5c822d544a4ecf19d00635c7117d82c9", + "sha256": "8159c67d29ab58efe546ebc4ce20872421996cc71b5f17737ff8b36cbc76d148" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "usage": "input", + "git_blob": "990c54caeeb4fb344de622de98d97e107ec67ed5", + "sha256": "0147e6b30ef328e227e89113323eb0d02d116e125b0e7c99a00ea4f2652dcc80" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "usage": "input", + "git_blob": "806784bf99d9d15004d2d227d06268556a0726c8", + "sha256": "08e6c96fbe3dfec96cb8451b3867ef8c1a214109ecd1e5af7fcc28e0f05728d0" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "usage": "input", + "git_blob": "c531be7383ad3ba941600c7ced14e5e10d6d1c67", + "sha256": "d83c2ec9cecc0ad092d34ea4080b28a4fd7199579356b6d5a8fc6cd53ff93299" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "usage": "input", + "git_blob": "f67031d3e12f7ca91075ba2b2fdeeb99a3de5873", + "sha256": "00071bc2e54bf5fd05a6aac9292a3861087e72898d86d1f6f7bbda65b07cfbda" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "64bcb35908f140bec80c73a2f4ba429be14ae225", + "sha256": "6e2f3ef76d90086784db92a7e3b0ac23893dd60750effe79287fa59c48b6bc99" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "faf479d61f57b88ced9b434d188a31f6ca5c3f2c", + "sha256": "e92568c62db0f220096870c2a01cd8c313497953bc9cff5f2c087fe9a6875109" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "usage": "input", + "git_blob": "7dfaaaa1b084e5971e03ce2586fc5d5ddd21c760", + "sha256": "70030e184e9c3d41169cabf5f6a07d6ec10590ce384ebfeabbeba7253d85404b" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "usage": "input", + "git_blob": "3ee17a1e5fbdfcdf14a481e35c69ab0a0615e5d9", + "sha256": "dd104d15719ae181fde3d6c93f210b09ddffe0e0ca16b07c85b4ebaf75641d91" + }, + { + "path": "research/staged544-mixed-fourth-entry/.gitattributes", + "usage": "input", + "git_blob": "fc06868c3d5cb57faf9146b154cb3961d5660360", + "sha256": "04e5e0efa0141765d3c58422bbc347caf588ab7e70c3429e63f78d892038a1d7" + }, + { + "path": "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "usage": "input", + "git_blob": "5d27e2d4f864e6d4a26be3af2d2131bd3000545a", + "sha256": "59b692adb4ed3c8caed033d380c23e2e2cf2a1547323b88f97b4a4ad7453141b" + }, + { + "path": "research/staged544-mixed-fourth-entry/INPUTS.json", + "usage": "input", + "git_blob": "5898f7e11f827baa4122fa17d4aa251b990efff6", + "sha256": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98" + }, + { + "path": "research/staged544-mixed-fourth-entry/MANIFEST.json", + "usage": "input", + "git_blob": "768091ef74f2212027222b3e5af84365694e4780", + "sha256": "f2f52b40e4b0dda45777fdeecf2267679da0d36be69daf467adc1740f4951b9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/NOTICE.md", + "usage": "input", + "git_blob": "56c36d6f5900b2d6cd3169c8996b7b2018649fe9", + "sha256": "1ba00cad41d7a1333da420bd23f078d09e28b7aa17cf5a8a89e54dd207123971" + }, + { + "path": "research/staged544-mixed-fourth-entry/PROOF.md", + "usage": "input", + "git_blob": "9c665b0442774b8c84116f51c3261d50dd5f8d2c", + "sha256": "3aa03a9ba64422474890c137d2b10ef830464712830fd469fe1b0e9538b24ebb" + }, + { + "path": "research/staged544-mixed-fourth-entry/README.md", + "usage": "input", + "git_blob": "29aac74f7ba382aad85189e5e297bf356414e2f9", + "sha256": "98b53ad6e6ee7ef7ba106e68e7a2a77d8f5a9823202cb3725cf101f5901e2d6f" + }, + { + "path": "research/staged544-mixed-fourth-entry/RESULT.json", + "usage": "input", + "git_blob": "1174e25e2ef8f8bc9a0815c43ba5d64c8af08349", + "sha256": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d" + }, + { + "path": "research/staged544-mixed-fourth-entry/SOURCES.json", + "usage": "input", + "git_blob": "a604c6a640acd80f08b7378a00739eff45ac0830", + "sha256": "53211542c4e92eee92458f2b313d0bf6c1706e56dada488c604e93a0760fec43" + }, + { + "path": "research/staged544-mixed-fourth-entry/TASK.json", + "usage": "input", + "git_blob": "77f24f0c846cb00a702cb7aa06c31c02a29198fd", + "sha256": "8c34b11a10f0317dd4a4dc765b036a2231cee55cb44fc0e1e59fb64e11326a13" + }, + { + "path": "research/staged544-mixed-fourth-entry/VERIFY.json", + "usage": "input", + "git_blob": "f8b3c9ab743525816d1a2f35ca437b7d3674d07a", + "sha256": "2814773f90ee84a1c367dfec1ee85ec4f001ed100469f354d0464e7952303e9d" + }, + { + "path": "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "usage": "input", + "git_blob": "a87dde507358dd3b60c0d80d6216ef16123c56ca", + "sha256": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "77ee265be3cc15d76054c023d825578d9c62fa5c", + "sha256": "bff67890d0d350646d11f45aa1b098d6a415b1850b4982e8a05b4c146d247eda" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "bc6433bbf5c355d53eec218448fa49c5f4d45346", + "sha256": "e0c473d62127a09cb3cbf451564dbdd19c0c10f1674dab0575e65251aa5e1e3c" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "usage": "input", + "git_blob": "7de151df4cf0639ee782bc7f32ba51f983b814f8", + "sha256": "51713c6bb1909bc90994d54467baac08bafd849945a0e246f0c96dbf3658307b" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "usage": "input", + "git_blob": "22fd191b74aadd219bc4095633ac552244b1083b", + "sha256": "e273538de7957b959c40f593c4aad5e8e3d81d83d662fe2895c17770c5fad8bd" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "usage": "input", + "git_blob": "f99019e597d38749594b06c7a47847bb78a40bc8", + "sha256": "c8f744c62670ad7d76faf4dee65e2f708f4036953041e72383929c7d0b32ec38" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "usage": "input", + "git_blob": "f6b24b3310609e9a862e6877a1412ce5d4d23120", + "sha256": "c422d41b5b316fe6823012ca31a13bd3c2c4a4a17c3712c36ce0156f311e5ce9" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "usage": "input", + "git_blob": "fe667708d7c878e80a6efdb6874496864ca67136", + "sha256": "2b6f90f3d00e7b2723fa12c6bd8e8f0d2881854b3ef625b0fd37ed6f51e2bfa4" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "usage": "input", + "git_blob": "40d74e5638d08ccb0b8270e6c47843cc45762c72", + "sha256": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "usage": "input", + "git_blob": "2af11b77b0d1f9ed54584fb1ec63f808d08071e6", + "sha256": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "usage": "input", + "git_blob": "f89b2988e31e510d9e2c6877bd0fb828d8e503d5", + "sha256": "706489e44f096f0449c72b411686388eb2ffc10c4391026373ce6fdd7b5fa040" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "usage": "input", + "git_blob": "135cd88e44786e26bcde18f67398a186653293ef", + "sha256": "dc7d4049460e2c754b6319d721efcad9a8bad7249aea130c19eabc8f9193975e" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "usage": "input", + "git_blob": "9f9d6a9c4116610a76abe8eeb6394317ac9c524c", + "sha256": "e18a62a1019dac507c278fda6342dbb38afabace8f48a8d3c45a8f1e9b2d7bce" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "usage": "input", + "git_blob": "494dd79f94634a84c1bcd7a7ef70ceaa209454db", + "sha256": "9d5316a1465a3eb2c62fac76c291394c0401c34a96fd8b94863d662b16a64552" + }, + { + "path": "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "usage": "input", + "git_blob": "00a86cdddcad95817b87322c13e22a0dd5faed22", + "sha256": "81c01d4b007bb720311dbdbbc63df673fdaf7baba707b360bbecc4b9cb6ee7b0" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "usage": "input", + "git_blob": "4bdbe9682413329415782da9ee9c33ec34bb2a21", + "sha256": "b00f1665c7096ca292079668bac86e25ca7552c57cbe62c8c45ea40aa8708ecf" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "usage": "input", + "git_blob": "a0485940af5330dc64a962937d8f3465074a7224", + "sha256": "a65bcb4624a96204b1d30ec8c82080fbcdda2c1a30349643b60db579f339c75c" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "usage": "input", + "git_blob": "d110afeaeecc8df7ccf1730eae63a8e124516b65", + "sha256": "817c39b155892ab3ea89b6e2bf04480c45e1ebb9a8f87e2bb9a48c715a7eee9e" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/LICENSE", + "usage": "input", + "git_blob": "261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64", + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "usage": "input", + "git_blob": "380e979f0e84e00a22bd890615d87cc4684ad740", + "sha256": "ee0c73ca35877aad0e0b6adc560a3881cb82276dba4cf2d4fc58cd19e57cc420" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/PINS.json", + "usage": "input", + "git_blob": "7c83dc543292205bc65abd332f77215b58feebf7", + "sha256": "f619e8e1c163078fb70c6fc3b98a498a671b8c02927b91d6cc253af2a775b6c9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "usage": "input", + "git_blob": "07cd8a78808413a4a2e58cd5d43e448ab50ac34b", + "sha256": "8daf4fc7c75db99d34641152682208ce6c974f50d509960d0f4fa021f862abee" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/common.py", + "usage": "input", + "git_blob": "9ed8d88b97bda87a30bcb01cb9fd81339cbc15ab", + "sha256": "8f04e08b99a370fa82115fc46fbb3af4ab44f4facd47de07b01e1a2499a94914" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/run_native.py", + "usage": "input", + "git_blob": "64ef0eb83f214c2a922e446fa079e7d2568f73ef", + "sha256": "a7bfe110fe5098f6ef8bde3c43ecf15e8d1e06149abf7321a4c945383dcc2627" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/stage.py", + "usage": "input", + "git_blob": "9ecc54bca4173b732e3f030fadee0a3b7f54f686", + "sha256": "3cce27dd5a359ebc4dc70d4aab994aee52bc0a12e59db7da3f902257f876cffe" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "usage": "input", + "git_blob": "a3b31e157fcb9f8978040535a98d30a640509424", + "sha256": "3da80a5155c625bff907a42a82c65bfcf92854d2c960bcea4537c19c99efd4f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "usage": "input", + "git_blob": "bbd59904396b5978c15e38720d0c0ad7a9ac5398", + "sha256": "d73e4522602404caba8e7f247005a45c8a8cd26ffd2a70d65f4f9556a391d053" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "usage": "input", + "git_blob": "ca39f73494e11bf0a860c51b8d711bec48ec0842", + "sha256": "e91210ecd5085cf9add872f40bb434806838da488e12152c63c86e51fb5a7a37" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "usage": "input", + "git_blob": "5d546d8a05f6025d58a5133fa0d67ce134993013", + "sha256": "2fe087ba4558bd21ca49945dbedaa4047e4170e8fd4e2280701bb2f0481811b5" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "usage": "input", + "git_blob": "a14b299ef55c5581166988aa78baba329cebde04", + "sha256": "6b6730303818f6edc2a253eb4d05471eee58f28b5815fb250c32ae376f774c8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "usage": "input", + "git_blob": "82beaa9c1d13bcd5f79d0a5e10e8a10733eac347", + "sha256": "c5907050a9a7fa36d4fcba3ad4fe440d1bec2063360c095013891785ba65c3ce" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "usage": "input", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55", + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "usage": "input", + "git_blob": "6db8ad50eb2562700432a852501aad720aa34816", + "sha256": "d600b959a0ac462dc28deb8c0d5d8f9e0c76d7f7d7b6f92a296c5ef9e0a1de19" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "usage": "input", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932", + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "usage": "input", + "git_blob": "1ff29dfb244e2114de8e586a450ae9fb70308d58", + "sha256": "0884b14d6d77cde419a3c773ad9b21d0d18de1e6e20e6b6d5add458ed32ba4cb" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "usage": "input", + "git_blob": "99f351785ebca5fbf3336bedcd7b48bac9c255e5", + "sha256": "9d1a620e26715f4c42fd0347ecc14ef5a4a9031867869b64e8bae4d8526a821e" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "usage": "input", + "git_blob": "a519863fd890ee1200043ad2ae4e307b95a1634e", + "sha256": "eab4b026965b9796eee92239660e1fb1fa629f6d9db44bc27b13911a018a6ee9" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "usage": "input", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1", + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "usage": "input", + "git_blob": "5ea70357a04d083dba066fbc5c809a5736d8edd6", + "sha256": "f1d45d886926915531e3a59968abf0a4c974d7038f869848e71bd3a21b834422" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "usage": "input", + "git_blob": "5c4fbe8cceedd769a1c367a31cd0beeae2175dc1", + "sha256": "b37b67a04681c776dafcdc6c9af0e8a2dbfa9893b02e0fa2d77ccc9182a87988" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "usage": "input", + "git_blob": "1bbe590206644e68d7654c23f0b46d5a18836e34", + "sha256": "0f9a47cdaeed0e22938c63251c232d6f23aeee2b62b0b1223cd4473c5428bcf7" + }, + { + "path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "usage": "input", + "git_blob": "942310947b4d7016ed7a5d23a87e9ae98e0427d6", + "sha256": "8ec7db430f4f4771c06bdcfc31736193614f6ec209d57b63d4e2b75f17fb3ac8" + }, + { + "path": "research/staged544-mixed-fourth-entry/operator_verify.py", + "usage": "input", + "git_blob": "60295d1c4622819c1bb2f514b885b952376e52bd", + "sha256": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner_verify.py", + "usage": "input", + "git_blob": "a74d1ee0b5d45feb4c87cc034ae49069d654467c", + "sha256": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72" + }, + { + "path": "research/staged544-mixed-fourth-entry/price.py", + "usage": "input", + "git_blob": "5b702b6fd94327f502fd9ef58594e1031dfa9db9", + "sha256": "89b7c623befd880a163baabc52f8ca576281ad0d8b71685e2ee37c9709edb335" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "usage": "input", + "git_blob": "d1c13c2ea786f790e96d45f18f58ec1ef2be7507", + "sha256": "221b56acc02ceeee35000f26f7098426421c0c90a075d81f9629170284f4aa25" + }, + { + "path": "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "usage": "input", + "git_blob": "8d5a8d22ddb5450abf414f9ec814077d16033111", + "sha256": "b1963fba45032238f773f3b375412d7db5f6e184edb59dcd05be15f6f70116f2" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "usage": "input", + "git_blob": "9ccffcfb7da1e36b158752ffed293dc95797e68e", + "sha256": "91f7f723bb616aca757812f940f6b893559e64e441d6158c907155a79b3b15a7" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "usage": "input", + "git_blob": "eb65f87966b1b8b61c5f9abad508a3f0cd6d689b", + "sha256": "864b2857f200a37b37f939b78887484f5230be0b68ab7755705713e2e2d45d3e" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "usage": "input", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462", + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "usage": "input", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491", + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "usage": "input", + "git_blob": "96dab46ab3404adc92c4b004481759db0c71dfdf", + "sha256": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "usage": "input", + "git_blob": "b2b50c0847c811248031ef14e0b9adc8010d0127", + "sha256": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "usage": "input", + "git_blob": "358ba3dcd984a19799bc9ed47e3ed81d1d111043", + "sha256": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "usage": "input", + "git_blob": "ca3e3effb97f46485ab7ac8c15ce4a92e1f93fbe", + "sha256": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "usage": "input", + "git_blob": "266a2e541edc82c77a77e9c403bfe79a7392b950", + "sha256": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329" + }, + { + "path": "research/staged544-mixed-fourth-entry/verify.py", + "usage": "input", + "git_blob": "816a7786a3570976ac86baf3b19ee798e6098895", + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "usage": "input", + "git_blob": "5e67f9bd27a42e38b9bd1a5ffd6f7ba7193578dc", + "sha256": "45f5bce58f2251b784b0ab89ca4657e0920515209810cfabd7e32d9a126e2db1" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "usage": "input", + "git_blob": "9fbaa36ec2d7706cadd6991028d882714b46af62", + "sha256": "7f3b4a82e556300e5cfa5f873a5b1975f5d1a10b494316289f6662941b8e39f2" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "usage": "input", + "git_blob": "8f342d307e0080f9a927dc129c993fe50b3901e7", + "sha256": "610cd49ed71e684481182ee3c7e5d1686f6a376ef8c6e74e3c3615bbb842d841" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-idle-rebind/vendor/rebind.py", + "usage": "provenance", + "git_blob": "a0453d3e956d80c2088b9f69650095dcae800343", + "sha256": "faf283eb4edd2e6a1ccb40b3cb3ba30ae54338eaf5ea0a10d84d11d7939502af" + }, + { + "path": "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "usage": "input", + "git_blob": "6f05d13347e650467b561f1861e6266ffc9ef15c", + "sha256": "c7455323c62a5b1d5c9ceef07a305a5758df6971ac8f88e2be5223eb5f4c7553" + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4180/TASK.json b/research/complex-pooled-full-admission/frozen/pr4180/TASK.json new file mode 100644 index 000000000..666597993 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/TASK.json @@ -0,0 +1,96 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Carry PR4088 four-provider dispatch through the inherited PR4085 ordinary/outer admission without weakening its predicates; bind native stage products and recompute the complete idle invoice from actual per-call widths.", + "scope_change_reason": "Narrow revision-7 supplier-boundary-audit to the concrete PR4165 four-provider rebind handoff, on the exact retained PR4088 word/order/fill. No parameter search, new supplier or all-size proof claim.", + "bottleneck_link": "docs/research/current-priorities.md revision 7: the mixed four-provider ordinary/outer engine has not been replayed. This successor targets that finite admission boundary, retaining all analytic/theorem obligations.", + "budget_minutes": 180, + "stop_rule": "At most four bounded rounds on this question. Stop after a reviewable result, equivalent live work, two experiments without actionable evidence, or a nonlocal proof/infrastructure blocker; preserve the final quarter for verification/handoff.", + "outcome": "completed", + "evidence": "COVERAGE.md maps caller obligations. replay.py executes exact source reconstruction and inherited admission; verify.py checks source pins, actual call/width/idle bindings and semantic controls. challenge.py exercises actual four-provider products and the cached engine; NATIVE-OUTPUTS.json fixes their scientific commitments.", + "author": "yssite", + "ai_assistance": "Substantial OpenAI Codex assistance in investigation, implementation and documentation. A separate Codex context independently scanned source-event/phase-axis owner rows; another adversarially challenged the implementation and reproduced two corrected reuse-binding gaps. Neither is independent human review or formal verification.", + "open_questions": [ + { + "question": "Does an independently reviewed all-size compiler/precision/fixed-tape transfer justify using the admitted finite supplier in the complete multiplication theorem?", + "why_it_matters": "Finite ordinary/outer arithmetic and native source replay do not establish uniform generation, physical execution, conditioning or the complete machine-cost theorem.", + "first_step": "Consult the current uniform-transfer-audit card and live PR4100/PR4169/Discussion4173 handoffs, then pin one unclaimed proposition at its actual caller; do not rerun this unchanged moment root or duplicate the live CRT reservoir audit.", + "blocked_by": "A general source-bound mathematical argument and independent scientific review, beyond this finite integration." + }, + { + "question": "Can a maintainer independently reproduce and review the four-provider successor before any frontier selection?", + "why_it_matters": "Archived predecessor packages and this author/AI evidence do not themselves select a result.", + "first_step": "Run the full replay command on the exact committed source, then inspect the coverage map and semantic mutation receipts.", + "blocked_by": "Independent maintainer execution/review; this campaign does not promote the selected record." + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4180/VERIFY.json b/research/complex-pooled-full-admission/frozen/pr4180/VERIFY.json new file mode 100644 index 000000000..187fa849f --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/VERIFY.json @@ -0,0 +1,231 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/kappa-adaptive-continuation/admission/receiver_share.py", + "research/kappa-adaptive-continuation/admission/review_receiver_share.py", + "research/kappa-adaptive-continuation/runtime-repair/FIXTURES.json", + "research/kappa-adaptive-continuation/runtime-repair/audit_fast.py", + "research/kappa-adaptive-continuation/sources/PR3815/research/staged544-producer-return/REPLAY-INPUTS.tar.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43base.json.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/BORROW-WORD-43extra.json.gz", + "research/kappa-operator-repair/late-staged-composition/candidate/CONSTRUCTION.json", + "research/kappa-operator-repair/late-staged-composition/native-base/RESULT.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/STEPS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CANONICAL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-RECIPES.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/CLIFFORD-REVIEW.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/FULL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/LOCAL-PROGRAMS.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/RESIDUAL-ADAPTERS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/SCALAR-FRAME-AUDIT.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WARP-RECIPE-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/native/local/WRAPPER-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/SPARSE-PROOF.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/sparse_state.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/accelerators/tables.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/NOTICE-PR2226.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_adapters.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_audit_local.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_check_recipes.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_emit.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_gauss.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_phases.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_tamper.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/bw_transport.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_operators.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/code/borrow/vendor/pr2226_replay.py", + "research/kappa-operator-repair/late-staged-composition/native-base/source/native/new/run_native_borrow.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/RESULT.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/STEPS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CANONICAL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-RECIPES.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/CLIFFORD-REVIEW.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/FULL-WORD.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/INDEPENDENT-LOCAL-REPLAY.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/LOCAL-PROGRAMS.json.gz", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/RESIDUAL-ADAPTERS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/SCALAR-FRAME-AUDIT.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WARP-RECIPE-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/native/local/WRAPPER-CHECKS.json", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/SPARSE-PROOF.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/sparse_state.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/accelerators/tables.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/NOTICE-PR2226.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_adapters.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_audit_local.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_check_recipes.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_emit.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_gauss.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_phases.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_tamper.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/bw_transport.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_operators.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/code/borrow/vendor/pr2226_replay.py", + "research/kappa-operator-repair/late-staged-composition/native-extra/source/native/new/run_native_borrow.py", + "research/kappa-operator-repair/late-staged-composition/run_release.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/full_replay.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/NEW-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCE-PATCHES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/SOURCES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/old-NATIVE-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_applier.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/admission/pr3945/terminal_review.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/NEW-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-base.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/inputs/OLD-extra.json.gz", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/ENTRIES.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-base.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/RECORD-extra.json", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/make_record.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_applier.py", + "research/kappa-operator-repair/sources/PR4076/research/staged544-triple-entry-fill/recipe/staged_entries_review.py", + "research/staged544-mixed-fourth-entry/.gitattributes", + "research/staged544-mixed-fourth-entry/EXPORTED-SOURCES.json", + "research/staged544-mixed-fourth-entry/INPUTS.json", + "research/staged544-mixed-fourth-entry/MANIFEST.json", + "research/staged544-mixed-fourth-entry/NOTICE.md", + "research/staged544-mixed-fourth-entry/PROOF.md", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged544-mixed-fourth-entry/RESULT.json", + "research/staged544-mixed-fourth-entry/SOURCES.json", + "research/staged544-mixed-fourth-entry/TASK.json", + "research/staged544-mixed-fourth-entry/VERIFY.json", + "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-base.json.gz", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-CANONICAL-extra.json.gz", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-LOCAL-extra.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-PHASES-extra.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-base.json", + "research/staged544-mixed-fourth-entry/evidence/NATIVE-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-base.json.gz", + "research/staged544-mixed-fourth-entry/evidence/THREE-CANONICAL-extra.json.gz", + "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-LOCAL-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-NATIVE-extra.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-base.json", + "research/staged544-mixed-fourth-entry/evidence/THREE-PHASES-extra.json", + "research/staged544-mixed-fourth-entry/inputs/DATA-PHASES.json", + "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "research/staged544-mixed-fourth-entry/inputs/OPERATOR-TEMPLATE.json.gz", + "research/staged544-mixed-fourth-entry/inputs/PR4076-RESULT.json", + "research/staged544-mixed-fourth-entry/inputs/PR4085-CLAIM.json", + "research/staged544-mixed-fourth-entry/inputs/PR4088-FIRST-RESULT.json", + "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "research/staged544-mixed-fourth-entry/native/LICENSE", + "research/staged544-mixed-fourth-entry/native/NATIVE-LINEAGE-NOTICE", + "research/staged544-mixed-fourth-entry/native/PINS.json", + "research/staged544-mixed-fourth-entry/native/SOURCE-PROVENANCE.json", + "research/staged544-mixed-fourth-entry/native/common.py", + "research/staged544-mixed-fourth-entry/native/run_native.py", + "research/staged544-mixed-fourth-entry/native/stage.py", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-NOTICE.md", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/SPARSE-PROOF.md", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/sparse_state.py", + "research/staged544-mixed-fourth-entry/native/vendor/accelerators/tables.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/NOTICE-PR2226.md", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_adapters.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_check_recipes.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_gauss.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_phases.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_tamper.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/PR2226-NOTICE.md", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_operators.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/pr2226_replay.py", + "research/staged544-mixed-fourth-entry/native/vendor/native/new/run_native_borrow.py", + "research/staged544-mixed-fourth-entry/operator_verify.py", + "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "research/staged544-mixed-fourth-entry/owner/FILL.json.gz", + "research/staged544-mixed-fourth-entry/owner/MIXED-DISPATCH.json", + "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "research/staged544-mixed-fourth-entry/owner/PR4085-PROFILE.json", + "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "research/staged544-mixed-fourth-entry/owner_verify.py", + "research/staged544-mixed-fourth-entry/price.py", + "research/staged544-mixed-fourth-entry/recipe/RECORD-base.json", + "research/staged544-mixed-fourth-entry/recipe/RECORD-extra.json", + "research/staged544-mixed-fourth-entry/vendor/PR4076-NOTICE.md", + "research/staged544-mixed-fourth-entry/vendor/PR4085-OPERATOR-PROOF.md", + "research/staged544-mixed-fourth-entry/vendor/audit_core.py", + "research/staged544-mixed-fourth-entry/vendor/audit_verify.py", + "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "research/staged544-mixed-fourth-entry/vendor/full_operator.py", + "research/staged544-mixed-fourth-entry/vendor/staged_entries_applier.py", + "research/staged544-mixed-fourth-entry/vendor/staged_pair.py", + "research/staged544-mixed-fourth-entry/vendor/t360_admission.py", + "research/staged544-mixed-fourth-entry/verify.py", + "research/staged544-mixed-idle-rebind/inputs/DISPATCH.json", + "research/staged544-mixed-idle-rebind/inputs/FILL.json.gz", + "research/staged544-mixed-idle-rebind/inputs/FOUR-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/FOUR-extra.json.gz", + "research/staged544-mixed-idle-rebind/inputs/MIXED-DISPATCH.json", + "research/staged544-mixed-idle-rebind/inputs/NATIVE-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/NATIVE-extra.json.gz", + "research/staged544-mixed-idle-rebind/inputs/ORDER.json", + "research/staged544-mixed-idle-rebind/inputs/PLAN.json.gz", + "research/staged544-mixed-idle-rebind/inputs/PR4085-PROFILE.json", + "research/staged544-mixed-idle-rebind/inputs/TEMPLATE.json.gz", + "research/staged544-mixed-idle-rebind/inputs/THREE-base.json.gz", + "research/staged544-mixed-idle-rebind/inputs/THREE-extra.json.gz", + "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "All declared live source pins; actual four-provider call/width/idle binding on 1,321,920 rows; semantic mutation controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/test_binding.py" + ], + "timeout_seconds": 60, + "checks": "The new explicit rejection predicates remain active in optimized Python; the inherited full engine separately rejects optimized execution." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/independent_ledger.py", + "--controls" + ], + "timeout_seconds": 180, + "checks": "Independent exact span enumeration and event-level chronology/capacity/accounting; three semantic mutations reach their specific rejection predicates." + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4180/adapt.py b/research/complex-pooled-full-admission/frozen/pr4180/adapt.py new file mode 100644 index 000000000..12579636b --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/adapt.py @@ -0,0 +1,154 @@ +"""Exact, reviewable extensions of a freshly reconstructed PR4085 source. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +Predecessor code and notices are retained in the generated external tree. +""" +import json +from pathlib import Path +import shutil + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +MIXED = REPO / "research/staged544-mixed-fourth-entry" +TAGS = {"gauge44": "base", "extra": "extra", + "gauge44-four": "base-four", "extra-four": "extra-four"} +BASE_MANIFEST = "4116ef61479e509811b60b5fd4e84db8811dae079092f2f83bdcc2c80052c0da" +BASE_ENGINE = "e69184d235d8790a3c520977dd44dcfb73a99d56989825485f922ff61059c8b1" + + +def write(path, value): + path.write_text(json.dumps(value, sort_keys=True, indent=2) + "\n") + + +def tree(path, exclude=()): + result = {} + for p in sorted(path.rglob("*")): + need(not p.is_symlink(), "unbound source symlink") + if p.is_file() and p.relative_to(path).as_posix() not in exclude: + result[p.relative_to(path).as_posix()] = sha(p) + return result + + +class Patches: + def __init__(self, root): + self.root = root + self.rows = [] + + def replace(self, name, old, new, count=1): + p = self.root / name + before = sha(p) + body = p.read_text() + need(body.count(old) == count, "exact patch preimage: " + name + ": " + old[:70]) + p.write_text(body.replace(old, new)) + self.rows.append(dict(path=name, before_sha256=before, after_sha256=sha(p), + old=old, new=new, occurrences=count)) + + +def extend_source(baseline, destination): + source = baseline / "inputs/source" + need(sha(source / "MANIFEST.json") == BASE_MANIFEST, "exact PR4085 source manifest") + need(tree(source, ("MANIFEST.json",)) == read(source / "MANIFEST.json"), + "complete PR4085 source inventory") + shutil.copytree(source, destination) + p = Patches(destination) + registry = read(destination / "new/BORROW-PROVIDERS.json") + contract = {"providers": {}, "dispatch": read(MIXED / "owner/MIXED-DISPATCH.json")} + for pid, tag in TAGS.items(): + base = tag.split("-")[0] + kind = "FOUR" if tag.endswith("-four") else "THREE" + word = MIXED / f"inputs/{kind}-{base}.json.gz" + value = read(word) + native = read(MIXED / f"owner/old-NATIVE-{base}.json.gz") + widths = [len(value["helper_final"].get(str(r), [1 << i for i in range(9)])) + - len(value["start_extra"].get(str(r), [])) for r in native["helper_origin"]] + relative = f"new/borrow/words/BORROW-WORD-43{tag}.json.gz" + if kind == "THREE": + need(sha(destination / relative) == sha(word), "unchanged THREE source") + else: + shutil.copyfile(word, destination / relative) + registry[pid] = {"widths": widths, "actual_paid_profile": value["report"]["local_profile"]} + need(registry[pid]["widths"] == widths + and registry[pid]["actual_paid_profile"] == value["report"]["local_profile"], + "complete native-order registry") + contract["providers"][pid] = dict(word=relative, word_sha256=sha(word), + widths=widths, profile=value["report"]["local_profile"]) + write(destination / "new/BORROW-PROVIDERS.json", registry) + write(destination / "new/MIXED-CONTRACT.json", contract) + shutil.copyfile(HERE / "binding.py", destination / "new/mixed_binding.py") + p.replace("new/rebind.py", + "pkg, loc_g, loc_e, out = map(Path, sys.argv[1:5]);", + "pkg, loc_g, loc_e, loc_g4, loc_e4, out = map(Path, sys.argv[1:7]);") + p.replace("new/rebind.py", "locs = {'gauge44': loc_g, 'extra': loc_e};", + "locs = {'gauge44': loc_g, 'extra': loc_e, 'gauge44-four': loc_g4, 'extra-four': loc_e4};") + p.replace("new/rebind.py", + "idle = {int(r): v for r, v in rd(pkg / 'CONSTRUCTION.json')['idle'].items()} # exact idle ranks of the shipped owner fill", + "from mixed_binding import validate_rebind\nidle = validate_rebind(pkg, plan, locs)") + # Both native entrypoints and both inherited replay call sites receive all providers. + p.replace("verify.py", + "new_words={'base':P/'new/borrow/words/BORROW-WORD-43base.json.gz','extra':P/'new/borrow/words/BORROW-WORD-43extra.json.gz'}", + "new_words={tag:P/'new/borrow/words'/('BORROW-WORD-43'+tag+'.json.gz') for tag in ('base','extra','base-four','extra-four')}") + p.replace("verify.py", "reuse=getattr(a,'new_%s_native_from'%key)", + "reuse=getattr(a,'new_%s_native_from'%key,None)") + p.replace("verify.py", + "P,nat['base']/'local',nat['extra']/'local',work/'data-rebound'", + "P,nat['base']/'local',nat['extra']/'local',nat['base-four']/'local',nat['extra-four']/'local',work/'data-rebound'") + p.replace("verify.py", "nat['base'],nat['extra'],*[p_", + "nat['base'],nat['extra'],nat['base-four'],nat['extra-four'],*[p_") + p.replace("verify.py", "shutil.copytree(nat['extra'],runtime/'native-extra')", + "for pid,tag in [('extra','extra'),('gauge44-four','base-four'),('extra-four','extra-four')]:shutil.copytree(nat[tag],runtime/('native-'+pid))") + p.replace("replay.py", "g=work/'global'", + "provider_dirs={'gauge44':local, **{pid:P/('native-'+pid)/'local' for pid in rd(data/'PLAN.json')['provider_registry'] if pid!='gauge44'}}\n" + "assert set(provider_dirs)==set(rd(data/'PLAN.json')['provider_registry'])\n" + "provider_args=[arg for pid,directory in sorted(provider_dirs.items()) for arg in ('--provider',pid+'='+str(directory))]\n" + "g=work/'global'") + p.replace("replay.py", + "'--provider','gauge44='+str(local),'--provider','extra='+str(P/'native-extra/local')", + "*provider_args", count=2) + after = tree(destination, ("MANIFEST.json",)) + before = read(source / "MANIFEST.json") + patched = {row["path"] for row in p.rows} + for name in sorted(set(before) | set(after)): + if name not in patched and before.get(name) != after.get(name): + p.rows.append(dict(path=name, kind="file_inventory_change", + before_sha256=before.get(name), after_sha256=after.get(name))) + write(destination / "MANIFEST.json", after) + return contract, p.rows + + +def extend_engine(baseline, source, output): + need(sha(baseline / "admit_composed.py") == BASE_ENGINE, "exact inherited admission engine") + shutil.copyfile(baseline / "admit_composed.py", output) + p = Patches(output.parent) + name = output.name + manifest = sha(source / "MANIFEST.json") + p.replace(name, "manifest='" + BASE_MANIFEST + "'", "manifest='" + manifest + "'") + p.replace(name, "helpers=408,source_file_count=676", + f"helpers=408,source_file_count={len(read(source / 'MANIFEST.json'))}") + p.replace(name, "commit='triple-staged-entry-and-receiver-share-20261019'", + "commit='pr4088-four-provider-admission-v1'") + p.replace(name, "for tag in ('base', 'extra'):", + "for tag in ('base', 'extra', 'base-four', 'extra-four'):", count=2) + p.replace(name, + "natives['extra'] / 'local', work / 'rebound'", + "natives['extra'] / 'local', natives['base-four'] / 'local', natives['extra-four'] / 'local', work / 'rebound'") + p.replace(name, "shutil.copytree(natives['extra'], runtime / 'native-extra')", + "for pid, tag in [('extra','extra'),('gauge44-four','base-four'),('extra-four','extra-four')]:\n" + " shutil.copytree(natives[tag], runtime / ('native-'+pid))") + p.replace(name, " write(work / 'RUNTIME-PATCHES.json', patches)", + " patch('verify.py', [(\"controller=15,independent_owner=8,geometry=6\", " + "\"controller=rd(P/'new/SPEC.json')['expected']['mutations_rejected'],independent_owner=8,geometry=6\")])\n" + " write(work / 'RUNTIME-PATCHES.json', patches)") + # New provider IDs inherit the unchanged interface descriptor, never an averaged width. + old = "P.require(pid in plan['provider_registry'],'provider in retained registry')" + new = ("if pid not in plan['provider_registry']:\n" + " P.require(pid.endswith('-four') and pid[:-5] in plan['provider_registry'], 'declared fourth provider')\n" + " plan['provider_registry'][pid]=copy.deepcopy(plan['provider_registry'][pid[:-5]])\n" + " " + old) + helper = output.parent / "helpers" + shutil.copytree(baseline / "inputs/helpers", helper) + hp = Patches(output.parent) + hp.replace("helpers/lift_parent.py", old, new) + return p.rows + hp.rows diff --git a/research/complex-pooled-full-admission/frozen/pr4180/binding.py b/research/complex-pooled-full-admission/frozen/pr4180/binding.py new file mode 100644 index 000000000..14eb67c6e --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/binding.py @@ -0,0 +1,128 @@ +"""Strict per-call binding added to the inherited PR4085 rebind. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +The inherited owner, native, phase, invoice and release checks remain required. +""" +from collections import Counter +import gzip +import hashlib +import json + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def account(plan, roles, dispatch): + """Recompute complements from actual rows, never an orientation average.""" + order = [tuple(c) for c in plan["order"]] + need(len(order) == len(set(order)), "duplicate call") + need(len(dispatch) == len(order), "dispatch row coverage") + selected = {(s, r): p for s, r, p in dispatch} + need(len(selected) == len(dispatch) and set(selected) == set(order), + "dispatch bijection") + registry = plan["provider_registry"] + need(set(selected.values()) == set(registry), "complete provider usage") + counts = {len(d["widths"]) for d in registry.values()} + need(len(counts) == 1, "common helper count") + helpers = counts.pop() + need(helpers > 0 and len(roles) == helpers * len(order), "role coverage") + calls, widths = plan["provider_calls"], plan["per_call_widths"] + need(len(calls) == len(widths) == len(order), "call descriptor coverage") + for t, (stage, replica) in enumerate(order): + c, w, pid = calls[t], widths[t], selected[stage, replica] + need((c["stage"], c["replica"], c["time"], c["provider"]) + == (stage, replica, t, pid), "per-call provider binding") + need(c["orientation"] == ("forward" if stage % 2 == 0 else "backward"), + "per-call orientation") + need(c["local_program_sha256"] == + registry[pid]["orientation_program_sha256"][c["orientation"]], + "per-call program binding") + need((w["stage"], w["replica"], w["time"]) == (stage, replica, t) + and w["widths"] == registry[pid]["widths"], "per-call width binding") + windows = {tuple(map(int, k.split(","))): (cap, set(times)) + for k, (cap, times) in plan["windows"].items()} + used = Counter() + families = set() + for j, z in enumerate(roles): + t, h = divmod(j, helpers) + stage, replica = order[t] + pid = selected[stage, replica] + need((z["time"], z["helper"], z["stage"], z["replica"]) + == (t, h, stage, replica), "ordered role identity") + owner, child, port = z["owner_replica"], z["child"], z["port"] + need(all(type(v) is int for v in (owner, child, port, z["offset"], z["width"])), + "integer owner record") + need((owner, child) in windows and 0 <= port < 112, "owner bin") + cap, times = windows[owner, child] + need(t in times, "strict inherited window") + width = registry[pid]["widths"][h] + need(type(width) is int and width > 0 and z["width"] == width, + "actual selected helper width") + stream = 2 * plan["pairs"][str(child)] + plan["sides"][str(child)] + family = 896 * owner + 112 * stream + port + need(z["family"] == family and z["copy"] == 112 * owner + port, + "physical family binding") + if h == 0: + families = set() + need(family not in families, "same-call family alias") + families.add(family) + key = owner, child, port + need(z["offset"] == used[key] and used[key] + width <= cap, + "compact per-call residual prefix") + used[key] += width + idle = Counter() + for (owner, child), (cap, _) in windows.items(): + for port in range(112): + left = cap - used[owner, child, port] + need(left >= 0, "negative idle remainder") + if left: + idle[left] += 1 + total = Counter(idle) + for call in order: + total.update({int(r): n for r, n in + registry[selected[call]]["actual_paid_profile"].items()}) + return dict(sorted(idle.items())), dict(sorted(total.items())) + + +def validate_rebind(pkg, plan, locs): + contract = read(pkg / "new/MIXED-CONTRACT.json") + need(set(locs) == set(plan["provider_registry"]) == set(contract["providers"]), + "complete four-provider binding") + for pid, source in contract["providers"].items(): + word = pkg / source["word"] + need(sha(word) == source["word_sha256"], "provider source changed") + full = read(locs[pid] / "FULL-WORD.json.gz") + need(full == read(word), "native source word") + canonical = read(locs[pid] / "CANONICAL-WORD.json.gz") + widths = [len(canonical["frames"][canonical["final"][r]]) + - len(canonical["frames"][canonical["start"][r]]) + for r in range(224, 224 + canonical["R"])] + desc = plan["provider_registry"][pid] + need(widths == source["widths"] == desc["widths"], "native selected widths") + checks = read(locs[pid] / "LOCAL-CHECKS.json") + need(all(checks[o]["paid_profile"] == source["profile"] + == desc["actual_paid_profile"] for o in ("forward", "backward")), + "both orientation paid profiles") + dispatch = read(pkg / "DISPATCH.json") + # The inherited reconstructor serializes in chronological order; the input + # table's row order is immaterial. account() separately requires a bijection + # and binds every chronological call, width and orientation program. + need(sorted(dispatch) == sorted(contract["dispatch"]), "literal mixed selector") + idle, total = account(plan, read(pkg / "OWNERS.json.gz"), dispatch) + need(idle == {int(k): v for k, v in read(pkg / "CONSTRUCTION.json")["idle"].items()}, + "stale construction idle") + need(total == {int(k): v for k, v in plan["profile"].items()}, + "complete mixed paid profile") + return idle diff --git a/research/complex-pooled-full-admission/frozen/pr4180/challenge.py b/research/complex-pooled-full-admission/frozen/pr4180/challenge.py new file mode 100644 index 000000000..2b27377cf --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/challenge.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 +"""Bounded semantic challenges against an actual prepared or completed replay. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance, incorporating +the separate adversarial context's demonstrated cache mutations. +This does not rerun or establish the full release. +""" +import argparse +import gzip +import json +from pathlib import Path +import shutil +import tempfile + +from adapt import TAGS, write +from binding import need, read, sha +from native_outputs import REFERENCES, authenticate_native +from replay import check_preflight + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--work", type=Path, required=True, help="existing replay.py output") + ap.add_argument("--preflight", type=Path, help="if the run supplied --checked-preflight") + args = ap.parse_args() + work = args.work.resolve() + baseline = (args.preflight or work / "baseline/release-work/preflight").resolve() + check_preflight(baseline) + results = [{"name": "actual predecessor preflight", "status": "PASS"}] + + def reject(name, call, reason): + try: + call() + except ValueError as exc: + need(reason in str(exc), "unexpected rejection: " + str(exc)) + results.append(dict(name=name, status="REJECTED", reason=str(exc))) + else: + raise ValueError("accepted semantic mutant: " + name) + + for pid, tag in TAGS.items(): + word_sha = sha(work / f"source/new/borrow/words/BORROW-WORD-43{tag}.json.gz") + original = work / "native-cache" / word_sha + # Engine caches add CACHE.json; its transport inventory is checked by + # the engine. The fixed scientific gate consumes only native products. + with tempfile.TemporaryDirectory() as td: + native = Path(td) / "native" + shutil.copytree(original, native, ignore=shutil.ignore_patterns("CACHE.json")) + products = authenticate_native(pid, word_sha, native) + need(len(products) == 11, "all scientific products") + results.append(dict(name=pid + " actual native products", status="PASS")) + + recipe_path = native / "local/CLIFFORD-RECIPES.json" + saved = recipe_path.read_bytes() + recipe = read(recipe_path) + recipe["warps"][0]["left"]["phase"] = (recipe["warps"][0]["left"]["phase"] + 1) % 4 + write(recipe_path, recipe) + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + path = native / "local" / name + value = read(path) + value["recipe_sha256"] = sha(recipe_path) + write(path, value) + reject(pid + " wrong phase with all recipe references rebound", + lambda: authenticate_native(pid, word_sha, native), + "native scientific output commitment") + recipe_path.write_bytes(saved) + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + shutil.copyfile(original / "local" / name, native / "local" / name) + + steps_path = native / "STEPS.json" + steps = read(steps_path) + write(steps_path, steps[:-1]) + reject(pid + " skipped phase stage", + lambda: authenticate_native(pid, word_sha, native), + "actual native stage products coverage") + write(steps_path, steps) + + # Positive control: transport and elapsed time may change without + # changing a mathematical product. Rebind actual serialized refs. + for path in (native / "local").iterdir(): + value = read(path) + if path.name in ("CLIFFORD-REVIEW.json", "SCALAR-FRAME-AUDIT.json"): + value["seconds"] += 1 + raw = json.dumps(value, sort_keys=True, indent=1).encode() + path.write_bytes(gzip.compress(raw, mtime=17) if path.suffix == ".gz" else raw) + for path in (native / "local").iterdir(): + value = read(path) + changed = False + for field, target in REFERENCES.items(): + if field in value: + value[field] = sha(native / "local" / target) + changed = True + if changed: + write(path, value) + need(authenticate_native(pid, word_sha, native) == products, + "transport-equivalent products") + results.append(dict(name=pid + " equivalent serialization and timing", status="PASS")) + + with tempfile.TemporaryDirectory() as td: + mutant = Path(td) / "preflight" + shutil.copytree(baseline, mutant) + engine = mutant / "admit_composed.py" + engine.write_bytes(engine.read_bytes() + b"\n# deliberate source mutation\n") + receipt_path = mutant / "PREFLIGHT-RESULT.json" + receipt = read(receipt_path) + receipt["admission_engine_sha256"] = sha(engine) + write(receipt_path, receipt) + reject("changed engine with rebound completion receipt", + lambda: check_preflight(mutant), "preflight admission engine") + + print(json.dumps(dict(status="PASS_ACTUAL_REPLAY_CHALLENGES", cases=results, + scope="Reuse gates only; not full native or ordinary admission."), + sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/frozen/pr4180/independent_ledger.py b/research/complex-pooled-full-admission/frozen/pr4180/independent_ledger.py new file mode 100644 index 000000000..396640e75 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/independent_ledger.py @@ -0,0 +1,312 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independently corroborate PR4088's mixed-provider owner invoice. + +Prepared for the yssite campaign with substantial OpenAI Codex assistance, +2026-10-20. This checker credits Cinna Davis's PR4088 construction and unpaidmoon's +PR4165 idle/rebind finding. It imports no repository code, invokes no subprocesses, +and writes no files. Optional controls change only private in-memory inputs. + +Independence: frame ranks enumerate complete F2 spans; exact observation windows +are reconstructed from the flat execution schedule. The owner walker and lead +admission binding are not imported. Local cost profiles and observer definitions +remain declared source interfaces. This is a finite ledger check, not a native, +scalar-semantics, Z4-operator, all-size, or ordinary/outer release proof. + +Use --repo PATH when this script is outside research/mixed-provider-admission. +Only that installed location permits repository-root inference. All consumed +source paths and byte hashes are emitted in consumed_sources. +""" +import argparse +from collections import Counter, defaultdict +import gzip +import hashlib +import json +from pathlib import Path + +PACKAGE = Path('research/staged544-mixed-fourth-entry') +PREDECESSOR = Path('research/staged544-mixed-idle-rebind') + + +class LedgerError(ValueError): + def __init__(self, code, detail=''): + self.code = code + self.detail = detail + super().__init__(code + (': ' + detail if detail else '')) + + +def require(condition, code, detail=''): + if not condition: + raise LedgerError(code, detail) + + +def rank(vectors): + """Enumerate at most 512 span elements, without a shared basis routine.""" + span = {0} + for vector in vectors: + require(type(vector) is int and 0 <= vector < 512, 'frame-vector') + span |= {value ^ vector for value in tuple(span)} + return len(span).bit_length() - 1 + + +def repo_path(argument): + if argument is not None: + return Path(argument).resolve() + here = Path(__file__).resolve().parent + require(here.name == 'mixed-provider-admission' and here.parent.name == 'research', + 'explicit-repo-required', 'use --repo PATH outside research/mixed-provider-admission') + return here.parent.parent + + +class Sources: + def __init__(self, repo): + self.repo = repo + self.consumed = {} + self.declared = {} + for name in ('MANIFEST.json', 'EXPORTED-SOURCES.json'): + manifest = self.read(PACKAGE / name, authenticate=False) + for relative, entry in manifest.items(): + digest = entry['sha256'] if isinstance(entry, dict) else entry + path = (PACKAGE / relative).as_posix() + require(path not in self.declared or self.declared[path] == digest, + 'conflicting-source-pin', path) + self.declared[path] = digest + + def raw(self, path, authenticate=True): + name = path.as_posix() + raw = (self.repo / path).read_bytes() + digest = hashlib.sha256(raw).hexdigest() + if authenticate: + require(name in self.declared, 'undeclared-source', name) + require(digest == self.declared[name], 'source-pin', name) + self.consumed[name] = digest + return raw + + def read(self, path, authenticate=True): + raw = self.raw(path, authenticate) + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def exact_windows(order, template, plan, phases): + clock = {tuple(call): time for time, call in enumerate(order)} + require(len(order) == len(clock) == 3240, 'order-uniqueness') + require(set(clock) == {(s, r) for s in range(9) for r in range(360)}, 'order-domain') + require(all(clock[s, r] < clock[s + 1, r] for r in range(360) for s in range(8)), + 'stage-chronology') + positive = {entry['child'] for entry in template['idle_children']} + require(len(positive) == 18 and len(phases['recipes']) == 112, 'bin-dimensions') + stage_pairs = {e['stage']: e['pair'] for e in template['recipe'] if e['kind'] == 'local'} + observations = defaultdict(list) + windows = {} + stage = None + index = -1 + for event in template['execution_schedule']: + kind = event['kind'] + if kind in ('bank_padding_cover_sweep', 'translate_every_live_family'): + continue + if kind == 'local_cover_sweep': + stage, index = event['stage'], 0 + else: + index += 1 + require(stage is not None, 'event-before-local-stage') + if kind == 'idle_cover_sweep': + for side, child in enumerate(event['child_indices']): + stream = 2 * event['pair'] + side + if child in positive: + require(stream == 2 * plan['pairs'][str(child)] + plan['sides'][str(child)], + 'stream-route') + for owner in range(360): + endpoint = (clock[stage, owner], index) + prior = observations[owner, stream][-1] if observations[owner, stream] else (-1, -1) + require((owner, child) not in windows, 'duplicate-window') + windows[owner, child] = prior, endpoint, stream + if kind == 'local_cover_sweep': + touched = (2 * stage_pairs[stage], 2 * stage_pairs[stage] + 1) + elif kind == 'bridge': + touched = [2 * pair + side for pair in (event['src'], event['dst']) for side in (0, 1)] + elif kind == 'terminal': + touched = range(8) + else: + require(kind in ('idle_cover_sweep', 'terminal_Y_translations'), 'unrecognized-event') + touched = () + for owner in range(360): + for stream in touched: + observations[owner, stream].append((clock[stage, owner], index)) + shared = defaultdict(list) + for (owner, child), (low, high, stream) in windows.items(): + if child in positive: + shared[owner, stream].append((low, high)) + for intervals in shared.values(): + intervals.sort() + require(all(left[1] <= right[0] for left, right in zip(intervals, intervals[1:])), + 'overlapping-stream-windows') + return clock, windows, stage_pairs + + +def scan(rows, order, dispatch, windows, stage_pairs, phases, widths, first_row_override=None): + require(len(rows) == 1321920, 'role-count') + used = defaultdict(int) + same_call = set() + hosted_mass = 0 + first = {} + for index, original in enumerate(rows): + row = first_row_override if index == 0 and first_row_override is not None else original + require(len(row) == 6 and all(type(value) is int for value in row), 'row-types') + time, helper, owner, child, port, offset = row + require((time, helper) == divmod(index, 408), 'row-identity') + if helper == 0: + same_call = set() + require((owner, child) in windows and 0 <= port < 112, 'owner-identity') + low, high, stream = windows[owner, child] + require(low < (time, -1) < high, 'strict-observation-window') + key = owner, child, port + physical = owner, stream, port + require(physical not in same_call, 'same-call-alias') + same_call.add(physical) + stage, replica = order[time] + require(4 * owner + stream // 2 != 4 * replica + stage_pairs[stage], 'productive-alias') + record = phases['recipes'][port]['idle_children'][child] + axes = record['orthogonal_axes'] + require(len(axes) == len(set(axes)) == record['rank'], 'axis-identity') + provider = dispatch[stage, replica] + width = widths[provider][helper] + require(offset == used[key], 'compact-prefix', + f'row {index}: expected {used[key]}, got {offset}') + require(offset + width <= len(axes), 'axis-capacity', f'row {index}') + used[key] += width + hosted_mass += width + if helper == 367 and provider not in first: + first[provider] = dict(row_index=index, row=row, call=order[time], width=width, + window=[low, high], stream=stream, axis_capacity=len(axes)) + idle = Counter() + axis_mass = positive_bins = 0 + for owner in range(360): + for port, recipe in enumerate(phases['recipes']): + for child, record in enumerate(recipe['idle_children']): + capacity = len(record['orthogonal_axes']) + axis_mass += capacity + positive_bins += bool(capacity) + left = capacity - used[owner, child, port] + require(left >= 0, 'negative-complement') + if left: + idle[left] += 1 + require(hosted_mass + sum(r * n for r, n in idle.items()) == axis_mass, 'axis-mass') + return dict(idle=idle, first=first, hosted_axis_mass=hosted_mass, total_axis_mass=axis_mass, + positive_bins=positive_bins, occupied_positive_bins=sum(bool(v) for v in used.values())) + + +def invoice(counts, profiles, idle, expected): + profile = Counter(idle) + for provider, count in counts.items(): + for r, n in profiles[provider].items(): + profile[r] += count * n + require(dict(profile) == {int(r): n for r, n in expected['profile'].items()}, 'complete-profile') + require(dict(idle) == {int(r): n for r, n in expected['idle'].items()}, 'idle-profile') + require(sum(r * n for r, n in profile.items()) == 65088 * 360, 'paid-rank-mass') + return dict(sorted(profile.items())) + + +def reject(label, expected_code, expected_detail, action): + try: + action() + except LedgerError as error: + require(error.code == expected_code and expected_detail in error.detail, + 'wrong-control-rejection', f'{label}: {error}') + return dict(control=label, rejection=error.code, detail=error.detail) + raise LedgerError('accepted-control', label) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--repo', type=Path, help='repository root') + parser.add_argument('--controls', action='store_true', help='run three bounded in-memory rejection controls') + args = parser.parse_args() + sources = Sources(repo_path(args.repo)) + read = sources.read + pairs = [('owner/' + n, 'inputs/' + n) for n in + ('ORDER.json', 'DISPATCH.json', 'MIXED-DISPATCH.json', 'FILL.json.gz', + 'PLAN.json.gz', 'TEMPLATE.json.gz', 'PR4085-PROFILE.json')] + pairs += [('owner/old-NATIVE-' + s + '.json.gz', 'inputs/NATIVE-' + s + '.json.gz') + for s in ('base', 'extra')] + pairs += [('inputs/' + k + '-' + s + '.json.gz', 'inputs/' + k + '-' + s + '.json.gz') + for k in ('THREE', 'FOUR') for s in ('base', 'extra')] + for left, right in pairs: + raw = sources.raw(PACKAGE / left) + # PR4165's duplicate input is authenticated by exact equality to the pinned PR4088 bytes. + other = sources.raw(PREDECESSOR / right, authenticate=False) + require(raw == other, 'cross-package-source', left) + order = read(PACKAGE / 'owner/ORDER.json') + template = read(PACKAGE / 'owner/TEMPLATE.json.gz') + plan = read(PACKAGE / 'owner/PLAN.json.gz') + phases = read(PACKAGE / 'inputs/DATA-PHASES.json') + require(template['exact_data_phase_recipe_sha256'] == sources.consumed[(PACKAGE / 'inputs/DATA-PHASES.json').as_posix()], + 'phase-pin') + clock, windows, stage_pairs = exact_windows(order, template, plan, phases) + old = read(PACKAGE / 'owner/DISPATCH.json') + new = read(PACKAGE / 'owner/MIXED-DISPATCH.json') + require(len(old) == len(new) == 3240, 'dispatch-row-count') + predecessor = {(s, r): provider for s, r, provider in old} + dispatch = {(s, r): provider for s, r, provider in new} + require(len(predecessor) == len(dispatch) == 3240 and set(dispatch) == set(clock) == set(predecessor), + 'dispatch-identity') + require(new == [[s, r, provider + ('-four' if 109 * clock[s, r] % 324 < 109 else '')] + for s, r, provider in old], 'literal-selector') + counts = Counter(dispatch.values()) + require(counts == Counter({'gauge44': 1040, 'gauge44-four': 528, 'extra': 1110, 'extra-four': 562}), + 'provider-counts') + origin = read(PACKAGE / 'owner/old-NATIVE-base.json.gz')['helper_origin'] + require(origin == read(PACKAGE / 'owner/old-NATIVE-extra.json.gz')['helper_origin'], 'orientation-origin') + widths, profiles, inventories = {}, {}, {} + for tag, provider in (('base', 'gauge44'), ('extra', 'extra')): + for kind, suffix in (('THREE', ''), ('FOUR', '-four')): + word = read(PACKAGE / f'inputs/{kind}-{tag}.json.gz') + name = provider + suffix + require(origin == sorted(set(range(224, 704)) - set(word['removed'])), 'helper-origin') + widths[name] = [rank(word['helper_final'].get(str(h), [1 << i for i in range(9)])) + - rank(word['start_extra'].get(str(h), [])) for h in origin] + profiles[name] = {int(r): n for r, n in word['report']['local_profile'].items()} + inventories[name] = dict(sorted(Counter(widths[name]).items())) + native_kind = 'THREE-CANONICAL' if kind == 'THREE' else 'NATIVE-CANONICAL' + canonical = read(PACKAGE / f'evidence/{native_kind}-{tag}.json.gz') + require(canonical['helper_origin'] == origin, 'native-helper-map') + native_widths = [rank(canonical['frames'][canonical['final'][r]]) + - rank(canonical['frames'][canonical['start'][r]]) for r in range(224, 632)] + require(native_widths == widths[name], 'native-candidate-widths') + for provider in ('gauge44', 'extra'): + changes = [(h, origin[h], a, b) for h, (a, b) in + enumerate(zip(widths[provider], widths[provider + '-four'])) if a != b] + require(changes == [(367, 601, 8, 7)], 'width-changes') + fill = read(PACKAGE / 'owner/FILL.json.gz') + require(fill['columns'] == ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'] + and fill['dispatch_overrides'] == [], 'fill-schema') + rows = fill['rows'] + result = read(PACKAGE / 'RESULT.json') + def walk(chosen_dispatch=dispatch, first_row_override=None): + return scan(rows, order, chosen_dispatch, windows, stage_pairs, phases, widths, first_row_override) + scanned = walk() + profile = invoice(counts, profiles, scanned['idle'], result) + controls = [] + if args.controls: + changed_dispatch = dict(dispatch) + require(dispatch[tuple(order[0])] == 'extra-four', 'control-t0-provider') + changed_dispatch[tuple(order[0])] = 'extra' + controls.append(reject('stamp-three-t0', 'compact-prefix', 'row 29389: expected 8, got 7', + lambda: walk(changed_dispatch))) + bad_row = list(rows[0]) + bad_row[-1] += 1 + controls.append(reject('offset-hole', 'compact-prefix', 'row 0: expected 0, got 1', + lambda: walk(first_row_override=bad_row))) + bad_profiles = {provider: dict(values) for provider, values in profiles.items()} + bad_profiles['extra-four'][1] += 1 + controls.append(reject('extra-rank-one', 'complete-profile', '', + lambda: invoice(counts, bad_profiles, scanned['idle'], result))) + output = dict(status='PASS_INDEPENDENT_MIXED_LEDGER', provider_counts=dict(counts), + width_histograms=inventories, first_helper601_per_provider=scanned.pop('first'), + profile=profile, rows=len(rows), exact_windows_including_zero_slots=len(windows), + paid_rank_mass=sum(r * n for r, n in profile.items()), controls=controls, + consumed_sources=dict(sorted(sources.consumed.items())), **scanned) + print(json.dumps(output, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-pooled-full-admission/frozen/pr4180/native_outputs.py b/research/complex-pooled-full-admission/frozen/pr4180/native_outputs.py new file mode 100644 index 000000000..4b7e6b217 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/native_outputs.py @@ -0,0 +1,56 @@ +"""Authenticate the scientific products of all five native stages. + +SPDX-License-Identifier: Apache-2.0 +Completion flags are not output commitments. This closure is fixed by recorded +honest executions, not regenerated from a caller's cache during verification. +Only two root elapsed-time fields and gzip transport bytes are normalized. +""" +import hashlib +import json +import math +from pathlib import Path + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +STAGES = ("native", "ledgers", "local-replay", "wrappers", "phases") +REFERENCES = {"canonical_word_sha256": "CANONICAL-WORD.json.gz", + "local_programs_sha256": "LOCAL-PROGRAMS.json.gz", + "recipe_sha256": "CLIFFORD-RECIPES.json"} + + +def digest(value): + return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":"), + allow_nan=False).encode()).hexdigest() + + +def scientific_products(native): + steps = read(native / "STEPS.json") + need([s["step"] for s in steps] == list(STAGES) + and all(type(s["exit_code"]) is int and s["exit_code"] == 0 for s in steps), + "actual native stage products coverage") + local = native / "local" + products = {} + for path in sorted(local.iterdir()): + need(path.is_file() and not path.is_symlink(), "ordinary native product") + value = read(path) + if path.name in ("SCALAR-FRAME-AUDIT.json", "CLIFFORD-REVIEW.json"): + seconds = value.pop("seconds") + need(type(seconds) in (int, float) and math.isfinite(seconds) and seconds >= 0, + "finite nonnegative native timing") + for field, target in REFERENCES.items(): + if field in value: + need(value[field] == sha(local / target), "stale native reference: " + path.name) + value[field] = digest(read(local / target)) + products[path.name] = digest(value) + need({p.relative_to(native).as_posix() for p in native.rglob("*") if p.is_file()} + == {"STEPS.json"} | {"local/" + n for n in products}, "native output file closure") + return products + + +def authenticate_native(pid, word_sha256, native): + expected = read(HERE / "NATIVE-OUTPUTS.json")["providers"][pid] + need(expected["word_sha256"] == word_sha256, "native commitment word binding") + actual = scientific_products(native) + need(actual == expected["products"], "native scientific output commitment") + return actual diff --git a/research/complex-pooled-full-admission/frozen/pr4180/replay.py b/research/complex-pooled-full-admission/frozen/pr4180/replay.py new file mode 100644 index 000000000..fe8ac09fd --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/replay.py @@ -0,0 +1,250 @@ +#!/usr/bin/env python3 +"""Run the source-bound four-provider extension in a fresh external directory. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +No frontier record is modified. Finite release is not an all-size proof. +""" +import argparse +from importlib.metadata import version +import importlib.util +import os +from pathlib import Path +import shutil +import signal +import subprocess +import sys +import time + +from adapt import BASE_ENGINE, BASE_MANIFEST, HERE, MIXED, REPO, TAGS, extend_engine, extend_source, tree, write +from binding import need, read, sha +from native_outputs import authenticate_native +from sources import authenticate_sources + +PREDECESSOR = REPO / "research/kappa-operator-repair/late-staged-composition" +STAGES = ["native", "ledgers", "local-replay", "wrappers", "phases"] +DEPENDENCIES = {"numpy": "2.3.5", "scipy": "1.17.0", "sympy": "1.14.0", "mpmath": "1.3.0"} + + +def baseline_preflight(output): + """Redirect output placement only; the predecessor's exact pins still apply.""" + output.mkdir() + shutil.copytree(PREDECESSOR / "candidate", output / "candidate") + path = PREDECESSOR / "run_release.py" + spec = importlib.util.spec_from_file_location("pr4085_preflight", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + module.HERE = output + saved = sys.argv + sys.argv = [str(path), "--work", str(output / "release-work/preflight"), "--preflight-only"] + try: + module.main() + finally: + sys.argv = saved + return output / "release-work/preflight" + + +def check_preflight(baseline): + result = read(baseline / "PREFLIGHT-RESULT.json") + need(result["status"] == "PASS_ALL_THREE_WORD_REVIEWS_SOURCE_READY_NOT_ADMITTED", + "completed predecessor preflight") + need(result["runner_sha256"] == sha(PREDECESSOR / "run_release.py"), + "preflight runner binding") + need(result["source_manifest_sha256"] == BASE_MANIFEST + == sha(baseline / "inputs/source/MANIFEST.json"), "preflight source pin") + need(result["source_files"] == 676, "preflight source count") + need(result["candidate_gzip_sha256"] == + {tag: sha(MIXED / f"inputs/THREE-{tag}.json.gz") for tag in ("base", "extra")}, + "preflight candidate bindings") + need(result["admission_engine_sha256"] == BASE_ENGINE + == sha(baseline / "admit_composed.py"), "preflight admission engine") + for field, name in (("source_adaptation_sha256", "SOURCE-ADAPTATION.json"), + ("admission_adapter_receipt_sha256", "COMPOSED-ADMISSION-ADAPTER.json")): + need(result[field] == sha(baseline / name), "preflight adaptation binding") + need(read(baseline / "COMPOSED-ADMISSION-ADAPTER.json")["adapted_sha256"] == BASE_ENGINE, + "preflight effective engine") + need(tree(baseline / "inputs/source", ("MANIFEST.json",)) + == read(baseline / "inputs/source/MANIFEST.json"), "preflight source inventory") + expected = ["independent-terminal-word", "independent-staged-word", "independent-receiver-word"] + need(read(baseline / "STAGES.json") == result["completed_reviews"], + "preflight stage receipt equality") + need([s["name"] for s in result["completed_reviews"]] == expected, + "predecessor review coverage") + for s in result["completed_reviews"]: + need(s["exit_code"] == 0 and sha(baseline / (s["name"] + ".log")) == s["log_sha256"], + "completed predecessor review log") + inventory = read(PREDECESSOR.parent / "sources/PR4076/research/" + "staged544-triple-entry-fill/admission/pr3945/PREDECESSOR.json")["files"] + retained = {n: h for n, h in inventory.items() if not n.startswith("source/")} + actual = {n: h for n, h in tree(baseline / "inputs").items() if not n.startswith("source/")} + need(actual == retained, "all 95 retained engine/helper/native-cache input bindings") + + +def bind_cache(baseline, source, output, native_dirs, fresh_tags=()): + cache = output / "native-cache" + shutil.copytree(baseline / "inputs/native-cache", cache) + receipt = read(baseline / "inputs/NATIVE-RECEIPT.json") + need(tree(cache) == receipt["cache_files"], "retained parent cache") + compiler = tree(source / "new/fastnative/vendor") + bindings = {} + for pid, tag in TAGS.items(): + origin = native_dirs[tag] + result = read(origin / "RESULT.json") + word = source / f"new/borrow/words/BORROW-WORD-43{tag}.json.gz" + need(result["status"] == "PASS_COMPLETE_T74_NATIVE_REPLAY" + and result["word_sha256"] == sha(word), "native source input") + need(result["source_sha256"] == compiler == tree(origin / "source"), + "exact native compiler closure") + need([r["step"] for r in result["steps"]] == STAGES + and all(r["exit_code"] == 0 for r in result["steps"]), "native five-stage coverage") + native = origin / "native" + need(read(native / "local/FULL-WORD.json.gz") == read(word), "native full word") + products = authenticate_native(pid, sha(word), native) + evidence = "NATIVE" if tag.endswith("-four") else "THREE" + base = tag.split("-")[0] + need(read(native / "local/CANONICAL-WORD.json.gz") + == read(MIXED / f"evidence/{evidence}-CANONICAL-{base}.json.gz"), + "retained canonical native identity") + entry = cache / sha(word) + need(not entry.exists(), "fresh candidate cache entry") + shutil.copytree(native, entry) + write(entry / "CACHE.json", dict(word_sha256=sha(word), files=tree(entry))) + receipt["providers"][tag] = dict(word_sha256=sha(word), + complete_native_files=tree(entry, ("CACHE.json",))) + bindings[pid] = dict(word_sha256=sha(word), compiler=compiler, + native_result_sha256=sha(origin / "RESULT.json"), + canonical_sha256=sha(entry / "local/CANONICAL-WORD.json.gz"), + scientific_products=products, + execution=("executed_by_this_driver" if tag in fresh_tags else + "explicitly_supplied_cache" if tag.endswith("-four") else + "retained_PR4085")) + receipt.update(source_commit="pr4088-four-provider-admission-v1", + manifest_sha256=sha(source / "MANIFEST.json"), cache_files=tree(cache)) + write(output / "NATIVE-RECEIPT.json", receipt) + write(output / "PROVIDER-BINDINGS.json", bindings) + return cache + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--work", type=Path, required=True) + ap.add_argument("--checked-preflight", type=Path) + ap.add_argument("--four-native-base", type=Path) + ap.add_argument("--four-native-extra", type=Path) + ap.add_argument("--prepare-only", action="store_true") + args = ap.parse_args() + need(__debug__, "inherited admission requires assertions") + authenticate_sources() + need(sys.version_info[:2] == (3, 12), "full replay requires Python 3.12") + need({name: version(name) for name in DEPENDENCIES} == DEPENDENCIES, + "full replay dependency pins") + if os.name == "posix": + # Let the stage's finally block clean its process group on termination. + signal.signal(signal.SIGTERM, lambda *_: sys.exit(128 + signal.SIGTERM)) + work = args.work.resolve() + need(not work.exists() and not work.is_relative_to(REPO), "fresh external work") + work.mkdir(parents=True) + # Research subprocesses do not inherit account credentials or network configuration. + env = dict(PATH=os.environ["PATH"], PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1", + PYTHONINTMAXSTRDIGITS="0", OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1", + AUDIT_RUNTIME_CONTROLS="fork" if hasattr(os, "fork") else "pickle") + stages = [] + + def run(name, command, timeout=1800): + started = time.monotonic() + log = work / (name + ".log") + with log.open("w") as stream: + process = subprocess.Popen(command, env=env, stdin=subprocess.DEVNULL, + stdout=stream, stderr=subprocess.STDOUT, + start_new_session=(os.name == "posix")) + try: + code = process.wait(timeout=timeout) + finally: + # A bounded replay must also stop descendants after failure or + # interruption. Proof-relevant children must finish before success. + if os.name == "posix": + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + elif process.poll() is None: + process.kill() + process.wait() + stages.append(dict(name=name, exit_code=code, seconds=time.monotonic()-started, + log_sha256=sha(log))) + write(work / "STAGES.json", stages) + need(code == 0, "failed " + name + "; inspect its log") + print("PASS", name, flush=True) + + # These source-specific word and all-character gates supplement the inherited release. + for name in ("verify.py", "owner_verify.py", "operator_verify.py"): + run("pr4088-" + name[:-3], [sys.executable, "-B", str(MIXED / name), "--controls"], 300) + if args.checked_preflight: + baseline = args.checked_preflight.resolve() + else: + # The source reconstruction also runs in the credential-free child + # environment, rather than importing predecessor code in the caller. + run("predecessor-preflight", + [sys.executable, "-B", "-c", + "import sys; from pathlib import Path; sys.path.insert(0, sys.argv[1]); " + "from replay import baseline_preflight; baseline_preflight(Path(sys.argv[2]))", + str(HERE), str(work / "baseline")], 300) + baseline = work / "baseline/release-work/preflight" + check_preflight(baseline) + source = work / "source" + _, changes = extend_source(baseline, source) + changes += extend_engine(baseline, source, work / "admit_mixed.py") + write(work / "ADAPTATION.json", changes) + natives = {tag: PREDECESSOR / ("native-" + tag) for tag in ("base", "extra")} + fresh_tags = set() + for tag in ("base", "extra"): + supplied = getattr(args, "four_native_" + tag) + if supplied: + natives[tag + "-four"] = supplied.resolve() + else: + natives[tag + "-four"] = work / ("native-four-" + tag) + run("native-four-" + tag, [sys.executable, "-B", str(MIXED / "native/run_native.py"), + str(MIXED / f"inputs/FOUR-{tag}.json.gz"), + str(natives[tag + "-four"])], 900) + fresh_tags.add(tag + "-four") + cache = bind_cache(baseline, source, work, natives, fresh_tags) + source_before = tree(source) + cache_before = tree(cache) + original = baseline / "inputs" + arguments = { + "source": source, "fill": MIXED / "owner/FILL.json.gz", + "order": MIXED / "owner/ORDER.json", "dispatch": MIXED / "owner/MIXED-DISPATCH.json", + "native-cache": cache, "native-receipt": work / "NATIVE-RECEIPT.json", + "work": work / "admission", "replica-helper-dir": work / "helpers", + "reconstructor": work / "helpers/reconstruct_replica.py", + "comparison-claim": REPO / "research/staged544-triple-entry-fill/admission/pr3945/PR3682-CLAIM.json", + "blocknorm-checker": original / "extension_blocknorm.py", + } + command = [sys.executable, "-B", str(work / "admit_mixed.py")] + for key, value in arguments.items(): + command += ["--" + key, str(value)] + command += ["--source-profile", "staged544", "--comparison-profile", "pr3682", "--jobs", "1"] + if args.prepare_only: + command.append("--prepare-only") + run("inherited-admission", command, 2400) + need(tree(source) == source_before and tree(cache) == cache_before, + "immutable source/cache after admission") + result = read(work / "admission/RESULT.json") + need(result["profile"] == read(MIXED / "RESULT.json")["profile"], "complete profile") + if args.prepare_only: + need(result["status"] == "PREPARED_REPLICA_SAME_WORD_DERIVATIVE_NOT_ADMITTED", + "preparation is not admission") + else: + need(result["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "complete inherited release") + write(work / "RESULT.json", dict(status=result["status"], stages=stages, + admission_result_sha256=sha(work / "admission/RESULT.json"), + source_manifest_sha256=sha(source / "MANIFEST.json"), + runtime=dict(python=sys.version.split()[0], + dependencies=DEPENDENCIES, platform=sys.platform), + selected_frontier_changed=False)) + print(result["status"], flush=True) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/frozen/pr4180/sources.py b/research/complex-pooled-full-admission/frozen/pr4180/sources.py new file mode 100644 index 000000000..d5a846024 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/sources.py @@ -0,0 +1,21 @@ +"""Live-input authentication for direct commands as well as registered replay. + +SPDX-License-Identifier: Apache-2.0 +Git provenance is separately checked by the repository package validator. +""" +from pathlib import Path + +from binding import need, read, sha + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] + + +def authenticate_sources(root=REPO): + rows = [r for r in read(HERE / "SOURCES.json")["files"] if r["usage"] == "input"] + for row in rows: + path = root / row["path"] + need(path.resolve().is_relative_to(root.resolve()) and not path.is_symlink(), + "ordinary in-tree source input") + need(sha(path) == row["sha256"], "changed live source: " + row["path"]) + return len(rows) diff --git a/research/complex-pooled-full-admission/frozen/pr4180/test_binding.py b/research/complex-pooled-full-admission/frozen/pr4180/test_binding.py new file mode 100644 index 000000000..03b3f8b83 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/test_binding.py @@ -0,0 +1,223 @@ +"""Semantic controls for the new binding, independent of source-hash failures. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +""" +import json +from pathlib import Path +import shutil +import tempfile +import unittest + +from binding import account, sha, validate_rebind +from native_outputs import authenticate_native +from replay import PREDECESSOR + + +def fixture(): + """Four real provider kinds, reduced to the shared 7/8-width boundary.""" + pids = ["extra-four", "extra", "gauge44", "gauge44-four"] + registry = { + p: {"widths": [7 if p.endswith("-four") else 8], + "actual_paid_profile": {"1": 2 if p.endswith("-four") else 1}, + "orientation_program_sha256": {o: p + ":" + o for o in ("forward", "backward")}} + for p in pids + } + plan = dict(order=[[s, 0] for s in range(4)], provider_registry=registry, + pairs={"0": 0}, sides={"0": 0}, + windows={"0,0": [16, [0, 1]], "1,0": [16, [2, 3]]}, + provider_calls=[], per_call_widths=[]) + roles, dispatch = [], [] + for t, pid in enumerate(pids): + ori = "forward" if t % 2 == 0 else "backward" + plan["provider_calls"].append(dict(stage=t, replica=0, time=t, provider=pid, + orientation=ori, local_program_sha256=pid + ":" + ori)) + plan["per_call_widths"].append(dict(stage=t, replica=0, time=t, + widths=registry[pid]["widths"][:])) + roles.append(dict(time=t, helper=0, stage=t, replica=0, owner_replica=t // 2, + child=0, port=107, family=896 * (t // 2) + 107, + copy=112 * (t // 2) + 107, offset=[0, 7, 0, 8][t], + width=registry[pid]["widths"][0])) + dispatch.append([t, 0, pid]) + return plan, roles, dispatch + + +class CallBindingTests(unittest.TestCase): + def test_positive_complements_and_row_order(self): + p, r, d = fixture() + idle, total = account(p, r, d) + self.assertEqual(idle, {1: 2, 16: 222}) + self.assertEqual(total, {1: 8, 16: 222}) + self.assertEqual(account(p, r, list(reversed(d))), (idle, total)) + + def test_wrong_dispatch_with_coherent_call_metadata(self): + p, r, d = fixture() + # Keep counts, programs, per-call widths and row widths coherent, but + # exchange which call uses FOUR. The old second offset is now illegal. + d[0][2], d[1][2] = d[1][2], d[0][2] + for t in (0, 1): + pid = d[t][2] + c = p["provider_calls"][t] + c["provider"] = pid + c["local_program_sha256"] = pid + ":" + c["orientation"] + p["per_call_widths"][t]["widths"] = p["provider_registry"][pid]["widths"][:] + r[t]["width"] = p["provider_registry"][pid]["widths"][0] + with self.assertRaisesRegex(ValueError, "compact per-call residual prefix"): + account(p, r, d) + + def test_omitted_provider(self): + p, r, d = fixture() + del p["provider_registry"]["gauge44-four"] + with self.assertRaisesRegex(ValueError, "complete provider usage"): + account(p, r, d) + + def test_program_binding_even_when_widths_agree(self): + p, r, d = fixture() + p["provider_calls"][2]["local_program_sha256"] = "extra:forward" + with self.assertRaisesRegex(ValueError, "per-call program binding"): + account(p, r, d) + + def test_averaged_width_or_wrong_orientation(self): + for field, value, reason in ( + ("width", 8, "actual selected helper width"), + ("orientation", "backward", "per-call orientation"), + ): + p, r, d = fixture() + if field == "width": + r[0][field] = value + else: + p["provider_calls"][0][field] = value + with self.assertRaisesRegex(ValueError, reason): + account(p, r, d) + + def test_capacity_window_hole_and_duplicate(self): + mutations = [ + (lambda p, r, d: r[0].__setitem__("offset", 1), "compact per-call residual prefix"), + (lambda p, r, d: p["windows"]["0,0"].__setitem__(0, 14), "compact per-call residual prefix"), + (lambda p, r, d: p["windows"]["0,0"].__setitem__(1, [1]), "strict inherited window"), + (lambda p, r, d: d.__setitem__(1, d[0][:]), "dispatch bijection"), + ] + for mutate, reason in mutations: + with self.subTest(reason=reason): + p, r, d = fixture() + mutate(p, r, d) + with self.assertRaisesRegex(ValueError, reason): + account(p, r, d) + + +class RebindContractTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.pkg = Path(self.temp.name) + (self.pkg / "new").mkdir() + self.plan, roles, dispatch = fixture() + idle, total = account(self.plan, roles, dispatch) + self.plan["profile"] = {str(r): n for r, n in total.items()} + self.contract = {"providers": {}, "dispatch": list(reversed(dispatch))} + self.locs = {} + + def put(path, value): + path.write_text(json.dumps(value)) + self.put = put + # This reduced fixture tests the binder contract, not native semantics; + # NativeProductTests uses the real source-bound native products. + for pid, desc in self.plan["provider_registry"].items(): + word = self.pkg / (pid + ".json") + value = {"provider": pid} + put(word, value) + local = self.pkg / pid + local.mkdir() + put(local / "FULL-WORD.json", value) + import gzip + (local / "FULL-WORD.json.gz").write_bytes(gzip.compress(json.dumps(value).encode())) + width = desc["widths"][0] + canonical = {"R": 1, "frames": [[], [1 << i for i in range(width)]], + "start": [0] * 225, "final": [0] * 224 + [1]} + (local / "CANONICAL-WORD.json.gz").write_bytes(gzip.compress(json.dumps(canonical).encode())) + put(local / "LOCAL-CHECKS.json", + {o: {"paid_profile": desc["actual_paid_profile"]} for o in ("forward", "backward")}) + self.contract["providers"][pid] = dict(word=word.name, word_sha256=sha(word), + widths=desc["widths"], profile=desc["actual_paid_profile"]) + self.locs[pid] = local + put(self.pkg / "new/MIXED-CONTRACT.json", self.contract) + put(self.pkg / "DISPATCH.json", dispatch) + import gzip + (self.pkg / "OWNERS.json.gz").write_bytes(gzip.compress(json.dumps(roles).encode())) + put(self.pkg / "CONSTRUCTION.json", {"idle": idle}) + + def test_positive_rebind_with_different_table_order(self): + self.assertEqual(validate_rebind(self.pkg, self.plan, self.locs), {1: 2, 16: 222}) + + def test_stale_idle(self): + self.put(self.pkg / "CONSTRUCTION.json", {"idle": {1: 1, 16: 222}}) + with self.assertRaisesRegex(ValueError, "stale construction idle"): + validate_rebind(self.pkg, self.plan, self.locs) + + def test_source_change(self): + (self.pkg / "gauge44-four.json").write_text('{"provider":"different"}') + with self.assertRaisesRegex(ValueError, "provider source changed"): + validate_rebind(self.pkg, self.plan, self.locs) + + def test_missing_provider_and_changed_selector(self): + locs = dict(self.locs) + del locs["gauge44-four"] + with self.assertRaisesRegex(ValueError, "complete four-provider binding"): + validate_rebind(self.pkg, self.plan, locs) + dispatch = json.loads((self.pkg / "DISPATCH.json").read_text()) + dispatch[0][2], dispatch[1][2] = dispatch[1][2], dispatch[0][2] + self.put(self.pkg / "DISPATCH.json", dispatch) + with self.assertRaisesRegex(ValueError, "literal mixed selector"): + validate_rebind(self.pkg, self.plan, self.locs) + + +class NativeProductTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.source = PREDECESSOR / "native-base/native" + cls.word_sha = json.loads((PREDECESSOR / "native-base/RESULT.json").read_text())["word_sha256"] + + def test_real_retained_positive_control(self): + self.assertEqual(len(authenticate_native("gauge44", self.word_sha, self.source)), 11) + + def test_phase_change_with_rebound_receipts(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "local/CLIFFORD-RECIPES.json" + recipe = json.loads(path.read_text()) + recipe["warps"][0]["left"]["phase"] = (recipe["warps"][0]["left"]["phase"] + 1) % 4 + path.write_text(json.dumps(recipe)) + # Rebind both receipt references, so rejection cannot be attributed + # to a stale raw hash or the intentionally unchanged success flags. + for name in ("CLIFFORD-REVIEW.json", "WARP-RECIPE-CHECKS.json"): + receipt = out / "local" / name + value = json.loads(receipt.read_text()) + value["recipe_sha256"] = sha(path) + receipt.write_text(json.dumps(value)) + with self.assertRaisesRegex(ValueError, "native scientific output commitment"): + authenticate_native("gauge44", self.word_sha, out) + + def test_missing_phase_stage(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "STEPS.json" + path.write_text(json.dumps(json.loads(path.read_text())[:-1])) + with self.assertRaisesRegex(ValueError, "actual native stage products coverage"): + authenticate_native("gauge44", self.word_sha, out) + + def test_uncovered_endpoint_claim(self): + with tempfile.TemporaryDirectory() as td: + out = Path(td) / "native" + shutil.copytree(self.source, out) + path = out / "local/INDEPENDENT-LOCAL-REPLAY.json" + value = json.loads(path.read_text()) + value["local"]["backward"]["private_work_erased"] = False + path.write_text(json.dumps(value)) + with self.assertRaisesRegex(ValueError, "native scientific output commitment"): + authenticate_native("gauge44", self.word_sha, out) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/complex-pooled-full-admission/frozen/pr4180/verify.py b/research/complex-pooled-full-admission/frozen/pr4180/verify.py new file mode 100644 index 000000000..7cb49ffd6 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4180/verify.py @@ -0,0 +1,76 @@ +#!/usr/bin/env python3 +"""Bounded binding regression; full inherited release uses replay.py separately. + +SPDX-License-Identifier: Apache-2.0 +Prepared for yssite with substantial OpenAI Codex assistance. +""" +import json +import sys +import unittest + +from adapt import MIXED, TAGS +from binding import account, need, read +from sources import authenticate_sources + + +def real_call_binding(): + # Reuse PR4088's declared source-window interpretation, not its walk(). + # The separate campaign scanner also challenged this interpretation from + # exact event positions and actual phase-axis lists. + sys.path.insert(0, str(MIXED)) + from owner_verify import context + order, selected, windows, family, widths, profiles = context() + original = read(MIXED / "owner/PLAN.json.gz") + registry = {} + for pid, tag in TAGS.items(): + kind = "NATIVE" if tag.endswith("-four") else "THREE" + checks = read(MIXED / f"evidence/{kind}-LOCAL-{tag.split('-')[0]}.json") + registry[pid] = dict(widths=widths[pid], actual_paid_profile=profiles[pid], + orientation_program_sha256={o: checks[o]["sha256"] + for o in ("forward", "backward")}) + calls, per_call = [], [] + for time, (stage, replica) in enumerate(order): + pid = selected[stage, replica] + orientation = "forward" if stage % 2 == 0 else "backward" + calls.append(dict(stage=stage, replica=replica, time=time, provider=pid, orientation=orientation, + local_program_sha256=registry[pid]["orientation_program_sha256"][orientation])) + per_call.append(dict(stage=stage, replica=replica, time=time, widths=widths[pid])) + plan = dict(order=order, provider_registry=registry, provider_calls=calls, per_call_widths=per_call, + pairs=original["pairs"], sides=original["sides"], + windows={f"{o},{c}": (cap, range(lo + 1, hi + 1)) + for (o, c), (cap, lo, hi) in windows.items()}) + rows = read(MIXED / "owner/FILL.json.gz")["rows"] + + class Roles: + def __len__(self): + return len(rows) + + def __iter__(self): + for time, helper, owner, child, port, offset in rows: + stage, replica = order[time] + yield dict(time=time, helper=helper, stage=stage, replica=replica, + owner_replica=owner, child=child, port=port, offset=offset, + family=896 * owner + 112 * family[child] + port, + copy=112 * owner + port, width=widths[selected[stage, replica]][helper]) + + idle, total = account(plan, Roles(), read(MIXED / "owner/MIXED-DISPATCH.json")) + expected = read(MIXED / "RESULT.json") + need(idle == {int(k): v for k, v in expected["idle"].items()}, "actual idle") + need(total == {int(k): v for k, v in expected["profile"].items()}, "actual complete profile") + return dict(rows=len(rows), calls=len(order), providers=len(registry), idle=idle, profile=total) + + +def main(): + inputs = authenticate_sources() + suite = unittest.defaultTestLoader.loadTestsFromName("test_binding") + result = unittest.TextTestRunner(verbosity=1).run(suite) + need(result.wasSuccessful(), "binding controls") + finite = real_call_binding() + print(json.dumps(dict(status="PASS_FOUR_PROVIDER_BINDING_REGRESSION", live_inputs=inputs, + tests=result.testsRun, finite=finite, + scope="Binding and negative controls only; full release is a separate command."), + sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/frozen/pr4181/README.md b/research/complex-pooled-full-admission/frozen/pr4181/README.md new file mode 100644 index 000000000..adbca18f1 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/README.md @@ -0,0 +1,95 @@ +# A one-third fourth-entry fill at the pooled ceiling: conditional κ = 0.001730980255989036959962 − 10⁻⁴⁶ − 10⁻⁷⁰ + +**Author-checked conditional candidate; not maintainer-reviewed.** This package keeps PR4088's four words, native +receipts, clock (`ORDER.json`), template and plan unchanged. It changes only two things: + +- **Selector.** It chooses which 1,080 of the 3,240 T360 calls use the four-entry word of their orientation. Here + these are the calls at ticks t < 1080. +- **Fill.** It builds a new literal chronological owner fill for that selector. + +| | PR4088 | this package | +|---|---|---| +| fourth-entry calls | 1,090 (`109·t mod 324 < 109`) | **1,080 (t < 1080)** | +| idle histogram | `{3:22783, 5:1625, 48:138492}` | `{3:22788, 5:1620, 48:138492}` | +| complete profile | `{1:8060060, 2:2310120, 3:751813, 4:327210, 5:66425, 8:25920, 48:138492}` | `{1:8060040, 2:2310120, 3:751788, 4:327240, 5:66420, 8:25920, 48:138492}` | +| root lower bound | 0.001730979115670792472760 | **0.001730980255989036959962** | + +The gain is **+1.1403·10⁻⁹ over PR4088 (+0.0000659%)**. The root bracket +`[0.001730980255989036959962, 0.001730980255989036959963]` equals the sharp pooled ceiling that PR4091 proves for +this fixed two-provider invoice. PR4170 reported this as the remaining headroom, 1.1403·10⁻⁹. The fill therefore +attains that ceiling, and no other fill of these four words does better. + +## Why PR4088 stopped at 1,090 calls, and the change here + +At exactly one third of the calls, the window-free LP optimum is integral: + +- 1,620 idle-5 bins of the form 32:(9,9,9); +- 22,788 idle-3 bins of the form 48:(9×5); +- 138,492 empty 48-bins. + +On PR4088's arithmetic selector, the time windows make that optimum unreachable. Adapting the staged544-clock-ceiling +per-tick Hall LP to per-call supply rates the 109-mod rule at 1,080 calls at only 0.0017309790862. That is below +PR4088's root, which is why PR4088 moved to 1,090 calls. + +The idle-5 bins close by about tick 208. They need early sevens and eights, which the arithmetic selector spreads too +thinly. Putting the fourth entry in the first 1,080 ticks instead makes the windowed LP reach the ceiling. The +reverse-time fill builder then gives an integral fill that attains it. + +## Verification + +```sh +python3.12 -B research/staged544-pooled-ceiling-fill/verify.py --controls # ~8 s, standard library only +``` + +The verifier runs **PR4088's unchanged `owner_verify.walk`** with the t < 1080 dispatch. It checks every one of the +1,321,920 roles and 725,760 bins: + +- chronology; +- same-call family distinctness; +- compact offsets; +- capacity; +- the complete histogram and rank mass. + +It then encloses the new root with PR4088's vendored rational `exact_root.py` on the 10⁻²⁴ grid. It also re-certifies +PR4088's own bracket and checks strict improvement of the padded endpoint. + +Six controls are rejected: + +- PR4088's selector applied to this fill; +- one fourth-entry call reverted; +- a same-call family collision; +- an offset hole; +- the next grid point; +- PR4088's profile at the new root. + +`construction/` holds the provenance tools. They are not run by the verifier and need numpy, scipy and highspy: + +- `hall_mixed.py`: the staged544-clock-ceiling `hall_lp.py` with per-tick supply; +- `build_mixed.py`: its `build_fill.py` with per-call width vectors, run with `--distinct 40` on the selector file. + +## Scope + +All four words and their native evidence are PR4088's. This package adds no word or native change; the operator and +native claims are PR4088's. It inherits PR4088's conditional hypotheses, which are the uniform native, common-cover, +analytic, precision, tape, recovery and BIT transfer hypotheses. + +The full ordinary/outer release has not been rerun for a mixed dispatch, as for PR4088 (see PR4165). + +## Open next questions + +- **Can the inherited release accept a mixed four-provider dispatch?** PR4165 shows that the inherited rebind stamps one + width vector per provider. First step: generalize the rebind to per-call widths and rerun it on this fill. +- **Is there more to gain?** This fill attains PR4091's ceiling for these four words, so further gains need a changed + word or inventory. + +## Credit + +- PR4088 (Cinna Davis / 1337isnot1337): the four-entry words, selector idea, owner walk and price. +- PR4091 (Ross Richardson): the sharp pooled optimum. +- PR4170 (Nick Petalas): the transfer audit. +- PR4085 (zxv): receiver sharing. +- PR4076, PR3945 and the staged544 lineage. +- The staged544-clock-ceiling package (ChaloupeMusic / Erwan Secousses): the Hall LP and reverse-time fill builder + adapted here. + +Prepared by Rohan Arun with Anthropic Claude assistance. Apache-2.0. diff --git a/research/complex-pooled-full-admission/frozen/pr4181/RESULT.json b/research/complex-pooled-full-admission/frozen/pr4181/RESULT.json new file mode 100644 index 000000000..5a0ba7aee --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/RESULT.json @@ -0,0 +1,31 @@ +{ + "status": "AUTHOR_CHECKED_FINITE_CONDITIONAL_CONSTRUCTION", + "calls": 3240, + "fourth_calls": 1080, + "selector": "tick t < 1080 uses the four-entry word of its orientation", + "profile": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "5": 66420, + "8": 25920, + "48": 138492 + }, + "idle": { + "3": 22788, + "5": 1620, + "48": 138492 + }, + "root_lower": "865490127994518479981/500000000000000000000000", + "root_upper": "1730980255989036959963/1000000000000000000000000", + "root_lower_decimal": "0.001730980255989036959962", + "root_upper_decimal": "0.001730980255989036959963", + "conditional_kappa": "17309802559890369599619999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "conditional_kappa_decimal": "0.0017309802559890369599619999999999999999999998999999999999999999999999", + "predecessor": "PR4088 research/staged544-mixed-fourth-entry", + "predecessor_upper": "1730979115670792472761/1000000000000000000000000", + "gain_over_pr4088_upper": "11403182444872009999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "gain_over_pr4088_upper_float": 1.140318244487201e-09, + "gain_percent": 6.587706542290104e-05 +} \ No newline at end of file diff --git a/research/complex-pooled-full-admission/frozen/pr4181/SOURCES.json b/research/complex-pooled-full-admission/frozen/pr4181/SOURCES.json new file mode 100644 index 000000000..c3c6766e8 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/SOURCES.json @@ -0,0 +1,120 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner_verify.py", + "usage": "input", + "git_blob": "a74d1ee0b5d45feb4c87cc034ae49069d654467c", + "sha256": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72" + }, + { + "path": "research/staged544-mixed-fourth-entry/verify.py", + "usage": "input", + "git_blob": "816a7786a3570976ac86baf3b19ee798e6098895", + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8" + }, + { + "path": "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "usage": "input", + "git_blob": "96dab46ab3404adc92c4b004481759db0c71dfdf", + "sha256": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe" + }, + { + "path": "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "usage": "input", + "git_blob": "a87dde507358dd3b60c0d80d6216ef16123c56ca", + "sha256": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04" + }, + { + "path": "research/staged544-mixed-fourth-entry/RESULT.json", + "usage": "input", + "git_blob": "1174e25e2ef8f8bc9a0815c43ba5d64c8af08349", + "sha256": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "usage": "input", + "git_blob": "58d4b4c34170788a825d4c4e595fe45e28ef3fd2", + "sha256": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "usage": "input", + "git_blob": "9e93daeaf8f8a234655f523374528979c561951b", + "sha256": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "usage": "input", + "git_blob": "3424e3b0fb72c12dd244c41ad3ba44b4875ce5a4", + "sha256": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "usage": "input", + "git_blob": "6c1e9149b26394607cca9d4765ab8d3c5fc029bb", + "sha256": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "usage": "input", + "git_blob": "137793e275870db2161048405017b83dcc1824ee", + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "usage": "input", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc", + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "usage": "input", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a", + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95" + }, + { + "path": "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz", + "usage": "input", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011", + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a" + }, + { + "path": "research/staged544-clock-ceiling/construction/hall_lp.py", + "usage": "provenance", + "git_blob": "22e135fc5cbfe8e3a7c861272f0db6f988eeb277", + "sha256": "103290a9398b562c0e34e140b24a3e83c6fc5adfbfe4737acb53d75d1334b9be" + }, + { + "path": "research/staged544-clock-ceiling/construction/build_fill.py", + "usage": "provenance", + "git_blob": "f7c141efcbef62ce5632eb37869f45fc998d08f4", + "sha256": "0e1c6fb322c06d63f24707c1effbe9143d13892510d8fb981faa07173d3f63a6" + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4181/TASK.json b/research/complex-pooled-full-admission/frozen/pr4181/TASK.json new file mode 100644 index 000000000..6927c1233 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/TASK.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "Re-select which 1,080 of the 3,240 T360 calls use PR4088's four-entry words (the first 1,080 ticks) and build a new literal chronological owner fill; words, natives, clock and template are PR4088's, unchanged.", + "scope_change_reason": "PR4091 proves one third of calls is the pooled optimum for PR4088's fixed two-provider invoice, and PR4170 finds 1.14e-9 of headroom above PR4088's literal fill; PR4088's 1,080-call selector lost to time windows, so a different selector is needed.", + "bottleneck_link": "The complex supplier binds; the new fill attains PR4091's pooled ceiling exactly, so the complete moment root rises to that ceiling.", + "budget_minutes": 120, + "stop_rule": "Require a literal owner fill accepted by PR4088's unchanged owner walk and an exact rational root above PR4088; stop at the pooled ceiling.", + "outcome": "completed", + "evidence": "PR4088's owner walk accepts all 1,321,920 roles and 725,760 bins under the t<1080 selector; idle histogram {3:22788, 5:1620, 48:138492}; exact rational root [0.001730980255989036959962, ...963]; PR4088's bracket re-certified; six rejecting controls.", + "author": "Rohan Arun", + "ai_assistance": "Substantial Anthropic Claude (Claude Code) assistance; construction adapted from the staged544-clock-ceiling Hall LP and fill builder.", + "open_questions": [ + { + "question": "Does the inherited ordinary/outer release accept a four-provider mixed dispatch?", + "why_it_matters": "PR4165 shows the inherited rebind stamps one width vector per provider; both PR4088 and this fill need a mixed-width rebind.", + "first_step": "Generalize the rebind to per-call width vectors and rerun the release on this fill.", + "blocked_by": "The inherited release engine." + }, + { + "question": "Is there gain beyond the pooled ceiling of this invoice?", + "why_it_matters": "This fill attains PR4091's ceiling, so further gains need a changed word or inventory.", + "first_step": "Search new staged entries or receiver/source identities on the mixed words.", + "blocked_by": "A new word construction." + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4181/VERIFY.json b/research/complex-pooled-full-admission/frozen/pr4181/VERIFY.json new file mode 100644 index 000000000..938dd6ea0 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/VERIFY.json @@ -0,0 +1,35 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/staged544-mixed-fourth-entry/owner_verify.py", + "research/staged544-mixed-fourth-entry/verify.py", + "research/staged544-mixed-fourth-entry/vendor/exact_root.py", + "research/staged544-mixed-fourth-entry/checks/inherited_frames.py", + "research/staged544-mixed-fourth-entry/RESULT.json", + "research/staged544-mixed-fourth-entry/owner/ORDER.json", + "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "research/staged544-mixed-fourth-entry/owner/DISPATCH.json", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-base.json.gz", + "research/staged544-mixed-fourth-entry/owner/old-NATIVE-extra.json.gz", + "research/staged544-mixed-fourth-entry/inputs/THREE-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/THREE-extra.json.gz", + "research/staged544-mixed-fourth-entry/inputs/FOUR-base.json.gz", + "research/staged544-mixed-fourth-entry/inputs/FOUR-extra.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py", + "--controls" + ], + "timeout_seconds": 300, + "checks": "PR4088's unchanged owner walk on the t<1080 selector and this fill (all roles, windows, families, offsets, capacity, histogram); exact rational root bracket; PR4088 bracket; strict improvement; six rejecting controls." + } + ] +} diff --git a/research/complex-pooled-full-admission/frozen/pr4181/construction/build_mixed.py b/research/complex-pooled-full-admission/frozen/pr4181/construction/build_mixed.py new file mode 100644 index 000000000..f7af1bbae --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/construction/build_mixed.py @@ -0,0 +1,236 @@ +"""Integer T360 owner fill for a given clock (construction provenance; not run by verify.py). + +Requires numpy, scipy and highspy (see ../README.md). Comments are in French. +Usage from the repository root: + python construction/build_fill.py research/staged544-clock-ceiling/inputs/ORDER.json --out DIR --distinct 40 + +Rangement entier T360 pour une horloge donnée, puis contrôle par owner_audit.py. + +1. PL de Hall (hall_lp) : motifs par classe ; on exige une solution entière (sinon arrêt). +2. Cases : les 224 cases d'une classe reçoivent les motifs de la classe, dans l'ordre. +3. Objets, instant par instant : chaque objet de largeur w va à la classe ouverte d'échéance + la plus proche (EDF) qui a encore une place de largeur w dans une case que cet appel n'a pas + encore touchée (un objet par appel et par case). Les cases d'une classe sont parcourues en + tourniquet pour étaler les appels. +4. FILL (colonnes, ordre (t, h), décalage chronologique), ORDER et PROFILE écrits dans une copie + du paquet ; owner_audit.py y est rejoué tel quel. +""" +import argparse +import gzip +import heapq +import json +import shutil +import subprocess +import sys +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +sys.path.insert(0, str(Path(__file__).parent)) +import hall_mixed as H # noqa: E402 + +PKG = Path('/tmp/claude-0/rs/research/staged544-mixed-fourth-entry') +sys.path.insert(0, str(PKG)); sys.argv_saved = sys.argv; sys.argv = ['x'] +import owner_verify as OV +from verify import read as vread +sys.argv = sys.argv_saved + + +def read(p): + raw = p.read_bytes() + return json.loads(gzip.decompress(raw) if p.suffix == '.gz' else raw) + + +def rank(U): + piv = {} + for x in U: + while x: + b = x.bit_length() + if b in piv: + x ^= piv[b] + else: + piv[b] = x + break + return len(piv) + + +def windows_for(order, template, children): + """Fenêtres (cap, lo, hi) par (propriétaire, enfant), avec la logique d'owner_audit.""" + clock = {tuple(v): i for i, v in enumerate(order)} + win = {} + for owner in range(H.T): + touched = {} + t = None + for ev in template['execution_schedule']: + k = ev['kind'] + if k in ('bank_padding_cover_sweep', 'translate_every_live_family'): + continue + if k == 'local_cover_sweep': + t = clock[ev['stage'], owner] + touched[next(x['pair'] for x in template['recipe'] if x['kind'] == 'local' and x['stage'] == ev['stage'])] = t + elif k == 'bridge': + touched[ev['src']] = t + touched[ev['dst']] = t + elif k == 'idle_cover_sweep': + for c in ev['child_indices']: + if c in children: + win[owner, c] = (children[c], touched.get(ev['pair'], -1), t) + return win + + +def build(order_path, out_dir, seed=0, distinct=0): + order = H.read_order(order_path) + template = read(PKG / 'owner/TEMPLATE.json.gz') + children = {c['child']: c['rank'] for c in template['idle_children']} + win = windows_for(order, template, children) + four = json.load(open(SEL)); H.set_selector(four) + # per-provider widths from the exact words (owner_verify logic) + I = OV.I; widths = {} + for kind in ('THREE', 'FOUR'): + w = vread(PKG / f'inputs/{kind}-base.json.gz'); origin = vread(PKG / 'owner/old-NATIVE-base.json.gz')['helper_origin'] + widths[kind] = [len(I.b(w['helper_final'].get(str(r), I.FULL))) - len(I.b(w['start_extra'].get(str(r), []))) for r in origin] + w2 = vread(PKG / f'inputs/{kind}-extra.json.gz'); origin2 = vread(PKG / 'owner/old-NATIVE-extra.json.gz')['helper_origin'] + assert [len(I.b(w2['helper_final'].get(str(r), I.FULL))) - len(I.b(w2['start_extra'].get(str(r), []))) for r in origin2] == widths[kind] + lp = H.HallLP(order, a=0.0017309791156708, verbose=False) + if distinct: + lp.add_distinct(range(H.N - distinct, H.N)) + lp.run() + r_lp = H.root(lp.profile()) + print(f'PL : racine {r_lp:.16f}', flush=True) + y = lp.x[lp.first_y:] + pats = defaultdict(list) # classe -> liste de motifs (224) + for (k, j), v in zip(lp.cols, y): + n = int(round(v)) + if abs(v - n) > 1e-6: + raise SystemExit(f'solution fractionnaire en classe {k}') + if n: + pats[k] += [tuple(int(a) for a in H.PATS[lp.cap[k]][0][j])] * n + assert all(len(pats[k]) == H.BINS for k in range(lp.K)) + + # classe du PL -> enfants (deux enfants de 112 ports chacun) + key_of = {(k // 9, int(lp.cap[k]), int(lp.lo[k]), int(lp.hi[k])): k for k in range(lp.K)} + kids = defaultdict(list) + for (o, c), (cap, lo, hi) in win.items(): + kids[key_of[o, cap, lo, hi]].append(c) + assert all(len(v) == 2 for v in kids.values()) and len(kids) == lp.K + for k in kids: + kids[k].sort() + + W = list(H.W) + K = lp.K + lo_k = np.array([int(lp.lo[k]) for k in range(K)]) + hi_k = np.array([int(lp.hi[k]) for k in range(K)]) + free = np.zeros((K, H.BINS, 6), dtype=np.int16) # places libres par case et largeur + for k in range(K): + free[k] = np.array(pats[k], dtype=np.int16) + demand = free.sum(1).astype(np.int64) # places libres par classe et largeur + ftot = free.sum(2).astype(np.int64) # places libres par case + used_by = np.full((K, H.BINS), -1, dtype=np.int32) # dernier appel ayant touché la case + placed = defaultdict(list) # (k, b) -> [(t, h, w)] + closing = defaultdict(list) + for k in range(K): + closing[int(hi_k[k])].append(k) + pool = np.where(lo_k < 0)[0] # classes (-1, hi] : réservoir du début + in_pool = np.zeros(len(pool), dtype=bool) + pool_pos = {int(k): i for i, k in enumerate(pool)} + heaps = [[] for _ in range(6)] + hof = {kind: [[h for h in range(408) if widths[kind][h] == w] for w in W] for kind in widths} + rng = np.random.default_rng(seed) + jitter = rng.random((K, H.BINS)) * 0.5 # départage des cases à égalité + + def take(k, bins, t, wi, hs): + for b, h in zip(bins, hs): + free[k, b, wi] -= 1 + ftot[k, b] -= 1 + used_by[k, b] = t + placed[k, int(b)].append((t, h, W[wi])) + demand[k, wi] -= len(bins) + + # À rebours : une classe devient disponible à t = hi et doit être servie avant t = lo. + for t in range(H.N - 1, -1, -1): + for k in closing.get(t, ()): + if lo_k[k] < 0: + in_pool[pool_pos[k]] = True + else: + for wi in range(6): + if demand[k, wi]: + heapq.heappush(heaps[wi], (-int(lo_k[k]), int(hi_k[k]), k)) + for wi in range(6): + hs = list(hof['FOUR' if four[t] else 'THREE'][wi]) + hp = heaps[wi] + aside = [] + while hs and hp: + neglo, _, k = hp[0] + if demand[k, wi] == 0: + heapq.heappop(hp) + continue + if -neglo >= t: + raise SystemExit(f'échéance manquée : classe {k} largeur {W[wi]} reste {demand[k, wi]} à t={t}') + elig = np.where((free[k, :, wi] > 0) & (used_by[k] != t))[0] + n = min(len(hs), int(demand[k, wi]), len(elig)) + if n == 0: + aside.append(heapq.heappop(hp)) + continue + pick = elig[np.argsort(-(ftot[k, elig] + jitter[k, elig]))[:n]] + take(k, pick, t, wi, hs[:n]) + hs = hs[n:] + if demand[k, wi] and hs: + aside.append(heapq.heappop(hp)) + for item in aside: + heapq.heappush(hp, item) + if hs: + ks = pool[in_pool] + fr = free[ks, :, wi] + ok = (fr > 0) & (used_by[ks] != t) + score = np.where(ok, ftot[ks] + jitter[ks], -1.0) + flat = score.ravel() + n = len(hs) + if (flat >= 0).sum() < n: + raise SystemExit(f'réservoir à court : t={t} largeur {W[wi]} besoin {n}') + top = np.argpartition(-flat, n - 1)[:n] + by_class = defaultdict(list) + for f in top: + by_class[int(ks[f // H.BINS])].append(int(f % H.BINS)) + pos = 0 + for k, bins in by_class.items(): + take(k, bins, t, wi, hs[pos:pos + len(bins)]) + pos += len(bins) + for k in np.where(lo_k == t)[0]: + if demand[k].any(): + raise SystemExit(f'classe {k} fermée incomplète à t={t} : {demand[k]}') + assert demand.sum() == 0 + rows = [None] * (H.N * 408) + load = np.zeros((K, H.BINS), dtype=np.int16) + for (k, b), items in placed.items(): + z = 0 + for t, h, w in sorted(items): + rows[t * 408 + h] = [int(t), int(h), int(k) // 9, int(kids[k][b // 112]), int(b) % 112, int(z)] + z += w + load[k, b] = z + assert demand.sum() == 0 and all(r is not None for r in rows) + + out = Path(out_dir); out.mkdir(parents=True, exist_ok=True) + (out / 'FILL.json.gz').write_bytes(gzip.compress(json.dumps({'columns': ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'], 'dispatch_overrides': [], 'rows': rows}).encode(), mtime=0)) + idle = Counter() + caps = np.array([lp.cap[k] for k in range(K)]) + left = caps[:, None] - load + for v in left.ravel(): + if v: + idle[int(v)] += 1 + n4 = int(sum(four)); prof = Counter({r: (H.N - n4) * H.LOC3.get(r, 0) + n4 * H.LOC4.get(r, 0) for r in set(H.LOC3) | set(H.LOC4)}) + prof.update(idle) + (out / 'PROFILE.json').write_text(json.dumps({str(r): n for r, n in sorted(prof.items())})) + r_int = H.root(dict(prof)) + print(f'entier : racine {r_int:.16f} restes inactifs {dict(sorted(idle.items()))}', flush=True) + return out, r_int + + +if __name__ == '__main__': + ap = argparse.ArgumentParser() + ap.add_argument('order') + ap.add_argument('--out', required=True) + ap.add_argument('--distinct', type=int, default=0) + ap.add_argument('--sel', required=True) + args = ap.parse_args(); SEL = args.sel + out, r = build(args.order, args.out, distinct=args.distinct) diff --git a/research/complex-pooled-full-admission/frozen/pr4181/construction/hall_mixed.py b/research/complex-pooled-full-admission/frozen/pr4181/construction/hall_mixed.py new file mode 100644 index 000000000..c62c75afb --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/construction/hall_mixed.py @@ -0,0 +1,396 @@ +"""Exact per-tick LP relaxation of the T360 owner fill for a given clock (diagnostic and +construction provenance; not run by verify.py). Comments are in French. + +PL exact, instant par instant, du rangement T360 de #3734 pour une horloge donnée. + +Classe = (réplique propriétaire, paire d'enfants) : 224 cases de même capacité et de même +fenêtre (lo, hi]. Chaque instant apporte le même lot de 408 objets ; pour une largeur w, le +transport instants → classes (intervalles) est réalisable si et seulement si, pour tout +intervalle d'instants [A, B], la demande des classes contenues dans [A, B] ne dépasse pas +l'offre s_w (B − A + 1) (Hall ; les totaux sont égaux). Ces lignes sont générées à la demande, +les motifs par classe aussi (tarification exacte sur tous les motifs de la capacité). + +Relaxation : ni l'intégrité des motifs ni la règle « un objet par appel et par case » ne sont +imposées. L'optimum majore donc κ pour cette horloge ; il ne dit pas qu'un rangement entier +l'atteint. +""" +import gzip +import json +import sys +import time +from collections import defaultdict +from pathlib import Path + +import highspy +import numpy as np + +W = np.array([4, 5, 6, 7, 8, 9]) +T = 360 +N = 9 * T +SUP3 = np.array([0, 28, 18, 56, 93, 213]); SUP4 = np.array([0, 28, 18, 57, 92, 213]) +LOC3 = {1: 2487, 2: 713, 3: 224, 4: 102, 5: 20, 8: 8}; LOC4 = {1: 2489, 2: 713, 3: 227, 4: 99, 5: 20, 8: 8} +FOUR = np.zeros(N, dtype=bool) # set by set_selector(): per-tick fourth-entry flag +SUPT = np.tile(SUP3, (N, 1)); CUM = np.vstack([np.zeros((1, 6)), np.cumsum(SUPT, 0)]) +LOCAL = {} +SUP = SUP3 +def set_selector(four): + global FOUR, SUPT, CUM, LOCAL, SUBSET_SUPT + FOUR = np.asarray(four, dtype=bool); SUPT = np.where(FOUR[:, None], SUP4[None, :], SUP3[None, :]) + CUM = np.vstack([np.zeros((1, 6)), np.cumsum(SUPT, 0)]) + n4 = int(FOUR.sum()); LOCAL = {r: ((N - n4) * LOC3.get(r, 0) + n4 * LOC4.get(r, 0)) / N for r in set(LOC3) | set(LOC4)} + SUBSET_SUPT = np.array([[sum(int(SUPT[t, w]) for w in range(6) if S >> w & 1) for S in SUBSETS] for t in range(N)]) +def supply(w, A, B): return float(CUM[B + 1, w] - CUM[A, w]) +BINS = 224 +# (capacité, étape d'ouverture ou -1, étape de fermeture) des neuf paires, lues dans TEMPLATE +SPANS = [(16, -1, 1), (8, 1, 2), (32, -1, 3), (8, 3, 4), (48, -1, 5), (8, 5, 6), (48, 2, 8), (32, 4, 8), (16, 6, 8)] +PENALTY = 1e4 + + +def all_patterns(cap): + out = [] + + def rec(i, rest, cur): + if i == len(W): + out.append(tuple(cur)) + return + for k in range(rest // W[i] + 1): + rec(i + 1, rest - k * W[i], cur + [k]) + rec(0, cap, []) + P = np.array(out, dtype=np.int64) + return P, cap - P @ W + + +PATS = {c: all_patterns(c) for c in (8, 16, 32, 48)} +SUBSETS = [S for S in range(1, 64)] +SUBSET_SUP = np.array([sum(int(SUP[w]) for w in range(6) if S >> w & 1) for S in SUBSETS]) +# INTER[c][j, i] = 1 si le motif j de capacité c a une place dans le sous-ensemble i +INTER = {c: np.array([[1.0 if any(P[j, w] and S >> w & 1 for w in range(6)) else 0.0 for S in SUBSETS] + for j in range(len(P))]) for c, (P, _) in PATS.items()} + + +def g_cost(left, a): + left = np.asarray(left, dtype=float) + with np.errstate(divide='ignore', invalid='ignore'): + v = (left ** (1 - a) - left) / a + return np.where(left == 0, 0.0, v) + + +def F(profile, a): + return sum(n * r ** (1 - a) for r, n in profile.items()) - 896 * T * 73 ** (1 - a) + + +def root(profile): + lo, hi = 1e-4, 5e-3 + for _ in range(200): + mid = (lo + hi) / 2 + if F(profile, mid) < 0: + lo = mid + else: + hi = mid + return lo + + +def read_order(path): + raw = Path(path).read_bytes() + return json.loads(gzip.decompress(raw) if str(path).endswith('.gz') else raw) + + +def taus(order): + tau = np.full((T, 9), -1, dtype=np.int64) + for t, (s, r) in enumerate(order): + tau[r, s] = t + assert (tau >= 0).all() and (np.diff(tau, axis=1) > 0).all(), 'ordre des étapes par réplique' + return tau + + +def classes(order): + tau = taus(order) + cap, lo, hi = [], [], [] + for r in range(T): + for c, s0, s1 in SPANS: + cap.append(c) + lo.append(-1 if s0 < 0 else tau[r, s0]) + hi.append(tau[r, s1]) + return np.array(cap), np.array(lo), np.array(hi) + + +class HallLP: + def __init__(self, order, a=0.0017304483602076, seeds=None, verbose=True): + self.a = a + self.cap, self.lo, self.hi = classes(order) + self.K = len(self.cap) + self.verbose = verbose + h = highspy.Highs() + h.setOptionValue('output_flag', False) + h.setOptionValue('solver', 'simplex') + self.h = h + K = self.K + # variables d[k, w] : 0 .. 6K-1 ; écarts u[w] : 6K .. 6K+5 + inf = highspy.kHighsInf + h.addVars(6 * K, np.zeros(6 * K), np.full(6 * K, inf)) + h.addVars(6, np.zeros(6), np.full(6, inf)) + h.changeColsCost(6, np.arange(6 * K, 6 * K + 6, dtype=np.int32), np.full(6, PENALTY)) + # lignes : R1[k] somme des motifs = 224 ; R2[k,w] d - sum p y = 0 ; R3[w] total + self.r1 = 0 + h.addRows(K, np.full(K, float(BINS)), np.full(K, float(BINS)), 0, + np.zeros(K, dtype=np.int32), np.array([], dtype=np.int32), np.array([])) + self.r2 = K + idx = np.arange(6 * K, dtype=np.int32) + h.addRows(6 * K, np.zeros(6 * K), np.zeros(6 * K), 6 * K, idx, idx, np.ones(6 * K)) + self.r3 = 7 * K + starts = np.arange(6, dtype=np.int32) * (K + 1) + ind, val = [], [] + for w in range(6): + ind += list(range(w, 6 * K, 6)) + [6 * K + w] + val += [1.0] * (K + 1) + tot = CUM[N].astype(float) + h.addRows(6, tot, tot, len(ind), starts, np.array(ind, dtype=np.int32), np.array(val)) + self.nrows = 7 * K + 6 + self.hall = [] # (w, A, B) + self.hall_rows = [] # indice de ligne de chaque condition intérieure + self.nhall_flushed = 0 + self.hall_set = set() + self.distinct = [] # (t, i sous-ensemble, ligne) + self.cols = [] # (k, index du motif) + self.col_set = set() + self.ncols = 6 * K + 6 + # motifs de départ : vide + motifs à reste nul ou idéal, pour chaque capacité + if seeds is None: + seeds = {} + for c, (P, left) in PATS.items(): + keep = np.where((P.sum(1) == 0) | (left <= 1) | ((c == 32) & (left == 5) & (P[:, 5] == 3)) + | ((c == 48) & (left == 3) & (P[:, 5] == 5)))[0] + seeds[c] = keep + self.add_cumulative() + new = [(k, int(j)) for k in range(K) for j in seeds[self.cap[k]]] + self.add_columns(new) + + def add_cumulative(self): + """Lignes de Hall préfixe [0, B] et suffixe [A, N-1], creuses grâce à des cumuls. + + C_w(b_i) = C_w(b_{i-1}) + somme des d[k, w] des classes fermées en b_i, borné par s_w (b_i + 1) ; + S_w(a_i) = S_w(a_{i+1}) + somme des d[k, w] des classes ouvertes en a_i, borné par s_w (N - a_i). + """ + h = self.h + lo1 = self.lo + 1 + ends, starts = np.unique(self.hi), np.unique(lo1) + for w in range(6): + for keys, kind in ((ends, 'C'), (starts, 'S')): + n = len(keys) + first = self.ncols + ub = CUM[keys + 1, w] if kind == 'C' else CUM[N, w] - CUM[keys, w] + h.addVars(n, np.zeros(n), ub.astype(float)) + self.ncols += n + rs, ind, val = [], [], [] + for i, b in enumerate(keys): + rs.append(len(ind)) + ind.append(first + i) + val.append(1.0) + prev = i - 1 if kind == 'C' else i + 1 + if 0 <= prev < n: + ind.append(first + prev) + val.append(-1.0) + ks = np.where((self.hi if kind == 'C' else lo1) == b)[0] + ind.extend((6 * ks + w).tolist()) + val.extend([-1.0] * len(ks)) + h.addRows(n, np.zeros(n), np.zeros(n), len(ind), np.array(rs, dtype=np.int32), + np.array(ind, dtype=np.int32), np.array(val)) + self.nrows += n + for b in keys: + self.hall_set.add((w, 0, int(b)) if kind == 'C' else (w, int(b), N - 1)) + self.first_y = self.ncols + + def add_columns(self, new): + new = [x for x in new if x not in self.col_set] + if not new: + return 0 + costs, starts, ind, val = [], [], [], [] + for k, j in new: + P, left = PATS[self.cap[k]] + costs.append(float(g_cost(left[j], self.a))) + starts.append(len(ind)) + ind.append(self.r1 + k) + val.append(1.0) + for w in range(6): + if P[j, w]: + ind.append(self.r2 + 6 * k + w) + val.append(-float(P[j, w])) + for t, i, row in self.distinct: + if self.lo[k] < t <= self.hi[k] and INTER[self.cap[k]][j, i]: + ind.append(row) + val.append(1.0) + self.col_set.add((k, j)) + self.cols.append((k, j)) + n = len(new) + self.h.addCols(n, np.array(costs), np.zeros(n), np.full(n, highspy.kHighsInf), len(ind), + np.array(starts, dtype=np.int32), np.array(ind, dtype=np.int32), np.array(val)) + self.ncols += n + return n + + def add_distinct(self, ticks): + """À chaque instant t : pour tout sous-ensemble S de largeurs, au moins sum_{w in S} s_w cases + ouvertes à t ont une place dans S (couplage par appel ; nécessaire, pas suffisant).""" + bycls = defaultdict(list) + for n, (k, j) in enumerate(self.cols): + bycls[k].append((j, self.first_y + n)) + lower, starts, ind, val = [], [], [], [] + for t in ticks: + ks = np.where((self.lo < t) & (t <= self.hi))[0] + for i in range(len(SUBSETS)): + starts.append(len(ind)) + lower.append(float(SUBSET_SUPT[t, i])) + for k in ks: + for j, col in bycls[k]: + if INTER[self.cap[k]][j, i]: + ind.append(col) + val.append(1.0) + self.distinct.append((t, i, self.nrows + len(lower) - 1)) + n = len(lower) + self.h.addRows(n, np.array(lower), np.full(n, highspy.kHighsInf), len(ind), + np.array(starts, dtype=np.int32), np.array(ind, dtype=np.int32), np.array(val)) + self.nrows += n + + def queue_hall(self, w, A, B): + if (w, A, B) in self.hall_set or B < A: + return + self.hall_set.add((w, A, B)) + self.pending = getattr(self, 'pending', []) + self.pending.append((w, A, B)) + + def flush_hall(self): + rows = getattr(self, 'pending', []) + self.pending = [] + if not rows: + return 0 + lo1 = self.lo + 1 + lower, upper, starts, ind, val = [], [], [], [], [] + for w, A, B in rows: + ks = np.where((lo1 >= A) & (self.hi <= B))[0] + starts.append(len(ind)) + ind.extend((6 * ks + w).tolist()) + val.extend([1.0] * len(ks)) + lower.append(-highspy.kHighsInf) + upper.append(supply(w, A, B)) + self.hall.append((w, A, B)) + self.hall_rows.append(self.nrows + len(self.hall_rows) - self.nhall_flushed) + n = len(rows) + self.h.addRows(n, np.array(lower), np.array(upper), len(ind), np.array(starts, dtype=np.int32), + np.array(ind, dtype=np.int32), np.array(val)) + self.nrows += n + self.nhall_flushed = len(self.hall_rows) + return n + + def solve(self): + self.h.run() + st = self.h.getModelStatus() + assert st == highspy.HighsModelStatus.kOptimal, self.h.modelStatusToString(st) + sol = self.h.getSolution() + self.x = np.array(sol.col_value) + self.dual = np.array(sol.row_dual) + self.obj = self.h.getInfo().objective_function_value + return self.obj + + def demand(self): + return self.x[:6 * self.K].reshape(self.K, 6) + + def separate(self, per_width=150, tol=1e-6): + d = self.demand() + lo1, hi = self.lo + 1, self.hi + added = 0 + Bidx = np.arange(N) + for w in range(6): + M = np.zeros((N, N)) + np.add.at(M, (lo1, hi), d[:, w]) + D = np.cumsum(np.cumsum(M[::-1], axis=0)[::-1], axis=1) + V = D - (CUM[Bidx[None, :] + 1, w] - CUM[Bidx[:, None], w]) + V[np.tril_indices(N, -1)] = -np.inf + bestB = V.argmax(1) + bestV = V[np.arange(N), bestB] + order = np.argsort(-bestV) + cnt = 0 + for A in order: + if bestV[A] <= tol or cnt >= per_width: + break + if (w, int(A), int(bestB[A])) not in self.hall_set: + self.queue_hall(w, int(A), int(bestB[A])) + cnt += 1 + added += cnt + del M, D, V + self.flush_hall() + return added + + def price(self, per_class=3, tol=1e-7): + mu = self.dual[self.r1:self.r1 + self.K] + pi = self.dual[self.r2:self.r2 + 6 * self.K].reshape(self.K, 6) + new = [] + best = 0.0 + for c, (P, left) in PATS.items(): + ks = np.where(self.cap == c)[0] + g = g_cost(left, self.a) + rc = g[None, :] - mu[ks, None] + pi[ks] @ P.T.astype(float) + for t, i, row in self.distinct: + lam = self.dual[row] + if lam: + open_ = (self.lo[ks] < t) & (t <= self.hi[ks]) + rc[open_] -= lam * INTER[c][:, i][None, :] + best = min(best, rc.min()) + for i, k in enumerate(ks): + js = np.argsort(rc[i])[:per_class] + for j in js: + if rc[i, j] < -tol and (k, int(j)) not in self.col_set: + new.append((int(k), int(j))) + return self.add_columns(new), best + + def profile(self): + prof = {r: float(N * n) for r, n in LOCAL.items()} + for (k, j), v in zip(self.cols, self.x[self.first_y:]): + if v > 1e-12: + l = int(PATS[self.cap[k]][1][j]) + if l: + prof[l] = prof.get(l, 0.0) + v + return prof + + def slack(self): + return self.x[6 * self.K:6 * self.K + 6] + + def run(self, max_rounds=200): + t0 = time.time() + for it in range(max_rounds): + self.solve() + nr = self.separate() + nc, best = self.price() + prof = self.profile() + if self.verbose: + print(f' tour {it:3d} obj {self.obj:.6f} écart {self.slack().sum():.3g} +{nr} lignes +{nc} motifs ' + f'(rc min {best:.2e}) lignes Hall {len(self.hall)} motifs {len(self.cols)} ' + f'racine {root(prof):.16f} [{time.time() - t0:.0f}s]', flush=True) + if nr == 0 and nc == 0: + break + return root(self.profile()) + + +IDEAL = 0.00173057843726628 +CURRENT = 0.00173044836020758 + + +def report(lp, label): + prof = lp.profile() + r = root(prof) + idle = {k: round(v - N * LOCAL.get(k, 0), 3) for k, v in sorted(prof.items()) if abs(v - N * LOCAL.get(k, 0)) > 1e-6} + gap_units = F(prof, IDEAL) + print(f'{label}: racine PL {r:.16f} idéal {IDEAL:.16f} actuel {CURRENT:.16f}') + print(f' écart à l\'idéal {IDEAL - r:.3e} ; gain possible sur l\'actuel {r - CURRENT:+.3e}') + print(f' restes {idle} (F à la racine idéale {gap_units:.4f})') + return r + + +if __name__ == '__main__': + order = read_order(sys.argv[1]); mode = sys.argv[2] + clock = {tuple(v): t for t, v in enumerate(order)} + if mode.startswith('mod'): # mod: selector (109 t) mod 324 < k + k = int(mode[3:]); four = [(t * 109) % 324 < k for t in range(N)] + else: + four = json.load(open(mode)) + set_selector(four); print('fourth calls', int(np.sum(four)), flush=True) + lp = HallLP(order, a=0.0017309791156708); lp.run() + prof = lp.profile(); print('ROOT', '%.16f' % root(prof), {k: round(v, 3) for k, v in sorted(prof.items())}) diff --git a/research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz b/research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz new file mode 100644 index 000000000..441878649 Binary files /dev/null and b/research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz differ diff --git a/research/complex-pooled-full-admission/frozen/pr4181/owner/MIXED-DISPATCH.json b/research/complex-pooled-full-admission/frozen/pr4181/owner/MIXED-DISPATCH.json new file mode 100644 index 000000000..d4d64c5d0 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/owner/MIXED-DISPATCH.json @@ -0,0 +1 @@ +[[0, 0, "extra-four"], [0, 45, "extra-four"], [0, 90, "extra-four"], [0, 135, "extra-four"], [0, 180, "extra-four"], [0, 225, "extra-four"], [0, 270, "extra-four"], [0, 315, "extra-four"], [0, 1, "extra-four"], [0, 46, "extra-four"], [0, 91, "extra-four"], [0, 136, "extra-four"], [0, 181, "extra-four"], [0, 226, "extra-four"], [0, 271, "extra-four"], [0, 316, "extra-four"], [0, 2, "extra-four"], [0, 47, "extra-four"], [0, 92, "extra-four"], [0, 137, "extra-four"], [0, 182, "extra-four"], [0, 227, "extra-four"], [0, 272, "extra-four"], [0, 317, "extra-four"], [0, 3, "extra-four"], [0, 48, "extra-four"], [0, 93, "extra-four"], [0, 138, "extra-four"], [0, 183, "extra-four"], [0, 228, "extra-four"], [0, 273, "extra-four"], [0, 318, "extra-four"], [0, 4, "extra-four"], [0, 49, "extra-four"], [0, 94, "extra-four"], [0, 139, "extra-four"], [0, 184, "extra-four"], [0, 229, "extra-four"], [0, 274, "extra-four"], [0, 319, "extra-four"], [1, 0, "extra-four"], [1, 45, "extra-four"], [1, 90, "extra-four"], [1, 135, "extra-four"], [1, 180, "extra-four"], [1, 225, "extra-four"], [1, 270, "extra-four"], [1, 315, "extra-four"], [0, 5, "extra-four"], [0, 50, "extra-four"], [0, 95, "extra-four"], [0, 140, "extra-four"], [0, 185, "extra-four"], [0, 230, "extra-four"], [0, 275, "extra-four"], [0, 320, "extra-four"], [1, 1, "extra-four"], [1, 46, "extra-four"], [1, 91, "extra-four"], [1, 136, "extra-four"], [1, 181, "extra-four"], [1, 226, "extra-four"], [1, 271, "extra-four"], [1, 316, "extra-four"], [0, 6, "extra-four"], [0, 51, "extra-four"], [0, 96, "extra-four"], [0, 141, "extra-four"], [0, 186, "extra-four"], [0, 231, "extra-four"], [0, 276, "extra-four"], [0, 321, "extra-four"], [1, 2, "extra-four"], [1, 47, "extra-four"], [1, 92, "extra-four"], [1, 137, "extra-four"], [1, 182, "extra-four"], [1, 227, "extra-four"], [1, 272, "extra-four"], [1, 317, "extra-four"], [0, 7, "extra-four"], [0, 52, "extra-four"], [0, 97, "extra-four"], [0, 142, "extra-four"], [0, 187, "extra-four"], [0, 232, "extra-four"], [0, 277, "extra-four"], [0, 322, "extra-four"], [1, 3, "extra-four"], [1, 48, "extra-four"], [1, 93, "extra-four"], [1, 138, "extra-four"], [1, 183, "extra-four"], [1, 228, "extra-four"], [1, 273, "extra-four"], [1, 318, "extra-four"], [0, 8, "extra-four"], [0, 53, "extra-four"], [0, 98, "extra-four"], [0, 143, "extra-four"], [0, 188, "extra-four"], [0, 233, "extra-four"], [0, 278, "extra-four"], [0, 323, "extra-four"], [1, 4, "extra-four"], [1, 49, "extra-four"], [1, 94, "extra-four"], [1, 139, "extra-four"], [1, 184, "extra-four"], [1, 229, "extra-four"], [1, 274, "extra-four"], [1, 319, "extra-four"], [0, 9, "extra-four"], [0, 54, "extra-four"], [0, 99, "extra-four"], [0, 144, "extra-four"], [0, 189, "extra-four"], [0, 234, "extra-four"], [0, 279, "extra-four"], [0, 324, "extra-four"], [2, 0, "extra-four"], [2, 45, "extra-four"], [2, 90, "extra-four"], [2, 135, "extra-four"], [2, 180, "extra-four"], [2, 225, "extra-four"], [2, 270, "extra-four"], [2, 315, "extra-four"], [1, 5, "extra-four"], [1, 50, "extra-four"], [1, 95, "extra-four"], [1, 140, "extra-four"], [1, 185, "extra-four"], [1, 230, "extra-four"], [1, 275, "extra-four"], [1, 320, "extra-four"], [0, 10, "extra-four"], [0, 55, "extra-four"], [0, 100, "extra-four"], [0, 145, "extra-four"], [0, 190, "extra-four"], [0, 235, "extra-four"], [0, 280, "extra-four"], [0, 325, "extra-four"], [2, 1, "extra-four"], [2, 46, "extra-four"], [2, 91, "extra-four"], [2, 136, "extra-four"], [2, 181, "extra-four"], [2, 226, "extra-four"], [2, 271, "extra-four"], [2, 316, "extra-four"], [1, 6, "extra-four"], [1, 51, "extra-four"], [1, 96, "extra-four"], [1, 141, "extra-four"], [1, 186, "extra-four"], [1, 231, "extra-four"], [1, 276, "extra-four"], [1, 321, "extra-four"], [0, 11, "extra-four"], [0, 56, "extra-four"], [0, 101, "extra-four"], [0, 146, "extra-four"], [0, 191, "extra-four"], [0, 236, "extra-four"], [0, 281, "extra-four"], [0, 326, "extra-four"], [2, 2, "extra-four"], [2, 47, "extra-four"], [2, 92, "extra-four"], [2, 137, "extra-four"], [2, 182, "extra-four"], [2, 227, "extra-four"], [2, 272, "extra-four"], [2, 317, "extra-four"], [1, 7, "extra-four"], [1, 52, "extra-four"], [1, 97, "extra-four"], [1, 142, "extra-four"], [1, 187, "extra-four"], [1, 232, "extra-four"], [1, 277, "extra-four"], [1, 322, "extra-four"], [0, 12, "extra-four"], [0, 57, "extra-four"], [0, 102, "extra-four"], [0, 147, "extra-four"], [0, 192, "extra-four"], [0, 237, "extra-four"], [0, 282, "extra-four"], [0, 327, "extra-four"], [2, 3, "extra-four"], [2, 48, "extra-four"], [2, 93, "extra-four"], [2, 138, "extra-four"], [2, 183, "extra-four"], [2, 228, "extra-four"], [2, 273, "extra-four"], [2, 318, "extra-four"], [1, 8, "extra-four"], [1, 53, "extra-four"], [1, 98, "extra-four"], [1, 143, "extra-four"], [1, 188, "extra-four"], [1, 233, "extra-four"], [1, 278, "extra-four"], [1, 323, "extra-four"], [0, 13, "extra-four"], [0, 58, "extra-four"], [0, 103, "extra-four"], [0, 148, "extra-four"], [0, 193, "extra-four"], [0, 238, "extra-four"], [0, 283, "extra-four"], [0, 328, "extra-four"], [2, 4, "extra-four"], [2, 49, "extra-four"], [2, 94, "extra-four"], [2, 139, "extra-four"], [2, 184, "extra-four"], [2, 229, "extra-four"], [2, 274, "extra-four"], [2, 319, "extra-four"], [1, 9, "extra-four"], [1, 54, "extra-four"], [1, 99, "extra-four"], [1, 144, "extra-four"], [1, 189, "extra-four"], [1, 234, "extra-four"], [1, 279, "extra-four"], [1, 324, "extra-four"], [3, 0, "extra-four"], [3, 45, "extra-four"], [3, 90, "extra-four"], [3, 135, "extra-four"], [3, 180, "extra-four"], [3, 225, "extra-four"], [3, 270, "extra-four"], [3, 315, "extra-four"], [0, 14, "extra-four"], [0, 59, "extra-four"], [0, 104, "extra-four"], [0, 149, "extra-four"], [0, 194, "extra-four"], [0, 239, "extra-four"], [0, 284, "extra-four"], [0, 329, "extra-four"], [2, 5, "extra-four"], [2, 50, "extra-four"], [2, 95, "extra-four"], [2, 140, "extra-four"], [2, 185, "extra-four"], [2, 230, "extra-four"], [2, 275, "extra-four"], [2, 320, "extra-four"], [1, 10, "extra-four"], [1, 55, "extra-four"], [1, 100, "extra-four"], [1, 145, "extra-four"], [1, 190, "extra-four"], [1, 235, "extra-four"], [1, 280, "extra-four"], [1, 325, "extra-four"], [3, 1, "extra-four"], [3, 46, "extra-four"], [3, 91, "extra-four"], [3, 136, "extra-four"], [3, 181, "extra-four"], [3, 226, "extra-four"], [3, 271, "extra-four"], [3, 316, "extra-four"], [0, 15, "extra-four"], [0, 60, "extra-four"], [0, 105, "extra-four"], [0, 150, "extra-four"], [0, 195, "extra-four"], [0, 240, "extra-four"], [0, 285, "extra-four"], [0, 330, "extra-four"], [2, 6, "extra-four"], [2, 51, "extra-four"], [2, 96, "extra-four"], [2, 141, "extra-four"], [2, 186, "extra-four"], [2, 231, "extra-four"], [2, 276, "extra-four"], [2, 321, "extra-four"], [1, 11, "extra-four"], [1, 56, "extra-four"], [1, 101, "extra-four"], [1, 146, "extra-four"], [1, 191, "extra-four"], [1, 236, "extra-four"], [1, 281, "extra-four"], [1, 326, "extra-four"], [3, 2, "extra-four"], [3, 47, "extra-four"], [3, 92, "extra-four"], [3, 137, "extra-four"], [3, 182, "extra-four"], [3, 227, "extra-four"], [3, 272, "extra-four"], [3, 317, "extra-four"], [0, 16, "extra-four"], [0, 61, "extra-four"], [0, 106, "extra-four"], [0, 151, "extra-four"], [0, 196, "extra-four"], [0, 241, "extra-four"], [0, 286, "extra-four"], [0, 331, "extra-four"], [2, 7, "extra-four"], [2, 52, "extra-four"], [2, 97, "extra-four"], [2, 142, "extra-four"], [2, 187, "extra-four"], [2, 232, "extra-four"], [2, 277, "extra-four"], [2, 322, "extra-four"], [1, 12, "extra-four"], [1, 57, "extra-four"], [1, 102, "extra-four"], [1, 147, "extra-four"], [1, 192, "extra-four"], [1, 237, "extra-four"], [1, 282, "extra-four"], [1, 327, "extra-four"], [3, 3, "extra-four"], [3, 48, "extra-four"], [3, 93, "extra-four"], [3, 138, "extra-four"], [3, 183, "extra-four"], [3, 228, "extra-four"], [3, 273, "extra-four"], [3, 318, "extra-four"], [0, 17, "extra-four"], [0, 62, "extra-four"], [0, 107, "extra-four"], [0, 152, "extra-four"], [0, 197, "extra-four"], [0, 242, "extra-four"], [0, 287, "extra-four"], [0, 332, "extra-four"], [2, 8, "extra-four"], [2, 53, "extra-four"], [2, 98, "extra-four"], [2, 143, "extra-four"], [2, 188, "extra-four"], [2, 233, "extra-four"], [2, 278, "extra-four"], [2, 323, "extra-four"], [1, 13, "extra-four"], [1, 58, "extra-four"], [1, 103, "extra-four"], [1, 148, "extra-four"], [1, 193, "extra-four"], [1, 238, "extra-four"], [1, 283, "extra-four"], [1, 328, "extra-four"], [3, 4, "extra-four"], [3, 49, "extra-four"], [3, 94, "extra-four"], [3, 139, "extra-four"], [3, 184, "extra-four"], [3, 229, "extra-four"], [3, 274, "extra-four"], [3, 319, "extra-four"], [0, 18, "extra-four"], [0, 63, "extra-four"], [0, 108, "extra-four"], [0, 153, "extra-four"], [0, 198, "extra-four"], [0, 243, "extra-four"], [0, 288, "extra-four"], [0, 333, "extra-four"], [2, 9, "extra-four"], [2, 54, "extra-four"], [2, 99, "extra-four"], [2, 144, "extra-four"], [2, 189, "extra-four"], [2, 234, "extra-four"], [2, 279, "extra-four"], [2, 324, "extra-four"], [4, 0, "extra-four"], [4, 45, "extra-four"], [4, 90, "extra-four"], [4, 135, "extra-four"], [4, 180, "extra-four"], [4, 225, "extra-four"], [4, 270, "extra-four"], [4, 315, "extra-four"], [1, 14, "extra-four"], [1, 59, "extra-four"], [1, 104, "extra-four"], [1, 149, "extra-four"], [1, 194, "extra-four"], [1, 239, "extra-four"], [1, 284, "extra-four"], [1, 329, "extra-four"], [3, 5, "extra-four"], [3, 50, "extra-four"], [3, 95, "extra-four"], [3, 140, "extra-four"], [3, 185, "extra-four"], [3, 230, "extra-four"], [3, 275, "extra-four"], [3, 320, "extra-four"], [0, 19, "extra-four"], [0, 64, "extra-four"], [0, 109, "extra-four"], [0, 154, "extra-four"], [0, 199, "extra-four"], [0, 244, "extra-four"], [0, 289, "extra-four"], [0, 334, "extra-four"], [2, 10, "extra-four"], [2, 55, "extra-four"], [2, 100, "extra-four"], [2, 145, "extra-four"], [2, 190, "extra-four"], [2, 235, "extra-four"], [2, 280, "extra-four"], [2, 325, "extra-four"], [4, 1, "extra-four"], [4, 46, "extra-four"], [4, 91, "extra-four"], [4, 136, "extra-four"], [4, 181, "extra-four"], [4, 226, "extra-four"], [4, 271, "extra-four"], [4, 316, "extra-four"], [1, 15, "extra-four"], [1, 60, "extra-four"], [1, 105, "extra-four"], [1, 150, "extra-four"], [1, 195, "extra-four"], [1, 240, "extra-four"], [1, 285, "extra-four"], [1, 330, "extra-four"], [3, 6, "extra-four"], [3, 51, "extra-four"], [3, 96, "extra-four"], [3, 141, "extra-four"], [3, 186, "extra-four"], [3, 231, "extra-four"], [3, 276, "extra-four"], [3, 321, "extra-four"], [0, 20, "extra-four"], [0, 65, "extra-four"], [0, 110, "extra-four"], [0, 155, "extra-four"], [0, 200, "extra-four"], [0, 245, "extra-four"], [0, 290, "extra-four"], [0, 335, "extra-four"], [2, 11, "extra-four"], [2, 56, "extra-four"], [2, 101, "extra-four"], [2, 146, "extra-four"], [2, 191, "extra-four"], [2, 236, "extra-four"], [2, 281, "extra-four"], [2, 326, "extra-four"], [4, 2, "extra-four"], [4, 47, "extra-four"], [4, 92, "extra-four"], [4, 137, "extra-four"], [4, 182, "extra-four"], [4, 227, "extra-four"], [4, 272, "extra-four"], [4, 317, "extra-four"], [1, 16, "extra-four"], [1, 61, "extra-four"], [1, 106, "extra-four"], [1, 151, "extra-four"], [1, 196, "extra-four"], [1, 241, "extra-four"], [1, 286, "extra-four"], [1, 331, "extra-four"], [3, 7, "extra-four"], [3, 52, "extra-four"], [3, 97, "extra-four"], [3, 142, "extra-four"], [3, 187, "extra-four"], [3, 232, "extra-four"], [3, 277, "extra-four"], [3, 322, "extra-four"], [0, 21, "extra-four"], [0, 66, "extra-four"], [0, 111, "extra-four"], [0, 156, "extra-four"], [0, 201, "extra-four"], [0, 246, "extra-four"], [0, 291, "extra-four"], [0, 336, "extra-four"], [2, 12, "extra-four"], [2, 57, "extra-four"], [2, 102, "extra-four"], [2, 147, "extra-four"], [2, 192, "extra-four"], [2, 237, "extra-four"], [2, 282, "extra-four"], [2, 327, "extra-four"], [4, 3, "extra-four"], [4, 48, "extra-four"], [4, 93, "extra-four"], [4, 138, "extra-four"], [4, 183, "extra-four"], [4, 228, "extra-four"], [4, 273, "extra-four"], [4, 318, "extra-four"], [1, 17, "extra-four"], [1, 62, "extra-four"], [1, 107, "extra-four"], [1, 152, "extra-four"], [1, 197, "extra-four"], [1, 242, "extra-four"], [1, 287, "extra-four"], [1, 332, "extra-four"], [3, 8, "extra-four"], [3, 53, "extra-four"], [3, 98, "extra-four"], [3, 143, "extra-four"], [3, 188, "extra-four"], [3, 233, "extra-four"], [3, 278, "extra-four"], [3, 323, "extra-four"], [0, 22, "extra-four"], [0, 67, "extra-four"], [0, 112, "extra-four"], [0, 157, "extra-four"], [0, 202, "extra-four"], [0, 247, "extra-four"], [0, 292, "extra-four"], [0, 337, "extra-four"], [2, 13, "extra-four"], [2, 58, "extra-four"], [2, 103, "extra-four"], [2, 148, "extra-four"], [2, 193, "extra-four"], [2, 238, "extra-four"], [2, 283, "extra-four"], [2, 328, "extra-four"], [4, 4, "extra-four"], [4, 49, "extra-four"], [4, 94, "extra-four"], [4, 139, "extra-four"], [4, 184, "extra-four"], [4, 229, "extra-four"], [4, 274, "extra-four"], [4, 319, "extra-four"], [1, 18, "extra-four"], [1, 63, "extra-four"], [1, 108, "extra-four"], [1, 153, "extra-four"], [1, 198, "extra-four"], [1, 243, "extra-four"], [1, 288, "extra-four"], [1, 333, "extra-four"], [3, 9, "extra-four"], [3, 54, "extra-four"], [3, 99, "extra-four"], [3, 144, "extra-four"], [3, 189, "extra-four"], [3, 234, "extra-four"], [3, 279, "extra-four"], [3, 324, "extra-four"], [0, 23, "extra-four"], [0, 68, "extra-four"], [0, 113, "extra-four"], [0, 158, "extra-four"], [0, 203, "extra-four"], [0, 248, "extra-four"], [0, 293, "extra-four"], [0, 338, "extra-four"], [5, 0, "extra-four"], [5, 45, "extra-four"], [5, 90, "extra-four"], [5, 135, "extra-four"], [5, 180, "extra-four"], [5, 225, "extra-four"], [5, 270, "extra-four"], [5, 315, "extra-four"], [2, 14, "extra-four"], [2, 59, "extra-four"], [2, 104, "extra-four"], [2, 149, "extra-four"], [2, 194, "extra-four"], [2, 239, "extra-four"], [2, 284, "extra-four"], [2, 329, "extra-four"], [4, 5, "extra-four"], [4, 50, "extra-four"], [4, 95, "extra-four"], [4, 140, "extra-four"], [4, 185, "extra-four"], [4, 230, "extra-four"], [4, 275, "extra-four"], [4, 320, "extra-four"], [1, 19, "extra-four"], [1, 64, "extra-four"], [1, 109, "extra-four"], [1, 154, "extra-four"], [1, 199, "extra-four"], [1, 244, "extra-four"], [1, 289, "extra-four"], [1, 334, "extra-four"], [3, 10, "extra-four"], [3, 55, "extra-four"], [3, 100, "extra-four"], [3, 145, "extra-four"], [3, 190, "extra-four"], [3, 235, "extra-four"], [3, 280, "extra-four"], [3, 325, "extra-four"], [0, 24, "extra-four"], [0, 69, "extra-four"], [0, 114, "extra-four"], [0, 159, "extra-four"], [0, 204, "extra-four"], [0, 249, "extra-four"], [0, 294, "extra-four"], [0, 339, "extra-four"], [5, 1, "extra-four"], [5, 46, "extra-four"], [5, 91, "extra-four"], [5, 136, "extra-four"], [5, 181, "extra-four"], [5, 226, "extra-four"], [5, 271, "extra-four"], [5, 316, "extra-four"], [2, 15, "extra-four"], [2, 60, "extra-four"], [2, 105, "extra-four"], [2, 150, "extra-four"], [2, 195, "extra-four"], [2, 240, "extra-four"], [2, 285, "extra-four"], [2, 330, "extra-four"], [4, 6, "extra-four"], [4, 51, "extra-four"], [4, 96, "extra-four"], [4, 141, "extra-four"], [4, 186, "extra-four"], [4, 231, "extra-four"], [4, 276, "extra-four"], [4, 321, "extra-four"], [1, 20, "extra-four"], [1, 65, "extra-four"], [1, 110, "extra-four"], [1, 155, "extra-four"], [1, 200, "extra-four"], [1, 245, "extra-four"], [1, 290, "extra-four"], [1, 335, "extra-four"], [3, 11, "extra-four"], [3, 56, "extra-four"], [3, 101, "extra-four"], [3, 146, "extra-four"], [3, 191, "extra-four"], [3, 236, "extra-four"], [3, 281, "extra-four"], [3, 326, "extra-four"], [0, 25, "extra-four"], [0, 70, "extra-four"], [0, 115, "extra-four"], [0, 160, "extra-four"], [0, 205, "extra-four"], [0, 250, "extra-four"], [0, 295, "extra-four"], [0, 340, "extra-four"], [5, 2, "extra-four"], [5, 47, "extra-four"], [5, 92, "extra-four"], [5, 137, "extra-four"], [5, 182, "extra-four"], [5, 227, "extra-four"], [5, 272, "extra-four"], [5, 317, "extra-four"], [2, 16, "extra-four"], [2, 61, "extra-four"], [2, 106, "extra-four"], [2, 151, "extra-four"], [2, 196, "extra-four"], [2, 241, "extra-four"], [2, 286, "extra-four"], [2, 331, "extra-four"], [4, 7, "extra-four"], [4, 52, "extra-four"], [4, 97, "extra-four"], [4, 142, "extra-four"], [4, 187, "extra-four"], [4, 232, "extra-four"], [4, 277, "extra-four"], [4, 322, "extra-four"], [1, 21, "extra-four"], [1, 66, "extra-four"], [1, 111, "extra-four"], [1, 156, "extra-four"], [1, 201, "extra-four"], [1, 246, "extra-four"], [1, 291, "extra-four"], [1, 336, "extra-four"], [3, 12, "extra-four"], [3, 57, "extra-four"], [3, 102, "extra-four"], [3, 147, "extra-four"], [3, 192, "extra-four"], [3, 237, "extra-four"], [3, 282, "extra-four"], [3, 327, "extra-four"], [0, 26, "extra-four"], [0, 71, "extra-four"], [0, 116, "extra-four"], [0, 161, "extra-four"], [0, 206, "extra-four"], [0, 251, "extra-four"], [0, 296, "extra-four"], [0, 341, "extra-four"], [5, 3, "extra-four"], [5, 48, "extra-four"], [5, 93, "extra-four"], [5, 138, "extra-four"], [5, 183, "extra-four"], [5, 228, "extra-four"], [5, 273, "extra-four"], [5, 318, "extra-four"], [2, 17, "extra-four"], [2, 62, "extra-four"], [2, 107, "extra-four"], [2, 152, "extra-four"], [2, 197, "extra-four"], [2, 242, "extra-four"], [2, 287, "extra-four"], [2, 332, "extra-four"], [4, 8, "extra-four"], [4, 53, "extra-four"], [4, 98, "extra-four"], [4, 143, "extra-four"], [4, 188, "extra-four"], [4, 233, "extra-four"], [4, 278, "extra-four"], [4, 323, "extra-four"], [1, 22, "extra-four"], [1, 67, "extra-four"], [1, 112, "extra-four"], [1, 157, "extra-four"], [1, 202, "extra-four"], [1, 247, "extra-four"], [1, 292, "extra-four"], [1, 337, "extra-four"], [3, 13, "extra-four"], [3, 58, "extra-four"], [3, 103, "extra-four"], [3, 148, "extra-four"], [3, 193, "extra-four"], [3, 238, "extra-four"], [3, 283, "extra-four"], [3, 328, "extra-four"], [0, 27, "extra-four"], [0, 72, "extra-four"], [0, 117, "extra-four"], [0, 162, "extra-four"], [0, 207, "extra-four"], [0, 252, "extra-four"], [0, 297, "extra-four"], [0, 342, "extra-four"], [5, 4, "extra-four"], [5, 49, "extra-four"], [5, 94, "extra-four"], [5, 139, "extra-four"], [5, 184, "extra-four"], [5, 229, "extra-four"], [5, 274, "extra-four"], [5, 319, "extra-four"], [2, 18, "extra-four"], [2, 63, "extra-four"], [2, 108, "extra-four"], [2, 153, "extra-four"], [2, 198, "extra-four"], [2, 243, "extra-four"], [2, 288, "extra-four"], [2, 333, "extra-four"], [4, 9, "extra-four"], [4, 54, "extra-four"], [4, 99, "extra-four"], [4, 144, "extra-four"], [4, 189, "extra-four"], [4, 234, "extra-four"], [4, 279, "extra-four"], [4, 324, "extra-four"], [1, 23, "extra-four"], [1, 68, "extra-four"], [1, 113, "extra-four"], [1, 158, "extra-four"], [1, 203, "extra-four"], [1, 248, "extra-four"], [1, 293, "extra-four"], [1, 338, "extra-four"], [6, 0, "extra-four"], [6, 45, "extra-four"], [6, 90, "extra-four"], [6, 135, "extra-four"], [6, 180, "extra-four"], [6, 225, "extra-four"], [6, 270, "extra-four"], [6, 315, "extra-four"], [3, 14, "extra-four"], [3, 59, "extra-four"], [3, 104, "extra-four"], [3, 149, "extra-four"], [3, 194, "extra-four"], [3, 239, "extra-four"], [3, 284, "extra-four"], [3, 329, "extra-four"], [0, 28, "extra-four"], [0, 73, "extra-four"], [0, 118, "extra-four"], [0, 163, "extra-four"], [0, 208, "extra-four"], [0, 253, "extra-four"], [0, 298, "extra-four"], [0, 343, "extra-four"], [5, 5, "extra-four"], [5, 50, "extra-four"], [5, 95, "extra-four"], [5, 140, "extra-four"], [5, 185, "extra-four"], [5, 230, "extra-four"], [5, 275, "extra-four"], [5, 320, "extra-four"], [2, 19, "extra-four"], [2, 64, "extra-four"], [2, 109, "extra-four"], [2, 154, "extra-four"], [2, 199, "extra-four"], [2, 244, "extra-four"], [2, 289, "extra-four"], [2, 334, "extra-four"], [4, 10, "extra-four"], [4, 55, "extra-four"], [4, 100, "extra-four"], [4, 145, "extra-four"], [4, 190, "extra-four"], [4, 235, "extra-four"], [4, 280, "extra-four"], [4, 325, "extra-four"], [1, 24, "extra-four"], [1, 69, "extra-four"], [1, 114, "extra-four"], [1, 159, "extra-four"], [1, 204, "extra-four"], [1, 249, "extra-four"], [1, 294, "extra-four"], [1, 339, "extra-four"], [6, 1, "extra-four"], [6, 46, "extra-four"], [6, 91, "extra-four"], [6, 136, "extra-four"], [6, 181, "extra-four"], [6, 226, "extra-four"], [6, 271, "extra-four"], [6, 316, "extra-four"], [3, 15, "extra-four"], [3, 60, "extra-four"], [3, 105, "extra-four"], [3, 150, "extra-four"], [3, 195, "extra-four"], [3, 240, "extra-four"], [3, 285, "extra-four"], [3, 330, "extra-four"], [0, 29, "extra-four"], [0, 74, "extra-four"], [0, 119, "extra-four"], [0, 164, "extra-four"], [0, 209, "extra-four"], [0, 254, "extra-four"], [0, 299, "extra-four"], [0, 344, "extra-four"], [5, 6, "extra-four"], [5, 51, "extra-four"], [5, 96, "extra-four"], [5, 141, "extra-four"], [5, 186, "extra-four"], [5, 231, "extra-four"], [5, 276, "extra-four"], [5, 321, "extra-four"], [2, 20, "extra-four"], [2, 65, "extra-four"], [2, 110, "extra-four"], [2, 155, "extra-four"], [2, 200, "extra-four"], [2, 245, "extra-four"], [2, 290, "extra-four"], [2, 335, "extra-four"], [4, 11, "extra-four"], [4, 56, "extra-four"], [4, 101, "extra-four"], [4, 146, "extra-four"], [4, 191, "extra-four"], [4, 236, "extra-four"], [4, 281, "extra-four"], [4, 326, "extra-four"], [1, 25, "extra-four"], [1, 70, "extra-four"], [1, 115, "extra-four"], [1, 160, "extra-four"], [1, 205, "extra-four"], [1, 250, "extra-four"], [1, 295, "extra-four"], [1, 340, "extra-four"], [6, 2, "extra-four"], [6, 47, "extra-four"], [6, 92, "extra-four"], [6, 137, "extra-four"], [6, 182, "extra-four"], [6, 227, "extra-four"], [6, 272, "extra-four"], [6, 317, "extra-four"], [3, 16, "extra-four"], [3, 61, "extra-four"], [3, 106, "extra-four"], [3, 151, "extra-four"], [3, 196, "extra-four"], [3, 241, "extra-four"], [3, 286, "extra-four"], [3, 331, "extra-four"], [0, 30, "extra-four"], [0, 75, "extra-four"], [0, 120, "extra-four"], [0, 165, "extra-four"], [0, 210, "extra-four"], [0, 255, "extra-four"], [0, 300, "extra-four"], [0, 345, "extra-four"], [5, 7, "extra-four"], [5, 52, "extra-four"], [5, 97, "extra-four"], [5, 142, "extra-four"], [5, 187, "extra-four"], [5, 232, "extra-four"], [5, 277, "extra-four"], [5, 322, "extra-four"], [2, 21, "extra-four"], [2, 66, "extra-four"], [2, 111, "extra-four"], [2, 156, "extra-four"], [2, 201, "extra-four"], [2, 246, "extra-four"], [2, 291, "extra-four"], [2, 336, "extra-four"], [4, 12, "extra-four"], [4, 57, "extra-four"], [4, 102, "extra-four"], [4, 147, "extra-four"], [4, 192, "extra-four"], [4, 237, "extra-four"], [4, 282, "extra-four"], [4, 327, "extra-four"], [1, 26, "extra-four"], [1, 71, "extra-four"], [1, 116, "extra-four"], [1, 161, "extra-four"], [1, 206, "extra-four"], [1, 251, "extra-four"], [1, 296, "extra-four"], [1, 341, "extra-four"], [6, 3, "extra-four"], [6, 48, "extra-four"], [6, 93, "extra-four"], [6, 138, "extra-four"], [6, 183, "extra-four"], [6, 228, "extra-four"], [6, 273, "extra-four"], [6, 318, "extra-four"], [3, 17, "extra-four"], [3, 62, "extra-four"], [3, 107, "extra-four"], [3, 152, "extra-four"], [3, 197, "extra-four"], [3, 242, "extra-four"], [3, 287, "extra-four"], [3, 332, "extra-four"], [0, 31, "extra-four"], [0, 76, "extra-four"], [0, 121, "extra-four"], [0, 166, "extra-four"], [0, 211, "extra-four"], [0, 256, "extra-four"], [0, 301, "extra-four"], [0, 346, "extra-four"], [5, 8, "extra-four"], [5, 53, "extra-four"], [5, 98, "extra-four"], [5, 143, "extra-four"], [5, 188, "extra-four"], [5, 233, "extra-four"], [5, 278, "extra-four"], [5, 323, "extra-four"], [2, 22, "extra-four"], [2, 67, "extra-four"], [2, 112, "extra-four"], [2, 157, "extra-four"], [2, 202, "extra-four"], [2, 247, "extra-four"], [2, 292, "extra-four"], [2, 337, "extra-four"], [4, 13, "extra-four"], [4, 58, "extra-four"], [4, 103, "extra-four"], [4, 148, "extra-four"], [4, 193, "extra-four"], [4, 238, "extra-four"], [4, 283, "extra-four"], [4, 328, "extra-four"], [1, 27, "extra-four"], [1, 72, "extra-four"], [1, 117, "extra-four"], [1, 162, "extra-four"], [1, 207, "extra-four"], [1, 252, "extra-four"], [1, 297, "extra-four"], [1, 342, "extra-four"], [6, 4, "extra-four"], [6, 49, "extra-four"], [6, 94, "extra-four"], [6, 139, "extra-four"], [6, 184, "extra-four"], [6, 229, "extra-four"], [6, 274, "extra-four"], [6, 319, "extra-four"], [3, 18, "extra-four"], [3, 63, "extra-four"], [3, 108, "extra-four"], [3, 153, "extra-four"], [3, 198, "extra-four"], [3, 243, "extra-four"], [3, 288, "extra-four"], [3, 333, "extra-four"], [0, 32, "extra-four"], [0, 77, "extra-four"], [0, 122, "extra-four"], [0, 167, "extra-four"], [0, 212, "extra-four"], [0, 257, "extra-four"], [0, 302, "extra-four"], [0, 347, "extra-four"], [5, 9, "extra-four"], [5, 54, "extra-four"], [5, 99, "extra-four"], [5, 144, "extra-four"], [5, 189, "extra-four"], [5, 234, "extra-four"], [5, 279, "extra-four"], [5, 324, "extra-four"], [2, 23, "extra-four"], [2, 68, "extra-four"], [2, 113, "extra-four"], [2, 158, "extra-four"], [2, 203, "extra-four"], [2, 248, "extra-four"], [2, 293, "extra-four"], [2, 338, "extra-four"], [7, 0, "extra-four"], [7, 45, "extra-four"], [7, 90, "extra-four"], [7, 135, "extra-four"], [7, 180, "extra-four"], [7, 225, "extra-four"], [7, 270, "extra-four"], [7, 315, "extra-four"], [4, 14, "extra-four"], [4, 59, "extra-four"], [4, 104, "extra-four"], [4, 149, "extra-four"], [4, 194, "extra-four"], [4, 239, "extra-four"], [4, 284, "extra-four"], [4, 329, "extra-four"], [1, 28, "extra"], [1, 73, "extra"], [1, 118, "extra"], [1, 163, "extra"], [1, 208, "extra"], [1, 253, "extra"], [1, 298, "extra"], [1, 343, "extra"], [6, 5, "extra"], [6, 50, "extra"], [6, 95, "extra"], [6, 140, "extra"], [6, 185, "extra"], [6, 230, "extra"], [6, 275, "extra"], [6, 320, "extra"], [3, 19, "extra"], [3, 64, "extra"], [3, 109, "extra"], [3, 154, "extra"], [3, 199, "extra"], [3, 244, "extra"], [3, 289, "extra"], [3, 334, "extra"], [0, 33, "extra"], [0, 78, "extra"], [0, 123, "extra"], [0, 168, "extra"], [0, 213, "extra"], [0, 258, "extra"], [0, 303, "extra"], [0, 348, "extra"], [5, 10, "extra"], [5, 55, "extra"], [5, 100, "extra"], [5, 145, "extra"], [5, 190, "extra"], [5, 235, "extra"], [5, 280, "extra"], [5, 325, "extra"], [2, 24, "extra"], [2, 69, "extra"], [2, 114, "extra"], [2, 159, "extra"], [2, 204, "extra"], [2, 249, "extra"], [2, 294, "extra"], [2, 339, "extra"], [7, 1, "extra"], [7, 46, "extra"], [7, 91, "extra"], [7, 136, "extra"], [7, 181, "extra"], [7, 226, "extra"], [7, 271, "extra"], [7, 316, "extra"], [4, 15, "extra"], [4, 60, "extra"], [4, 105, "extra"], [4, 150, "extra"], [4, 195, "extra"], [4, 240, "extra"], [4, 285, "extra"], [4, 330, "extra"], [1, 29, "extra"], [1, 74, "extra"], [1, 119, "extra"], [1, 164, "extra"], [1, 209, "extra"], [1, 254, "extra"], [1, 299, "extra"], [1, 344, "extra"], [6, 6, "extra"], [6, 51, "extra"], [6, 96, "extra"], [6, 141, "extra"], [6, 186, "extra"], [6, 231, "extra"], [6, 276, "extra"], [6, 321, "extra"], [3, 20, "extra"], [3, 65, "extra"], [3, 110, "extra"], [3, 155, "extra"], [3, 200, "extra"], [3, 245, "extra"], [3, 290, "extra"], [3, 335, "extra"], [0, 34, "extra"], [0, 79, "extra"], [0, 124, "extra"], [0, 169, "extra"], [0, 214, "extra"], [0, 259, "extra"], [0, 304, "extra"], [0, 349, "extra"], [5, 11, "extra"], [5, 56, "extra"], [5, 101, "extra"], [5, 146, "extra"], [5, 191, "extra"], [5, 236, "extra"], [5, 281, "extra"], [5, 326, "extra"], [2, 25, "extra"], [2, 70, "extra"], [2, 115, "extra"], [2, 160, "extra"], [2, 205, "extra"], [2, 250, "extra"], [2, 295, "extra"], [2, 340, "extra"], [7, 2, "extra"], [7, 47, "extra"], [7, 92, "extra"], [7, 137, "extra"], [7, 182, "extra"], [7, 227, "extra"], [7, 272, "extra"], [7, 317, "extra"], [4, 16, "extra"], [4, 61, "extra"], [4, 106, "extra"], [4, 151, "extra"], [4, 196, "extra"], [4, 241, "extra"], [4, 286, "extra"], [4, 331, "extra"], [1, 30, "extra"], [1, 75, "extra"], [1, 120, "extra"], [1, 165, "extra"], [1, 210, "extra"], [1, 255, "extra"], [1, 300, "extra"], [1, 345, "extra"], [6, 7, "extra"], [6, 52, "extra"], [6, 97, "extra"], [6, 142, "extra"], [6, 187, "extra"], [6, 232, "extra"], [6, 277, "extra"], [6, 322, "extra"], [3, 21, "extra"], [3, 66, "extra"], [3, 111, "extra"], [3, 156, "extra"], [3, 201, "extra"], [3, 246, "extra"], [3, 291, "extra"], [3, 336, "extra"], [0, 35, "extra"], [0, 80, "extra"], [0, 125, "extra"], [0, 170, "extra"], [0, 215, "extra"], [0, 260, "extra"], [0, 305, "extra"], [0, 350, "extra"], [5, 12, "extra"], [5, 57, "extra"], [5, 102, "extra"], [5, 147, "extra"], [5, 192, "extra"], [5, 237, "extra"], [5, 282, "extra"], [5, 327, "extra"], [2, 26, "extra"], [2, 71, "extra"], [2, 116, "extra"], [2, 161, "extra"], [2, 206, "extra"], [2, 251, "extra"], [2, 296, "extra"], [2, 341, "extra"], [7, 3, "extra"], [7, 48, "extra"], [7, 93, "extra"], [7, 138, "extra"], [7, 183, "extra"], [7, 228, "extra"], [7, 273, "extra"], [7, 318, "extra"], [4, 17, "extra"], [4, 62, "extra"], [4, 107, "extra"], [4, 152, "extra"], [4, 197, "extra"], [4, 242, "extra"], [4, 287, "extra"], [4, 332, "extra"], [1, 31, "extra"], [1, 76, "extra"], [1, 121, "extra"], [1, 166, "extra"], [1, 211, "extra"], [1, 256, "extra"], [1, 301, "extra"], [1, 346, "extra"], [6, 8, "extra"], [6, 53, "extra"], [6, 98, "extra"], [6, 143, "extra"], [6, 188, "extra"], [6, 233, "extra"], [6, 278, "extra"], [6, 323, "extra"], [3, 22, "extra"], [3, 67, "extra"], [3, 112, "extra"], [3, 157, "extra"], [3, 202, "extra"], [3, 247, "extra"], [3, 292, "extra"], [3, 337, "extra"], [0, 36, "extra"], [0, 81, "extra"], [0, 126, "extra"], [0, 171, "extra"], [0, 216, "extra"], [0, 261, "extra"], [0, 306, "extra"], [0, 351, "extra"], [5, 13, "extra"], [5, 58, "extra"], [5, 103, "extra"], [5, 148, "extra"], [5, 193, "extra"], [5, 238, "extra"], [5, 283, "extra"], [5, 328, "extra"], [2, 27, "extra"], [2, 72, "extra"], [2, 117, "extra"], [2, 162, "extra"], [2, 207, "extra"], [2, 252, "extra"], [2, 297, "extra"], [2, 342, "extra"], [7, 4, "extra"], [7, 49, "extra"], [7, 94, "extra"], [7, 139, "extra"], [7, 184, "extra"], [7, 229, "extra"], [7, 274, "extra"], [7, 319, "extra"], [4, 18, "extra"], [4, 63, "extra"], [4, 108, "extra"], [4, 153, "extra"], [4, 198, "extra"], [4, 243, "extra"], [4, 288, "extra"], [4, 333, "extra"], [1, 32, "extra"], [1, 77, "extra"], [1, 122, "extra"], [1, 167, "extra"], [1, 212, "extra"], [1, 257, "extra"], [1, 302, "extra"], [1, 347, "extra"], [6, 9, "extra"], [6, 54, "extra"], [6, 99, "extra"], [6, 144, "extra"], [6, 189, "extra"], [6, 234, "extra"], [6, 279, "extra"], [6, 324, "extra"], [3, 23, "extra"], [3, 68, "extra"], [3, 113, "extra"], [3, 158, "extra"], [3, 203, "extra"], [3, 248, "extra"], [3, 293, "extra"], [3, 338, "extra"], [8, 0, "extra"], [8, 45, "extra"], [8, 90, "extra"], [8, 135, "extra"], [8, 180, "extra"], [8, 225, "extra"], [8, 270, "extra"], [8, 315, "extra"], [5, 14, "extra"], [5, 59, "extra"], [5, 104, "extra"], [5, 149, "extra"], [5, 194, "extra"], [5, 239, "extra"], [5, 284, "extra"], [5, 329, "extra"], [2, 28, "extra"], [2, 73, "extra"], [2, 118, "extra"], [2, 163, "extra"], [2, 208, "extra"], [2, 253, "extra"], [2, 298, "extra"], [2, 343, "extra"], [7, 5, "extra"], [7, 50, "extra"], [7, 95, "extra"], [7, 140, "extra"], [7, 185, "extra"], [7, 230, "extra"], [7, 275, "extra"], [7, 320, "extra"], [4, 19, "extra"], [4, 64, "extra"], [4, 109, "extra"], [4, 154, "extra"], [4, 199, "extra"], [4, 244, "extra"], [4, 289, "extra"], [4, 334, "extra"], [1, 33, "extra"], [1, 78, "extra"], [1, 123, "extra"], [1, 168, "extra"], [1, 213, "extra"], [1, 258, "extra"], [1, 303, "extra"], [1, 348, "extra"], [6, 10, "extra"], [6, 55, "extra"], [6, 100, "extra"], [6, 145, "extra"], [6, 190, "extra"], [6, 235, "extra"], [6, 280, "extra"], [6, 325, "extra"], [3, 24, "extra"], [3, 69, "extra"], [3, 114, "extra"], [3, 159, "extra"], [3, 204, "extra"], [3, 249, "extra"], [3, 294, "extra"], [3, 339, "extra"], [8, 1, "extra"], [8, 46, "extra"], [8, 91, "extra"], [8, 136, "extra"], [8, 181, "extra"], [8, 226, "extra"], [8, 271, "extra"], [8, 316, "extra"], [5, 15, "extra"], [5, 60, "extra"], [5, 105, "extra"], [5, 150, "extra"], [5, 195, "extra"], [5, 240, "extra"], [5, 285, "extra"], [5, 330, "extra"], [2, 29, "extra"], [2, 74, "extra"], [2, 119, "extra"], [2, 164, "extra"], [2, 209, "extra"], [2, 254, "extra"], [2, 299, "extra"], [2, 344, "extra"], [7, 6, "extra"], [7, 51, "extra"], [7, 96, "extra"], [7, 141, "extra"], [7, 186, "extra"], [7, 231, "extra"], [7, 276, "extra"], [7, 321, "extra"], [4, 20, "extra"], [4, 65, "extra"], [4, 110, "extra"], [4, 155, "extra"], [4, 200, "extra"], [4, 245, "extra"], [4, 290, "extra"], [4, 335, "extra"], [1, 34, "extra"], [1, 79, "extra"], [1, 124, "extra"], [1, 169, "extra"], [1, 214, "extra"], [1, 259, "extra"], [1, 304, "extra"], [1, 349, "extra"], [6, 11, "extra"], [6, 56, "extra"], [6, 101, "extra"], [6, 146, "extra"], [6, 191, "extra"], [6, 236, "extra"], [6, 281, "extra"], [6, 326, "extra"], [3, 25, "extra"], [3, 70, "extra"], [3, 115, "extra"], [3, 160, "extra"], [3, 205, "extra"], [3, 250, "extra"], [3, 295, "extra"], [3, 340, "extra"], [8, 2, "extra"], [8, 47, "extra"], [8, 92, "extra"], [8, 137, "extra"], [8, 182, "extra"], [8, 227, "extra"], [8, 272, "extra"], [8, 317, "extra"], [5, 16, "extra"], [5, 61, "extra"], [5, 106, "extra"], [5, 151, "extra"], [5, 196, "extra"], [5, 241, "extra"], [5, 286, "extra"], [5, 331, "extra"], [2, 30, "extra"], [2, 75, "extra"], [2, 120, "extra"], [2, 165, "extra"], [2, 210, "extra"], [2, 255, "extra"], [2, 300, "extra"], [2, 345, "extra"], [7, 7, "extra"], [7, 52, "extra"], [7, 97, "extra"], [7, 142, "extra"], [7, 187, "extra"], [7, 232, "extra"], [7, 277, "extra"], [7, 322, "extra"], [4, 21, "extra"], [4, 66, "extra"], [4, 111, "extra"], [4, 156, "extra"], [4, 201, "extra"], [4, 246, "extra"], [4, 291, "extra"], [4, 336, "extra"], [1, 35, "extra"], [1, 80, "extra"], [1, 125, "extra"], [1, 170, "extra"], [1, 215, "extra"], [1, 260, "extra"], [1, 305, "extra"], [1, 350, "extra"], [6, 12, "extra"], [6, 57, "extra"], [6, 102, "extra"], [6, 147, "extra"], [6, 192, "extra"], [6, 237, "extra"], [6, 282, "extra"], [6, 327, "extra"], [3, 26, "extra"], [3, 71, "extra"], [3, 116, "extra"], [3, 161, "extra"], [3, 206, "extra"], [3, 251, "extra"], [3, 296, "extra"], [3, 341, "extra"], [8, 3, "extra"], [8, 48, "extra"], [8, 93, "extra"], [8, 138, "extra"], [8, 183, "extra"], [8, 228, "extra"], [8, 273, "extra"], [8, 318, "extra"], [5, 17, "extra"], [5, 62, "extra"], [5, 107, "extra"], [5, 152, "extra"], [5, 197, "extra"], [5, 242, "extra"], [5, 287, "extra"], [5, 332, "extra"], [2, 31, "extra"], [2, 76, "extra"], [2, 121, "extra"], [2, 166, "extra"], [2, 211, "extra"], [2, 256, "extra"], [2, 301, "extra"], [2, 346, "extra"], [7, 8, "extra"], [7, 53, "extra"], [7, 98, "extra"], [7, 143, "extra"], [7, 188, "extra"], [7, 233, "extra"], [7, 278, "extra"], [7, 323, "extra"], [4, 22, "extra"], [4, 67, "extra"], [4, 112, "extra"], [4, 157, "extra"], [4, 202, "extra"], [4, 247, "extra"], [4, 292, "extra"], [4, 337, "extra"], [1, 36, "extra"], [1, 81, "extra"], [1, 126, "extra"], [1, 171, "extra"], [1, 216, "extra"], [1, 261, "extra"], [1, 306, "extra"], [1, 351, "extra"], [6, 13, "extra"], [6, 58, "extra"], [6, 103, "extra"], [6, 148, "extra"], [6, 193, "extra"], [6, 238, "extra"], [6, 283, "extra"], [6, 328, "extra"], [3, 27, "extra"], [3, 72, "extra"], [3, 117, "extra"], [3, 162, "extra"], [3, 207, "extra"], [3, 252, "extra"], [3, 297, "extra"], [3, 342, "extra"], [8, 4, "extra"], [8, 49, "extra"], [8, 94, "extra"], [8, 139, "extra"], [8, 184, "extra"], [8, 229, "extra"], [8, 274, "extra"], [8, 319, "extra"], [5, 18, "extra"], [5, 63, "extra"], [5, 108, "extra"], [5, 153, "extra"], [5, 198, "extra"], [5, 243, "extra"], [5, 288, "extra"], [5, 333, "extra"], [2, 32, "extra"], [2, 77, "extra"], [2, 122, "extra"], [2, 167, "extra"], [2, 212, "extra"], [2, 257, "extra"], [2, 302, "extra"], [2, 347, "extra"], [7, 9, "extra"], [7, 54, "extra"], [7, 99, "extra"], [7, 144, "extra"], [7, 189, "extra"], [7, 234, "extra"], [7, 279, "extra"], [7, 324, "extra"], [4, 23, "extra"], [4, 68, "extra"], [4, 113, "extra"], [4, 158, "extra"], [4, 203, "extra"], [4, 248, "extra"], [4, 293, "extra"], [4, 338, "extra"], [6, 14, "extra"], [6, 59, "extra"], [6, 104, "extra"], [6, 149, "extra"], [6, 194, "extra"], [6, 239, "extra"], [6, 284, "extra"], [6, 329, "extra"], [3, 28, "gauge44"], [3, 73, "gauge44"], [3, 118, "gauge44"], [3, 163, "gauge44"], [3, 208, "gauge44"], [3, 253, "gauge44"], [3, 298, "gauge44"], [3, 343, "gauge44"], [8, 5, "gauge44"], [8, 50, "gauge44"], [8, 95, "gauge44"], [8, 140, "gauge44"], [8, 185, "gauge44"], [8, 230, "gauge44"], [8, 275, "gauge44"], [8, 320, "gauge44"], [5, 19, "gauge44"], [5, 64, "gauge44"], [5, 109, "gauge44"], [5, 154, "gauge44"], [5, 199, "gauge44"], [5, 244, "gauge44"], [5, 289, "gauge44"], [5, 334, "gauge44"], [2, 33, "gauge44"], [2, 78, "gauge44"], [2, 123, "gauge44"], [2, 168, "gauge44"], [2, 213, "gauge44"], [2, 258, "gauge44"], [2, 303, "gauge44"], [2, 348, "gauge44"], [7, 10, "gauge44"], [7, 55, "gauge44"], [7, 100, "gauge44"], [7, 145, "gauge44"], [7, 190, "gauge44"], [7, 235, "gauge44"], [7, 280, "gauge44"], [7, 325, "gauge44"], [4, 24, "gauge44"], [4, 69, "gauge44"], [4, 114, "gauge44"], [4, 159, "gauge44"], [4, 204, "gauge44"], [4, 249, "gauge44"], [4, 294, "gauge44"], [4, 339, "gauge44"], [6, 15, "gauge44"], [6, 60, "gauge44"], [6, 105, "gauge44"], [6, 150, "gauge44"], [6, 195, "gauge44"], [6, 240, "gauge44"], [6, 285, "gauge44"], [6, 330, "gauge44"], [3, 29, "gauge44"], [3, 74, "gauge44"], [3, 119, "gauge44"], [3, 164, "gauge44"], [3, 209, "gauge44"], [3, 254, "gauge44"], [3, 299, "gauge44"], [3, 344, "gauge44"], [8, 6, "gauge44"], [8, 51, "gauge44"], [8, 96, "gauge44"], [8, 141, "gauge44"], [8, 186, "gauge44"], [8, 231, "gauge44"], [8, 276, "gauge44"], [8, 321, "gauge44"], [5, 20, "gauge44"], [5, 65, "gauge44"], [5, 110, "gauge44"], [5, 155, "gauge44"], [5, 200, "gauge44"], [5, 245, "gauge44"], [5, 290, "gauge44"], [5, 335, "gauge44"], [2, 34, "gauge44"], [2, 79, "gauge44"], [2, 124, "gauge44"], [2, 169, "gauge44"], [2, 214, "gauge44"], [2, 259, "gauge44"], [2, 304, "gauge44"], [2, 349, "gauge44"], [7, 11, "gauge44"], [7, 56, "gauge44"], [7, 101, "gauge44"], [7, 146, "gauge44"], [7, 191, "gauge44"], [7, 236, "gauge44"], [7, 281, "gauge44"], [7, 326, "gauge44"], [4, 25, "gauge44"], [4, 70, "gauge44"], [4, 115, "gauge44"], [4, 160, "gauge44"], [4, 205, "gauge44"], [4, 250, "gauge44"], [4, 295, "gauge44"], [4, 340, "gauge44"], [6, 16, "gauge44"], [6, 61, "gauge44"], [6, 106, "gauge44"], [6, 151, "gauge44"], [6, 196, "gauge44"], [6, 241, "gauge44"], [6, 286, "gauge44"], [6, 331, "gauge44"], [3, 30, "gauge44"], [3, 75, "gauge44"], [3, 120, "gauge44"], [3, 165, "gauge44"], [3, 210, "gauge44"], [3, 255, "gauge44"], [3, 300, "gauge44"], [3, 345, "gauge44"], [8, 7, "gauge44"], [8, 52, "gauge44"], [8, 97, "gauge44"], [8, 142, "gauge44"], [8, 187, "gauge44"], [8, 232, "gauge44"], [8, 277, "gauge44"], [8, 322, "gauge44"], [5, 21, "gauge44"], [5, 66, "gauge44"], [5, 111, "gauge44"], [5, 156, "gauge44"], [5, 201, "gauge44"], [5, 246, "gauge44"], [5, 291, "gauge44"], [5, 336, "gauge44"], [2, 35, "gauge44"], [2, 80, "gauge44"], [2, 125, "gauge44"], [2, 170, "gauge44"], [2, 215, "gauge44"], [2, 260, "gauge44"], [2, 305, "gauge44"], [2, 350, "gauge44"], [7, 12, "gauge44"], [7, 57, "gauge44"], [7, 102, "gauge44"], [7, 147, "gauge44"], [7, 192, "gauge44"], [7, 237, "gauge44"], [7, 282, "gauge44"], [7, 327, "gauge44"], [4, 26, "gauge44"], [4, 71, "gauge44"], [4, 116, "gauge44"], [4, 161, "gauge44"], [4, 206, "gauge44"], [4, 251, "gauge44"], [4, 296, "gauge44"], [4, 341, "gauge44"], [6, 17, "gauge44"], [6, 62, "gauge44"], [6, 107, "gauge44"], [6, 152, "gauge44"], [6, 197, "gauge44"], [6, 242, "gauge44"], [6, 287, "gauge44"], [6, 332, "gauge44"], [3, 31, "gauge44"], [3, 76, "gauge44"], [3, 121, "gauge44"], [3, 166, "gauge44"], [3, 211, "gauge44"], [3, 256, "gauge44"], [3, 301, "gauge44"], [3, 346, "gauge44"], [8, 8, "gauge44"], [8, 53, "gauge44"], [8, 98, "gauge44"], [8, 143, "gauge44"], [8, 188, "gauge44"], [8, 233, "gauge44"], [8, 278, "gauge44"], [8, 323, "gauge44"], [5, 22, "gauge44"], [5, 67, "gauge44"], [5, 112, "gauge44"], [5, 157, "gauge44"], [5, 202, "gauge44"], [5, 247, "gauge44"], [5, 292, "gauge44"], [5, 337, "gauge44"], [2, 36, "gauge44"], [2, 81, "gauge44"], [2, 126, "gauge44"], [2, 171, "gauge44"], [2, 216, "gauge44"], [2, 261, "gauge44"], [2, 306, "gauge44"], [2, 351, "gauge44"], [7, 13, "gauge44"], [7, 58, "gauge44"], [7, 103, "gauge44"], [7, 148, "gauge44"], [7, 193, "gauge44"], [7, 238, "gauge44"], [7, 283, "gauge44"], [7, 328, "gauge44"], [4, 27, "gauge44"], [4, 72, "gauge44"], [4, 117, "gauge44"], [4, 162, "gauge44"], [4, 207, "gauge44"], [4, 252, "gauge44"], [4, 297, "gauge44"], [4, 342, "gauge44"], [6, 18, "gauge44"], [6, 63, "gauge44"], [6, 108, "gauge44"], [6, 153, "gauge44"], [6, 198, "gauge44"], [6, 243, "gauge44"], [6, 288, "gauge44"], [6, 333, "gauge44"], [3, 32, "gauge44"], [3, 77, "gauge44"], [3, 122, "gauge44"], [3, 167, "gauge44"], [3, 212, "gauge44"], [3, 257, "gauge44"], [3, 302, "gauge44"], [3, 347, "gauge44"], [8, 9, "gauge44"], [8, 54, "gauge44"], [8, 99, "gauge44"], [8, 144, "gauge44"], [8, 189, "gauge44"], [8, 234, "gauge44"], [8, 279, "gauge44"], [8, 324, "gauge44"], [5, 23, "gauge44"], [5, 68, "gauge44"], [5, 113, "gauge44"], [5, 158, "gauge44"], [5, 203, "gauge44"], [5, 248, "gauge44"], [5, 293, "gauge44"], [5, 338, "gauge44"], [7, 14, "gauge44"], [7, 59, "gauge44"], [7, 104, "gauge44"], [7, 149, "gauge44"], [7, 194, "gauge44"], [7, 239, "gauge44"], [7, 284, "gauge44"], [7, 329, "gauge44"], [4, 28, "gauge44"], [4, 73, "gauge44"], [4, 118, "gauge44"], [4, 163, "gauge44"], [4, 208, "gauge44"], [4, 253, "gauge44"], [4, 298, "gauge44"], [4, 343, "gauge44"], [6, 19, "gauge44"], [6, 64, "gauge44"], [6, 109, "gauge44"], [6, 154, "gauge44"], [6, 199, "gauge44"], [6, 244, "gauge44"], [6, 289, "gauge44"], [6, 334, "gauge44"], [3, 33, "gauge44"], [3, 78, "gauge44"], [3, 123, "gauge44"], [3, 168, "gauge44"], [3, 213, "gauge44"], [3, 258, "gauge44"], [3, 303, "gauge44"], [3, 348, "gauge44"], [8, 10, "gauge44"], [8, 55, "gauge44"], [8, 100, "gauge44"], [8, 145, "gauge44"], [8, 190, "gauge44"], [8, 235, "gauge44"], [8, 280, "gauge44"], [8, 325, "gauge44"], [5, 24, "gauge44"], [5, 69, "gauge44"], [5, 114, "gauge44"], [5, 159, "gauge44"], [5, 204, "gauge44"], [5, 249, "gauge44"], [5, 294, "gauge44"], [5, 339, "gauge44"], [7, 15, "gauge44"], [7, 60, "gauge44"], [7, 105, "gauge44"], [7, 150, "gauge44"], [7, 195, "gauge44"], [7, 240, "gauge44"], [7, 285, "gauge44"], [7, 330, "gauge44"], [4, 29, "gauge44"], [4, 74, "gauge44"], [4, 119, "gauge44"], [4, 164, "gauge44"], [4, 209, "gauge44"], [4, 254, "gauge44"], [4, 299, "gauge44"], [4, 344, "gauge44"], [6, 20, "gauge44"], [6, 65, "gauge44"], [6, 110, "gauge44"], [6, 155, "gauge44"], [6, 200, "gauge44"], [6, 245, "gauge44"], [6, 290, "gauge44"], [6, 335, "gauge44"], [3, 34, "gauge44"], [3, 79, "gauge44"], [3, 124, "gauge44"], [3, 169, "gauge44"], [3, 214, "gauge44"], [3, 259, "gauge44"], [3, 304, "gauge44"], [3, 349, "gauge44"], [8, 11, "gauge44"], [8, 56, "gauge44"], [8, 101, "gauge44"], [8, 146, "gauge44"], [8, 191, "gauge44"], [8, 236, "gauge44"], [8, 281, "gauge44"], [8, 326, "gauge44"], [5, 25, "gauge44"], [5, 70, "gauge44"], [5, 115, "gauge44"], [5, 160, "gauge44"], [5, 205, "gauge44"], [5, 250, "gauge44"], [5, 295, "gauge44"], [5, 340, "gauge44"], [7, 16, "gauge44"], [7, 61, "gauge44"], [7, 106, "gauge44"], [7, 151, "gauge44"], [7, 196, "gauge44"], [7, 241, "gauge44"], [7, 286, "gauge44"], [7, 331, "gauge44"], [4, 30, "gauge44"], [4, 75, "gauge44"], [4, 120, "gauge44"], [4, 165, "gauge44"], [4, 210, "gauge44"], [4, 255, "gauge44"], [4, 300, "gauge44"], [4, 345, "gauge44"], [6, 21, "gauge44"], [6, 66, "gauge44"], [6, 111, "gauge44"], [6, 156, "gauge44"], [6, 201, "gauge44"], [6, 246, "gauge44"], [6, 291, "gauge44"], [6, 336, "gauge44"], [3, 35, "gauge44"], [3, 80, "gauge44"], [3, 125, "gauge44"], [3, 170, "gauge44"], [3, 215, "gauge44"], [3, 260, "gauge44"], [3, 305, "gauge44"], [3, 350, "gauge44"], [8, 12, "gauge44"], [8, 57, "gauge44"], [8, 102, "gauge44"], [8, 147, "gauge44"], [8, 192, "gauge44"], [8, 237, "gauge44"], [8, 282, "gauge44"], [8, 327, "gauge44"], [5, 26, "gauge44"], [5, 71, "gauge44"], [5, 116, "gauge44"], [5, 161, "gauge44"], [5, 206, "gauge44"], [5, 251, "gauge44"], [5, 296, "gauge44"], [5, 341, "gauge44"], [7, 17, "gauge44"], [7, 62, "gauge44"], [7, 107, "gauge44"], [7, 152, "gauge44"], [7, 197, "gauge44"], [7, 242, "gauge44"], [7, 287, "gauge44"], [7, 332, "gauge44"], [4, 31, "gauge44"], [4, 76, "gauge44"], [4, 121, "gauge44"], [4, 166, "gauge44"], [4, 211, "gauge44"], [4, 256, "gauge44"], [4, 301, "gauge44"], [4, 346, "gauge44"], [6, 22, "gauge44"], [6, 67, "gauge44"], [6, 112, "gauge44"], [6, 157, "gauge44"], [6, 202, "gauge44"], [6, 247, "gauge44"], [6, 292, "gauge44"], [6, 337, "gauge44"], [3, 36, "gauge44"], [3, 81, "gauge44"], [3, 126, "gauge44"], [3, 171, "gauge44"], [3, 216, "gauge44"], [3, 261, "gauge44"], [3, 306, "gauge44"], [3, 351, "gauge44"], [8, 13, "gauge44"], [8, 58, "gauge44"], [8, 103, "gauge44"], [8, 148, "gauge44"], [8, 193, "gauge44"], [8, 238, "gauge44"], [8, 283, "gauge44"], [8, 328, "gauge44"], [5, 27, "gauge44"], [5, 72, "gauge44"], [5, 117, "gauge44"], [5, 162, "gauge44"], [5, 207, "gauge44"], [5, 252, "gauge44"], [5, 297, "gauge44"], [5, 342, "gauge44"], [7, 18, "gauge44"], [7, 63, "gauge44"], [7, 108, "gauge44"], [7, 153, "gauge44"], [7, 198, "gauge44"], [7, 243, "gauge44"], [7, 288, "gauge44"], [7, 333, "gauge44"], [4, 32, "gauge44"], [4, 77, "gauge44"], [4, 122, "gauge44"], [4, 167, "gauge44"], [4, 212, "gauge44"], [4, 257, "gauge44"], [4, 302, "gauge44"], [4, 347, "gauge44"], [6, 23, "gauge44"], [6, 68, "gauge44"], [6, 113, "gauge44"], [6, 158, "gauge44"], [6, 203, "gauge44"], [6, 248, "gauge44"], [6, 293, "gauge44"], [6, 338, "gauge44"], [8, 14, "gauge44"], [8, 59, "gauge44"], [8, 104, "gauge44"], [8, 149, "gauge44"], [8, 194, "gauge44"], [8, 239, "gauge44"], [8, 284, "gauge44"], [8, 329, "gauge44"], [5, 28, "gauge44"], [5, 73, "gauge44"], [5, 118, "gauge44"], [5, 163, "gauge44"], [5, 208, "gauge44"], [5, 253, "gauge44"], [5, 298, "gauge44"], [5, 343, "gauge44"], [7, 19, "gauge44"], [7, 64, "gauge44"], [7, 109, "gauge44"], [7, 154, "gauge44"], [7, 199, "gauge44"], [7, 244, "gauge44"], [7, 289, "gauge44"], [7, 334, "gauge44"], [4, 33, "gauge44"], [4, 78, "gauge44"], [4, 123, "gauge44"], [4, 168, "gauge44"], [4, 213, "gauge44"], [4, 258, "gauge44"], [4, 303, "gauge44"], [4, 348, "gauge44"], [6, 24, "gauge44"], [6, 69, "gauge44"], [6, 114, "gauge44"], [6, 159, "gauge44"], [6, 204, "gauge44"], [6, 249, "gauge44"], [6, 294, "gauge44"], [6, 339, "gauge44"], [8, 15, "gauge44"], [8, 60, "gauge44"], [8, 105, "gauge44"], [8, 150, "gauge44"], [8, 195, "gauge44"], [8, 240, "gauge44"], [8, 285, "gauge44"], [8, 330, "gauge44"], [5, 29, "gauge44"], [5, 74, "gauge44"], [5, 119, "gauge44"], [5, 164, "gauge44"], [5, 209, "gauge44"], [5, 254, "gauge44"], [5, 299, "gauge44"], [5, 344, "gauge44"], [7, 20, "gauge44"], [7, 65, "gauge44"], [7, 110, "gauge44"], [7, 155, "gauge44"], [7, 200, "gauge44"], [7, 245, "gauge44"], [7, 290, "gauge44"], [7, 335, "gauge44"], [4, 34, "gauge44"], [4, 79, "gauge44"], [4, 124, "gauge44"], [4, 169, "gauge44"], [4, 214, "gauge44"], [4, 259, "gauge44"], [4, 304, "gauge44"], [4, 349, "gauge44"], [6, 25, "gauge44"], [6, 70, "gauge44"], [6, 115, "gauge44"], [6, 160, "gauge44"], [6, 205, "gauge44"], [6, 250, "gauge44"], [6, 295, "gauge44"], [6, 340, "gauge44"], [8, 16, "gauge44"], [8, 61, "gauge44"], [8, 106, "gauge44"], [8, 151, "gauge44"], [8, 196, "gauge44"], [8, 241, "gauge44"], [8, 286, "gauge44"], [8, 331, "gauge44"], [5, 30, "gauge44"], [5, 75, "gauge44"], [5, 120, "gauge44"], [5, 165, "gauge44"], [5, 210, "gauge44"], [5, 255, "gauge44"], [5, 300, "gauge44"], [5, 345, "gauge44"], [7, 21, "gauge44"], [7, 66, "gauge44"], [7, 111, "gauge44"], [7, 156, "gauge44"], [7, 201, "gauge44"], [7, 246, "gauge44"], [7, 291, "gauge44"], [7, 336, "gauge44"], [4, 35, "gauge44"], [4, 80, "gauge44"], [4, 125, "gauge44"], [4, 170, "gauge44"], [4, 215, "gauge44"], [4, 260, "gauge44"], [4, 305, "gauge44"], [4, 350, "gauge44"], [6, 26, "gauge44"], [6, 71, "gauge44"], [6, 116, "gauge44"], [6, 161, "gauge44"], [6, 206, "gauge44"], [6, 251, "gauge44"], [6, 296, "gauge44"], [6, 341, "gauge44"], [8, 17, "gauge44"], [8, 62, "gauge44"], [8, 107, "gauge44"], [8, 152, "gauge44"], [8, 197, "gauge44"], [8, 242, "gauge44"], [8, 287, "gauge44"], [8, 332, "gauge44"], [5, 31, "gauge44"], [5, 76, "gauge44"], [5, 121, "gauge44"], [5, 166, "gauge44"], [5, 211, "gauge44"], [5, 256, "gauge44"], [5, 301, "gauge44"], [5, 346, "gauge44"], [7, 22, "gauge44"], [7, 67, "gauge44"], [7, 112, "gauge44"], [7, 157, "gauge44"], [7, 202, "gauge44"], [7, 247, "gauge44"], [7, 292, "gauge44"], [7, 337, "gauge44"], [4, 36, "gauge44"], [4, 81, "gauge44"], [4, 126, "gauge44"], [4, 171, "gauge44"], [4, 216, "gauge44"], [4, 261, "gauge44"], [4, 306, "gauge44"], [4, 351, "gauge44"], [6, 27, "gauge44"], [6, 72, "gauge44"], [6, 117, "gauge44"], [6, 162, "gauge44"], [6, 207, "gauge44"], [6, 252, "gauge44"], [6, 297, "gauge44"], [6, 342, "gauge44"], [8, 18, "gauge44"], [8, 63, "gauge44"], [8, 108, "gauge44"], [8, 153, "gauge44"], [8, 198, "gauge44"], [8, 243, "gauge44"], [8, 288, "gauge44"], [8, 333, "gauge44"], [5, 32, "gauge44"], [5, 77, "gauge44"], [5, 122, "gauge44"], [5, 167, "gauge44"], [5, 212, "gauge44"], [5, 257, "gauge44"], [5, 302, "gauge44"], [5, 347, "gauge44"], [7, 23, "gauge44"], [7, 68, "gauge44"], [7, 113, "gauge44"], [7, 158, "gauge44"], [7, 203, "gauge44"], [7, 248, "gauge44"], [7, 293, "gauge44"], [7, 338, "gauge44"], [6, 28, "gauge44"], [6, 73, "gauge44"], [6, 118, "gauge44"], [6, 163, "gauge44"], [6, 208, "gauge44"], [6, 253, "gauge44"], [6, 298, "gauge44"], [6, 343, "gauge44"], [8, 19, "gauge44"], [8, 64, "gauge44"], [8, 109, "gauge44"], [8, 154, "gauge44"], [8, 199, "gauge44"], [8, 244, "gauge44"], [8, 289, "gauge44"], [8, 334, "gauge44"], [5, 33, "gauge44"], [5, 78, "gauge44"], [5, 123, "gauge44"], [5, 168, "gauge44"], [5, 213, "gauge44"], [5, 258, "gauge44"], [5, 303, "gauge44"], [5, 348, "gauge44"], [7, 24, "gauge44"], [7, 69, "gauge44"], [7, 114, "gauge44"], [7, 159, "gauge44"], [7, 204, "gauge44"], [7, 249, "gauge44"], [7, 294, "gauge44"], [7, 339, "gauge44"], [6, 29, "gauge44"], [6, 74, "gauge44"], [6, 119, "gauge44"], [6, 164, "gauge44"], [6, 209, "gauge44"], [6, 254, "gauge44"], [6, 299, "gauge44"], [6, 344, "gauge44"], [8, 20, "gauge44"], [8, 65, "gauge44"], [8, 110, "gauge44"], [8, 155, "gauge44"], [8, 200, "gauge44"], [8, 245, "gauge44"], [8, 290, "gauge44"], [8, 335, "gauge44"], [5, 34, "gauge44"], [5, 79, "gauge44"], [5, 124, "gauge44"], [5, 169, "gauge44"], [5, 214, "gauge44"], [5, 259, "gauge44"], [5, 304, "gauge44"], [5, 349, "gauge44"], [7, 25, "gauge44"], [7, 70, "gauge44"], [7, 115, "gauge44"], [7, 160, "gauge44"], [7, 205, "gauge44"], [7, 250, "gauge44"], [7, 295, "gauge44"], [7, 340, "gauge44"], [6, 30, "gauge44"], [6, 75, "gauge44"], [6, 120, "gauge44"], [6, 165, "gauge44"], [6, 210, "gauge44"], [6, 255, "gauge44"], [6, 300, "gauge44"], [6, 345, "gauge44"], [8, 21, "gauge44"], [8, 66, "gauge44"], [8, 111, "gauge44"], [8, 156, "gauge44"], [8, 201, "gauge44"], [8, 246, "gauge44"], [8, 291, "gauge44"], [8, 336, "gauge44"], [5, 35, "gauge44"], [5, 80, "gauge44"], [5, 125, "gauge44"], [5, 170, "gauge44"], [5, 215, "gauge44"], [5, 260, "gauge44"], [5, 305, "gauge44"], [5, 350, "gauge44"], [7, 26, "gauge44"], [7, 71, "gauge44"], [7, 116, "gauge44"], [7, 161, "gauge44"], [7, 206, "gauge44"], [7, 251, "gauge44"], [7, 296, "gauge44"], [7, 341, "gauge44"], [6, 31, "gauge44"], [6, 76, "gauge44"], [6, 121, "gauge44"], [6, 166, "gauge44"], [6, 211, "gauge44"], [6, 256, "gauge44"], [6, 301, "gauge44"], [6, 346, "gauge44"], [8, 22, "gauge44"], [8, 67, "gauge44"], [8, 112, "gauge44"], [8, 157, "gauge44"], [8, 202, "gauge44"], [8, 247, "gauge44"], [8, 292, "gauge44"], [8, 337, "gauge44"], [5, 36, "gauge44"], [5, 81, "gauge44"], [5, 126, "gauge44"], [5, 171, "gauge44"], [5, 216, "gauge44"], [5, 261, "gauge44"], [5, 306, "gauge44"], [5, 351, "gauge44"], [7, 27, "gauge44"], [7, 72, "gauge44"], [7, 117, "gauge44"], [7, 162, "gauge44"], [7, 207, "gauge44"], [7, 252, "gauge44"], [7, 297, "gauge44"], [7, 342, "gauge44"], [6, 32, "gauge44"], [6, 77, "gauge44"], [6, 122, "gauge44"], [6, 167, "gauge44"], [6, 212, "gauge44"], [6, 257, "gauge44"], [6, 302, "gauge44"], [6, 347, "gauge44"], [8, 23, "gauge44"], [8, 68, "gauge44"], [8, 113, "gauge44"], [8, 158, "gauge44"], [8, 203, "gauge44"], [8, 248, "gauge44"], [8, 293, "gauge44"], [8, 338, "gauge44"], [7, 28, "gauge44"], [7, 73, "gauge44"], [7, 118, "gauge44"], [7, 163, "gauge44"], [7, 208, "gauge44"], [7, 253, "gauge44"], [7, 298, "gauge44"], [7, 343, "gauge44"], [6, 33, "gauge44"], [6, 78, "gauge44"], [6, 123, "gauge44"], [6, 168, "gauge44"], [6, 213, "gauge44"], [6, 258, "gauge44"], [6, 303, "gauge44"], [6, 348, "gauge44"], [8, 24, "gauge44"], [8, 69, "gauge44"], [8, 114, "gauge44"], [8, 159, "gauge44"], [8, 204, "gauge44"], [8, 249, "gauge44"], [8, 294, "gauge44"], [8, 339, "gauge44"], [7, 29, "gauge44"], [7, 74, "gauge44"], [7, 119, "gauge44"], [7, 164, "gauge44"], [7, 209, "gauge44"], [7, 254, "gauge44"], [7, 299, "gauge44"], [7, 344, "gauge44"], [6, 34, "gauge44"], [6, 79, "gauge44"], [6, 124, "gauge44"], [6, 169, "gauge44"], [6, 214, "gauge44"], [6, 259, "gauge44"], [6, 304, "gauge44"], [6, 349, "gauge44"], [8, 25, "gauge44"], [8, 70, "gauge44"], [8, 115, "gauge44"], [8, 160, "gauge44"], [8, 205, "gauge44"], [8, 250, "gauge44"], [8, 295, "gauge44"], [8, 340, "gauge44"], [7, 30, "gauge44"], [7, 75, "gauge44"], [7, 120, "gauge44"], [7, 165, "gauge44"], [7, 210, "gauge44"], [7, 255, "gauge44"], [7, 300, "gauge44"], [7, 345, "gauge44"], [6, 35, "gauge44"], [6, 80, "gauge44"], [6, 125, "gauge44"], [6, 170, "gauge44"], [6, 215, "gauge44"], [6, 260, "gauge44"], [6, 305, "gauge44"], [6, 350, "gauge44"], [8, 26, "gauge44"], [8, 71, "gauge44"], [8, 116, "gauge44"], [8, 161, "gauge44"], [8, 206, "gauge44"], [8, 251, "gauge44"], [8, 296, "gauge44"], [8, 341, "gauge44"], [7, 31, "gauge44"], [7, 76, "gauge44"], [7, 121, "gauge44"], [7, 166, "gauge44"], [7, 211, "gauge44"], [7, 256, "gauge44"], [7, 301, "gauge44"], [7, 346, "gauge44"], [6, 36, "gauge44"], [6, 81, "gauge44"], [6, 126, "gauge44"], [6, 171, "gauge44"], [6, 216, "gauge44"], [6, 261, "gauge44"], [6, 306, "gauge44"], [6, 351, "gauge44"], [8, 27, "gauge44"], [8, 72, "gauge44"], [8, 117, "gauge44"], [8, 162, "gauge44"], [8, 207, "gauge44"], [8, 252, "gauge44"], [8, 297, "gauge44"], [8, 342, "gauge44"], [7, 32, "gauge44"], [7, 77, "gauge44"], [7, 122, "gauge44"], [7, 167, "gauge44"], [7, 212, "gauge44"], [7, 257, "gauge44"], [7, 302, "gauge44"], [7, 347, "gauge44"], [8, 28, "gauge44"], [8, 73, "gauge44"], [8, 118, "gauge44"], [8, 163, "gauge44"], [8, 208, "gauge44"], [8, 253, "gauge44"], [8, 298, "gauge44"], [8, 343, "gauge44"], [7, 33, "gauge44"], [7, 78, "gauge44"], [7, 123, "gauge44"], [7, 168, "gauge44"], [7, 213, "gauge44"], [7, 258, "gauge44"], [7, 303, "gauge44"], [7, 348, "gauge44"], [8, 29, "gauge44"], [8, 74, "gauge44"], [8, 119, "gauge44"], [8, 164, "gauge44"], [8, 209, "gauge44"], [8, 254, "gauge44"], [8, 299, "gauge44"], [8, 344, "gauge44"], [7, 34, "gauge44"], [7, 79, "gauge44"], [7, 124, "gauge44"], [7, 169, "gauge44"], [7, 214, "gauge44"], [7, 259, "gauge44"], [7, 304, "gauge44"], [7, 349, "gauge44"], [8, 30, "gauge44"], [8, 75, "gauge44"], [8, 120, "gauge44"], [8, 165, "gauge44"], [8, 210, "gauge44"], [8, 255, "gauge44"], [8, 300, "gauge44"], [8, 345, "gauge44"], [7, 35, "gauge44"], [7, 80, "gauge44"], [7, 125, "gauge44"], [7, 170, "gauge44"], [7, 215, "gauge44"], [7, 260, "gauge44"], [7, 305, "gauge44"], [7, 350, "gauge44"], [8, 31, "gauge44"], [8, 76, "gauge44"], [8, 121, "gauge44"], [8, 166, "gauge44"], [8, 211, "gauge44"], [8, 256, "gauge44"], [8, 301, "gauge44"], [8, 346, "gauge44"], [7, 36, "gauge44"], [7, 81, "gauge44"], [7, 126, "gauge44"], [7, 171, "gauge44"], [7, 216, "gauge44"], [7, 261, "gauge44"], [7, 306, "gauge44"], [7, 351, "gauge44"], [8, 32, "gauge44"], [8, 77, "gauge44"], [8, 122, "gauge44"], [8, 167, "gauge44"], [8, 212, "gauge44"], [8, 257, "gauge44"], [8, 302, "gauge44"], [8, 347, "gauge44"], [8, 33, "gauge44"], [8, 78, "gauge44"], [8, 123, "gauge44"], [8, 168, "gauge44"], [8, 213, "gauge44"], [8, 258, "gauge44"], [8, 303, "gauge44"], [8, 348, "gauge44"], [8, 34, "gauge44"], [8, 79, "gauge44"], [8, 124, "gauge44"], [8, 169, "gauge44"], [8, 214, "gauge44"], [8, 259, "gauge44"], [8, 304, "gauge44"], [8, 349, "gauge44"], [8, 35, "gauge44"], [8, 80, "gauge44"], [8, 125, "gauge44"], [8, 170, "gauge44"], [8, 215, "gauge44"], [8, 260, "gauge44"], [8, 305, "gauge44"], [8, 350, "gauge44"], [0, 37, "extra"], [0, 82, "extra"], [0, 127, "extra"], [0, 172, "extra"], [0, 217, "extra"], [0, 262, "extra"], [0, 307, "extra"], [0, 352, "extra"], [8, 36, "gauge44"], [8, 81, "gauge44"], [8, 126, "gauge44"], [8, 171, "gauge44"], [8, 216, "gauge44"], [8, 261, "gauge44"], [8, 306, "gauge44"], [8, 351, "gauge44"], [0, 38, "gauge44"], [0, 83, "gauge44"], [0, 128, "gauge44"], [0, 173, "gauge44"], [0, 218, "gauge44"], [0, 263, "gauge44"], [0, 308, "gauge44"], [0, 353, "gauge44"], [1, 37, "gauge44"], [1, 82, "gauge44"], [1, 127, "gauge44"], [1, 172, "gauge44"], [1, 217, "gauge44"], [1, 262, "gauge44"], [1, 307, "gauge44"], [1, 352, "gauge44"], [0, 39, "gauge44"], [0, 84, "gauge44"], [0, 129, "gauge44"], [0, 174, "gauge44"], [0, 219, "gauge44"], [0, 264, "gauge44"], [0, 309, "gauge44"], [0, 354, "gauge44"], [1, 38, "gauge44"], [1, 83, "gauge44"], [1, 128, "gauge44"], [1, 173, "gauge44"], [1, 218, "gauge44"], [1, 263, "gauge44"], [1, 308, "gauge44"], [1, 353, "gauge44"], [2, 37, "gauge44"], [2, 82, "gauge44"], [2, 127, "gauge44"], [2, 172, "gauge44"], [2, 217, "gauge44"], [2, 262, "gauge44"], [2, 307, "gauge44"], [2, 352, "gauge44"], [0, 40, "gauge44"], [0, 85, "gauge44"], [0, 130, "gauge44"], [0, 175, "gauge44"], [0, 220, "gauge44"], [0, 265, "gauge44"], [0, 310, "gauge44"], [0, 355, "gauge44"], [3, 37, "gauge44"], [3, 82, "gauge44"], [3, 127, "gauge44"], [3, 172, "gauge44"], [3, 217, "gauge44"], [3, 262, "gauge44"], [3, 307, "gauge44"], [3, 352, "gauge44"], [1, 39, "gauge44"], [1, 84, "gauge44"], [1, 129, "gauge44"], [1, 174, "gauge44"], [1, 219, "gauge44"], [1, 264, "gauge44"], [1, 309, "gauge44"], [1, 354, "gauge44"], [2, 38, "gauge44"], [2, 83, "gauge44"], [2, 128, "gauge44"], [2, 173, "gauge44"], [2, 218, "gauge44"], [2, 263, "gauge44"], [2, 308, "gauge44"], [2, 353, "gauge44"], [0, 41, "gauge44"], [0, 86, "gauge44"], [0, 131, "gauge44"], [0, 176, "gauge44"], [0, 221, "gauge44"], [0, 266, "gauge44"], [0, 311, "gauge44"], [0, 356, "gauge44"], [2, 39, "gauge44"], [2, 84, "gauge44"], [2, 129, "gauge44"], [2, 174, "gauge44"], [2, 219, "gauge44"], [2, 264, "gauge44"], [2, 309, "gauge44"], [2, 354, "gauge44"], [1, 40, "gauge44"], [1, 85, "gauge44"], [1, 130, "gauge44"], [1, 175, "gauge44"], [1, 220, "gauge44"], [1, 265, "gauge44"], [1, 310, "gauge44"], [1, 355, "gauge44"], [3, 38, "gauge44"], [3, 83, "gauge44"], [3, 128, "gauge44"], [3, 173, "gauge44"], [3, 218, "gauge44"], [3, 263, "gauge44"], [3, 308, "gauge44"], [3, 353, "gauge44"], [4, 37, "gauge44"], [4, 82, "gauge44"], [4, 127, "gauge44"], [4, 172, "gauge44"], [4, 217, "gauge44"], [4, 262, "gauge44"], [4, 307, "gauge44"], [4, 352, "gauge44"], [0, 42, "gauge44"], [0, 87, "gauge44"], [0, 132, "gauge44"], [0, 177, "gauge44"], [0, 222, "gauge44"], [0, 267, "gauge44"], [0, 312, "gauge44"], [0, 357, "gauge44"], [1, 41, "gauge44"], [1, 86, "gauge44"], [1, 131, "gauge44"], [1, 176, "gauge44"], [1, 221, "gauge44"], [1, 266, "gauge44"], [1, 311, "gauge44"], [1, 356, "gauge44"], [2, 40, "gauge44"], [2, 85, "gauge44"], [2, 130, "gauge44"], [2, 175, "gauge44"], [2, 220, "gauge44"], [2, 265, "gauge44"], [2, 310, "gauge44"], [2, 355, "gauge44"], [3, 39, "gauge44"], [3, 84, "gauge44"], [3, 129, "gauge44"], [3, 174, "gauge44"], [3, 219, "gauge44"], [3, 264, "gauge44"], [3, 309, "gauge44"], [3, 354, "gauge44"], [4, 38, "gauge44"], [4, 83, "gauge44"], [4, 128, "gauge44"], [4, 173, "gauge44"], [4, 218, "gauge44"], [4, 263, "gauge44"], [4, 308, "gauge44"], [4, 353, "gauge44"], [5, 37, "gauge44"], [5, 82, "gauge44"], [5, 127, "gauge44"], [5, 172, "gauge44"], [5, 217, "gauge44"], [5, 262, "gauge44"], [5, 307, "gauge44"], [5, 352, "gauge44"], [0, 43, "gauge44"], [0, 88, "gauge44"], [0, 133, "gauge44"], [0, 178, "gauge44"], [0, 223, "gauge44"], [0, 268, "gauge44"], [0, 313, "gauge44"], [0, 358, "gauge44"], [1, 42, "gauge44"], [1, 87, "gauge44"], [1, 132, "gauge44"], [1, 177, "gauge44"], [1, 222, "gauge44"], [1, 267, "gauge44"], [1, 312, "gauge44"], [1, 357, "gauge44"], [2, 41, "gauge44"], [2, 86, "gauge44"], [2, 131, "gauge44"], [2, 176, "gauge44"], [2, 221, "gauge44"], [2, 266, "gauge44"], [2, 311, "gauge44"], [2, 356, "gauge44"], [3, 40, "gauge44"], [3, 85, "gauge44"], [3, 130, "gauge44"], [3, 175, "gauge44"], [3, 220, "gauge44"], [3, 265, "gauge44"], [3, 310, "gauge44"], [3, 355, "gauge44"], [4, 39, "gauge44"], [4, 84, "gauge44"], [4, 129, "gauge44"], [4, 174, "gauge44"], [4, 219, "gauge44"], [4, 264, "gauge44"], [4, 309, "gauge44"], [4, 354, "gauge44"], [5, 38, "gauge44"], [5, 83, "gauge44"], [5, 128, "gauge44"], [5, 173, "gauge44"], [5, 218, "gauge44"], [5, 263, "gauge44"], [5, 308, "gauge44"], [5, 353, "gauge44"], [0, 44, "gauge44"], [0, 89, "gauge44"], [0, 134, "gauge44"], [0, 179, "gauge44"], [0, 224, "gauge44"], [0, 269, "gauge44"], [0, 314, "gauge44"], [0, 359, "gauge44"], [6, 37, "gauge44"], [6, 82, "gauge44"], [6, 127, "gauge44"], [6, 172, "gauge44"], [6, 217, "gauge44"], [6, 262, "gauge44"], [6, 307, "gauge44"], [6, 352, "gauge44"], [1, 43, "gauge44"], [1, 88, "gauge44"], [1, 133, "gauge44"], [1, 178, "gauge44"], [1, 223, "gauge44"], [1, 268, "gauge44"], [1, 313, "gauge44"], [1, 358, "gauge44"], [2, 42, "gauge44"], [2, 87, "gauge44"], [2, 132, "gauge44"], [2, 177, "gauge44"], [2, 222, "gauge44"], [2, 267, "gauge44"], [2, 312, "gauge44"], [2, 357, "gauge44"], [3, 41, "gauge44"], [3, 86, "gauge44"], [3, 131, "gauge44"], [3, 176, "gauge44"], [3, 221, "gauge44"], [3, 266, "gauge44"], [3, 311, "gauge44"], [3, 356, "gauge44"], [4, 40, "gauge44"], [4, 85, "gauge44"], [4, 130, "gauge44"], [4, 175, "gauge44"], [4, 220, "gauge44"], [4, 265, "gauge44"], [4, 310, "gauge44"], [4, 355, "gauge44"], [5, 39, "gauge44"], [5, 84, "gauge44"], [5, 129, "gauge44"], [5, 174, "gauge44"], [5, 219, "gauge44"], [5, 264, "gauge44"], [5, 309, "gauge44"], [5, 354, "gauge44"], [6, 38, "gauge44"], [6, 83, "gauge44"], [6, 128, "gauge44"], [6, 173, "gauge44"], [6, 218, "gauge44"], [6, 263, "gauge44"], [6, 308, "gauge44"], [6, 353, "gauge44"], [1, 44, "gauge44"], [1, 89, "gauge44"], [1, 134, "gauge44"], [1, 179, "gauge44"], [1, 224, "gauge44"], [1, 269, "gauge44"], [1, 314, "gauge44"], [1, 359, "gauge44"], [7, 37, "gauge44"], [7, 82, "gauge44"], [7, 127, "gauge44"], [7, 172, "gauge44"], [7, 217, "gauge44"], [7, 262, "gauge44"], [7, 307, "gauge44"], [7, 352, "gauge44"], [2, 43, "gauge44"], [2, 88, "gauge44"], [2, 133, "gauge44"], [2, 178, "gauge44"], [2, 223, "gauge44"], [2, 268, "gauge44"], [2, 313, "gauge44"], [2, 358, "gauge44"], [3, 42, "gauge44"], [3, 87, "gauge44"], [3, 132, "gauge44"], [3, 177, "gauge44"], [3, 222, "gauge44"], [3, 267, "gauge44"], [3, 312, "gauge44"], [3, 357, "gauge44"], [4, 41, "gauge44"], [4, 86, "gauge44"], [4, 131, "gauge44"], [4, 176, "gauge44"], [4, 221, "gauge44"], [4, 266, "gauge44"], [4, 311, "gauge44"], [4, 356, "gauge44"], [5, 40, "gauge44"], [5, 85, "gauge44"], [5, 130, "gauge44"], [5, 175, "gauge44"], [5, 220, "gauge44"], [5, 265, "gauge44"], [5, 310, "gauge44"], [5, 355, "gauge44"], [6, 39, "gauge44"], [6, 84, "gauge44"], [6, 129, "gauge44"], [6, 174, "gauge44"], [6, 219, "gauge44"], [6, 264, "gauge44"], [6, 309, "gauge44"], [6, 354, "gauge44"], [7, 38, "gauge44"], [7, 83, "gauge44"], [7, 128, "gauge44"], [7, 173, "gauge44"], [7, 218, "gauge44"], [7, 263, "gauge44"], [7, 308, "gauge44"], [7, 353, "gauge44"], [2, 44, "gauge44"], [2, 89, "gauge44"], [2, 134, "gauge44"], [2, 179, "gauge44"], [2, 224, "gauge44"], [2, 269, "gauge44"], [2, 314, "gauge44"], [2, 359, "gauge44"], [8, 37, "gauge44"], [8, 82, "gauge44"], [8, 127, "gauge44"], [8, 172, "gauge44"], [8, 217, "gauge44"], [8, 262, "gauge44"], [8, 307, "gauge44"], [8, 352, "gauge44"], [3, 43, "gauge44"], [3, 88, "gauge44"], [3, 133, "gauge44"], [3, 178, "gauge44"], [3, 223, "gauge44"], [3, 268, "gauge44"], [3, 313, "gauge44"], [3, 358, "gauge44"], [4, 42, "gauge44"], [4, 87, "gauge44"], [4, 132, "gauge44"], [4, 177, "gauge44"], [4, 222, "gauge44"], [4, 267, "gauge44"], [4, 312, "gauge44"], [4, 357, "gauge44"], [5, 41, "gauge44"], [5, 86, "gauge44"], [5, 131, "gauge44"], [5, 176, "gauge44"], [5, 221, "gauge44"], [5, 266, "gauge44"], [5, 311, "gauge44"], [5, 356, "gauge44"], [6, 40, "gauge44"], [6, 85, "gauge44"], [6, 130, "gauge44"], [6, 175, "gauge44"], [6, 220, "gauge44"], [6, 265, "gauge44"], [6, 310, "gauge44"], [6, 355, "gauge44"], [7, 39, "gauge44"], [7, 84, "gauge44"], [7, 129, "gauge44"], [7, 174, "gauge44"], [7, 219, "gauge44"], [7, 264, "gauge44"], [7, 309, "gauge44"], [7, 354, "gauge44"], [8, 38, "gauge44"], [8, 83, "gauge44"], [8, 128, "gauge44"], [8, 173, "gauge44"], [8, 218, "gauge44"], [8, 263, "gauge44"], [8, 308, "gauge44"], [8, 353, "gauge44"], [3, 44, "gauge44"], [3, 89, "gauge44"], [3, 134, "gauge44"], [3, 179, "gauge44"], [3, 224, "gauge44"], [3, 269, "gauge44"], [3, 314, "gauge44"], [3, 359, "gauge44"], [4, 43, "gauge44"], [4, 88, "gauge44"], [4, 133, "gauge44"], [4, 178, "gauge44"], [4, 223, "gauge44"], [4, 268, "gauge44"], [4, 313, "gauge44"], [4, 358, "gauge44"], [5, 42, "gauge44"], [5, 87, "gauge44"], [5, 132, "gauge44"], [5, 177, "gauge44"], [5, 222, "gauge44"], [5, 267, "gauge44"], [5, 312, "gauge44"], [5, 357, "gauge44"], [6, 41, "gauge44"], [6, 86, "gauge44"], [6, 131, "gauge44"], [6, 176, "gauge44"], [6, 221, "gauge44"], [6, 266, "gauge44"], [6, 311, "gauge44"], [6, 356, "gauge44"], [7, 40, "gauge44"], [7, 85, "gauge44"], [7, 130, "gauge44"], [7, 175, "gauge44"], [7, 220, "gauge44"], [7, 265, "gauge44"], [7, 310, "gauge44"], [7, 355, "gauge44"], [8, 39, "gauge44"], [8, 84, "gauge44"], [8, 129, "gauge44"], [8, 174, "gauge44"], [8, 219, "gauge44"], [8, 264, "gauge44"], [8, 309, "gauge44"], [8, 354, "gauge44"], [4, 44, "gauge44"], [4, 89, "gauge44"], [4, 134, "gauge44"], [4, 179, "gauge44"], [4, 224, "gauge44"], [4, 269, "gauge44"], [4, 314, "gauge44"], [4, 359, "gauge44"], [5, 43, "gauge44"], [5, 88, "gauge44"], [5, 133, "gauge44"], [5, 178, "gauge44"], [5, 223, "gauge44"], [5, 268, "gauge44"], [5, 313, "gauge44"], [5, 358, "gauge44"], [6, 42, "gauge44"], [6, 87, "gauge44"], [6, 132, "gauge44"], [6, 177, "gauge44"], [6, 222, "gauge44"], [6, 267, "gauge44"], [6, 312, "gauge44"], [6, 357, "gauge44"], [7, 41, "gauge44"], [7, 86, "gauge44"], [7, 131, "gauge44"], [7, 176, "gauge44"], [7, 221, "gauge44"], [7, 266, "gauge44"], [7, 311, "gauge44"], [7, 356, "gauge44"], [8, 40, "gauge44"], [8, 85, "gauge44"], [8, 130, "gauge44"], [8, 175, "gauge44"], [8, 220, "gauge44"], [8, 265, "gauge44"], [8, 310, "gauge44"], [8, 355, "gauge44"], [5, 44, "gauge44"], [5, 89, "gauge44"], [5, 134, "gauge44"], [5, 179, "gauge44"], [5, 224, "gauge44"], [5, 269, "gauge44"], [5, 314, "gauge44"], [5, 359, "gauge44"], [6, 43, "gauge44"], [6, 88, "gauge44"], [6, 133, "gauge44"], [6, 178, "gauge44"], [6, 223, "gauge44"], [6, 268, "gauge44"], [6, 313, "gauge44"], [6, 358, "gauge44"], [7, 42, "gauge44"], [7, 87, "gauge44"], [7, 132, "gauge44"], [7, 177, "gauge44"], [7, 222, "gauge44"], [7, 267, "gauge44"], [7, 312, "gauge44"], [7, 357, "gauge44"], [8, 41, "gauge44"], [8, 86, "gauge44"], [8, 131, "gauge44"], [8, 176, "gauge44"], [8, 221, "gauge44"], [8, 266, "gauge44"], [8, 311, "gauge44"], [8, 356, "gauge44"], [6, 44, "gauge44"], [6, 89, "gauge44"], [6, 134, "gauge44"], [6, 179, "gauge44"], [6, 224, "gauge44"], [6, 269, "gauge44"], [6, 314, "gauge44"], [6, 359, "gauge44"], [7, 43, "gauge44"], [7, 88, "gauge44"], [7, 133, "gauge44"], [7, 178, "gauge44"], [7, 223, "gauge44"], [7, 268, "gauge44"], [7, 313, "gauge44"], [7, 358, "gauge44"], [8, 42, "gauge44"], [8, 87, "gauge44"], [8, 132, "gauge44"], [8, 177, "gauge44"], [8, 222, "gauge44"], [8, 267, "gauge44"], [8, 312, "gauge44"], [8, 357, "gauge44"], [7, 44, "gauge44"], [7, 89, "gauge44"], [7, 134, "gauge44"], [7, 179, "gauge44"], [7, 224, "gauge44"], [7, 269, "gauge44"], [7, 314, "gauge44"], [7, 359, "gauge44"], [8, 43, "gauge44"], [8, 88, "gauge44"], [8, 133, "gauge44"], [8, 178, "gauge44"], [8, 223, "gauge44"], [8, 268, "gauge44"], [8, 313, "gauge44"], [8, 358, "gauge44"], [8, 44, "gauge44"], [8, 89, "gauge44"], [8, 134, "gauge44"], [8, 179, "gauge44"], [8, 224, "gauge44"], [8, 269, "gauge44"], [8, 314, "gauge44"], [8, 359, "gauge44"]] \ No newline at end of file diff --git a/research/complex-pooled-full-admission/frozen/pr4181/verify.py b/research/complex-pooled-full-admission/frozen/pr4181/verify.py new file mode 100644 index 000000000..474c80fd3 --- /dev/null +++ b/research/complex-pooled-full-admission/frozen/pr4181/verify.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Literal owner audit and exact root for the 1,080-call fourth-entry fill (standard library only). + +The four words, their native receipts, the clock (ORDER), template, plan and the owner walk are PR4088's +(research/staged544-mixed-fourth-entry), imported unchanged. Only the dispatch selector and the fill change: +tick t < 1080 uses the four-entry word of its orientation, every later tick the three-entry word. +""" +import gzip, json, sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PRED = HERE.parent / 'staged544-mixed-fourth-entry' +sys.path.insert(0, str(PRED)) +_argv = sys.argv; sys.argv = [sys.argv[0]] +import owner_verify as OV # PR4088 literal owner walk (unchanged) +from verify import read, need # PR4088 helpers +from vendor import exact_root as E # PR3945/4076 rational log/exp enclosures +sys.argv = _argv +FOURTH = 1080 + + +def reject(name, fn): + try: fn() + except (ValueError, AssertionError): return name + raise ValueError('accepted mutant: ' + name) + + +def context(selector=lambda t: t < FOURTH): + P = PRED + order = read(P / 'owner/ORDER.json'); clock = {tuple(v): t for t, v in enumerate(order)} + need(len(order) == 3240 and set(clock) == {(s, r) for s in range(9) for r in range(360)}, 'all calls') + need(all(clock[s, r] < clock[s + 1, r] for r in range(360) for s in range(8)), 'source order') + template = read(P / 'owner/TEMPLATE.json.gz'); plan = read(P / 'owner/PLAN.json.gz') + children = {x['child']: x['rank'] for x in template['idle_children']} + pair = {x['stage']: x['pair'] for x in template['recipe'] if x['kind'] == 'local'} + family = {c: 2 * plan['pairs'][str(c)] + plan['sides'][str(c)] for c in children} + windows = {} + for o in range(360): + touched = {}; tick = None + for e in template['execution_schedule']: + k = e['kind'] + if k == 'local_cover_sweep': tick = clock[e['stage'], o]; touched[pair[e['stage']]] = tick + elif k == 'bridge': touched[e['src']] = tick; touched[e['dst']] = tick + elif k == 'idle_cover_sweep': + for c in e['child_indices']: + if c in children: + need((o, c) not in windows, 'duplicate owner child'); windows[o, c] = (children[c], touched.get(e['pair'], -1), tick) + else: need(k in ['bank_padding_cover_sweep', 'translate_every_live_family', 'terminal_Y_translations', 'terminal'], 'schedule kind') + old = read(P / 'owner/DISPATCH.json') + expected = [[s, r, pid + ('-four' if selector(clock[s, r]) else '')] for s, r, pid in old] + provider = {(s, r): pid for s, r, pid in expected} + I = OV.I; widths = {}; local = {} + for tag, pid in [('base', 'gauge44'), ('extra', 'extra')]: + origin = read(P / f'owner/old-NATIVE-{tag}.json.gz')['helper_origin'] + for kind, suffix in [('THREE', ''), ('FOUR', '-four')]: + w = read(P / f'inputs/{kind}-{tag}.json.gz') + need(origin == sorted(set(range(224, 704)) - set(w['removed'])), 'native helper order') + widths[pid + suffix] = [len(I.b(w['helper_final'].get(str(r), I.FULL))) - len(I.b(w['start_extra'].get(str(r), []))) for r in origin] + local[pid + suffix] = {int(k): v for k, v in w['report']['local_profile'].items()} + return (order, provider, windows, family, widths, local), expected + + +def main(): + if not __debug__: raise SystemExit('assertions required') + ctx, dispatch = context() + need(read(HERE / 'owner/MIXED-DISPATCH.json') == dispatch, 'committed dispatch equals the t < 1080 rule') + need(sum(p.endswith('-four') for p in ctx[1].values()) == FOURTH, 'exactly 1080 fourth-entry calls') + rows = read(HERE / 'owner/FILL.json.gz')['rows'] + profile, idle = OV.walk(rows, ctx) + r = read(HERE / 'RESULT.json') + need(profile == {int(k): v for k, v in r['profile'].items()} and idle == {int(k): v for k, v in r['idle'].items()}, 'declared histogram') + lo, hi = Q(r['root_lower']), Q(r['root_upper']) + need(hi - lo == Q(1, 10 ** 24), 'grid bracket') + E.certify_bracket(profile, lo, hi) + pred = read(PRED / 'RESULT.json') + pl, pu = Q(pred['root_lower']), Q(pred['root_upper']) + E.certify_bracket({int(k): v for k, v in pred['profile'].items()}, pl, pu) + kappa = lo - Q(1, 10 ** 46) - Q(1, 10 ** 70) + need(Q(r['conditional_kappa']) == kappa and kappa > pu, 'strict improvement over PR4088') + need(E.moment(E.signed(profile), kappa)[1] < 0, 'padded endpoint') + need(sum(k * v for k, v in profile.items()) == 65088 * 360, 'rank mass') + out = [] + if '--controls' in sys.argv: + ctx109, _ = context(lambda t: t * 109 % 324 < 109) + out.append(reject('pr4088_selector_with_this_fill', lambda: OV.walk(rows, ctx109))) + ctx1079, _ = context(lambda t: t < FOURTH - 1) + out.append(reject('one_fourth_call_reverted', lambda: OV.walk(rows, ctx1079))) + bad = [list(x) for x in rows[:2]] + rows[2:]; bad[1][2:5] = bad[0][2:5] + out.append(reject('same_call_family', lambda: OV.walk(bad, ctx))) + bad = [list(rows[0])] + rows[1:]; bad[0][5] += 1 + out.append(reject('offset_hole', lambda: OV.walk(bad, ctx))) + out.append(reject('next_grid_point', lambda: E.certify_bracket(profile, hi, hi + Q(1, 10 ** 24)))) + out.append(reject('pr4088_profile_at_new_root', lambda: E.certify_bracket({int(k): v for k, v in pred['profile'].items()}, lo, hi))) + print(json.dumps({'status': 'PASS_POOLED_CEILING_FILL', 'fourth_calls': FOURTH, 'roles': len(rows), 'idle': idle, + 'root_bracket': [r['root_lower_decimal'], r['root_upper_decimal']], 'gain_over_pr4088_upper': str(kappa - pu), + 'controls': out}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/complex-pooled-full-admission/joint_bound.py b/research/complex-pooled-full-admission/joint_bound.py new file mode 100644 index 000000000..eaa2d5986 --- /dev/null +++ b/research/complex-pooled-full-admission/joint_bound.py @@ -0,0 +1,377 @@ +#!/usr/bin/env python3 +"""Exact joint arithmetic, with an optional binding to completed finite release. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +The interval implementation is separate from the inherited moment engines. +Finite arithmetic and receipt binding do not prove the all-size interfaces. +""" +import argparse +from collections import Counter +from decimal import Decimal, localcontext +from fractions import Fraction as Q +from functools import lru_cache +import hashlib +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PINS = { + "frozen/pr4181/RESULT.json": "d823509ea38e545db6c287a85c00bc4257825fb2710728dfc776c8801d2becd9", + "frozen/pr4181/owner/MIXED-DISPATCH.json": "ab8c774b614730701435c0f5dc1bfba4a46d980690a1b6bc09225555ff9be6f4", + "frozen/selected/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "frozen/selected/BIT-EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", +} +THREE = {1: 2487, 2: 713, 3: 224, 4: 102, 5: 20, 8: 8} +FOUR = {1: 2489, 2: 713, 3: 227, 4: 99, 5: 20, 8: 8} +PREVIOUS = {1: 8060060, 2: 2310120, 3: 751813, 4: 327210, + 5: 66425, 8: 25920, 48: 138492} +PREVIOUS_LOWER = Q("0.001730979115670792472760") +PREVIOUS_UPPER = PREVIOUS_LOWER + Q(1, 10**24) +SCALE = 1 << 384 +LOG_TERMS = 140 +EXP_TERMS = 80 + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + return json.loads(path.read_bytes()) + + +def sha(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def hist(x): + return {int(k): int(v) for k, v in x.items() if v} + + +def decimal(x): + with localcontext() as ctx: + ctx.prec = 90 + return str(Decimal(x.numerator) / Decimal(x.denominator)) + + +def ceildiv(a, b): + return -((-a) // b) + + +def down(x): + return (x.numerator * SCALE) // x.denominator + + +def up(x): + return ceildiv(x.numerator * SCALE, x.denominator) + + +def unit_log(x): + """Enclose ln(x), 1<=x<=2, in integer units of 2^-384. + + ln(x)=2 sum z^(2j+1)/(2j+1), z=(x-1)/(x+1)<=1/3. + Every recurrence rounds out; the remaining positive tail is at most + 2*z^(2N+1)/((2N+1)*(1-z*z)). + """ + need(1 <= x <= 2, "unit logarithm domain") + z = (x - 1) / (x + 1) + p, q = z.numerator, z.denominator + lo, hi = down(z), up(z) + sl = sh = 0 + for j in range(LOG_TERMS): + sl += lo // (2*j + 1) + sh += ceildiv(hi, 2*j + 1) + lo = lo * p*p // (q*q) + hi = ceildiv(hi * p*p, q*q) + tail = ceildiv(2 * hi * q*q, (2*LOG_TERMS + 1) * (q*q-p*p)) + return 2*sl, 2*sh + tail + + +@lru_cache(None) +def log_interval(x): + need(x >= 1, "positive logarithm domain") + k = 0 + while x >= 2: + x /= 2 + k += 1 + lo, hi = unit_log(x) + l2, h2 = unit_log(Q(2)) + return lo + k*l2, hi + k*h2 + + +def exp_interval(lo, hi): + """Enclose exp(x), x in [lo,hi]/SCALE, with positive Taylor terms.""" + need(0 <= lo <= hi < SCALE//100, "exponential domain x<0.01") + tl = th = sl = sh = SCALE + for j in range(1, EXP_TERMS): + tl = tl * lo // (SCALE*j) + th = ceildiv(th * hi, SCALE*j) + sl += tl + sh += th + next_upper = ceildiv(th * hi, SCALE*EXP_TERMS) + # Subsequent term ratios are < 1/2, so this geometric tail is valid. + return Q(sl, SCALE), Q(sh + 2*next_upper, SCALE) + + +def moment(profile, m, live, a, fallback=Q(0)): + """Normalized complete moment minus one; fallback is a rank-one count.""" + need(0 <= a < Q(1, 500), "certified arithmetic exponent domain") + terms = {r: Q(n) for r, n in profile.items()} + terms[1] = terms.get(1, Q(0)) + fallback + lo = hi = Q(0) + for rank, count in sorted(terms.items()): + need(0 < rank < m and count >= 0, "positive proper child") + ll, lh = log_interval(Q(m, rank)) + el, eh = exp_interval(down(a * Q(ll, SCALE)), up(a * Q(lh, SCALE))) + weight = Q(count * rank, m*live) + lo += weight * el + hi += weight * eh + return lo-1, hi-1 + + +def bracket(profile, m, live, lower, upper, fallback=Q(0)): + need(upper-lower == Q(1, 10**24), "adjacent root bracket") + at = moment(profile, m, live, lower, fallback) + nxt = moment(profile, m, live, upper, fallback) + need(at[1] < 0 < nxt[0], "strict lower/upper moment signs") + return {"lower_interval": list(map(str, at)), "upper_interval": list(map(str, nxt))} + + +def profile_check(profile, idle): + full = Counter(idle) + full.update({r: 2160*n for r, n in THREE.items()}) + full.update({r: 1080*n for r, n in FOUR.items()}) + need(dict(full) == profile, "all local, restoration and idle children included") + need(sum(r*n for r, n in profile.items()) == 65088*360, "complete rank mass") + need(73*(896*360)-sum(r*n for r, n in profile.items()) == 320*360, "rank deficit") + need(max(profile) == 48 and 73**2 > 2*48**2, "proper contraction and halving guard") + + +def legacy(complex_rate, bit_rate): + """Selected PR1094 convention, independently written in exact rationals.""" + eta = beta = Q(1, 10**24) + s = min(bit_rate, (1-beta)*complex_rate) - Q(1, 10**27) + a = Q(384599, 10**10) + chain = [a] + for _ in range(7): + nxt = s*(1-s) + s*a + need(0 < a < nxt < s < 1-nxt, "strict finite bootstrap") + a = nxt + chain.append(a) + q = (1-2*eta)*a + ceiling = (1-eta)*q/(1+q) + scale = 10**18 + ticks = ceiling*scale + kappa = Q(ceildiv(ticks.numerator, ticks.denominator)-1, scale) + need(kappa < ceiling <= kappa+Q(1, scale), "strict legacy grid") + return {"kappa": kappa, "ceiling": ceiling, "s": s, + "chain": chain, "binding": "bit" if bit_rate <= (1-beta)*complex_rate else "complex"} + + +def modern(complex_rate, bit_rate): + """Exact endpoint-DIG24 parameter algebra; analytic hypotheses are external.""" + r = Q(1, 10**104) + delta = Q(1025, 1024)*r + eps, beta = 1-delta, 1-3*delta + b, q = complex_rate-r, complex_rate-2*r + a = (q+b)/2 + saving = eps*q + need(0 < q < a < b < complex_rate < bit_rate, "joint modern rates") + need(0 < complex_rate-saving < Q(1, 10**70), "modern floor gap") + need((complex_rate*10**70).denominator == 1, "modern endpoint on floor grid") + kappa = Q((saving*10**70).__floor__(), 10**70)-Q(1, 10**46) + need(kappa == complex_rate-Q(1, 10**70)-Q(1, 10**46), "derived modern kappa") + need(1-eps-r > 0 and 1-beta-2*(1-eps) > 0, "gamma and membership costs") + need(1-eps+q*beta-saving == delta*(1-2*q) > 0, "Gaussian cost exceeds main saving") + # An explicit finite ordinary-bootstrap witness can reach the effective a. + # It requires the inherited arbitrary-strict-rate bootstrap lemma, with + # carried constants; the historical twelve-stage receipt alone is not it. + s = complex_rate-r/2 + a0 = Q(384599, 10**10) + aj = s-(s-a0)*s**38 + need(a < aj < s < bit_rate, "38-stage ordinary-rate existence witness") + return {"kappa": kappa, "b": b, "q": q, "a": a, "epsilon": eps, + "beta": beta, "r0": r, "ordinary_bootstrap_steps_sufficient": 38, + "ordinary_bootstrap_s": s, "ordinary_bootstrap_final_above_effective": aj-a} + + +def reject(name, fn): + try: + fn() + except ValueError: + return name + raise ValueError("accepted mutation: " + name) + + +def release_binding(work, profile, idle, complex_rate, bit_rate, modern_kappa, legacy_kappa): + """Cross-bind actual emitted ledgers, without claiming to re-execute them.""" + work = work.resolve() + admission = work / "admission" + paths = { + "result": admission / "RESULT.json", + "release": admission / "release/RELEASE-RECEIPT.json", + "strict_result": admission / "release/verify/RESULT.json", + "assembly": admission / "release/verify/strict/ASSEMBLY.json", + "invoice": admission / "release/verify/strict/global/audit/PREFIX-AND-INVOICE.json", + "outer": admission / "release/outer-tmp/outer/LEDGER.json", + "spec": admission / "package/new/SPEC.json", + "contract": work / "source/new/MIXED-CONTRACT.json", + } + x = {k: read(p) for k, p in paths.items()} + need(x["result"]["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "completed inherited release") + need(x["release"]["status"] == "PASS_RELEASE", "completed release verifier") + need(hist(x["result"]["profile"]) == profile and Q(x["result"]["kappa"]) == modern_kappa, "actual new result") + need(Q(x["release"]["kappa_decimal"]) == modern_kappa, "actual modern release endpoint") + selected = read(HERE / "frozen/pr4181/owner/MIXED-DISPATCH.json") + need(sorted(x["contract"]["dispatch"]) == sorted(selected), "actual pooled selector") + a = x["assembly"] + need(hist(a["complex_profile"]) == profile and Q(a["complex_lower"]) == complex_rate, "actual complete complex profile") + need(Q(a["bit_lower"]) == bit_rate and a["surcharge_model"] == {"complex": False, "bit": True}, "actual surcharge models") + need(Q(a["kappa"]) == legacy_kappa, "actual legacy grid comparison") + need(len(a["outer"]) == 47 and all(Q(v) > 0 for v in a["outer"].values()), "all 47 inherited outer rows") + outer = x["outer"]["rows"]["struct_boundary_radix_union"] + need(Q(outer["kappa"]["rational"]) == modern_kappa, "actual modern outer ledger") + need(len(outer["strict_checks"]) == 63 and all(Q(v["rational"]) > 0 for v in outer["strict_checks"].values()), "all 63 modern outer rows") + s = x["strict_result"] + need(s["status"] == "PASS_T74_EXACT_FILL_COMPLETE_FINITE_ADMISSION", "ordinary strict admission") + expected = x["spec"]["expected"] + need(s["controls"] == {"admission": expected["assembly_controls_rejected"], "bit": 12, + "controller": expected["mutations_rejected"], "independent_owner": 8, + "geometry": 6}, "actual generated mutation coverage") + need(s["controls"]["admission"] > 119 and s["controls"]["controller"] > 25, + "active third provider retains expanded control families") + i = x["invoice"] + need(i["physical"] == 323069 == 896*360+408+8+91+2 and i["live"] == 896*360, "all physical families") + need(i["helpers"] == 408 and i["centres"] == 8 and i["private_zero_buffers"] == 91, "private and helper inventory") + calls = i["selected_calls"] + need(len(calls) == 3240 and len({(c["stage"], c["replica"]) for c in calls}) == 3240, "all literal calls") + dispatch = {(s, r): p for s, r, p in selected} + counts = Counter() + local = Counter() + for c in calls: + pid, orientation = c["provider_id"], c["orientation"] + need(dispatch[c["stage"], c["replica"]] == pid, "invoice follows pooled dispatch") + p = i["providers"][pid] + need(c["program_sha256"] == p["program_hashes"][orientation], "actual program binding") + need(hist(p["paid_profile"]) == (FOUR if pid.endswith("-four") else THREE), "complete local rank bill") + local.update(hist(p["paid_profile"])) + counts[pid] += 1 + z = p["local"][orientation] + need(z["all_exact_columns"] == 632 and z["dirty_helper_columns"] == 408 and z["all_dirty_helper_columns_restored"] and z["private_centres_and_coefficient_work_cleared"], "dirty and private restoration") + for key in ("real_component_primitives", "coefficient_work_primitive_count", "macros", "pre_wrappers", "post_wrappers"): + need(c[key] == z[key], "actual local cost: " + key) + need(dict(counts) == i["provider_counts"] == {"gauge44": 1568, "extra": 592, "extra-four": 1080}, "actual three active provider counts") + need(dict(local) == hist(i["selected_local_paid_profile"]), "local invoice sum") + local.update(idle) + need(dict(local) == profile, "actual local plus idle invoice") + for field, key in (("selected_real_component_primitives", "real_component_primitives"), ("selected_coefficient_work_primitive_count", "coefficient_work_primitive_count"), ("selected_scalar_macros", "macros")): + need(i[field] == sum(c[key] for c in calls), "full invoice sum: " + field) + need(i["wrapper_elementary_factors_charged"] == 144*sum(c["pre_wrappers"]+c["post_wrappers"] for c in calls), "paid wrapper factors") + b = i["blocknorm"] + need(b["local_actual_prefix_bits"] == 95 and b["stock_l2_bits"] == 1323 and b["max_active_depth"] == 18, "actual prefix components") + need(i["global_prefix_bits"] == 95+37+18+1323+1+4 == 1478 and i["charged_prefix_bits"] == 2048, "complete prefix reserve") + f = i["finite"] + need(f["physical_stock_bits"] == 2646 and f["physical_row_coefficient"] == 19549 < f["retained_row_coefficient"] == 20161, "complete stock and row reserve") + need(f["required_C0_bits"] < f["C0_exponent"] == 210000 and all(i["strict_checks"].values()), "precision, tape, router and finite guards") + return {"status": "COMPLETED_FINITE_RELEASE_RECEIPTS_BOUND", + "files": {k: {"path": str(p.relative_to(work)), "sha256": sha(p)} for k, p in paths.items()}, + "provider_counts": dict(counts), "physical": i["physical"], "global_prefix_bits": i["global_prefix_bits"], + "charged_prefix_bits": i["charged_prefix_bits"], "finite": f, + "selected_real_component_primitives": i["selected_real_component_primitives"], + "selected_coefficient_work_primitive_count": i["selected_coefficient_work_primitive_count"], + "selected_scalar_macros": i["selected_scalar_macros"], + "conservative_pervertex_used": i["conservative_pervertex_used"], + "scope": "Cross-binding of the parent driver's actual complete finite release; this check neither reruns the engine nor proves its all-size premises."} + + +def certificate(release_work=None): + for name, digest in PINS.items(): + need(sha(HERE/name) == digest, "frozen source pin: " + name) + source = read(HERE / "frozen/pr4181/RESULT.json") + selected = read(HERE / "frozen/selected/ASSEMBLY.json") + bit = read(HERE / "frozen/selected/BIT-EXPECTED.json")["nine"] + profile, idle = hist(source["profile"]), hist(source["idle"]) + provider_counts = Counter(p for _, _, p in read(HERE / "frozen/pr4181/owner/MIXED-DISPATCH.json")) + need(dict(provider_counts) == {"gauge44": 1568, "extra": 592, "extra-four": 1080}, + "actual pooled dispatch has three active providers") + profile_check(profile, idle) + c, upper = Q(source["root_lower"]), Q(source["root_upper"]) + b = Q(bit["bit_lower"]) + need(b == Q(selected["bit_lower"]) and selected["surcharge_model"] == {"complex": False, "bit": True}, "selected BIT and native-complex models") + candidate_signs = bracket(profile, 73, 896*360, c, upper) + previous_signs = bracket(PREVIOUS, 73, 896*360, PREVIOUS_LOWER, PREVIOUS_UPPER) + bh = hist(bit["profile"]) + fallback = Q(32*64**2*sum(bh.values()), 10**16) + bit_signs = bracket(bh, 64, bit["bit"]["live"], b, b+Q(1, 10**24), fallback) + need(b > upper, "retained BIT strictly above candidate complex root") + old_legacy = legacy(Q(selected["complex_lower"]), b) + need(old_legacy["kappa"] == Q(selected["kappa"]), "reproduce selected normalization") + new_legacy, pred_legacy = legacy(c, b), legacy(PREVIOUS_LOWER, b) + new_modern = modern(c, b) + need(new_modern["kappa"] == Q(source["conditional_kappa"]), "pooled modern claim") + gain = {r: PREVIOUS.get(r, 0)-profile.get(r, 0) for r in set(PREVIOUS)|set(profile)} + gain = {r: n for r, n in gain.items() if n} + need(gain == {1: 20, 3: 25, 4: -30, 5: 5}, "complete signed profile difference") + need(3**15*5**5 < 4**24, "uniform power-gain derivative witness") + controls = [ + reject("missing_idle_children", lambda: profile_check(profile, {})), + reject("root_used_as_legacy_kappa", lambda: need(c < new_legacy["ceiling"], "legacy outer loss omitted")), + reject("unpadded_root_used_as_modern_kappa", lambda: need(c == new_modern["kappa"], "strict modern padding omitted")), + reject("bit_improvement_only_claims_joint_gain", lambda: need(legacy(Q(selected["complex_lower"]), Q("0.001737631818486007553483"))["kappa"] > Q(selected["kappa"]), "unchanged complex side still binds")), + reject("bit_fallback_omitted", lambda: bracket(bh, 64, bit["bit"]["live"], b, b+Q(1, 10**24))), + reject("old_profile_claims_new_root", lambda: bracket(PREVIOUS, 73, 896*360, c, upper)), + ] + out = {"status": "PASS_JOINT_CONDITIONAL_ARITHMETIC_NOT_SUPPLIER_ADMISSION", "source_sha256": PINS, + "profile": profile, "idle": idle, "rank_mass": sum(r*n for r, n in profile.items()), + "active_provider_counts": dict(provider_counts), + "rank_deficit": 320*360, "child_count": sum(profile.values()), + "complex_root_bracket": [str(c), str(upper)], "complex_signs": candidate_signs, + "previous_complex_signs": previous_signs, "bit_endpoint": str(b), "bit_signs": bit_signs, + "bit_fallback_rank_one_count": str(fallback), "bit_slack_above_candidate_upper": str(b-upper), + "legacy": {**new_legacy, "kappa_decimal": decimal(new_legacy["kappa"]), + "gain_over_selected": new_legacy["kappa"]-Q(selected["kappa"]), + "gain_over_previous": new_legacy["kappa"]-pred_legacy["kappa"]}, + "modern": {**new_modern, "kappa_decimal": decimal(new_modern["kappa"]), + "gain_over_previous_upper": new_modern["kappa"]-PREVIOUS_UPPER}, + "uniform_profile_gain": {"previous_minus_new": gain, "covered_domain": "0 < a < 1", + "exact_integer_witness": [3**15*5**5, 4**24], + "argument": "F(p)=4*4^(-p)+5*(3/4)^p+(5/4)^p-6 is strictly convex; F(1)=0 and F'(1)<0. Therefore F(p)>0 for p=1-a<1. See RECURSION.md."}, + "controls": controls, + "release_binding": {"status": "NOT_REQUESTED_ARITHMETIC_ONLY"}, + "all_size_admission": False, "selected_frontier_changed": False, + "scope": "Exact complete-profile and joint-transfer arithmetic. A finite conditional improvement requires the new literal owner/operator and full ordinary/outer release. Uniform source/native generation, whole-call hosting, rounded cleanup, precision, fixed tapes, and the stated analytic transfer remain hypotheses."} + if release_work is not None: + out["release_binding"] = release_binding(release_work, profile, idle, c, b, new_modern["kappa"], new_legacy["kappa"]) + out["status"] = "PASS_JOINT_CONDITIONAL_ARITHMETIC_WITH_FINITE_RELEASE_BINDING" + return out + + +def encode(x): + if isinstance(x, Q): + return str(x) + if isinstance(x, dict): + return {str(k): encode(v) for k, v in x.items()} + if isinstance(x, (list, tuple)): + return [encode(v) for v in x] + return x + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--release-work", type=Path) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = encode(certificate(args.release_work)) + if args.output: + with args.output.open("x") as stream: + json.dump(result, stream, indent=2, sort_keys=True) + stream.write("\n") + else: + print(json.dumps(result, sort_keys=True)) + print(result["status"], "legacy_kappa=" + result["legacy"]["kappa_decimal"], + "controls=" + str(len(result["controls"])), "all_size_admission=false") + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/joint_bound_inputs.py b/research/complex-pooled-full-admission/joint_bound_inputs.py new file mode 100644 index 000000000..780c71f0d --- /dev/null +++ b/research/complex-pooled-full-admission/joint_bound_inputs.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Run the unchanged exact engine with two byte-identical canonical inputs. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +Only the two input addresses change; all engine predicates and functions remain. +""" +from hashlib import sha256 +import json +import types + +from common import authenticate +from receipt_transport import HERE, check, need, regular, selected_path + + +def main(): + authenticate() + check() + path = HERE / 'joint_bound.py' + raw = regular(path) + recorded = json.loads(regular(HERE / 'EVIDENCE.json')) + need(sha256(raw).hexdigest() == recorded['execution_source_sha256']['joint_bound.py'], + 'unchanged exact interval engine') + module = types.ModuleType('pooled_joint_arithmetic_with_canonical_inputs') + module.__file__ = str(path) + exec(compile(raw, str(path), 'exec', optimize=0), module.__dict__) + # Preserve the original readers for every other path, including release-work. + original_read, original_sha = module.read, module.sha + module.read = lambda name: original_read(selected_path(name)) + module.sha = lambda name: original_sha(selected_path(name)) + module.main() + authenticate() + + +if __name__ == '__main__': + main() diff --git a/research/complex-pooled-full-admission/operator_admission.py b/research/complex-pooled-full-admission/operator_admission.py new file mode 100644 index 000000000..4d07be88f --- /dev/null +++ b/research/complex-pooled-full-admission/operator_admission.py @@ -0,0 +1,324 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Bind PR4181's literal fill to the retained all-character phase operator. + +This is a source-bound reuse of Cinna Davis's PR4088 owner/operator walkers +and David Ganz's PR4085 exact Z4 normalizer, not an independent algorithm. +The frozen PR4181 context supplies only its new selector. All phase, window, +nonaliasing, axis and complete-invoice predicates are executed unchanged. +Prepared by Ross Richardson with substantial OpenAI Codex assistance. +""" +import argparse +from collections import Counter +from contextlib import contextmanager +from copy import deepcopy +import gzip +import hashlib +import importlib.util +import json +from pathlib import Path +import py_compile +import sys +import tempfile +import types + +HERE = Path(__file__).resolve().parent +PRED = HERE.parent / "staged544-mixed-fourth-entry" +CANDIDATE = HERE / "frozen/pr4181" +PINS = { + "verify.py": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8", + "owner_verify.py": "7cc34c6cd6092550ca356093823252764f97bde8c3daecfe7d84afffe383ce72", + "operator_verify.py": "9f1af2585df3f24ac0862d967cebc71c07c98bbc51506b0b95f82a2ab9ce6564", + "vendor/audit_core.py": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "vendor/audit_verify.py": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "vendor/staged_pair.py": "25fc9b025dbb90358032013303adea650a5f19937fd3edf30b6c6fd023e2d747", + "vendor/staged_entries_applier.py": "41f889bcdf6ef4e8033ac45bf4d2c0fdb20d7b51dd194806d79bba789e207661", + "checks/inherited_frames.py": "25ba8774b1be4f0be27abeac94232eb8db657f02d7830bd93208c53649e65a04", + "vendor/full_operator.py": "06f9f5128e19b6ea07756a9a11fcc9a9757a440a8048b5210422d12f183dfac3", + "vendor/t360_admission.py": "d3c3786a54fd4b2e5df98a1b39319628e855f65ffacabe7ab4d0deba8fe13329", + "vendor/exact_root.py": "565e0d7de2fcd7587045f11731dfaba202e18f93e3a7a8178374f4933e502fbe", + "owner/ORDER.json": "743e74b538432e2b2045e754b0de9c18f36fc5039fdb8eb542177a898ec78e44", + "owner/DISPATCH.json": "5d6fa711d704a1b498e5fe066ea821c4fa0217463702e82a7ce5be9da4023e8a", + "owner/TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "owner/PLAN.json.gz": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e", + "owner/old-NATIVE-base.json.gz": "bfe0cc0badac6c6d18461ceea0b299162c0f280c05f81b63f11fcc06cf9180e6", + "owner/old-NATIVE-extra.json.gz": "c5eec94a64cecfd6b83de05619628ad4868e889d62a55b49973f09705cc60448", + "inputs/THREE-base.json.gz": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "inputs/THREE-extra.json.gz": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "inputs/FOUR-base.json.gz": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95", + "inputs/FOUR-extra.json.gz": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a", + "inputs/DATA-PHASES.json": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa", + "inputs/OPERATOR-TEMPLATE.json.gz": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e", + "INPUTS.json": "43ab5cd305ec23dbc63accaffb0dca8bdf201130bff89f5e807d919c5118fc98", + "RESULT.json": "6346ee768637aa9a1891d1d61d800d640235420b320fb7e659d1bf664ec42b3d", +} +CANDIDATE_PINS = { + "verify.py": "e89870761ddefe0a7f983512c6ae884ccff26235085238624e00f75a31cd6e76", + "RESULT.json": "d823509ea38e545db6c287a85c00bc4257825fb2710728dfc776c8801d2becd9", + "owner/MIXED-DISPATCH.json": "ab8c774b614730701435c0f5dc1bfba4a46d980690a1b6bc09225555ff9be6f4", + "owner/FILL.json.gz": "5455c120a121a7ec70897fb2c58e1988ce01d7172d6a5622519bea6b25efe8fe", +} + + +def need(ok, message): + if not ok: + raise ValueError(message) + + +def read(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == ".gz" else raw) + + +def authenticate(): + pins = {} + for root, expected in ((PRED, PINS), (CANDIDATE, CANDIDATE_PINS)): + for name, digest in expected.items(): + path = root / name + need(not path.is_symlink(), "ordinary source file: " + name) + need(hashlib.sha256(path.read_bytes()).hexdigest() == digest, + "operator source pin: " + str(path)) + pins[path.relative_to(HERE.parent).as_posix()] = digest + return pins + + +def exact_source_module(name, path, expected_digest): + """Execute the same source bytes whose fixed digest was just checked. + + SourceFileLoader.exec_module may use an existing .pyc even when bytecode + writes are disabled. Compilation here never consults that cache. + """ + source = path.read_bytes() + need(hashlib.sha256(source).hexdigest() == expected_digest, + "executed source digest: " + str(path)) + spec = importlib.util.spec_from_file_location(name, path) + need(spec is not None, "explicit source module spec") + module = importlib.util.module_from_spec(spec) + sys.modules[name] = module + exec(compile(source, str(path), "exec"), module.__dict__) + return module + + +def source_cache_control(): + """An unchecked-hash cache must never substitute for authenticated bytes.""" + name = "_pooled_operator_source_cache_control" + clean = b"witness = 'authenticated_source'\n" + stale = b"witness = 'stale_unchecked_hash_cache'\n" + before = sys.modules.get(name) + try: + with tempfile.TemporaryDirectory(prefix="pooled-operator-source-cache-") as temp: + path = Path(temp) / "fixture.py" + path.write_bytes(stale) + py_compile.compile(str(path), doraise=True, + invalidation_mode=py_compile.PycInvalidationMode.UNCHECKED_HASH) + path.write_bytes(clean) + spec = importlib.util.spec_from_file_location(name, path) + need(spec is not None and spec.loader is not None, "cache witness spec") + stock = importlib.util.module_from_spec(spec) + spec.loader.exec_module(stock) + need(stock.witness == "stale_unchecked_hash_cache", + "negative fixture must actually expose cached-source substitution") + exact = exact_source_module(name, path, hashlib.sha256(clean).hexdigest()) + need(exact.witness == "authenticated_source", "authenticated source bypasses stale cache") + rejected("executed_source_digest_mismatch", + lambda: exact_source_module(name, path, hashlib.sha256(stale).hexdigest()), + "executed source digest") + finally: + if before is None: + sys.modules.pop(name, None) + else: + sys.modules[name] = before + return {"unchecked_hash_pyc_fixture_exposes_stock_loader": True, + "exact_loader_executes_authenticated_source": True, + "wrong_source_digest_rejected": True} + + +@contextmanager +def retained_modules(): + """Import exact files without borrowing a caller's generic verify/vendor. + + A few upstream modules use absolute local imports. Temporarily provide their + exact aliases before executing every dependent module, then restore the + original module table and search path. Every nonstdlib transitive import + resolves to one of these preloaded exact-source modules. No source text is + changed and no bytecode is read from or written beside frozen sources. + """ + aliases = {"audit_core", "audit_verify", "staged_pair", + "staged_entries_applier", "inherited_frames", "verify", + "owner_verify", "operator_verify", "full_operator", + "pooled_owner_source"} + def owned(name): + return name in aliases or name == "vendor" or name.startswith("vendor.") + saved = {n: m for n, m in sys.modules.items() if owned(n)} + saved_path, saved_argv = list(sys.path), list(sys.argv) + saved_bytecode = sys.dont_write_bytecode + for name in saved: + del sys.modules[name] + sys.dont_write_bytecode = True + sys.argv = [str(CANDIDATE / "verify.py")] + + def load(name, path): + if path.is_relative_to(PRED): + digest = PINS[path.relative_to(PRED).as_posix()] + else: + digest = CANDIDATE_PINS[path.relative_to(CANDIDATE).as_posix()] + return exact_source_module(name, path, digest) + + try: + for name, relative in ( + ("audit_core", "vendor/audit_core.py"), + ("audit_verify", "vendor/audit_verify.py"), + ("staged_pair", "vendor/staged_pair.py"), + ("staged_entries_applier", "vendor/staged_entries_applier.py"), + ("inherited_frames", "checks/inherited_frames.py"), + ("verify", "verify.py"), ("owner_verify", "owner_verify.py"), + ): + load(name, PRED / relative) + vendor = types.ModuleType("vendor") + vendor.__path__ = [str(PRED / "vendor")] + sys.modules["vendor"] = vendor + full = load("vendor.full_operator", PRED / "vendor/full_operator.py") + vendor.full_operator = full + sys.modules["full_operator"] = full + vendor.t360_admission = load("vendor.t360_admission", PRED / "vendor/t360_admission.py") + vendor.exact_root = load("vendor.exact_root", PRED / "vendor/exact_root.py") + operator = load("operator_verify", PRED / "operator_verify.py") + pooled = load("pooled_owner_source", CANDIDATE / "verify.py") + # Only its predecessor-directory location changes. Its selector and + # context algorithm, including all imported owner predicates, are exact. + pooled.PRED = PRED + yield sys.modules["owner_verify"], operator, pooled + finally: + for name in list(sys.modules): + if owned(name): + del sys.modules[name] + sys.modules.update(saved) + sys.path[:] = saved_path + sys.argv[:] = saved_argv + sys.dont_write_bytecode = saved_bytecode + + +def bound_scan(operator, expected): + """Execute the unchanged scan code with only its expected RESULT rebound.""" + original = operator.read + expected_path = PRED / "RESULT.json" + def read_bound(path): + return deepcopy(expected) if path == expected_path else original(path) + namespace = dict(operator.scan.__globals__, read=read_bound) + return types.FunctionType(operator.scan.__code__, namespace, operator.scan.__name__, + operator.scan.__defaults__, operator.scan.__closure__) + + +def rejected(name, fn, expected_reason=None): + try: + fn() + except ValueError as error: + reason = str(error) + need(expected_reason is None or expected_reason in reason, + "wrong mutation rejection for " + name + ": " + reason) + return {"name": name, "reason": reason} + raise ValueError("accepted operator mutation: " + name) + + +def audit(controls=True): + pins = authenticate() + cache_control = source_cache_control() + expected = read(CANDIDATE / "RESULT.json") + with retained_modules() as (owner, operator, pooled): + ctx, dispatch = pooled.context() + need(dispatch == read(CANDIDATE / "owner/MIXED-DISPATCH.json"), + "exact t<1080 dispatch") + counts = dict(sorted(Counter(ctx[1].values()).items())) + need(counts == {"extra": 592, "extra-four": 1080, "gauge44": 1568}, + "exact active provider counts") + fill = read(CANDIDATE / "owner/FILL.json.gz") + need(fill["columns"] == ["time", "helper", "owner_replica", "child", "port", "offset"], + "literal fill schema") + need(fill["dispatch_overrides"] == [], "no hidden dispatch overrides") + rows = fill["rows"] + profile, idle = owner.walk(rows, ctx) + need(profile == {int(k): v for k, v in expected["profile"].items()}, "pooled owner profile") + need(idle == {int(k): v for k, v in expected["idle"].items()}, "pooled owner complement") + template = read(PRED / "owner/TEMPLATE.json.gz") + plan = read(PRED / "owner/PLAN.json.gz") + phases = read(PRED / "inputs/DATA-PHASES.json") + need(template["exact_data_phase_recipe_sha256"] == PINS["inputs/DATA-PHASES.json"], + "exact phase recipe binding") + ports = read(PRED / "inputs/THREE-base.json.gz")["ports"] + for tag in ("base", "extra"): + for kind in ("THREE", "FOUR"): + need(read(PRED / f"inputs/{kind}-{tag}.json.gz")["ports"] == ports, + "common ordered all112 port interface") + identities = operator.phase_checks(template, phases, ports) + need(identities == 10416, "complete exact phase identity count") + windows, pairs = operator.exact_windows(template, plan, ctx[0], phases) + scan = bound_scan(operator, expected) + need(scan(rows, ctx, windows, pairs, phases) == idle, + "exact original-axis complement equals owner complement") + results = [] + if controls: + bad = deepcopy(phases) + child = next(c for c in bad["recipes"][0]["idle_children"] if c["rank"] > 0) + child["translation_after"] = int(child["translation_after"]) ^ 1 + results.append(rejected("wrong_global_phase", + lambda: operator.phase_checks(template, bad, ports), "idle exact phase")) + bad_template = deepcopy(template) + bridge = next(e for e in bad_template["execution_schedule"] if e["kind"] == "bridge") + bridge["coefficient"] = -bridge["coefficient"] + results.append(rejected("wrong_signed_controller", + lambda: operator.phase_checks(bad_template, phases, ports), "scalar controller identity")) + original = rows[0][:] + tick = rows[0][0] + owner_id, child_id = next(k for k, (lo, hi, stream) in windows.items() if lo >= (tick, -1)) + rows[0][2:4] = owner_id, child_id + try: + results.append(rejected("cross_scalar_observation", + lambda: scan(rows, ctx, windows, pairs, phases), "strict exact observation window")) + finally: + rows[0][:] = original + wrong_ctx, _ = pooled.context(lambda t: t * 109 % 324 < 109) + results.append(rejected("pr4088_dispatch_on_pr4181_fill", + lambda: scan(rows, wrong_ctx, windows, pairs, phases))) + stale = deepcopy(expected) + stale["idle"] = read(PRED / "RESULT.json")["idle"] + results.append(rejected("stale_pr4088_idle_complement", + lambda: bound_scan(operator, stale)(rows, ctx, windows, pairs, phases), "exact phase residual")) + axis_mass = 360 * sum(len(c["orthogonal_axes"]) for r in phases["recipes"] for c in r["idle_children"]) + residual_mass = sum(rank * n for rank, n in idle.items()) + result = { + "status": "PASS_POOLED_ALL_CHARACTER_OPERATOR_ADMISSION", + "source_head_pr4088": "72d7efc181edb21806a878f174847c96dd410ab0", + "source_head_pr4181": "4ed92bed95dd483f5662e98ef246b258c3cfe64f", + "calls": len(ctx[0]), "active_provider_counts": counts, + "authenticated_word_catalogue": ["extra", "extra-four", "gauge44", "gauge44-four"], + "unused_catalogue_provider": "gauge44-four", + "hosted_rows": len(rows), "physical_bins": len(ctx[2]) * 112, + "exact_observation_windows": len(windows), + "ports": len(ports), "exact_Z4_identities": identities, + "all_characters": True, "all_positive_tensor_multiplicities": True, + "global_phase_retained": True, "original_axis_mass": axis_mass, + "hosted_width_mass": axis_mass - residual_mass, + "residual_rank_mass": residual_mass, "idle": idle, "profile": profile, + "paid_rank_mass": sum(rank * n for rank, n in profile.items()), + "controls": results, "source_pins": pins, + "source_execution_control": cache_control, + "scope": "Exact phase/chronology binding of the PR4181 fill under the retained local native endpoint and common-cover embedding interfaces. Source-bound interpreter reuse; not an independent algorithm, native rerun, ordinary/outer release, or an all-size multiplication theorem.", + } + need(authenticate() == pins, "read-only source inputs after audit") + return result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + parser.add_argument("--controls", action="store_true", help="Retained for explicit replay commands; controls run by default.") + args = parser.parse_args() + result = audit() + if args.output is not None: + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + print(json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/outer_check.py b/research/complex-pooled-full-admission/outer_check.py new file mode 100644 index 000000000..c0eee8c6b --- /dev/null +++ b/research/complex-pooled-full-admission/outer_check.py @@ -0,0 +1,450 @@ +#!/usr/bin/env python3 +"""Bounded exact checks for the written integer outer join. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +These are algebra/arithmetic checks, not execution of the physical tensor. +""" +import argparse +import ast +from fractions import Fraction as Q +import gzip +from hashlib import sha256 +import io +from itertools import product +import json +from math import gcd, isqrt, prod +from pathlib import Path, PurePosixPath +import subprocess +import tarfile + +HERE = Path(__file__).resolve().parent +BUNDLE_SHA256 = "a93f3e4df06a8ee18c69f68697cec463bbb86ddff642cc1df652d87ba642f046" +MANIFEST_SHA256 = "cc5c879b5c28c9d2d4191c1ac2c5563213c1b58ffd1e4d25a3e6c0a6a6dbeb18" +SOURCE_PINS = { + "f687fa171ef760fa98a4be1289717b47dd4ee0b3": { + "research/physical-gaussian-tensor/PROOF.md": "1e3450344552e744e0187cf1115c7b470bbe1babc9a2414586ff8ffc8f84476e", + "research/physical-gaussian-tensor/tensor_plan.py": "474730f42fcd2bd24720af4e08c71fb51cc374c3e16b8b6d7e565900f1a9e7c3", + "research/physical-gaussian-tensor/tensor_engine.py": "1a5a766426b16718e168619d5988cc18711b4574f0041ec7f3877c1024de59d1", + "research/physical-gaussian-tensor/tensor_word.py": "6ad8a2b9c9661ac42c727caefd8b4c4acf9f8bffedb5fe5f8a6e74675e85aa26", + "research/physical-gaussian-tensor/ARITHMETIC.md": "bf809380781faf39227b363aa1abd388694a4c26cac48548a3595d1aa0673440", + }, + "12fa8c5c844be21bfefb38a19503fbd867a11244": { + "research/crt-address-streams/PROOF.md": "7b141475955cc372c5936118ff16e8748b589b93de2d26b76da28feec9b45de4", + "research/crt-address-streams/crt_converter.py": "b81fe8b266af59f5c5354cf53276c36a16b3a4e5a2ec015e8c8969ee22a17fea", + "research/physical-synthetic-fourier/PROOF.md": "b2a6da7501a04848d0a42930da91f15b6653fccf42ed7a018cf602fc12a1d4f7", + "research/physical-synthetic-fourier/fourier_engine.py": "7ef404f4a758a67d9ebe111bbedf501aa8bab223c54d61704cdec629c1f07ad9", + }, +} + + +def need(ok, label): + if not ok: + raise ValueError(label) + + +def checked_blob(raw, expected, label): + need(sha256(raw).hexdigest() == expected, label) + return raw + + +def bundle_inventory(raw, manifest): + expected = {row["path"]: row for row in manifest["files"]} + need(len(expected) == len(manifest["files"]) == 35, "complete 35-file source references") + files = {} + with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as archive: + for entry in archive.getmembers(): + path = PurePosixPath(entry.name) + need(entry.isfile() and not path.is_absolute() and ".." not in path.parts + and "\\" not in entry.name and path.as_posix() == entry.name + and entry.name not in files and entry.name in expected, + "unique regular declared source reference") + row = expected[entry.name] + need(entry.size == row["bytes"] and entry.size < 2**20, "source reference extent") + value = archive.extractfile(entry).read() + need(len(value) == entry.size, "complete source reference bytes") + files[entry.name] = checked_blob(value, row["sha256"], "source reference digest") + need(set(files) == set(expected), "no omitted source reference") + return files + + +def source_contracts(files): + tensor = ast.parse(files["research/physical-gaussian-tensor/tensor_plan.py"]) + calls = {ast.unparse(node) for node in ast.walk(tensor) if isinstance(node, ast.Call)} + for expression in ("self.keep('dimensions', Count(axes))", "self.dimensions.increment()", + "self.keep('d', Count(self.dimensions))", "self.d.increment()", + "self.keep('gamma', Count.product(self.dimensions, scale))", + "scale.multiply_small(2)", "scale.add(self.j)", "scale.increment()"): + need(expression in calls, "literal TensorPlan dimension/normalization contract") + converter = ast.parse(files["research/crt-address-streams/crt_converter.py"]) + methods = [node for node in ast.walk(converter) + if isinstance(node, ast.FunctionDef) and node.name == "run_plan"] + expected = ast.parse("""def run_plan(self, payload, plan, rows, inverse=False, record_bits=None): + return self.run(payload, None, plan.dimensions, plan.p, + plan.record_bits if record_bits is None else record_bits, rows, + inverse=inverse, tensor_plan=plan) +""").body[0] + need(len(methods) == 1 and ast.dump(methods[0]) == ast.dump(expected), + "actual inverse CRT opaque-width override") + need(b"gamma=D(2u+ceil(log2(32p))+1)" in files["research/physical-gaussian-tensor/PROOF.md"], + "Gaussian complete inverse normalization reference") + need(b"F+ F- = F- F+ = I/M" in files["research/physical-synthetic-fourier/PROOF.md"], + "both synthetic Fourier transforms normalized") + need(b"three completed Karatsuba children" in files["research/physical-ring-product/word_product.py"], + "actual scalar three-child continuation") + need(b"[y-y^(21/40),y]" in + files["references/semantic-bulk/rad20/reports/review-reusable-banded-inverse.md"], + "retained short-interval prime premise") + return ["TensorPlan_dimensions_and_gamma", "CRT_explicit_record_width", + "normalized_Fourier_pair", "scalar_Karatsuba_continuation", "BHP_21_over_40"] + + +def frozen_sources(): + pins = json.loads((HERE / "OUTER-PINS.json").read_bytes()) + need(pins["archive"] == "frozen/outer-source/SOURCE-CONTRACTS.tar.gz" + and pins["archive_sha256"] == BUNDLE_SHA256 and pins["bytes"] == 116428 + and pins["manifest"] == "frozen/outer-source/MANIFEST.json" + and pins["manifest_sha256"] == MANIFEST_SHA256 and pins["files"] == 35, + "fixed outer proof-reference bundle") + for relative in (pins["archive"], pins["manifest"]): + need((HERE / relative).is_file() and not (HERE / relative).is_symlink(), + "regular proof-reference artifact") + manifest = json.loads(checked_blob((HERE / pins["manifest"]).read_bytes(), + MANIFEST_SHA256, "immutable reference manifest")) + need(manifest["canonical_base"] == "12fa8c5c844be21bfefb38a19503fbd867a11244" + and manifest["gaussian_head"] == "f687fa171ef760fa98a4be1289717b47dd4ee0b3", + "exact source commit family") + compressed = checked_blob((HERE / pins["archive"]).read_bytes(), BUNDLE_SHA256, + "immutable reference archive") + need(len(compressed) == 116428, "fixed compressed reference extent") + raw = gzip.decompress(compressed) + need(len(raw) < 2**20, "bounded reference archive") + files = bundle_inventory(raw, manifest) + overlap = 0 + for paths in SOURCE_PINS.values(): + for path, digest in paths.items(): + if path in files: + checked_blob(files[path], digest, "independent cited source pin") + overlap += 1 + need(overlap == 7, "all seven shared independent source references") + facts = source_contracts(files) + reduced = dict(manifest, files=manifest["files"][:-1]) + for label, check in ( + ("omitted_source_manifest_row", lambda: bundle_inventory(raw, reduced)), + ("changed_source_bytes", lambda: checked_blob( + files["research/physical-gaussian-tensor/tensor_plan.py"]+b"\n", + SOURCE_PINS["f687fa171ef760fa98a4be1289717b47dd4ee0b3"][ + "research/physical-gaussian-tensor/tensor_plan.py"], "changed source"))): + try: + check() + except ValueError: + pass + else: + raise ValueError("accepted invalid source binding: "+label) + return {"archive_sha256": BUNDLE_SHA256, "manifest_sha256": MANIFEST_SHA256, + "reference_files": len(files), "source_contract_checks": facts, + "controls": ["omitted_source_manifest_row", "changed_source_bytes"], + "scope": "Exact proof/constructor references; no source imports or physical execution"} + + +def trim(a): + while len(a) > 1 and a[-1] == 0: + a.pop() + return a + + +def divide_exact(a, b): + """Monic integer polynomial division, coefficients in increasing order.""" + a = list(a) + need(b[-1] == 1, "monic polynomial divisor") + q = [0] * (len(a) - len(b) + 1) + while len(a) >= len(b): + k, c = len(a) - len(b), a[-1] + q[k] = c + for j, v in enumerate(b): + a[k + j] -= c * v + trim(a) + need(a == [0], "exact cyclotomic division") + return trim(q) + + +def roots_of_unity(n): + """Exact powers of z in Z[z]/Phi_n, with no floating point.""" + phis = {} + for k in range(1, n + 1): + if n % k: + continue + polynomial = [-1] + [0] * (k - 1) + [1] + for d, earlier in phis.items(): + if k % d == 0: + polynomial = divide_exact(polynomial, earlier) + phis[k] = polynomial + phi = phis[n] + degree = len(phi) - 1 + one = (1,) + (0,) * (degree - 1) + powers = [one] + for _ in range(n): + row = [0] + list(powers[-1]) + high = row.pop() + for i in range(degree): + row[i] -= high * phi[i] + powers.append(tuple(row)) + need(powers[-1] == one, "root order divides n") + for d in range(1, n): + if n % d == 0: + need(powers[d] != one, "primitive root order") + need(all(sum(row[i] for row in powers[:-1]) == 0 for i in range(degree)), + "exact character orthogonality") + return powers[:-1], phi + + +def normalization(shape, targets): + """Every bilinear coefficient of RF+((RF-x)(RF-y)).""" + S = prod(shape) + need(len(shape) == len(targets) and + all(gcd(s, t) == 1 for s, t in zip(shape, targets)), "unit R map") + roots, phi = roots_of_unity(S) + addresses = list(product(*(range(s) for s in shape))) + zero = (0,) * len(roots[0]) + hit = (S,) + zero[1:] + def triple(a, b, z, final_R=True, final_sign=1): + answer = [0] * len(zero) + for j in addresses: + exponent = sum((S // s) * jv * + (final_sign * (t if final_R else 1) * zv - t * (av + bv)) + for s, t, jv, av, bv, zv in zip(shape, targets, j, a, b, z)) + row = roots[exponent % S] + for i, value in enumerate(row): + answer[i] += value + return tuple(answer) + cases = 0 + controls = {"omitted_final_R": False, "wrong_final_Fourier_sign": False, + "S_instead_of_S_squared": False} + for a in addresses: + for b in addresses: + location = tuple((x + y) % s for x, y, s in zip(a, b, shape)) + for z in addresses: + expected = hit if z == location else zero + value = triple(a, b, z) + need(value == expected, "complete bilinear Fourier coefficient") + cases += 1 + if not controls["omitted_final_R"]: + controls["omitted_final_R"] = triple(a, b, z, False) != expected + if not controls["wrong_final_Fourier_sign"]: + controls["wrong_final_Fourier_sign"] = triple(a, b, z, True, -1) != expected + if z == location: + # The three normalized transforms contribute S^-3. + controls["S_instead_of_S_squared"] |= Q(value[0], S**2) != 1 + return {"source_axes": shape, "target_axes": targets, "S": S, + "cyclotomic_polynomial": phi, "bilinear_coefficients": cases, + "mutation_witnesses": controls} + + +def crt_map(shape): + prefix, mus = 1, [] + for s in shape: + need(s >= 3 and s % 2 == 1 and gcd(prefix, s) == 1, "coprime odd CRT axes") + mus.append(pow(prefix, -1, s)) + prefix *= s + mapping = [tuple(mu * k % s for mu, s in zip(mus, shape)) for k in range(prefix)] + need(len(set(mapping)) == prefix, "all CRT coefficient addresses") + for k in range(prefix): + for l in range(prefix): + need(tuple((a + b) % s for a, b, s in zip(mapping[k], mapping[l], shape)) + == mapping[(k + l) % prefix], "CRT convolution homomorphism") + return mapping, mus + + +def rounded(x): + return (2 * x.numerator + x.denominator) // (2 * x.denominator) + + +def recovery(): + cases = 0 + for shape in ((3, 5), (3, 7), (5, 7)): + mapping, _ = crt_map(shape) + S = len(mapping) + for b in (2, 3, 5): + B = 1 << b + m = (S + 1) // 2 + need(2 * m - 2 < S, "no cyclic alias") + for mode in range(3): + x = [B - 1 if mode == 0 else (i * 3 + mode) % B for i in range(m)] + y = [B - 1 if mode == 0 else (i * 5 + 2 * mode) % B for i in range(m)] + convolution = [0] * S + for i, a in enumerate(x): + for j, c in enumerate(y): + convolution[i + j] += a * c + tensor = {mapping[k]: convolution[k] for k in range(S)} + restored = [] + for k, address in enumerate(mapping): + exact = Q(tensor[address], S * S * (1 << (2*b + 4))) + scale = S * S * (1 << (2*b + 4)) + error = Q(1 if k % 2 else -1, 4) + recovered = rounded(scale * exact + error) + need(recovered == convolution[k] and rounded(error) == 0, + "integer and imaginary recovery under strict margin") + restored.append(recovered) + carry, digits = 0, [] + for c in restored: + digits.append((c + carry) % B) + carry = (c + carry) // B + while carry: + digits.append(carry % B) + carry //= B + value = sum(digit * B**i for i, digit in enumerate(digits)) + need(value == sum(a * B**i for i, a in enumerate(x)) * + sum(a * B**i for i, a in enumerate(y)), "complete carry recovery") + cases += 1 + # A nonproduction format witness: 18 on a p-grid cannot use p+2 signed bits. + p = 12 + need(18 * (1 << p) >= 1 << (p + 1), "old disk-grid width rejects scaled integer") + # Degree four aliases to one at cyclic length three. + need(4 % 3 != 4, "insufficient padding mutation witness") + need(rounded(Q(1, 2)) != 0, "half-unit error cannot certify unique rounding") + try: + crt_map((3, 3)) + except ValueError: + pass + else: + raise ValueError("accepted duplicate CRT prime") + return {"complete_round_scale_CRT_carry_cases": cases, + "controls": ["disk_width_after_scaling", "cyclic_alias_without_padding", + "non_strict_half_unit_margin", "duplicate_CRT_prime"]} + + +def exact_arithmetic(): + C = Q("0.001730980255989036959962") + sigma, alpha, eta = Q("0.99826995"), Q("0.99827"), Q(1, 10**6) + tau, epsilon = Q(332353, 332929), Q(997, 1000) + need(1-C < sigma and tau < sigma < alpha < 1, "root strict exponent ordering") + internal, leaf = (1-eta)*sigma + eta*tau, (1-eta)*sigma + eta + need(internal < alpha and leaf < alpha, "complete recurrence exponent margins") + need(500*(1-alpha) < 1 and Q("0.998") < alpha, "fallback and reserved bill") + beta = 1-epsilon*(1-tau) + Phi = 1-epsilon*(1-alpha) + kappa = Q(1, 580) + need(beta < Phi and Q("0.9981") < Phi and Q(3, 5) < Phi, "complete outer cost gaps") + need(epsilon < Phi and 1-Phi > kappa, "strict target kappa allowance") + need(3**5 < 2**8, "log2(3) < 8/5 exact scalar exponent") + need(not tau < 1-C, "raw complex moment endpoint fails tau ordering") + old_Phi = 1-epsilon*(1-Q("0.99827101")) + need(not kappa < 1-old_Phi, "old root does not certify this kappa") + # Uniform gamma/p bound in blocks 2^(1000m)<=p<2^(1000(m+1)), m>=7. + gamma_ratio = Q(2, 2**7) + Q(8007, 2**21) + need(gamma_ratio < Q(1, 12), "eventual gamma <= p/12") + need(9007 < 8*8007, "logarithmic gamma term decreases between blocks") + margins = [] + for b in (32, 33): + p, gamma = 6*b, b//2 + need(216*b**3 + 12*b + 32 <= 2**b, "polynomial error coefficient bound") + E = Q(7, 2**(5*b-gamma)) + h = Q(1, 2**p) + scale = Q(2**(4*b+10), b*b) + output_error = scale * (Q(3, 2)*E + E*E + 2*h) + input_norm = (Q(1, 4)+E)**2 + 2*h + need(E < Q(1, 256) and input_norm < Q(1, 2) and output_error < Q(1, 2), + "sufficient recovery and third-call admission margins") + margins.append({"b": b, "gamma_cap": gamma, "E_upper": str(E), + "scaled_error_upper": str(output_error), + "third_input_norm_upper": str(input_norm)}) + need(Q(33, 32)**3 < 2, "polynomial coefficient bound propagates") + # For b -> b+2 the three positive scaled error terms decrease by at least + # factors 1/2, 1/1024, 1/16, respectively, even before the b^-2 decrease. + need(2**8 * Q(1, 2**9) == Q(1, 2) and + 2**8 * Q(1, 2**18) == Q(1, 1024) and + 2**8 * Q(1, 2**12) == Q(1, 16), "all-b recovery bound propagation") + D, u, j = 4, 4, 13 + gamma = D*(2*u+j+1) + need(gamma == 88 and gamma != 2*D*u and gamma != (D-1)*(2*u+j+1), + "normalization includes inverse factors and actual dimensions") + need(Q(2**(2*D*u), 2**gamma) != 1, "old restoration produces the wrong amplitude") + gate_cases = [] + for b, gamma, H in ((32, 8, 2**8), (48, 16, 2**12), (64, 24, 2**20-1)): + log_H = (H-1).bit_length() + need(b >= gamma+log_H+9, "encoded recovery gate") + E = Q(H, 2**(5*b-gamma)) # T<=2^b, p=6b. + h = Q(1, 2**(6*b)) + scale = 2**(4*b+4) # S= gamma+b+log_H+8, "recovery gate also supplies TensorPlan margin") + gate_cases.append({"b": b, "gamma": gamma, "H": H, "ceil_log2_H": log_H, + "coarse_recovery_upper": str(coarse_bound)}) + return {"complex_rate_lower": str(C), "sigma": str(sigma), "tau": str(tau), + "alpha": str(alpha), "eta": str(eta), "internal": str(internal), + "leaf": str(leaf), "beta": str(beta), "Phi": str(Phi), "kappa": str(kappa), + "saving_gap": str(1-Phi-kappa), "router_gap": str(Phi-beta), + "gamma_ratio_upper_for_p_ge_2_pow_7000": str(gamma_ratio), + "sufficient_margin_base_cases_not_production_plans": margins, + "encoded_recovery_gate_cases_not_production_plans": gate_cases, + "controls": ["sigma_without_router_slack", "old_root_target_kappa", + "omitted_inverse_normalization", "axes_dimensions_off_by_one"]} + + +def prime_fixture(): + D, d, targets = 4, 5, (2048, 2048, 4096, 4096) + used, sources = set(), [] + for t in targets: + lower, upper = Q((2*d-1)*t, 2*d), Q((4*d-1)*t, 4*d) + selected = None + for s in range(lower.numerator//lower.denominator+1, (upper.numerator-1)//upper.denominator+1): + if s not in used and s >= 3 and s % 2 and all(s % k for k in range(3, isqrt(s)+1, 2)): + selected = s + break + need(selected is not None, "bounded distinct-prime fixture") + s = selected + need(lower < s < upper and 4*d*(t-s) > s and (2*d-1)*(t-s) < s, + "interior prime interval implies actual TensorPlan ratio guards") + used.add(s) + sources.append(s) + need(prod(sources)*2 > prod(targets), "complete prime product exceeds T/2") + return {"scope": "finite interval and ratio fixture, not a production TensorPlan", + "dimensions": D, "d": d, "source_axes": sources, "target_axes": targets} + + +def verify_sources(repo): + rows = [] + for commit, paths in SOURCE_PINS.items(): + for path, expected in paths.items(): + raw = subprocess.run(["git", "-C", str(repo), "show", commit+":"+path], + check=True, stdout=subprocess.PIPE).stdout + need(sha256(raw).hexdigest() == expected, "exact cited source: "+path) + rows.append({"commit": commit, "path": path, "sha256": expected}) + return rows + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--source-repo", type=Path, help="Additionally hash the nine cited exact Git source blobs") + parser.add_argument("--out", type=Path) + args = parser.parse_args() + bundle = frozen_sources() + reports = [normalization(s, t) for s, t in + (((3,), (4,)), ((5,), (8,)), ((3, 5), (4, 8)), ((3, 7), (4, 8)))] + controls = {name: any(row["mutation_witnesses"][name] for row in reports) + for name in reports[0]["mutation_witnesses"]} + need(all(controls.values()), "normalization mutants distinguished") + arithmetic = exact_arithmetic() + recovered = recovery() + receipt = { + "status": "PASS_EXACT_OUTER_ALGEBRA_AND_ARITHMETIC_NOT_PHYSICAL_EXECUTION", + "normalization": reports, "normalization_controls": controls, + "arithmetic": arithmetic, "recovery": recovered, "prime_interval_fixture": prime_fixture(), + "immutable_source_references": bundle, + "source_pins": SOURCE_PINS, + "source_blob_checks": verify_sources(args.source_repo) if args.source_repo else [], + "source_blob_checks_performed": args.source_repo is not None, + "controls": list(controls) + arithmetic["controls"] + recovered["controls"] + bundle["controls"], + "checker_sha256": sha256(Path(__file__).read_bytes()).hexdigest(), + "scope": "Complete bilinear coefficient checks only on four stated finite groups; exact rational exponent and sufficient-margin certificates. Written eventual prime supply, Gaussian/CRT/Fourier source contracts, replacement-root binding, tape execution and all-size restoration are not proved by this checker.", + } + if args.out: + args.out.write_text(json.dumps(receipt, sort_keys=True, indent=2)+"\n") + print(receipt["status"], "bilinear coefficients", + sum(row["bilinear_coefficients"] for row in reports), "controls", len(receipt["controls"])) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/outer_domain.py b/research/complex-pooled-full-admission/outer_domain.py new file mode 100644 index 000000000..cf83e9d32 --- /dev/null +++ b/research/complex-pooled-full-admission/outer_domain.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Bounded exact cost, constructor-source and CRT-token checks. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +No production ordinary constructor or numerical payload is executed. +""" +import argparse +import ast +from fractions import Fraction as Q +from hashlib import sha256 +import importlib.util +import json +from pathlib import Path +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import outer_factory as factory + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def reject(name, action): + try: + action() + except (ValueError, KeyError): + return name + raise ValueError("control accepted: "+name) + + +def source_receipts(contracts): + pins = json.loads((HERE/"OUTER-DOMAIN-PINS.json").read_bytes()) + need(pins["schema"] == 1, "outer-domain receipt schema") + receipts = {name: json.loads(factory.checked(HERE/"evidence"/name, expected)) + for name, expected in pins["receipts"].items()} + crt = receipts["CRT-3935-COMPATIBILITY.json"] + need(crt["old"] == "240597ed313fc2854c0462b23c89dc3bae72aaf5" + and crt["new"] == factory.GAUSSIAN_HEAD and crt["all_same"], "exact CRT source comparison identity") + network = json.loads(contracts[factory.CRT+"/NETWORK-SOURCES.json"]) + expected = {row["path"]: row for row in network["files"]} + observed = {row["path"]: row for row in crt["files"]} + need(len(expected) == len(observed) == 8 and set(expected) == set(observed), "all eight CRT source inputs") + replayed = [] + for name, row in expected.items(): + seen = observed[name] + need(seen["same"] and seen["sha256"] == row["sha256"] and seen["bytes"] == row["size"], + "complete retained archive comparison: "+name) + if name in contracts: + need(factory.digest(contracts[name]) == row["sha256"], "replayed CRT constructor comparison") + replayed.append(name) + need(len(replayed) == 5, "five included CRT constructor/proof inputs") + cohort = receipts["GAUSSIAN-PHYSICAL-COHORT.json"] + need(cohort["source_head"] == factory.GAUSSIAN_HEAD and len(cohort["found"]) == 10, + "complete retained constructor cohort observation") + for row in cohort["found"]: + need(row["archive_chain"] and row["archive_chain"][0].startswith("PR3935:inputs/"), + "explicit retained nested archive path") + if row["path"] in contracts: + need(factory.digest(contracts[row["path"]]) == row["sha256"] and row["matches_contract"], + "replayed nested constructor member comparison") + else: + need(row["path"] == "research/physical-complex-controller/scalar_program.py" + and row["sha256"] == "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "separately pinned ScalarProgram cohort") + return {"retained_full_CRT_inputs": 8, "replayed_CRT_contract_bodies": replayed, + "retained_nested_constructor_members": 10, + "whole_runtime_archive_comparison_replayed": False, + "receipt_sha256": pins["receipts"]} + + +CONSTRUCTORS = { + "ComposedRoot": ("research/t74-support-composition/composed_engine.py", ["self", "router", "root", "policy"], 1), + "Fourier": ("research/physical-synthetic-fourier/fourier_engine.py", ["self", "layer"], 0), + "Convolution": ("research/physical-ring-product/convolution_engine.py", ["self", "fourier"], 1), + "Cyclic": ("research/physical-chirp-middle/cyclic_engine.py", ["self", "convolution"], 1), + "Chirp": ("research/physical-chirp-middle/chirp_engine.py", ["self", "cyclic"], 1), + "Tensor": ("research/physical-gaussian-tensor/tensor_engine.py", ["self", "chirp", "router"], 0), + "FullRouter": ("research/physical-gaussian-tensor/tensor_router.py", ["self", "native"], 1), + "Converter": ("research/crt-address-streams/crt_converter.py", ["self", "router"], 0), +} + + +def constructors(contracts): + result = {} + for name, (path, arguments, defaults) in CONSTRUCTORS.items(): + classes = [node for node in ast.parse(contracts[path]).body + if isinstance(node, ast.ClassDef) and node.name == name] + need(len(classes) == 1, "one exact constructor class") + init = [node for node in classes[0].body if isinstance(node, ast.FunctionDef) and node.name == "__init__"] + need(len(init) == 1 and [arg.arg for arg in init[0].args.args] == arguments + and len(init[0].args.defaults) == defaults, "actual constructor parameters: "+name) + result[name] = arguments[1:] + return result + + +def factory_graph(body): + tree = ast.parse(body) + fn = next(node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name == "production_consumers") + calls = [node for node in ast.walk(fn) if isinstance(node, ast.Call)] + full = [node for node in calls if isinstance(node.func, ast.Attribute) and node.func.attr == "FullRouter"] + need(len(full) == 2 and all(len(node.args) == 1 and isinstance(node.args[0], ast.Name) for node in full) + and {node.args[0].id for node in full} == {"gaussian_native", "crt_native"}, + "FullRouter receives ordinary natives, not Router objects") + natives = [node for node in calls if isinstance(node.func, ast.Name) and node.func.id == "native"] + need(len(natives) == 3 and all(not node.args and not node.keywords for node in natives), + "three additional fresh ordinary factories") + pooled = [node for node in calls if isinstance(node.func, ast.Attribute) and node.func.attr == "production_layer"] + need(len(pooled) == 1 and not pooled[0].args and not pooled[0].keywords, + "one pooled complex root owns the fourth ordinary factory") + need(not any(isinstance(node.func, ast.Attribute) and node.func.attr == "opened" for node in calls), + "constructor adapter opens no cold source cohort") + + +def token_checks(contracts): + """Execute the unchanged loader's authentication and token, not numerical classes.""" + with tempfile.TemporaryDirectory(prefix="outer-crt-token-") as directory: + root = Path(directory) + for path in (factory.CRT+"/crt_sources.py", factory.CRT+"/SOURCES.json", factory.ASSEMBLY): + target = root/path + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(contracts[path]) + module_path = root/factory.CRT/"crt_sources.py" + spec = importlib.util.spec_from_file_location("outer_domain_crt_fixture", module_path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + factory.authenticate_module(module, contracts[factory.CRT+"/crt_sources.py"]) + state = object() # Token-only fixture, never a production cohort. + controls = [reject("unbound_CRT_token", module.activate)] + with factory.crt_token(module, state): + need(module.activate() is state, "real CRT activate returns the scoped token") + controls.append(reject("nested_CRT_token", lambda: enter_token(module, object()))) + need(module._active is state, "nested rejection preserves outer token") + need(module._active is None, "successful token scope restoration") + try: + with factory.crt_token(module, state): + raise RuntimeError("injected post-authentication scope failure") + except RuntimeError: + pass + need(module._active is None, "exception token scope restoration") + assembly = root/factory.ASSEMBLY + assembly.write_bytes(contracts[factory.ASSEMBLY]+b"\nchanged\n") + controls.append(reject("changed_CRT_authenticated_input", lambda: enter_token(module, state))) + need(module._active is None, "activation failure restores the source token") + controls.append(reject("changed_loaded_constructor_body", lambda: factory.authenticate_module( + module, contracts[factory.CRT+"/crt_sources.py"]+b"\n"))) + return controls + + +def enter_token(module, state): + with factory.crt_token(module, state): + pass + + +def bridge_checks(): + aliases = (factory.GLOBAL_ALIAS, factory.LOCAL_ALIAS) + need(all(name not in sys.modules for name in aliases), "fresh bounded bridge-check aliases") + controls = [] + for alias in aliases: + sentinel = object() + sys.modules[alias] = sentinel + try: + controls.append(reject("foreign_private_bridge_alias:"+alias, enter_bridge)) + need(sys.modules[alias] is sentinel, "rejection preserves the foreign module") + finally: + del sys.modules[alias] + previous = None + for _ in range(2): + with factory.global_bridge() as module: + need(callable(module.production_layer) and sys.modules[factory.GLOBAL_ALIAS] is module, + "exact authenticated global-bridge definitions compiled") + local = module.local_module() + need(local is not previous and sys.modules[factory.LOCAL_ALIAS] is local + and callable(local.frozen_inputs), "fresh exact-byte local bridge definitions") + previous = local + need(all(name not in sys.modules for name in aliases), "both private bridge aliases restored") + return controls + + +def enter_bridge(): + with factory.global_bridge(): + pass + + +def exponent_bounds(sigma=Q(".99826995"), alpha=Q(".99827")): + C = Q(".001730980255989036959962") + tau, eta, cap = Q(332353, 332929), Q(1, 10**6), Q(997, 1000) + beta = 1-cap*(1-tau) + Phi = 1-cap*(1-alpha) + target = 1-Q(1, 580) + need(1-C < sigma and tau < sigma < alpha, "stopped-tree moment and inequality ordering") + internal = sigma-eta*(sigma-tau) + leaf = sigma+eta*(1-sigma) + need(internal < alpha and leaf < alpha and Q(499, 500) < alpha, + "all internal, stopped-leaf and reservation costs") + need(500*(1-alpha) < 1, "complete failed-guard root tariff") + need(beta == Q(41544341, 41616125) and beta < Phi < target, + "complete support-cap, router and final logarithm allowance") + need(Q(".9981") < Phi and Q(".603") < Phi and Q(3, 5) < Phi, + "complete Gaussian, chirp-extra and scalar bills") + return {name: str(value) for name, value in dict(C=C, tau=tau, sigma=sigma, alpha=alpha, + internal=internal, leaf=leaf, beta=beta, Phi=Phi, target=target, + internal_gap=alpha-internal, leaf_gap=alpha-leaf, router_gap=Phi-beta, + final_log_gap=target-Phi, kappa=Q(1, 580)).items()} + + +def certificate(): + contracts, manifest = factory.contract_sources() + source = source_receipts(contracts) + specifications = factory.runtime_pins() + for package, rows in specifications.items(): + for name, row in rows["files"].items(): + path = package+"/"+name + if path in contracts: + need(factory.digest(contracts[path]) == row["sha256"], "runtime pins match included contracts") + graph = (HERE/"outer_factory.py").read_bytes() + factory_graph(graph) + mutated = graph.replace(b"FullRouter(gaussian_native)", b"FullRouter(Router(gaussian_native))") + need(mutated != graph, "constructor mutation reaches the actual invocation") + controls = token_checks(contracts) + controls.extend(bridge_checks()) + controls.extend([ + reject("original_sigma_below_tau", lambda: exponent_bounds(1-Q(".001730980255989036959962"))), + reject("old_complex_layer_target", lambda: exponent_bounds(alpha=Q(".99827101"))), + reject("Router_passed_as_native", lambda: factory_graph(mutated)), + ]) + return {"status": "PASS_OUTER_COST_DOMAIN_SOURCE_AND_TOKEN_CHECKS", + "exact_exponents": exponent_bounds(), "source_comparison": source, + "constructor_parameters": constructors(contracts), + "source_contract_files": len(manifest["files"]), + "runtime_package_pins": {name: len(row["files"]) for name, row in specifications.items()}, + "controls_rejected": controls, + "real_CRT_loader_authentication_executed": True, + "global_bridge_definitions_compiled_from_authenticated_bytes": True, + "local_bridge_definitions_compiled_in_two_fresh_scopes": True, + "token_scope_success_and_exception_restoration": True, + "production_native_constructors_executed": False, + "numerical_payload_executed": False, + "runtime_source_closure_supplied": False, + "scope": "Exact exponents, actual constructor source interfaces, retained archive comparison receipts and actual CRT loader token lifecycle on a small token-only fixture. The production adapter and conditional all-size proof are distinct from these bounded checks."} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path) + args = parser.parse_args() + result = certificate() + encoded = json.dumps(result, sort_keys=True, indent=2)+"\n" + if args.output: + args.output.write_text(encoded) + else: + print(encoded, end="") + print(result["status"]+" controls="+str(len(result["controls_rejected"]))+ + " production_native_constructors_executed=false numerical_payload_executed=false") + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/outer_factory.py b/research/complex-pooled-full-admission/outer_factory.py new file mode 100644 index 000000000..30b79e2af --- /dev/null +++ b/research/complex-pooled-full-admission/outer_factory.py @@ -0,0 +1,244 @@ +"""Construct the pooled Gaussian/CRT consumers in one existing physical cohort. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +This module does not open a cold cohort or execute a production payload. +The caller supplies complete authenticated runtime source packages; the small +published proof-reference archive alone is intentionally insufficient. +""" +from contextlib import contextmanager +from hashlib import sha1, sha256 +import importlib +import importlib.util +import io +import json +from pathlib import Path, PurePosixPath +import sys +import tarfile +import tempfile +from types import ModuleType, SimpleNamespace + +HERE = Path(__file__).resolve().parent +GAUSSIAN = "research/physical-gaussian-tensor" +CRT = "research/crt-address-streams" +BASE = "12fa8c5c844be21bfefb38a19503fbd867a11244" +GAUSSIAN_HEAD = "f687fa171ef760fa98a4be1289717b47dd4ee0b3" +ASSEMBLY = "upstream/build/sections/08-assembly.tex" +GLOBAL_ALIAS = "pooled_outer_authenticated_global_bridge" +LOCAL_ALIAS = "pooled_physical_local_bridge" + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def digest(body): + return sha256(body).hexdigest() + + +def checked(path, expected): + need(path.is_file() and not path.is_symlink(), "regular constructor source: "+str(path)) + body = path.read_bytes() + need(digest(body) == expected, "constructor source SHA256: "+str(path)) + return body + + +def contract_sources(): + """Read the bounded proof/constructor reference archive, without execution.""" + pins = json.loads((HERE/"OUTER-PINS.json").read_bytes()) + need(pins["schema"] == 1, "outer contract pin schema") + manifest = json.loads(checked(HERE/pins["manifest"], pins["manifest_sha256"])) + raw = checked(HERE/pins["archive"], pins["archive_sha256"]) + need(len(raw) == pins["bytes"] < 2**20, "bounded constructor reference archive") + expected = {row["path"]: row for row in manifest["files"]} + need(len(expected) == len(manifest["files"]) == pins["files"], "unique outer contract inventory") + result = {} + with tarfile.open(fileobj=io.BytesIO(raw), mode="r:gz") as archive: + for member in archive.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and ".." not in path.parts + and path.as_posix() == member.name and "\\" not in member.name + and member.name in expected and member.name not in result + and member.size < 2**20, "declared regular constructor reference") + body = archive.extractfile(member).read() + row = expected[member.name] + blob = sha1(b"blob "+str(len(body)).encode()+b"\0"+body).hexdigest() + need(len(body) == row["bytes"] and digest(body) == row["sha256"] + and blob == row["git_blob"], "exact source contract member") + result[member.name] = body + need(set(result) == set(expected), "complete outer source contract set") + return result, manifest + + +def runtime_pins(): + pins = json.loads((HERE/"OUTER-FACTORY-PINS.json").read_bytes()) + need(pins["schema"] == 1 and set(pins["packages"]) == {GAUSSIAN, CRT}, + "two exact outer runtime package identities") + need(pins["packages"][GAUSSIAN]["commit"] == GAUSSIAN_HEAD + and pins["packages"][CRT]["commit"] == BASE, "fixed runtime source heads") + return pins["packages"] + + +@contextmanager +def global_bridge(): + """Compile the authenticated bridge bytes, without a bytecode-cache loader.""" + pins = json.loads((HERE/"OUTER-FACTORY-PINS.json").read_bytes()) + expected = pins["local_bridges"]["physical_global_bridge.py"] + body = checked(HERE/"physical_global_bridge.py", expected) + need(GLOBAL_ALIAS not in sys.modules, "fresh private global-bridge alias") + need(LOCAL_ALIAS not in sys.modules, "fresh private local-bridge alias") + module = ModuleType(GLOBAL_ALIAS) + module.__file__ = str(HERE/"physical_global_bridge.py") + sys.modules[GLOBAL_ALIAS] = module + try: + exec(compile(body, module.__file__, "exec", optimize=0), module.__dict__) + yield module + finally: + local = getattr(module, "_local_bridge", None) + if local is not None and sys.modules.get(LOCAL_ALIAS) is local: + del sys.modules[LOCAL_ALIAS] + if sys.modules.get(GLOBAL_ALIAS) is module: + del sys.modules[GLOBAL_ALIAS] + + +def copy_runtime(source_root, destination, package, specification): + """Copy only declared, authenticated files; unpinned siblings never enter sys.path.""" + target = destination/package + target.mkdir(parents=True) + for name, row in specification["files"].items(): + path = PurePosixPath(name) + need(not path.is_absolute() and ".." not in path.parts and path.as_posix() == name, + "relative runtime package file") + body = checked(source_root/package/name, row["sha256"]) + need(len(body) == row["bytes"] and + sha1(b"blob "+str(len(body)).encode()+b"\0"+body).hexdigest() == row["git_blob"], + "complete runtime file identity") + output = target/name + output.parent.mkdir(parents=True, exist_ok=True) + output.write_bytes(body) + return target + + +def authenticate_module(module, body): + path = Path(module.__file__) + need(path.is_file() and not path.is_symlink() and path.read_bytes() == body, + "loaded module matches retained bytes: "+module.__name__) + + +@contextmanager +def crt_token(module, state): + """Scoped loader token; authentication is performed before entering here.""" + need(module._active is None, "unbound CRT loader in existing tensor cohort") + module._active = state + try: + need(module.activate() is state, "CRT and tensor share one active source state") + yield + finally: + module._active = None + + +def consumers_idle(consumers): + consumers.tensor.idle() + consumers.converter.idle() + from words import BLANK + for owner in (consumers.tensor, consumers.converter): + need(owner.closed and not owner.pool.live and owner.output.read() == BLANK, + "consume complete outer factory returns before leaving the cohort") + + +@contextmanager +def production_consumers(*, tensor_source_root, crt_source_root): + """Yield actual Tensor/Converter owners inside tensor_sources.opened(). + + tensor_source_root contains the complete f687 PR3935 package, including + its immutable archives. crt_source_root contains the base CRT package. + They may be distinct source trees. The caller must already have opened + the authenticated tensor cohort. Four fresh ordinary instances are + allocated before numerical input. Their finite compilation is charged. + """ + contracts, _ = contract_sources() + pins = runtime_pins() + tensor_sources = sys.modules.get("tensor_sources") + need(tensor_sources is not None, "open the authenticated tensor cohort first") + authenticate_module(tensor_sources, contracts[GAUSSIAN+"/tensor_sources.py"]) + state = tensor_sources.active() + crt_names = {name[:-3] for name in pins[CRT]["files"] if name.endswith(".py") and "/" not in name} + need(not (crt_names & set(sys.modules)), "fresh CRT extension in the existing tensor cohort") + old_path = sys.path[:] + old_cache = sys.pycache_prefix + old_write = sys.dont_write_bytecode + before_modules = set(sys.modules) + crt_module = None + tensor_source_root = Path(tensor_source_root).resolve() + crt_source_root = Path(crt_source_root).resolve() + with tempfile.TemporaryDirectory(prefix="pooled-outer-factory-") as directory: + staged = Path(directory) + tensor_package = copy_runtime(tensor_source_root, staged, GAUSSIAN, pins[GAUSSIAN]) + crt_package = copy_runtime(crt_source_root, staged, CRT, pins[CRT]) + assembly = staged/ASSEMBLY + assembly.parent.mkdir(parents=True) + assembly.write_bytes(contracts[ASSEMBLY]) + try: + sys.pycache_prefix = str(staged/"empty-bytecode") + sys.dont_write_bytecode = True + sys.path[:0] = [str(HERE), str(crt_package), str(tensor_package)] + # Reject incompatible preloaded package modules before importing. + for package, row in pins.items(): + for name, expected in row["files"].items(): + if name.endswith(".py") and "/" not in name and name[:-3] in sys.modules: + module = sys.modules[name[:-3]] + checked(Path(module.__file__), expected["sha256"]) + spec = importlib.util.spec_from_file_location("crt_sources", crt_package/"crt_sources.py") + crt_module = importlib.util.module_from_spec(spec) + sys.modules["crt_sources"] = crt_module + spec.loader.exec_module(crt_module) + crt_module.authenticate() + crt_module.check_tree(tensor_source_root, crt_module.source_manifest()) + with crt_token(crt_module, state): + names = ("active_sources", "active_root", "retuned_native", "retuned_machine", + "composed_engine", "fourier_engine", "convolution_engine", "cyclic_engine", + "chirp_engine", "tensor_engine", "tensor_router", "crt_converter") + modules = {name: importlib.import_module(name) for name in names} + from cardinal_counts import Count + from records import Tape + for name, module in modules.items(): + matches = [body for path, body in contracts.items() if path.endswith("/"+name+".py")] + need(len(matches) == 1, "one retained constructor body: "+name) + authenticate_module(module, matches[0]) + need(not hasattr(module, "Count") or module.Count is Count, + "one physical Count vocabulary: "+name) + need(not hasattr(module, "Tape") or module.Tape is Tape, + "one physical Tape vocabulary: "+name) + from router_engine import Router + with global_bridge() as physical_global_bridge: + root = physical_global_bridge.production_layer() + native = modules["retuned_native"].build_native + support_native, gaussian_native, crt_native = native(), native(), native() + complex_native = root.machine.monomial.compact.binary.native + need(len({id(value) for value in (complex_native, support_native, gaussian_native, crt_native)}) == 4, + "four distinct complete ordinary owners") + support = modules["composed_engine"].ComposedRoot(Router(support_native), root) + fourier = modules["fourier_engine"].Fourier(support) + convolution = modules["convolution_engine"].Convolution(fourier) + cyclic = modules["cyclic_engine"].Cyclic(convolution) + chirp = modules["chirp_engine"].Chirp(cyclic) + tensor_router = modules["tensor_router"].FullRouter(gaussian_native) + tensor = modules["tensor_engine"].Tensor(chirp, tensor_router) + crt_router = modules["tensor_router"].FullRouter(crt_native) + converter = modules["crt_converter"].Converter(crt_router) + consumers = SimpleNamespace(tensor=tensor, converter=converter, root=root, + support=support, source_state=state) + consumers_idle(consumers) + yield consumers + consumers_idle(consumers) + finally: + if crt_module is not None: + crt_module._active = None + sys.path[:] = old_path + sys.pycache_prefix = old_cache + sys.dont_write_bytecode = old_write + # Modules newly loaded from private staging must not survive it. + for name in set(sys.modules)-before_modules: + path = getattr(sys.modules[name], "__file__", None) + if name == "crt_sources" or (path and Path(path).is_relative_to(staged)): + del sys.modules[name] diff --git a/research/complex-pooled-full-admission/outer_suite.py b/research/complex-pooled-full-admission/outer_suite.py new file mode 100644 index 000000000..339ff24c7 --- /dev/null +++ b/research/complex-pooled-full-admission/outer_suite.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +"""Bounded outer checks; no production construction or numerical payload. + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Each child finishes and its status propagates before returning. +""" +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent + + +def main(): + options = ['-O'] if not __debug__ else [] + with tempfile.TemporaryDirectory(prefix='pooled-outer-checks-') as directory: + env = dict(os.environ, PYTHONDONTWRITEBYTECODE='1', + PYTHONPYCACHEPREFIX=str(Path(directory)/'bytecode')) + env.pop('PYTHONOPTIMIZE', None) + for name, flag, recorded in ( + ('outer_check.py', '--out', 'OUTER-CHECK-PORTABLE.json'), + ('outer_domain.py', '--output', 'OUTER-DOMAIN.json')): + receipt = Path(directory)/recorded + subprocess.run([sys.executable, *options, '-B', str(HERE/name), + flag, str(receipt)], env=env, check=True, timeout=90) + if json.loads(receipt.read_bytes()) != json.loads((HERE/'evidence'/recorded).read_bytes()): + raise ValueError('fresh bounded receipt differs from preserved evidence: '+recorded) + print('PASS_BOUNDED_OUTER_SUITE_NOT_PRODUCTION_EXECUTION') + + +if __name__ == '__main__': + main() diff --git a/research/complex-pooled-full-admission/physical_bridge.py b/research/complex-pooled-full-admission/physical_bridge.py new file mode 100644 index 000000000..b005982c2 --- /dev/null +++ b/research/complex-pooled-full-admission/physical_bridge.py @@ -0,0 +1,351 @@ +"""Source-bound complete macro lowering for the three pooled providers. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +This is a static exact compilation audit, not a physical execution theorem. +""" +import argparse +import ast +from collections import Counter +from contextlib import contextmanager +from copy import deepcopy +from fractions import Fraction +import gzip +from hashlib import sha256 +import io +import json +from pathlib import Path, PurePosixPath +import tarfile +import tempfile +import types + +HERE = Path(__file__).resolve().parent +BASE = "12fa8c5c844be21bfefb38a19503fbd867a11244" +BUNDLE_SHA256 = "91226b99943069f21d845c3242b54ba492418d1194422d04cf2569fd14cbb9ea" +SOURCE_PINS = { + 'research/physical-scalar-stream/scalar_words.py': 'f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00', + 'research/physical-scalar-stream/scalar_engine.py': 'be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6', + 'research/physical-complex-controller/scalar_packets.py': 'cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35', + "research/t74-physical-layer/compile_word.py": "1ae8eeedd1a3e8fea68762550d6f7c9495112785ed82bf824d8f82eba21f64a2", + "research/t74-physical-layer/t74_machine.py": "3bc4c40f275852cea82dbdcf41b8e586bae2e599112ee073a367acc66f37ce83", + "research/t74-physical-layer/PROOF.md": "1054f13f3e370a2e5d5f5cbc0e767e84927d4879f4c7be54cccb9b9a6a58e8ba", + "research/physical-complex-controller/scalar_program.py": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "research/physical-complex-controller/bank_packets.py": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "research/physical-complex-controller/machine.py": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "research/physical-complex-compact/PROOF.md": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48", + "research/physical-gaussian-leaf/inputs/pr3087.tar": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", +} +NATIVE_PINS = { + "gauge44": { + "CANONICAL-WORD.json.gz": "f07fae1011160b53e2df1f3135465db1277a093319de2a1da52d648f00a39542", + "LOCAL-PROGRAMS.json.gz": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "CLIFFORD-RECIPES.json": "bf88fc775e883227bbea9532ebf97df9e29576054dc0a893f8dc7fa1dc9744e2", + "RESIDUAL-ADAPTERS.json": "4711da8324861b5ab4d50dbcf1404c7f14c1b20b87bb750959912ff5da1c2e76", + }, + "extra": { + "CANONICAL-WORD.json.gz": "882271d70602354cbada8d77f479703ccc6c47e689e8ccd91f9e4c87de0f4379", + "LOCAL-PROGRAMS.json.gz": "67d700388eaa162e008e7d6f588278fb429872cfc5b56b7dcddc9f576316bc72", + "CLIFFORD-RECIPES.json": "3d90c6657966224c7b92e85dddec28633ef7fd56af9eafeeb44fef468605ff06", + "RESIDUAL-ADAPTERS.json": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d", + }, + "extra-four": { + "CANONICAL-WORD.json.gz": "06168f8f432aa153a0605177e95239261d093894f1c3cc826fcd98fc5671c2f3", + "LOCAL-PROGRAMS.json.gz": "d1f91c2d18262e4aff221fa0daa8441a968ececc4fd53ae3b52b4db9afb5aaba", + "CLIFFORD-RECIPES.json": "d259754558d9616665069423644a71535b5c331a565c77211b9719f0a319d29d", + "RESIDUAL-ADAPTERS.json": "e14450952c98caa3f948527a3dd107555381eed6a08dd041bc859d142aa3522d", + }, +} +PROFILES = { + "gauge44": {1: 2487, 2: 713, 3: 224, 4: 102, 5: 20, 8: 8}, + "extra": {1: 2487, 2: 713, 3: 224, 4: 102, 5: 20, 8: 8}, + "extra-four": {1: 2489, 2: 713, 3: 227, 4: 99, 5: 20, 8: 8}, +} + + +def need(condition, label): + if not condition: + raise ValueError(label) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":")).encode() + + +def checked(path, expected): + need(path.is_file() and not path.is_symlink(), "regular input: " + str(path)) + raw = path.read_bytes() + need(sha256(raw).hexdigest() == expected, "source drift: " + str(path)) + return raw + + +def module(name, raw): + result = types.ModuleType(name) + result.__file__ = name + exec(compile(raw, name, "exec", optimize=0), result.__dict__) + return result + + +def member(raw, name): + with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as archive: + rows = [r for r in archive.getmembers() if r.name == name] + need(len(rows) == 1 and rows[0].isfile(), "unique regular retained member") + return archive.extractfile(rows[0]).read() + + +def affine_lowerer(archive): + compact = member(archive, "inputs/pr3055.tar") + need(sha256(compact).hexdigest() == "c76e11cce0696db643715a362631b60fb14f26ba66c1e3bb5b5b0389eb52e95d", "PR3055 nested pin") + original = member(compact, "inputs/pr2250.tar") + need(sha256(original).hexdigest() == "f7c4412bed944228e911c370d847d057a68d27b7d80aac86964b396df6a31756", "PR2250 nested pin") + raw = member(original, "monomial.py") + need(sha256(raw).hexdigest() == "394f9a465ac9148af0c20844d375e4befbef17d92b2fcc840d83419480dd4740", "PR2250 monomial body pin") + tree = ast.parse(raw) + nodes = [n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == "binary_word"] + need(len(nodes) == 1, "one retained pure affine lowerer") + namespace = {"need": need} + exec(compile(ast.Module(body=nodes, type_ignores=[]), "PR2250.binary_word", "exec", optimize=0), namespace) + return namespace["binary_word"], raw + + +def check_recipe(record, binary_word): + m = len(record["matrix_rows"]) + need(m == 9, "complete native nine-coordinate recipe") + need(len(record["linear_Z4"]) == len(record["quadratic_rows"]) == m, "complete native phase") + need(all(type(v) is int and 0 <= v < 4 for v in record["linear_Z4"]), "Z4 linear coefficients") + need(type(record["phase"]) is int and 0 <= record["phase"] < 4, "Z4 constant") + need(0 <= record["offset"] < (1 << m), "affine offset") + extended = dict(matrix_rows=record["matrix_rows"] + [1 << i for i in range(m, 73)], + offset=record["offset"]) + code = binary_word(extended) + # A row is an affine polynomial over F2. Equality proves all 2^73 addresses. + constant = 1 << 73 + rows = [1 << i for i in range(73)] + for kind, target, source in code: + need(kind in ("add", "flip") and 0 <= target < 73, "fixed affine alphabet") + rows[target] ^= rows[source] if kind == "add" else constant + expected = [v ^ (constant if record["offset"] >> i & 1 else 0) + for i, v in enumerate(extended["matrix_rows"])] + need(rows == expected, "all-address affine identity") + for kind, target, source in reversed(code): + rows[target] ^= rows[source] if kind == "add" else constant + need(rows == [1 << i for i in range(73)], "all-address inverse affine identity") + # Exhaust every native address; higher 64 coordinates are explicit spectators. + phases = [] + quadratic = tuple((i, j) for i in range(m) for j in range(i + 1, m) + if record["quadratic_rows"][i] >> j & 1) + for x in range(1 << m): + direct = record["phase"] + sum(a for i, a in enumerate(record["linear_Z4"]) if x >> i & 1) + direct += 2 * sum(((record["quadratic_rows"][i] >> (i + 1)) & (x >> (i + 1))).bit_count() + for i in range(m) if x >> i & 1) + compiled = record["phase"] + sum(a * (x >> i & 1) for i, a in enumerate(record["linear_Z4"])) + compiled += 2 * sum((x >> i & 1) * (x >> j & 1) for i, j in quadratic) + need(direct % 4 == compiled % 4, "complete native phase table") + phases.append(direct % 4) + # Both source orders incur their actual Compact multiplicity. + compact_calls = sum(4 if kind == "flip" or source < target else 12 + for kind, target, source in code) + return len(code), len(quadratic), compact_calls, sha256(bytes(phases)).hexdigest() + + +def rejection(compiler, original, mutation): + data = deepcopy(original) + mutation(data) + try: + compiler(data, "forward").run() + except (ValueError, KeyError): + return True + raise ValueError("accepted invalid lifetime or recursive tariff") + + +def audit_new_instructions(compiler, data, direction, code, ranges): + """Independent event-to-macro checks for the added source alphabet.""" + instance = compiler(data, direction) + events = data["programs"][direction] + need(len(events) == len(ranges), "one ordered range per authenticated event") + next_index = 0 + for i, event in enumerate(events): + start, end = ranges[i] + need(start == next_index and start < end <= len(code), "contiguous source ranges") + need(all(op[1] == i for op in code[start:end]), "exact source-event provenance") + next_index = end + if event[0] == "warp": + _, role, operation, old, new = event + key = (1 if operation > 0 else -1, abs(operation), old, new) + record = instance.warps[key] + digest = sha256(canonical(record["left"])).hexdigest() + need(code[start:end] == (("monomial", i, instance.slot(role), digest, False),), + "exact directed warp recipe, target and non-inverted invocation") + elif event[0] == "zero_buffer": + opcode = "zero" if event[1] == "alloc" else "release_zero" + need(code[start:end] == ((opcode, i, instance.zmap[event[2]]),), + "allocate/checked-release exact private Z slot") + need(next_index == len(code), "no trailing unbound instructions") + + +def calculate(repo, providers): + raw = {name: checked(repo / name, digest) for name, digest in SOURCE_PINS.items()} + native = module("pooled_retained_t74_compiler", raw["research/t74-physical-layer/compile_word.py"]) + scalar = module("pooled_retained_scalar_lowerer", raw["research/physical-complex-controller/scalar_program.py"]) + binary_word, monomial_raw = affine_lowerer(raw["research/physical-gaussian-leaf/inputs/pr3087.tar"]) + reports, recipes, scalars, originals = {}, {}, {}, {} + for provider, pins in NATIVE_PINS.items(): + for name, digest in pins.items(): + checked(providers / provider / name, digest) + data = native.read_native(providers / provider) + originals[provider] = data + reports[provider] = {} + for direction in ("forward", "backward"): + code, selected, ranges = native.Compiler(data, direction).run() + es = data["programs"][direction] + need(len(ranges) == len(es), "all source events covered") + need(all(code[j][1] == i for i, (a, b) in enumerate(ranges) for j in range(a, b)), "ordered event coverage") + audit_new_instructions(native.Compiler, data, direction, code, ranges) + profile = Counter(op[3] for op in code if op[0] == "child") + need(dict(profile) == PROFILES[provider], "changed complete positive-child profile") + expected = 22808 if provider == "extra-four" else 22807 + need(len(es) == expected, "actual changed event inventory") + for i, event in enumerate(es): + a, b = ranges[i] + if event[0] == "warp": + need(b == a + 1 and code[a][0] == "monomial", "one monomial and zero children per warp") + elif event[0] == "zero_buffer": + need(b == a + 1 and code[a][0] == ("zero" if event[1] == "alloc" else "release_zero"), "one full-packet zero operation per Z event") + need(len(code) < 65536, "local program counter capacity") + for key, record in selected.items(): + need(key not in recipes or recipes[key] == record, "shared monomial content") + recipes[key] = record + for op in code: + if op[0] == "scalar" and op[4] not in scalars: + scalars[op[4]] = scalar.ScalarProgram(*op[4]) + reports[provider][direction] = { + "source_events": len(es), "instructions": len(code), + "instruction_counts": dict(Counter(op[0] for op in code)), + "paid_profile": dict(sorted(profile.items())), + "local_code_sha256": sha256(canonical(code)).hexdigest(), + "zero_map": {str(k): v for k, v in native.Compiler(data, direction).zmap.items()}, + "source_warps": sum(e[0] == "warp" for e in es), + "source_zero_events": sum(e[0] == "zero_buffer" for e in es), + "scalar_recipe_instructions_plus_packet_zero_copy_release": sum(len(scalars[op[4]].program) if op[0] == "scalar" else + int(op[0] in ("zero", "copy", "release_zero")) for op in code), + } + need(len(scalars) == 36, "actual pooled scalar vocabulary") + guards = [scalar.prefix_guard(value) for value in scalars.values()] + need(max(g[0] for g in guards) == 3 and max(g[1] for g in guards) == 9, "exact scalar prefix guards") + recipe_rows = {key: check_recipe(rec, binary_word) for key, rec in sorted(recipes.items())} + controls = [] + original = originals["extra-four"] + def missing_release(data): + es = data["programs"]["forward"] + es.pop(next(i for i, e in enumerate(es) if e[:2] == ["zero_buffer", "free"])) + def early_release(data): + next(e for e in data["programs"]["forward"] if e[:2] == ["zero_buffer", "alloc"])[1] = "free" + def wrong_frame(data): + next(e for e in data["programs"]["forward"] if e[0] == "warp")[3] = -1 + def paid_warp(data): + e = next(e for e in data["programs"]["forward"] if e[0] == "warp") + row = next(r for r in data["native"]["warps"] if (r["sign"], r["op"], r["old"], r["new"]) == (1 if e[2] > 0 else -1, abs(e[2]), e[3], e[4])) + row["rank"] = 1 + for label, fn in (("missing_Z_release", missing_release), ("Z_release_before_allocation", early_release), + ("wrong_warp_source_frame", wrong_frame), ("unpriced_positive_rank_warp", paid_warp)): + rejection(native.Compiler, original, fn) + controls.append(label) + code, _, ranges = native.Compiler(original, "forward").run() + warp_index = next(i for i, event in enumerate(original["programs"]["forward"]) if event[0] == "warp") + w = ranges[warp_index][0] + free_index = next(i for i, event in enumerate(original["programs"]["forward"]) if event[:2] == ["zero_buffer", "free"]) + z = ranges[free_index][0] + mutations = { + "lowered_warp_omitted": lambda c: c.__setitem__(w, ("identity", *c[w][1:3])), + "lowered_warp_inverted": lambda c: c.__setitem__(w, (*c[w][:-1], True)), + "lowered_warp_wrong_recipe": lambda c: c.__setitem__(w, (*c[w][:3], "0" * 64, False)), + "Z_release_changed_to_unchecked_clear": lambda c: c.__setitem__(z, ("zero", *c[z][1:])), + "Z_release_wrong_private_slot": lambda c: c.__setitem__(z, (*c[z][:-1], c[z][-1] + 1)), + } + for label, mutate in mutations.items(): + changed = list(code) + mutate(changed) + try: + audit_new_instructions(native.Compiler, original, "forward", tuple(changed), ranges) + except ValueError: + controls.append(label) + else: + raise ValueError("accepted wrong lowering: " + label) + return { + "status": "PASS_POOLED_SIX_PROGRAM_LOCAL_LOWERING_NOT_GLOBAL_MACHINE_ADMISSION", + "base_commit": BASE, "source_sha256": SOURCE_PINS, "native_sha256": NATIVE_PINS, + "programs": reports, "persistent_roles": 632, "private_centre_roles": 8, "private_Z_roles": 91, + "local_packet_roles": 731, "scalar_literals": len(scalars), + "scalar_maximum_instructions": max(len(value.program) for value in scalars.values()), + "scalar_prefix_denominator_bits": 3, "scalar_prefix_l1": "9", + "monomial_literals": len(recipes), "native_phase_columns_per_literal": 512, + "maximum_affine_gates": max(row[0] for row in recipe_rows.values()), + "maximum_quadratic_terms": max(row[1] for row in recipe_rows.values()), + "maximum_ordinary_calls_per_outer_row_per_monomial": max(row[2] for row in recipe_rows.values()), + "affine_coverage": "Every 73-bit address by symbolic affine forms, both directions", + "recipe_sha256": sha256(canonical(recipe_rows)).hexdigest(), + "inherited_affine_source_sha256": sha256(monomial_raw).hexdigest(), + "controls": controls, + "scope": "Unchanged retained compiler on all six exact current programs; independent symbolic affine check; complete finite native phase table; source-preserving scalar prefix identities. All-width primitive, complete global owner binding, physical ordinary B2 and outer transfer are separate written contracts. No physical payload execution or formal-kernel proof.", + } + + +@contextmanager +def frozen_inputs(): + """Validate the complete immutable closure before writing regular members.""" + pin_path = HERE / "PHYSICAL-PINS.json" + need(pin_path.is_file() and not pin_path.is_symlink(), "regular physical manifest") + pins = json.loads(pin_path.read_bytes()) + need(pins["base_commit"] == BASE and pins["source_sha256"] == SOURCE_PINS + and pins["native_sha256"] == NATIVE_PINS, "manifest scientific commitments") + bundle = pins["bundle"] + need(bundle["path"] == "frozen/physical-t74/SOURCE-BUNDLE.tar.gz" + and bundle["sha256"] == BUNDLE_SHA256, "fixed physical closure archive") + compressed = checked(HERE / bundle["path"], BUNDLE_SHA256) + need(len(compressed) == bundle["bytes"] and len(compressed) < 3 * 2**20, "bounded compressed closure") + raw = gzip.decompress(compressed) + need(len(raw) < 12 * 2**20, "bounded decompressed closure") + members = {} + with tarfile.open(fileobj=io.BytesIO(raw), mode="r:") as archive: + for entry in archive.getmembers(): + path = PurePosixPath(entry.name) + need(entry.isfile() and not path.is_absolute() and ".." not in path.parts + and "\\" not in entry.name and path.as_posix() == entry.name + and entry.name not in members, "unique regular contained archive member") + need(entry.name in bundle["files"] and entry.size <= 2 * 2**20, "declared bounded member") + value = archive.extractfile(entry).read() + expected = bundle["files"][entry.name] + need(len(value) == entry.size == expected["bytes"] + and sha256(value).hexdigest() == expected["sha256"], "exact physical source member") + members[entry.name] = value + need(set(members) == set(bundle["files"]) and len(members) == 26, "complete physical closure inventory") + with tempfile.TemporaryDirectory(prefix="pooled-physical-local-") as directory: + root = Path(directory) + for name, value in members.items(): + path = root / name + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(value) + yield root / "source", root / "native" + + +def main(): + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--release-providers", type=Path, + help="Also bind all twelve native files to a fresh completed release provider directory") + p.add_argument("--out", type=Path, help="Optional receipt outside this published package") + a = p.parse_args() + if a.out: + target = a.out.resolve() + need(target != HERE and HERE not in target.parents, "receipt must be outside the published package") + if a.release_providers: + for provider, paths in NATIVE_PINS.items(): + for name, digest in paths.items(): + checked(a.release_providers / provider / name, digest) + with frozen_inputs() as (repo, providers): + result = calculate(repo, providers) + result["source_bundle_sha256"] = BUNDLE_SHA256 + if a.out: + a.out.write_text(json.dumps(result, sort_keys=True, indent=2) + "\n") + print(result["status"], "programs", 6, "monomials", result["monomial_literals"], "controls", len(result["controls"])) + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/physical_global_bridge.py b/research/complex-pooled-full-admission/physical_global_bridge.py new file mode 100644 index 000000000..cb0d5301c --- /dev/null +++ b/research/complex-pooled-full-admission/physical_global_bridge.py @@ -0,0 +1,462 @@ +"""Exact-source global physical rebinding for the pooled complex supplier. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +The finite audit and the retained all-width primitive/root contracts are distinct. +""" +import argparse +import ast +from collections import Counter +from contextlib import contextmanager +from fractions import Fraction as Q +from hashlib import sha256 +import io +import json +import lzma +from pathlib import Path, PurePosixPath +import sys +import tarfile +import types + +HERE = Path(__file__).resolve().parent +# Replaced once by the package preparation script; these are scientific pins. +BUNDLE_SHA256 = '511ef8e6f9d1519886a8a531d788af6ef51bfcf684172a15890895f66dbcf308' +PINS_SHA256 = '66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b' +SOURCE_PINS = {'research/physical-complex-controller/PROOF.md': '471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e', 'research/physical-complex-controller/cover.py': 'd797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da', 'research/physical-complex-controller/selected_binding.py': 'd6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985', 'research/t74-physical-layer/binding.py': 'bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057', 'research/t74-retuned-physical-layer/PROOF.md': '59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f', 'research/t74-retuned-physical-layer/active_plan.py': 'e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e', 'research/t74-retuned-physical-layer/active_root.py': '5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7', 'research/t74-retuned-physical-layer/active_sources.py': '599c701b15d45f3dfee531a118e11a0aa0997d070e9cce4b6298d5b20defad49', 'research/t74-retuned-physical-layer/retuned_machine.py': 'd4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a', 'research/t74-retuned-physical-layer/retuned_native.py': '4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc'} +PROFILE = {1:8060040,2:2310120,3:751788,4:327240,5:66420,8:25920,48:138492} +OLD_PROFILE = {1:1645680,2:470196,3:159468,4:71928,5:13716,8:5328,48:28190} +GLOBAL_FIELDS = {'m','live','physical','private_namespace','local_providers', + 'private_zero_buffer_lowering','calls','execution_schedule','idle_children','bank_padding'} +DELTA = {66304:322560,66813:323069,66312:322568,66720:322976, + 66811:323067,666:3240,2222:10802,8659:6489} +DELTA_COUNTS = {66304: 3, 8659: 1, 66813: 2, 666: 2, 2222: 1, 66720: 3, 66312: 2, 66811: 2, 'providers': 1, 'phases': 1, 'providers_tuple': 1, 'profile': 1} +JOINT_ARITHMETIC_SHA = 'c4740234bee2bab8292aeef7fb561246cff8a060ea6e96f0bc14a7b69c62042c' +LOCAL_BRIDGE_SHA = '590c928e290fe8d7cbaa08bcd73fcac4fee6fe21aca193f5c41e3d612f57fd9a' +_local_bridge = None + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def local_module(): + global _local_bridge + name = 'pooled_physical_local_bridge' + path = HERE/'physical_bridge.py' + need(path.is_file() and not path.is_symlink(), 'regular local bridge') + raw = path.read_bytes() + need(sha256(raw).hexdigest() == LOCAL_BRIDGE_SHA, 'exact local bridge source bytes') + if name in sys.modules: + value = sys.modules[name] + need(_local_bridge is not None and value is _local_bridge + and value.__file__ == str(path) + and value.pooled_source_sha256 == LOCAL_BRIDGE_SHA, + 'only reuse the locally authenticated source-module identity') + return value + need(_local_bridge is None, 'authenticated local module alias remains installed') + value = types.ModuleType(name) + value.__file__ = str(path) + sys.modules[name] = value + try: + # Never consult an import loader or an existing bytecode cache. + exec(compile(raw,str(path),'exec',optimize=0),value.__dict__) + except BaseException: + if sys.modules.get(name) is value: + del sys.modules[name] + raise + value.pooled_source_sha256 = LOCAL_BRIDGE_SHA + _local_bridge = value + return value + + +def local_source_controls(): + global LOCAL_BRIDGE_SHA + value = local_module() + name = 'pooled_physical_local_bridge' + controls = [] + sys.modules[name] = types.ModuleType(name) + try: + try: + local_module() + except ValueError: + controls.append('unowned_local_module_alias') + else: + raise RuntimeError('accepted an unowned local bridge module') + finally: + sys.modules[name] = value + expected = LOCAL_BRIDGE_SHA + LOCAL_BRIDGE_SHA = '0'*64 + try: + try: + local_module() + except ValueError: + controls.append('changed_local_source_commitment') + else: + raise RuntimeError('accepted mismatched local bridge source bytes') + finally: + LOCAL_BRIDGE_SHA = expected + need(local_module() is value, 'source controls restore the authenticated module') + return controls + + +def frozen_global(): + path = HERE/'PHYSICAL-GLOBAL-PINS.json' + need(path.is_file() and not path.is_symlink(), 'regular global source manifest') + raw = path.read_bytes() + need(sha256(raw).hexdigest() == PINS_SHA256, 'complete global scientific manifest commitment') + pins = json.loads(raw) + need(pins['source_sha256'] == SOURCE_PINS, 'global source commitments') + bundle = pins['bundle'] + need(bundle['path'] == 'frozen/physical-t74/GLOBAL-BINDING.tar.xz' + and bundle['sha256'] == BUNDLE_SHA256, 'fixed global source archive') + path = HERE/bundle['path'] + need(path.is_file() and not path.is_symlink(), 'regular global source archive') + compressed = path.read_bytes() + need(len(compressed) == bundle['bytes'] and len(compressed) < 8*2**20 + and sha256(compressed).hexdigest() == BUNDLE_SHA256, 'bounded authenticated global source') + raw = lzma.decompress(compressed) + need(len(raw) < 128*2**20, 'bounded global source expansion') + files = {} + with tarfile.open(fileobj=io.BytesIO(raw),mode='r:') as archive: + for member in archive.getmembers(): + name = PurePosixPath(member.name) + need(member.isfile() and not name.is_absolute() and '..' not in name.parts + and '\\' not in member.name and name.as_posix() == member.name + and member.name not in files and member.name in bundle['files'] + and member.size < 100*2**20, 'declared regular global member') + value = archive.extractfile(member).read() + expected = bundle['files'][member.name] + need(len(value) == member.size == expected['bytes'] + and sha256(value).hexdigest() == expected['sha256'], 'exact global member') + files[member.name] = value + need(set(files) == set(bundle['files']) and len(files) == 13, 'complete global source inventory') + for name, digest in SOURCE_PINS.items(): + need(sha256(files['source/'+name]).hexdigest() == digest, 'global source pin') + return pins, files + + +def expand_projection(files, native): + template = json.loads(files['data/PHYSICAL-PROJECTION.json']) + routes = template.pop('physical_owner_routes') + need(len(routes) == len({canonical(route) for route in routes}), 'unique owner route dictionary') + for call in template['calls']: + for owner in call['owners']: + index = owner[1] + need(type(index) is int and 0 <= index < len(routes), 'complete route dictionary index') + owner[1] = routes[index] + for pid, row in template['local_providers'].items(): + programs = native[pid]['programs'] + need(row.pop('physical_program_binding') == sha256(canonical(programs)).hexdigest(), + 'physical projection to exact local program') + row['local_programs'] = programs + return template + + +def source_module(name, raw, injected=None, definitions_only=False): + tree = ast.parse(raw) + if definitions_only: + # The only removed syntax is loader/import plumbing. Every retained + # definition is compiled exactly, including all method bodies. + tree.body = [node for node in tree.body if isinstance(node,(ast.ClassDef,ast.FunctionDef))] + value = types.ModuleType(name) + value.__file__ = name + if injected: + value.__dict__.update(injected) + sys.modules[name] = value + exec(compile(tree,name,'exec',optimize=0),value.__dict__) + return value + + +def binding_class(files, compiler, scalar_type, template, phases, sigmas, native): + cover = source_module('pooled_physical_cover',files['source/research/physical-complex-controller/cover.py']) + from dataclasses import dataclass + injected = dict(Counter=Counter,sha256=sha256,json=json,dataclass=dataclass) + injected.update({name:getattr(cover,name) for name in + ('OrthogonalCover','act','is_orthogonal','multiply','parity','transpose')}) + selected = source_module('pooled_selected_binding', + files['source/research/physical-complex-controller/selected_binding.py'],injected,True) + raw = files['source/research/t74-physical-layer/binding.py'] + tree = ast.parse(raw) + counts = Counter() + class Change(ast.NodeTransformer): + def visit_Constant(self,node): + if type(node.value) is int and node.value in DELTA: + counts[node.value] += 1 + return ast.copy_location(ast.Constant(DELTA[node.value]),node) + if node.value == 'bound/base/providers': + counts['providers'] += 1 + return ast.copy_location(ast.Constant('base/providers'),node) + if node.value == 'bound/base/work/complex-nine-native/DATA-PHASES.json': + counts['phases'] += 1 + return ast.copy_location(ast.Constant('base/work/complex-nine-native/DATA-PHASES.json'),node) + return node + def visit_Tuple(self,node): + if all(isinstance(v,ast.Constant) for v in node.elts) and [v.value for v in node.elts] == ['gauge44','extra']: + counts['providers_tuple'] += 1 + node.elts.append(ast.Constant('extra-four')) + return self.generic_visit(node) + def visit_Dict(self,node): + if all(isinstance(v,ast.Constant) for v in node.keys+node.values) and { + k.value:v.value for k,v in zip(node.keys,node.values)} == OLD_PROFILE: + counts['profile'] += 1 + return ast.copy_location(ast.Dict(keys=[ast.Constant(k) for k in PROFILE], + values=[ast.Constant(v) for v in PROFILE.values()]),node) + return self.generic_visit(node) + tree = Change().visit(tree) + need(dict(counts) == DELTA_COUNTS, 'exact complete T74 source delta') + classes = [node for node in tree.body if isinstance(node,ast.ClassDef)] + need(len(classes) == 1 and classes[0].name == 'T74Binding', 'one adapted retained binding class') + # Reads are capabilities bound to authenticated objects, never arbitrary paths. + root = Path('authenticated-pooled-source') + data = {str(root/'hosted/GLOBAL-TEMPLATE.json.gz'):template, + str(root/'base/work/complex-nine-native/DATA-PHASES.json'):phases, + str(root/'hosted/ACTUAL-SIGMAS.json.gz'):sigmas} + def read(path): + need(str(path) in data,'declared physical snapshot read') + return data[str(path)] + def read_native(path): + path = Path(path) + need(path.parent == root/'base/providers' and path.name in native,'declared native snapshot read') + return native[path.name] + def authenticate_prepared(path): + need(path == root,'one immutable prepared snapshot') + injected.update(dict(Path=Path,Compiler=compiler,canonical=canonical,need=need, + read=read,read_native=read_native,authenticate_prepared=authenticate_prepared, + ScalarProgram=scalar_type)) + injected.update({name:getattr(selected,name) for name in + ('Group','Owner','SelectedBinding','data_route','embed','literal','port_basis')}) + transformed = ast.fix_missing_locations(ast.Module(body=classes,type_ignores=[])) + exec(compile(transformed,'pooled_physical_binding','exec',optimize=0),injected) + return injected['T74Binding'],root,cover,sha256(ast.dump(transformed,include_attributes=False).encode()).hexdigest() + + +def validate_schedule(binding, cover): + local_events = [event for event in binding.events if event['kind'] == 'local_cover_sweep'] + need(Counter(event['time'] for event in local_events) == Counter(binding.calls.keys()), + 'every complete call dispatched exactly once') + for event in local_events: + call = binding.calls[event['time']] + need(event['provider_id'] == call['provider_id'], 'actual provider at each local event') + pending = set() + unique_suffixes = set() + for event in binding.events: + kind = event['kind'] + if kind == 'idle_cover_sweep': + for side, child in enumerate(event['child_indices']): + for port in range(112): + family = 896*event['replica']+(2*event['pair']+side)*112+port + need(0 <= family < binding.families,'idle family within bank') + key = (event['replica'],child,port) + row = binding.remainders.get(key) + if row: + need(key not in pending and row['family'] == family, 'one exact pending idle tail') + pending.add(key) + suffix = (port,child,row['pending_offset'],row['rank']) + if suffix not in unique_suffixes: + axes = binding.data['phases']['recipes'][port]['idle_children'][child]['orthogonal_axes'] + active = axes[row['pending_offset']:] + need(len(active) == row['rank'] and 0 < len(active) <= binding.maximum_rank, + 'complete positive idle suffix') + basis = binding.bases[port] + chart = tuple(active)+tuple(v for v in basis if v not in active) + need(len(chart) == 73 and set(chart) == set(basis), 'orthogonal pending suffix chart') + unique_suffixes.add(suffix) + elif kind == 'bridge': + need(event['coefficient'] in (-1,1) and 0 <= event['src'] < 4 + and 0 <= event['dst'] < 4 and event['src'] != event['dst'], 'retained signed bridge') + else: + need(kind in {'local_cover_sweep','terminal_Y_translations','terminal', + 'bank_padding_cover_sweep','translate_every_live_family'}, 'complete global event alphabet') + if 'replica' in event: + need(type(event['replica']) is int and 0 <= event['replica'] < 360,'all replica families fit') + need(pending == set(binding.remainders), 'all positive idle children reached') + data_charts = {(call['stage'],role%112):owner.sigma_columns + for call in binding.calls.values() + for role,owner in enumerate(binding.owner_specs[call['time']][:224])} + need(all(cover.is_orthogonal(value) for value in data_charts.values()),'all exact data route charts orthogonal') + return {'pending_children':len(pending),'distinct_pending_suffixes':len(unique_suffixes), + 'data_charts':len(data_charts), 'all_owner_entries':sum(map(len,binding.owner_specs.values()))} + + +def negative_controls(binding, cover): + controls = [] + def reject(label, change, restore, check): + change() + try: + try: + check() + except (ValueError,KeyError): + controls.append(label) + else: + raise RuntimeError('accepted invalid global physical binding: '+label) + finally: + restore() + first = binding.calls[0] + old_family = first['owners'][0][0] + reject('duplicate_complete_owner_family', + lambda:first['owners'][0].__setitem__(0,first['owners'][1][0]), + lambda:first['owners'][0].__setitem__(0,old_family),binding.bind_owners) + widths = binding.template['local_providers'][first['provider_id']]['widths'] + width = widths[0] + reject('misbound_actual_provider_width',lambda:widths.__setitem__(0,width+1), + lambda:widths.__setitem__(0,width),binding.bind_owners) + mapping = binding.template['private_zero_buffer_lowering']['provider_maps'][first['provider_id']] + label = next(iter(mapping)); old_slot = mapping[label] + reject('private_Z_map_outside_declared_family',lambda:mapping.__setitem__(label,old_slot+1), + lambda:mapping.__setitem__(label,old_slot),binding.bind_owners) + first_event = next(event for event in binding.events if event['kind'] == 'local_cover_sweep') + time = first_event['time'] + reject('missing_or_duplicate_complete_call_dispatch',lambda:first_event.__setitem__('time',(time+1)%3240), + lambda:first_event.__setitem__('time',time),lambda:validate_schedule(binding,cover)) + pid = first_event['provider_id'] + reject('misbound_local_provider_dispatch',lambda:first_event.__setitem__('provider_id','missing'), + lambda:first_event.__setitem__('provider_id',pid),lambda:validate_schedule(binding,cover)) + row = next(iter(binding.remainders.values())); offset = row['pending_offset'] + reject('omitted_pending_idle_axis',lambda:row.__setitem__('pending_offset',offset+1), + lambda:row.__setitem__('pending_offset',offset),lambda:validate_schedule(binding,cover)) + return controls + + +def rate_certificate(binding): + path = HERE/'joint_bound.py' + raw = path.read_bytes() + need(sha256(raw).hexdigest() == JOINT_ARITHMETIC_SHA,'exact rational moment implementation') + value = types.ModuleType('pooled_physical_joint_arithmetic') + value.__file__ = str(path) + exec(compile(raw,str(path),'exec',optimize=0),value.__dict__) + sigma,alpha,eta = Q('0.99826995'),Q('0.99827'),Q(1,10**6) + tau = Q(332353,332929) + lower,upper = value.moment(PROFILE,73,binding.families,1-sigma) + need(upper < 0 and tau < sigma < alpha,'strict complete moment and unchanged B1 rate') + internal = sigma-eta*(sigma-tau) + leaf = sigma+eta*(1-sigma) + need(internal < alpha and leaf < alpha and Q(499,500) < alpha, + 'complete internal, stopped-leaf and reservation margins') + need(500*(1-alpha) < 1,'small-width fallback paid by one logarithm') + gamma = binding.cover.size + mass = sum(rank*count for rank,count in PROFILE.items()) + B = mass*gamma+(1<<100000) + need(32*73*B*B < 1<<210000 and 2*B+18 < 1<<210000 + and 2*B*(73-48) >= mass*gamma+(1<<100000),'unchanged all-width exact coefficient guard') + # A deliberately coarse complete finite bound, including view adapters. + maximum_group = max(map(len,binding.codes.values()))+2*632+2*224 + need(maximum_group < 65536,'unchanged physical program counter bound') + groups = sum(binding.group_count(i) for i in range(len(binding.events))) + need(groups*(maximum_group+1)*10*gamma < 1<<100000, + 'complete scalar and nonchild literal allowance below inherited E') + header = sum((bound-1).bit_length() for bound in + (2,len(binding.events),binding.families,gamma,65536,731,73)) + need(header == 2695,'derived finite header size') + return dict(sigma=str(sigma),tau=str(tau),alpha=str(alpha),stopping_power=10**6, + moment_minus_one=[str(lower),str(upper)], + internal_exponent=str(internal),leaf_exponent=str(leaf), + internal_margin=str(alpha-internal),leaf_margin=str(alpha-leaf), + reserved_margin=str(alpha-Q(499,500)),fallback_log_power=str(500*(1-alpha)), + rank_mass=mass,cover_bits=gamma.bit_length(),header_bits=header, + maximum_local_group_instructions=maximum_group, + exact_guard_exponent=210000, + joint_arithmetic_sha256=JOINT_ARITHMETIC_SHA) + + +@contextmanager +def bound_inputs(scalar_module=None, release_global=None): + local = local_module() + pins, files = frozen_global() + with local.frozen_inputs() as (repo,providers): + compiler = local.module('pooled_global_compiler',(repo/'research/t74-physical-layer/compile_word.py').read_bytes()) + if scalar_module is None: + scalar_module = local.module('pooled_global_scalar',(repo/'research/physical-complex-controller/scalar_program.py').read_bytes()) + else: + path = Path(scalar_module.__file__) + need(path.is_file() and sha256(path.read_bytes()).hexdigest() == + local.SOURCE_PINS['research/physical-complex-controller/scalar_program.py'], + 'same authenticated physical ScalarProgram cohort') + native = {pid:compiler.read_native(providers/pid) for pid in local.NATIVE_PINS} + template = expand_projection(files,native) + need(sha256(canonical(template)).hexdigest() == pins['projection_sha256'], + 'lossless global physical projection') + phases,sigmas = (json.loads(files['data/'+name]) for name in ('DATA-PHASES.json','ACTUAL-SIGMAS.json')) + if release_global: + import gzip + release_global = Path(release_global) + for relative,pin in pins['release_inputs'].items(): + raw = (release_global/relative).read_bytes() + value = json.loads(gzip.decompress(raw) if relative.endswith('.gz') else raw) + need(sha256(canonical(value)).hexdigest() == pin['canonical_sha256'], + 'fresh complete release semantic binding: '+relative) + if relative.endswith('GLOBAL-TEMPLATE.json.gz'): + need({name:value[name] for name in GLOBAL_FIELDS} == template, + 'every consumed physical field matches fresh release') + for pid,paths in local.NATIVE_PINS.items(): + for name,digest in paths.items(): + local.checked(release_global/'base/providers'/pid/name,digest) + cls,root,cover,ast_digest = binding_class(files,compiler.Compiler,scalar_module.ScalarProgram, + template,phases,sigmas,native) + yield cls(root),cover,ast_digest + + +def production_layer(): + """Bind the new dispatcher to the actual existing PR3599 B1 root factory. + + The caller must already be inside active_sources.opened(). This does not + create another tape cohort or replace its Ordinary/Profile constructors. + Production geometry is enormous; the standalone audit does not execute it. + """ + import active_sources + state = active_sources.active() + import scalar_program + import active_root + import active_plan + import retuned_machine + import retuned_native + for name,module in (('active_sources',active_sources),('active_root',active_root), + ('active_plan',active_plan),('retuned_machine',retuned_machine), + ('retuned_native',retuned_native)): + need(sha256(Path(module.__file__).read_bytes()).hexdigest() == + SOURCE_PINS['research/t74-retuned-physical-layer/'+name+'.py'], + 'exact retained active physical factory: '+name) + need(active_root.ActiveWidthPlan is active_plan.ActiveWidthPlan + and active_root.RetunedMachine is retuned_machine.RetunedMachine + and active_root.build_native is retuned_native.build_native, + 'one actual root planner, machine and ordinary factory cohort') + need(Path(scalar_program.__file__).resolve().parent == state.controller.resolve(), + 'scalar compiler belongs to the existing physical cohort') + with bound_inputs(scalar_program) as (binding,_,_): + native = retuned_native.build_native() + return active_root.ActiveWidthRoot(binding,native,binding.catalogue) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--release-global',type=Path) + parser.add_argument('--out',type=Path) + args = parser.parse_args() + if args.out: + need(HERE not in args.out.resolve().parents,'receipt outside published package') + with bound_inputs(release_global=args.release_global) as (binding,cover,digest): + audit = validate_schedule(binding,cover) + controls = local_source_controls()+negative_controls(binding,cover) + rates = rate_certificate(binding) + need(binding.check_profile() == PROFILE,'full positive-child physical invoice') + inventory = binding.inventory() + need(inventory['owner_entries'] == 2047680 and inventory['helper_charts'] == 6489, + 'complete new owner and chart inventory') + result = dict(status='PASS_POOLED_GLOBAL_PHYSICAL_BINDING_WITH_RETAINED_PRIMITIVE_CONTRACTS', + source_bundle_sha256=BUNDLE_SHA256,source_sha256=SOURCE_PINS, + local_bridge_sha256=LOCAL_BRIDGE_SHA, + retained_binding_ast_sha256=digest,inventory=inventory,schedule=audit, + positive_children=PROFILE,families=binding.families, + local_packet_roles=binding.slots+binding.private, + negative_controls=controls,physical_layer_rate=rates, + scope='All finite global owner/event/child bindings; all-cover and all-width endpoint and cost are written compositional proofs under the retained primitive/root contracts. No production physical payload execution or formal kernel proof.') + if args.out: + args.out.write_text(json.dumps(result,sort_keys=True,indent=2)+'\n') + print(result['status'],'calls',inventory['calls'],'owners',inventory['owner_entries']) + + +if __name__ == '__main__': + main() diff --git a/research/complex-pooled-full-admission/receipt_transport.py b/research/complex-pooled-full-admission/receipt_transport.py new file mode 100644 index 000000000..8fd737a48 --- /dev/null +++ b/research/complex-pooled-full-admission/receipt_transport.py @@ -0,0 +1,180 @@ +"""Lossless receipt storage and canonical addresses; no arithmetic changes. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +Historical EVIDENCE.json commitments always refer to decompressed original bytes. +""" +import copy +import gzip +from hashlib import sha256 +import json +from pathlib import Path +import tempfile + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +RECEIPTS = {'evidence/PREFIX-AND-INVOICE.json', 'evidence/SPEC.json', + 'evidence/MIXED-CONTRACT.json'} +SELECTED = { + 'frozen/selected/ASSEMBLY.json': 'research/community-frontier1094-audit/ASSEMBLY.json', + 'frozen/selected/BIT-EXPECTED.json': 'research/e8-bit-p111-tuned/tune/EXPECTED.json', +} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def regular(path): + need(path.is_file() and not path.is_symlink(), 'ordinary transport file: ' + str(path)) + return path.read_bytes() + + +def unpack(path, record): + packed = regular(path) + need(len(packed) == record['bytes'] and sha256(packed).hexdigest() == record['sha256'], + 'compressed container commitment') + raw = gzip.decompress(packed) + need(len(raw) == record['payload_bytes'] and + sha256(raw).hexdigest() == record['payload_sha256'], 'original payload commitment') + return raw + + +def validate_manifest(value): + need(value['schema_version'] == 1 and set(value['receipts']) == RECEIPTS, + 'complete compressed receipt inventory') + need(set(value['selected_inputs']) == set(SELECTED), 'complete selected input inventory') + for logical, row in value['receipts'].items(): + need(row['path'] == logical + '.gz', 'fixed compressed receipt address') + for logical, row in value['selected_inputs'].items(): + need(row['path'] == SELECTED[logical], 'fixed canonical input address') + need(value['historical_input_pins']['path'] == 'frozen/RECORDED-INPUT-PINS.json.gz', + 'fixed recorded source address') + return value + + +def manifest(): + return validate_manifest(json.loads(regular(HERE / 'PACKAGING.json'))) + + +def relative(path): + # Match lexical package addresses without following an unexpected symlink. + path = Path(path).absolute() + return path.relative_to(HERE).as_posix() if path.is_relative_to(HERE) else None + + +def payload(path): + key = relative(path) + if key in RECEIPTS: + need(not Path(path).exists() and not Path(path).is_symlink(), + 'only one compressed receipt representation') + row = manifest()['receipts'][key] + return unpack(HERE / row['path'], row) + return regular(Path(path)) + + +def read(path): + raw = payload(path) + return json.loads(gzip.decompress(raw) if Path(path).suffix == '.gz' else raw) + + +def sha(path): + return sha256(payload(path)).hexdigest() + + +def selected_bytes(path, row): + raw = regular(path) + need(len(raw) == row['bytes'] and sha256(raw).hexdigest() == row['sha256'], + 'identical pinned canonical input') + return raw + + +def selected_path(path): + key = relative(path) + if key not in SELECTED: + return Path(path) + need(not Path(path).exists() and not Path(path).is_symlink(), + 'only one selected input representation') + row = manifest()['selected_inputs'][key] + target = REPO / row['path'] + selected_bytes(target, row) + return target + + +def historical_source_sha(name): + if name != 'INPUT-PINS.json': + return sha(HERE / name) + row = manifest()['historical_input_pins'] + return sha256(unpack(HERE / row['path'], row)).hexdigest() + + +def check(): + """Keep the complete historical commitments and equivalent live input set.""" + value = manifest() + evidence = read(HERE / 'EVIDENCE.json') + for name, row in value['receipts'].items(): + need(row['payload_sha256'] == evidence['receipt_sha256'][name], + 'historical receipt commitment') + read(HERE / name) + row = value['historical_input_pins'] + old_raw = unpack(HERE / row['path'], row) + need(sha256(old_raw).hexdigest() == evidence['execution_source_sha256']['INPUT-PINS.json'], + 'historical execution source commitment') + old = json.loads(old_raw) + expected = copy.deepcopy(old) + seen = set() + for entry in expected['files']: + if entry['kind'] == 'package' and entry['path'] in SELECTED: + logical = entry['path'] + target = selected_path(HERE / logical) + need(sha(target) == entry['sha256'], 'same selected input payload') + entry.update(kind='repository', path=SELECTED[logical]) + seen.add(logical) + need(seen == set(SELECTED) and read(HERE / 'INPUT-PINS.json') == expected, + 'only two equivalent input addresses changed') + return {'receipt_payloads': len(RECEIPTS), 'reused_canonical_inputs': len(seen), + 'historical_execution_sources': len(evidence['execution_source_sha256'])} + + +def controls(): + """Reject lost coverage, damaged containers/payloads, and missing inputs.""" + count = 0 + + def rejects(action): + nonlocal count + try: + action() + except (ValueError, OSError, EOFError): + count += 1 + return + raise ValueError('accepted invalid transport fixture') + + value = manifest() + for field in ('receipts', 'selected_inputs'): + mutant = copy.deepcopy(value) + mutant[field].pop(next(iter(mutant[field]))) + rejects(lambda: validate_manifest(mutant)) + mutant = copy.deepcopy(value) + next(iter(mutant['selected_inputs'].values()))['path'] = 'different/source.json' + rejects(lambda: validate_manifest(mutant)) + row = next(iter(value['receipts'].values())) + raw = unpack(HERE / row['path'], row) + with tempfile.TemporaryDirectory(prefix='pooled-transport-controls-') as temporary: + path = Path(temporary) / 'receipt.gz' + rejects(lambda: unpack(path, row)) + path.write_bytes(regular(HERE / row['path']) + b'changed') + rejects(lambda: unpack(path, row)) + path.write_bytes(regular(HERE / row['path'])) + wrong = dict(row, payload_sha256='0' * 64) + rejects(lambda: unpack(path, wrong)) + wrong = dict(row, payload_bytes=len(raw) + 1) + rejects(lambda: unpack(path, wrong)) + link = Path(temporary) / 'linked.gz' + link.symlink_to(path) + rejects(lambda: unpack(link, row)) + selected = next(iter(value['selected_inputs'].values())) + missing = Path(temporary) / 'selected.json' + rejects(lambda: selected_bytes(missing, selected)) + missing.write_bytes(b'changed canonical input') + rejects(lambda: selected_bytes(missing, selected)) + return count diff --git a/research/complex-pooled-full-admission/replay.py b/research/complex-pooled-full-admission/replay.py new file mode 100644 index 000000000..27304cc62 --- /dev/null +++ b/research/complex-pooled-full-admission/replay.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python3 +"""Admit PR4181's optimal chronological fill with the source-bound PR4180 engine. + +Only the selected fill/dispatch, active provider set, exact source identity, +and output placement change. All inherited scientific predicates remain. +Frozen source files are never edited. Apache-2.0; substantial Codex assistance. +""" +import argparse +from collections import Counter +import os +from pathlib import Path +import shutil +import subprocess +import sys + +from common import (ADMISSION, CANDIDATE, HERE, REPO, authenticate, + check_no_python_caches, need, read, sha, write) + +ACTIVE = {"gauge44": "base", "extra": "extra", "extra-four": "extra-four"} +COUNTS = {"gauge44": 1568, "extra": 592, "extra-four": 1080} + + +def make_adapter(destination): + """Derive a separately recorded executable copy from exact frozen source.""" + authenticate() + dispatch = read(CANDIDATE / "owner/MIXED-DISPATCH.json") + need(Counter(r[2] for r in dispatch) == COUNTS, "exact active provider census") + shutil.copytree(ADMISSION, destination) + patches = [] + + def replace(name, old, new, count=1, purpose="source binding"): + path = destination / name + before = sha(path) + text = path.read_text() + need(text.count(old) == count, "exact successor preimage: " + name + ": " + old[:80]) + path.write_text(text.replace(old, new)) + patches.append(dict(path=name, before_sha256=before, after_sha256=sha(path), + old=old, new=new, occurrences=count, purpose=purpose)) + + # Location adapters do not change authenticated source bytes or predicates. + for name in ("adapt.py", "sources.py"): + replace(name, "REPO = HERE.parents[1]", "REPO = Path(" + repr(str(REPO)) + ")", + purpose="resolve canonical inputs from external adapter") + replace("adapt.py", 'MIXED = REPO / "research/staged544-mixed-fourth-entry"', + 'MIXED = REPO / "research/staged544-mixed-fourth-entry"\n' + + "CANDIDATE = Path(" + repr(str(CANDIDATE)) + ")") + replace("adapt.py", 'TAGS = {"gauge44": "base", "extra": "extra",\n' + ' "gauge44-four": "base-four", "extra-four": "extra-four"}', + "TAGS = " + repr(ACTIVE), purpose="exact active registry, retaining bijection checks") + replace("adapt.py", 'read(MIXED / "owner/MIXED-DISPATCH.json")', + 'read(CANDIDATE / "owner/MIXED-DISPATCH.json")', purpose="actual t<1080 selector") + # These strings are the new sides of PR4180's literal two-to-four patches. + # Their old sides stay byte-identical, so the inherited two-provider source + # must still match before every generated change. + replacements = [ + ("pkg, loc_g, loc_e, loc_g4, loc_e4, out = map(Path, sys.argv[1:7]);", + "pkg, loc_g, loc_e, loc_e4, out = map(Path, sys.argv[1:6]);"), + ("locs = {'gauge44': loc_g, 'extra': loc_e, 'gauge44-four': loc_g4, 'extra-four': loc_e4};", + "locs = {'gauge44': loc_g, 'extra': loc_e, 'extra-four': loc_e4};"), + ("('base','extra','base-four','extra-four')", "('base','extra','extra-four')"), + ("nat['base']/'local',nat['extra']/'local',nat['base-four']/'local',nat['extra-four']/'local'", + "nat['base']/'local',nat['extra']/'local',nat['extra-four']/'local'"), + ("nat['base'],nat['extra'],nat['base-four'],nat['extra-four'],*[p_", + "nat['base'],nat['extra'],nat['extra-four'],*[p_"), + ("[('extra','extra'),('gauge44-four','base-four'),('extra-four','extra-four')]", + "[('extra','extra'),('extra-four','extra-four')]"), + ("for tag in ('base', 'extra', 'base-four', 'extra-four'):", + "for tag in ('base', 'extra', 'extra-four'):"), + ("natives['extra'] / 'local', natives['base-four'] / 'local', natives['extra-four'] / 'local', work / 'rebound'", + "natives['extra'] / 'local', natives['extra-four'] / 'local', work / 'rebound'"), + ] + for old, new in replacements: + # The runtime-copy list occurs once in source adaptation and once in + # engine adaptation. Both paths must use the same active catalogue. + count = 2 if old.startswith("[('extra','extra')") else 1 + replace("adapt.py", old, new, count=count, purpose="route all three active providers") + replace("adapt.py", "pr4088-four-provider-admission-v1", "pr4181-pooled-active-provider-admission-v1") + replace("replay.py", "from binding import need, read, sha", "from binding import need, read, sha\nfrom adapt import CANDIDATE") + replace("replay.py", "pr4088-four-provider-admission-v1", "pr4181-pooled-active-provider-admission-v1") + replace("replay.py", ' for tag in ("base", "extra"):\n supplied =', + ' for tag in ("extra",):\n supplied =', + purpose="fresh native execution for the only active FOUR word") + for path in ("owner/FILL.json.gz", "owner/MIXED-DISPATCH.json", "RESULT.json"): + replace("replay.py", 'MIXED / "' + path + '"', 'CANDIDATE / "' + path + '"', + purpose="bind full engine to actual pooled fill and complete price") + marker = " if args.checked_preflight:\n" + extra = (' run("pooled-exact-operator", [sys.executable, "-B", ' + + repr(str(HERE / "operator_admission.py")) + + ', "--controls", "--output", str(work / "POOLED-OPERATOR.json")], 300)\n') + replace("replay.py", marker, extra + marker, + purpose="fresh all-character admission for the changed chronological fill") + # All reuse and inherited semantic challenges are unchanged; only their + # runtime paths and active TAGS are supplied by the derived adapter. + write(destination / "SUCCESSOR-ADAPTATION.json", dict( + predecessor="15a4153e734a8d1d485c6d3bea9b1a8201328a4c", + candidate="4ed92bed95dd483f5662e98ef246b258c3cfe64f", + active_providers=ACTIVE, call_counts=COUNTS, patches=patches)) + return patches + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--work", type=Path, required=True) + ap.add_argument("--adapter-only", action="store_true") + ap.add_argument("--checked-preflight", type=Path) + ap.add_argument("--four-native-extra", type=Path) + args = ap.parse_args() + need(__debug__, "full inherited admission requires assertions") + work = args.work.resolve() + need(not work.exists() and not work.is_relative_to(REPO), "fresh external work") + work.mkdir(parents=True) + if args.checked_preflight: + check_no_python_caches([args.checked_preflight.resolve()]) + adapter = work / "adapter" + patches = make_adapter(adapter) + if args.adapter_only: + print("PREPARED_POOLED_ADAPTER_NOT_ADMITTED", len(patches)) + return + command = [sys.executable, "-B", str(adapter / "replay.py"), "--work", str(work / "replay")] + for flag in ("checked_preflight", "four_native_extra"): + value = getattr(args, flag) + if value: + command += ["--" + flag.replace("_", "-"), str(value.resolve())] + env = dict(PATH=os.environ["PATH"], PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1", + PYTHONINTMAXSTRDIGITS="0", OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1") + subprocess.run(command, check=True, env=env) + result = read(work / "replay/RESULT.json") + need(result["status"] == "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", + "complete pooled-fill release") + for optimized in (False, True): + command = [sys.executable] + (["-O"] if optimized else []) + [ + "-B", str(adapter / "challenge.py"), "--work", str(work / "replay")] + if args.checked_preflight: + command += ["--preflight", str(args.checked_preflight.resolve())] + log = work / ("challenges-optimized.json" if optimized else "challenges-normal.json") + with log.open("w") as stream: + subprocess.run(command, env=env, check=True, stdout=stream) + authenticate() + check_no_python_caches([work] + ([args.checked_preflight.resolve()] + if args.checked_preflight else [])) + write(work / "RESULT.json", dict( + status="PASS_POOLED_COMPLETE_FINITE_ADMISSION", inherited_status=result["status"], + source_pins=sha(HERE / "INPUT-PINS.json"), active_providers=ACTIVE, call_counts=COUNTS, + candidate_profile=read(CANDIDATE / "RESULT.json")["profile"], + adaptation_sha256=sha(adapter / "SUCCESSOR-ADAPTATION.json"), + inherited_result_sha256=sha(work / "replay/RESULT.json"), + operator_receipt_sha256=sha(work / "replay/POOLED-OPERATOR.json"), + inherited_source_loading="Clean scientific source trees before and after; bytecode writes disabled.", + mathematical_scope="Finite complete conditional admission; uniform physical and analytic hypotheses remain.", + selected_frontier_changed=False)) + print("PASS_POOLED_COMPLETE_FINITE_ADMISSION") + + +if __name__ == "__main__": + main() diff --git a/research/complex-pooled-full-admission/verify.py b/research/complex-pooled-full-admission/verify.py new file mode 100644 index 000000000..9cf67b84f --- /dev/null +++ b/research/complex-pooled-full-admission/verify.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 +"""Bounded source/operator/arithmetic regression; full admission is separate. + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Preserved full-run receipts are evidence, not a substitute replay. +""" +import json +import os +from pathlib import Path +import subprocess +import sys +import tempfile + +from common import HERE, REPO, authenticate, check_no_python_caches, need +from replay import ACTIVE, COUNTS, make_adapter +from receipt_transport import (check as check_transport, controls as transport_controls, + historical_source_sha, read, sha) + +EXECUTION_SOURCES = {"common.py", "replay.py", "operator_admission.py", + "joint_bound.py", "INPUT-PINS.json"} +RECEIPTS = {"RESULT.json", "INHERITED-RESULT.json", "ADMISSION-RESULT.json", + "RELEASE-RECEIPT.json", "STRICT-RESULT.json", "OPERATOR.json", + "JOINT-BOUND.json", "ASSEMBLY.json", "PREFIX-AND-INVOICE.json", + "OUTER-LEDGER.json", "SPEC.json", "MIXED-CONTRACT.json", + "CHALLENGES-normal.json", "CHALLENGES-optimized.json"} +BOUND_RECEIPTS = {"result": "ADMISSION-RESULT.json", "release": "RELEASE-RECEIPT.json", + "strict_result": "STRICT-RESULT.json", "assembly": "ASSEMBLY.json", + "invoice": "PREFIX-AND-INVOICE.json", "outer": "OUTER-LEDGER.json", + "spec": "SPEC.json", "contract": "MIXED-CONTRACT.json"} + + +def evidence_coverage(evidence): + need(set(evidence["execution_source_sha256"]) == EXECUTION_SOURCES, + "complete execution source coverage") + need(set(evidence["receipt_sha256"]) == {"evidence/" + p for p in RECEIPTS}, + "complete recorded receipt coverage") + + +def rejecting(action, message): + try: + action() + except ValueError as exc: + need(message in str(exc), "specific cache rejection") + return + raise ValueError("accepted invalid cache fixture") + + +def cache_controls(root): + cache = root / "cache-fixture" + cache.mkdir() + bad = cache / "module.pyc" + bad.write_bytes(b"compiled cache witness") + rejecting(lambda: check_no_python_caches([cache]), "compiled scientific source cache") + bad.unlink() + link = cache / "linked-source" + link.symlink_to(root, target_is_directory=True) + rejecting(lambda: check_no_python_caches([cache]), "scientific source symlink") + link.unlink() + check_no_python_caches([cache]) + + +def main(): + count = authenticate() + transport = check_transport() + transport['negative_controls'] = transport_controls() + evidence = read(HERE / "EVIDENCE.json") + need(evidence["status"] == "RECORDED_COMPLETE_FINITE_REPLAY", "complete run evidence") + evidence_coverage(evidence) + for field, message in (("execution_source_sha256", "execution source coverage"), + ("receipt_sha256", "recorded receipt coverage")): + mutant = json.loads(json.dumps(evidence)) + mutant[field].pop(next(iter(mutant[field]))) + rejecting(lambda: evidence_coverage(mutant), message) + for name, digest in evidence["execution_source_sha256"].items(): + need(historical_source_sha(name) == digest, "full-run source changed: " + name) + for name, digest in evidence["receipt_sha256"].items(): + need(sha(HERE / name) == digest, "preserved receipt changed: " + name) + outer = read(HERE / "evidence/RESULT.json") + inherited = read(HERE / "evidence/INHERITED-RESULT.json") + admitted = read(HERE / "evidence/ADMISSION-RESULT.json") + need(outer["status"] == "PASS_POOLED_COMPLETE_FINITE_ADMISSION", "recorded wrapper result") + need(inherited["status"] == admitted["status"] == + "PASS_REPLICA_ORDER_FILL_DERIVATIVE_COMPLETE_RELEASE", "recorded complete engine result") + need(outer["inherited_result_sha256"] == sha(HERE / "evidence/INHERITED-RESULT.json") + and inherited["admission_result_sha256"] == sha(HERE / "evidence/ADMISSION-RESULT.json") + and admitted["release_receipt_sha256"] == sha(HERE / "evidence/RELEASE-RECEIPT.json") + and outer["operator_receipt_sha256"] == sha(HERE / "evidence/OPERATOR.json"), + "recorded release chain") + env = dict(PATH=os.environ["PATH"], PYTHONDONTWRITEBYTECODE="1", PYTHONUTF8="1", + PYTHONINTMAXSTRDIGITS="0", OPENBLAS_NUM_THREADS="1", OMP_NUM_THREADS="1") + options = ["-O"] if not __debug__ else [] + with tempfile.TemporaryDirectory(prefix="pooled-complex-check-") as temp: + root = Path(temp) + cache_controls(root) + adapter = root / "adapter" + patches = make_adapter(adapter) + need(len(patches) == 21, "complete recorded adapter") + + def run(script, args=()): + command = [sys.executable, *options, "-B", str(script), *map(str, args)] + result = subprocess.run(command, cwd=REPO, env=env, text=True, + stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + timeout=180) + need(result.returncode == 0, "failed " + script.name + ":\n" + result.stdout) + + run(adapter / "test_binding.py") + run(HERE / "operator_admission.py", ["--controls", "--output", root / "operator.json"]) + run(HERE / "joint_bound_inputs.py", ["--output", root / "joint.json"]) + operator = read(root / "operator.json") + joint = read(root / "joint.json") + need(operator == read(HERE / "evidence/OPERATOR.json"), "exact operator reproduction") + recorded = read(HERE / "evidence/JOINT-BOUND.json") + for key in set(joint) | set(recorded): + if key not in ("status", "release_binding"): + need(joint[key] == recorded[key], "independent joint arithmetic: " + key) + need(recorded["release_binding"]["status"] == "COMPLETED_FINITE_RELEASE_RECEIPTS_BOUND", + "recorded full release binding") + need(set(recorded["release_binding"]["files"]) == set(BOUND_RECEIPTS), + "complete joint receipt coverage") + for key, name in BOUND_RECEIPTS.items(): + need(recorded["release_binding"]["files"][key]["sha256"] == sha(HERE / "evidence" / name), + "joint receipt binding: " + key) + need(joint["all_size_admission"] is False and joint["selected_frontier_changed"] is False, + "finite scope remains explicit") + check_no_python_caches([root]) + authenticate() + print(json.dumps(dict(status="PASS_POOLED_BOUNDED_REGRESSION", pinned_inputs=count, + active_providers=ACTIVE, call_counts=COUNTS, adapter_changes=len(patches), + operator_controls=len(operator["controls"]), arithmetic_controls=len(joint["controls"]), + lossless_transport=transport, + scope="Fresh operator/arithmetic/binding regression plus preserved full-run source/receipt integrity; not a fresh complete release or all-size theorem."), + sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/pooled-native-hosting-admission/ADMISSION-PINS.json b/research/pooled-native-hosting-admission/ADMISSION-PINS.json new file mode 100644 index 000000000..6f53c6ccd --- /dev/null +++ b/research/pooled-native-hosting-admission/ADMISSION-PINS.json @@ -0,0 +1,107 @@ +{ + "files": { + "research/complex-pooled-full-admission/EVIDENCE.json": { + "bytes": 5052, + "sha256": "78b97937f56b7989b9bf13c1889521fddb7cfeb68c5d8a3ed6a4a6f5d246ac9e" + }, + "research/complex-pooled-full-admission/OUTER-CHECK.md": { + "bytes": 13704, + "sha256": "f44591b102fd618b0fbe171c9b571f4e109735713beb5b29b9887a6f4fddea9b" + }, + "research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json": { + "bytes": 393, + "sha256": "f35c851e78f4eba0df41fb937940acdfcae8048b74c9938eb6a9172f2253fe8d" + }, + "research/complex-pooled-full-admission/OUTER-DOMAIN.md": { + "bytes": 13294, + "sha256": "280be120c31c88c7d9d906d040f0d851227dd06dc8657773455b0b42d6dddc55" + }, + "research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json": { + "bytes": 11415, + "sha256": "6e066a1b7f5aa26ce2915ea67186a167614c87ca444c46c25e4a5c57d4c032c5" + }, + "research/complex-pooled-full-admission/OUTER-JOIN.md": { + "bytes": 16494, + "sha256": "bfb4677ee82ffc070be880eca87af05fd096686b464dfd5268cee1b27afa453e" + }, + "research/complex-pooled-full-admission/OUTER-PINS.json": { + "bytes": 793, + "sha256": "5cd7e6c92aa5be34cb4f9fd2db475e90954c4bff0f9a2a980d319d2079086dc9" + }, + "research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md": { + "bytes": 11566, + "sha256": "2fa75b9af51d31f68b818aeca7f2cb9e9f9d940ebe509fdb29d77053e05f8218" + }, + "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json": { + "bytes": 4969, + "sha256": "66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b" + }, + "research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md": { + "bytes": 15402, + "sha256": "1d1f06c714f0f3e5e6ab660084191a080ce4a86c0dfef8022b57c00778085b97" + }, + "research/complex-pooled-full-admission/PHYSICAL-PINS.json": { + "bytes": 8433, + "sha256": "2ea958a9c87c5202113d84f176972de662fd87b45e5fde57c33a3251c7eeab53" + }, + "research/complex-pooled-full-admission/RECURSION.md": { + "bytes": 18657, + "sha256": "5bdb640810a1a81fe5b47fbedbf61c3799b6028f0f25ebdde387fe4d18407f9a" + }, + "research/complex-pooled-full-admission/UNIFORM-GAP.md": { + "bytes": 3466, + "sha256": "7891456ce2716b25399a7857737169ca82a68676b3b2c1565ca29c2105651f47" + }, + "research/complex-pooled-full-admission/evidence/ADMISSION-RESULT.json": { + "bytes": 24525, + "sha256": "90378c981ca4def5ea12432ef54cdf66324ec301fa8d489264a48923e89d478b" + }, + "research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json": { + "bytes": 7540, + "sha256": "c3606f99d68fdef705d512341c65f1758eff3e4ec2b9f34f28d5f047192724a6" + }, + "research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json": { + "bytes": 2980, + "sha256": "8258b918fc549a1e6554e80cba4f27edaf09dd7066e0e39a099efcefee009ff5" + }, + "research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json": { + "bytes": 4359, + "sha256": "782ef40f6e1a4fa5e88c3d8757ba064508d184aff6989aab6f1c57de7282897e" + }, + "research/complex-pooled-full-admission/joint_bound.py": { + "bytes": 19446, + "sha256": "c4740234bee2bab8292aeef7fb561246cff8a060ea6e96f0bc14a7b69c62042c" + }, + "research/pooled-native-hosting-admission/ADMISSION.md": { + "bytes": 13880, + "sha256": "a040c25eb15022c66ed01677ed44b3f5e2ae7a34099d776313bbc4c7d67787a5" + }, + "research/pooled-native-hosting-admission/HOSTING-ADMISSION.md": { + "bytes": 13241, + "sha256": "e706da89148b9da1505b9b24fa6a92729604dd08ca0721dce421f474400b4d81" + }, + "research/pooled-native-hosting-admission/MACHINE-ADMISSION.md": { + "bytes": 31896, + "sha256": "fa2af131803f5cf7e09e5bac6c09de1f15899bb5d903a291c2a5197e16c824b8" + }, + "research/pooled-native-hosting-admission/NATIVE-ADMISSION.md": { + "bytes": 15299, + "sha256": "dc6e40d78fd7df67642b21b5f6d7c13b824586d1ac5f65ed7d35e9263301b8fd" + }, + "research/pooled-native-hosting-admission/evidence/HOSTING-ADMISSION.json": { + "bytes": 1984, + "sha256": "ef18f5987b7b72d566e90c355311b7b07d88825cfc8593b7c9694882d531ac83" + }, + "research/pooled-native-hosting-admission/evidence/MACHINE-ADMISSION.json": { + "bytes": 4851, + "sha256": "8222741d411cbdf496c81ed28ff2ca8ac6ce878f4cd9c18e982ea4738275e7c9" + }, + "research/pooled-native-hosting-admission/evidence/NATIVE-ADMISSION.json": { + "bytes": 7864, + "sha256": "22acf428574ba51c187b042fecd039d2cfc19d2c903d2df28f405e33640ff0ed" + } + }, + "meaning": "Exact written proof, finite receipt and unchanged predecessor boundary; no automatic mathematical acceptance", + "schema": 1, + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887" +} diff --git a/research/pooled-native-hosting-admission/ADMISSION.md b/research/pooled-native-hosting-admission/ADMISSION.md new file mode 100644 index 000000000..095147272 --- /dev/null +++ b/research/pooled-native-hosting-admission/ADMISSION.md @@ -0,0 +1,269 @@ +# Admission of the pooled source and conditional integer improvement + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. This successor preserves PR4270 at exact head +`a929a3fa36301bdfcffe82afd37434dd9e3c4887`. Its retained word, owner, controller, +ordinary, support, Fourier, Gaussian, CRT and analytic sources keep their +original credit. The new result is the source-specific native/hosting/control +admission proof and its noncircular join; it is not a new word or a new +analytic inverse theorem. + +## 1. Exact theorem and remaining hypotheses + +The companion proofs establish the following **source-specific conclusion**: +the actual pooled complex implementation has its full arbitrary-input native +endpoint, valid complete-family hosting on every common-cover chart, exact +recursive children and a uniform paid finite-tape controller. These facts +are conclusions below, rather than a remaining hypothesis named U(S1). +They include source restoration, all private cleanup and the complete invoice. + +Under the separately named foundational and analytic contracts retained in +PR4270, this proves the conditional integer bound + +``` +T(n) = O(n (log n)^(1-1/580)), +occupied and visited space O(n)+F_q. +``` + +The remaining hypothesis cut is explicit: + +* **B_ordinary:** PR3599's completed retuned B1 ordinary backend, including + BIT H1–H5 and its complete physical endpoint, ownership and tariff + `tau=332353/332929`. B2 and a recursively assumed faster complex supplier + are unnecessary. +* **P_elementary:** the pinned completed Compact/monomial, exact signed scalar, + Gaussian-leaf, root-normalization and preallocated-work components, at their + literal complete-record/grid/return interfaces. Their declared arithmetic, + copy, source-access and head-return costs are retained. The newly proved + control lowering does not reprove these foundational component theorems. +* **G_modern:** the retained support/Fourier/chirp/Gaussian/CRT construction + contracts in PR4270 OUTER-JOIN and OUTER-DOMAIN, with their complete domains, + physical component bills, coefficient approximation, phase-cell inverse, + gap, locality and rounding estimates. In particular the modern Gaussian + inverse hypothesis includes `gap(H)>=1/(8p)` and `||H^-1||<=8p`; these + analytic inequalities are not inferred from finite fixtures. The outer + constructions and their primitive source refinements keep their stated + conditional scope; this package does not claim an independent proof of + every transitive Gaussian component. +* **BHP:** Baker–Harman–Pintz's stated short-interval prime theorem, used with + the explicit multiplicity and eventual-domain argument of OUTER-JOIN. + +No pooled native, pooled hosting, pooled controller or pooled root-refinement +contract is included in this retained list. The dependency order is + +``` +native recipe/free-word proof + hosting/cover proof + control construction + -> exact pooled recursive implementation U_pooled +U_pooled + B_ordinary + P_elementary + G_modern + BHP + -> conditional integer kappa=1/580. +``` + +This is a source-specific conditional improvement. Its modern analytic +hypotheses are not the selected legacy hypotheses applied unchanged. Legacy +resampling requires `theta>p/alpha^4`; the modern family has +`alpha~p^.001` and `theta~p^-.997`, so that legacy premise fails. The modern +phase-cell inverse replaces that regime, and BHP is an explicit dependency. +No unconditional theorem, identical-premise legacy transfer, human approval, +formal-kernel proof or selected-frontier promotion is asserted. + +## 2. Noncircular exact recursive construction + +Fix the complete source, prime q, cover and elementary components. First work +with the ideal rational procedure, without a finite word-size restriction. +At width e its internal algebraic interface is the exact complex quarter transform +on its selected e binary axes, extended by identity on every other coordinate +and all complete spectators. Its owned work and borrowed caller coordinates +obey the algebraic component return contracts. It accepts arbitrary Gaussian +dyadics and is **not** restricted to the public unit disk. + +The finite-width implementation has a narrower guarded ABI. If the incoming +values have height a, meaning `z in 2^-(p+a) Z[i]` and `|z|<=2^a`, let A(e) +bound the ideal internal procedure's additional height at every prefix as +in Section 3. Require `a+A(e)<=Delta`, with the caller retaining the separate +reserve for its remaining operations. This supplies both dyadic divisibility +and signed headroom on `h=p+2Delta+3` bits. Merely fitting the incoming values +in h bits is insufficient: a transform can amplify them. Every actual internal +call of the stated unit-disk root satisfies the guarded ABI by the whole-root +height proof below; no arbitrary-h-bit physical endpoint is claimed. For +example, h-bit components `u=M-iM`, `v=M+iM`, `M=2^(h-1)-1`, are valid inputs +as words, but one C output has real numerator 2M and overflows that word size. + +We prove the ideal algebraic interface by strong induction on e, then realize +that same well-founded procedure on the guarded grid. The elementary leaf +and the zero-width identity are +the base cases. The actual source may also stop at `e^1000000=1`. The source pays the t +remainder axes and groups the remaining axes into f columns of 73. Every +positive native or residual child has rank r with + +``` +1<=r<=48, child width r f <=48 floor(e/73)= s+E +``` + +and the complete finite instruction allowance give the all-prefix denominator +and magnitude bound on `h=p+2Delta+3` signed bits. MACHINE-ADMISSION traces +that bound to the actual HALF transducers: every division has an even +integer numerator and every signed prefix fits. Internal calls retain that +h grid, including amplified values; no recursive truncation is inserted. +Only the prescribed root normalization and final truncation produce the +public normalized H endpoint and error contract. + +The machine has fixed preallocated roles, bounded source/cover selectors +and encoded numerical extents. Bank gathering, scattering and replacement +are full paid scans. A parent frame stores all 751 roles with four-bit body +encoding and delimiters, at most + +``` +4(1+731/L)V/(1-1/L) +``` + +payload cells over the branch, before the fixed current/capsule/result copies. +The complete actual-record bounds `2^(b(log2 p)^2)<=r` and `log2 r<=Bp` +pay polynomial descriptor work uniformly at every invocation, not from a +nominal coarse-label count. All owned payload and each role's maximum visited +extent are `O(V)+F_q`. Erased simulator arrays are not treated as released +backing capacity. The new finite header has 2695 bits and its maximum group +has 31632 instructions; neither adds a positive-rank child. + +## 4. Complete recursive and outer prices + +Combining every actual native recipe and residual yields exactly + +``` +{1:8060040, 2:2310120, 3:751788, 4:327240, + 5:66420, 8:25920, 48:138492}. +``` + +Every restoration, warp inverse, helper wrapper and private cleanup is in +that profile or the complete nonchild bill. The native and hosting receipts +independently reproduce its constituents; no hypothetical helper saving is +substituted for the actual selector. + +With `sigma=.99826995`, `tau=332353/332929` and `eta=10^-6`, the normalized +full moment at sigma is strictly below one. Both stopped-tree powers + +``` +sigma-eta(sigma-tau), sigma+eta(1-sigma)=.99826995173005 +``` + +are below `alpha_layer=.99827`, and `tau 0. +``` + +All source production polynomials, signed scalar work, CRT setup and +catalogue storage keep the explicit source family which pays them. Thus +`O(n p^Phi log p)` with `p=Theta(log n)` fits the displayed integer bound, +and the one-active-branch and fixed-owner outer storage remains `O(n)+F_q`. +The source constants and eventual cutoff may be enormous; no measured +performance claim follows. The stronger legacy arithmetic number +`.001727989140903569` remains outside this theorem. + +## 5. Evidence and admission status + +The three companion checkers instantiate the finite source hypotheses of +their written all-parameter proofs. admission.py joins their exact receipts, +recomputes the complete profile and strict rational/interval costs, and +authenticates the unchanged PR4270 proof boundary. Each registered command +runs in normal and optimized Python with the same result. The old complete +finite release is preserved evidence; this package does not rerun that long +release or advertise a production-prime payload execution. + +The word **admission** here names the proved source-specific implication +under the explicit contracts above. It does not record a maintainer decision. +Independent Astra AI review is recorded separately with exact reviewed bytes +and scope; it is not independent human or formal verification. Repository +scientific acceptance, archive integration, merge and selected-frontier +promotion are separate decisions. No selected result is edited by this work. diff --git a/research/pooled-native-hosting-admission/HOSTING-ADMISSION.md b/research/pooled-native-hosting-admission/HOSTING-ADMISSION.md new file mode 100644 index 000000000..426fda506 --- /dev/null +++ b/research/pooled-native-hosting-admission/HOSTING-ADMISSION.md @@ -0,0 +1,260 @@ +# Whole-call hosting and common-cover admission + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. The nine-stage word and phase recipes retain Rohan Arun and the +source contributors' attribution; the physical charts/controller retain +Gareth Davidson and Jose Manuel's attribution. This note proves the +source-specific implication for PR4270's pooled owner assignment. It does not +claim the underlying word, orthogonal cover or native tensor lemma as new. + +## Statement and dependency boundary + +Assume the **proved** native theorem in NATIVE-ADMISSION.md, with the completed +internal child operation substituted for every child call. Then the actual +3,240 local invocations, 1,321,920 hosted helper assignments, 162,900 residual +children and all nonlocal events in PR4270 implement the full 73f-axis complex +quarter transform on every live family, for every integer f>=1. This is an +identity on complete arrays with arbitrary values and correlations, including +all row, value, address and inactive-axis spectators. It returns all private +centres, coefficient cells and Z buffers as specified by the native theorem. + +The statement is algebraic. The recursive implementation and its paid costs +are supplied by MACHINE-ADMISSION.md; neither a numerical test nor an assumed +pooled physical root is used to prove the algebra here. The induction combining +the two statements is given in ADMISSION.md. No analytic Gaussian estimate is +needed for this exact internal endpoint. + +The bytes used below are bound by HOSTING-PINS.json, including PR4270's immutable +GLOBAL-BINDING archive and owner FILL, and the original PLAN/TEMPLATE. The +checker reads every actual row, rather than borrowing the old fill's status +label. It also authenticates every member of the global archive. All old +packages and their receipts remain unchanged. + +## Operators and spectators + +Let V=(F2^73)^f and let the coefficient module be Q(i)-valued complete arrays +on V times an arbitrary spectator set. For a column vector v in F2^73, write +X_v for translation by v on one column and + +``` +C_v = ((1+i)I + (1-i)X_v)/2. +``` + +Every X_v commutes with every X_w, hence all C_v and translations commute. +Write C_[A],f for the product of C_v over the literal ordered original axis +list A, separately in each of the f columns. This notation includes every +inactive coordinate and spectator by an identity factor. It does not identify +arbitrary bases of the same subspace: the actual vectors in A are material. +The scalar signed shear between two role streams is applied once, independently +of f. Only the unary operators and coordinate permutations are lifted across +the f columns. + +For an invertible binary matrix d, set (P_d u)(x)=u(d^-1 x), column by column. +Then P_d X_v P_d^-1=X_(dv), and the same conjugation rule holds for C_v. +These are complete operator equalities, so no independence, cleanliness or +absence of correlation is required of persistent inputs. + +## Literal charts and every cover label + +The source port q has odd weight and is not the all-ones 9-bit vector. Choose +the source's first missing coordinate a and put v=q+e_a. The even-weight vector +v is isotropic. The transvection T_v=I+vv^T is an orthogonal involution: +T_v T_v^T=I because v^T v=0. Applying it to the standard basis with coordinates +0 and a swapped gives the exact port basis B_q emitted by port_basis; its +first vector is q. The checker verifies all 112 actual bases. + +A helper chart consists of the exact slice A[offset:offset+width], followed +by the source's literal spectator completion, then the remaining B_q vectors. +It is a permutation of that orthonormal basis. The checker reconstructs all +6,489 emitted helper charts and checks their complete 73 coordinates and +digests, including inactive spectators. The data chart at positive stage s +uses the eight transvections with vectors B_q[1+i]+e_(9+8(s-1)+i). +These vectors are isotropic and mutually orthogonal, so their product is +orthogonal. The checker checks all 1,008 actual port/stage matrices as well. + +Let sigma have those chart vectors as its columns. The source stores the +columns as a tuple, which, when consumed as matrix rows, is sigma^T=sigma^-1. +For each d in O(73,2) the literal group key is + +``` +(base_family, rank(d sigma^-1)). +``` + +Right multiplication by sigma^-1 is a bijection of the entire group. If +h=d sigma^-1, then d=h sigma. Consequently the completed helper endpoint in +the common view is + +``` +P_d C_[e0,...,e(width-1)],f P_d^-1 + = P_h C_[A[offset:offset+width]],f P_h^-1. +``` + +The native endpoint preserves its remaining axes literally. For data, +the source entry mask is sigma^-1 times the original entry mask, so +P_d X_(sigma^-1 entry) P_d^-1=X_(h entry), and likewise at exit. Both members +of a productive data pair have the same sigma. Thus the actual completed +physical endpoint for that pair is exactly the one used in the phase proof +below at physical cover label h. No transpose or inverse of the full backward +role matrix is presumed. + +Within each call the 632 base families are distinct and in the live namespace. +For different d, every role therefore reaches every physical cover member +exactly once and the persistent packets are disjoint. The native theorem +returns private scratch to zero, so it may be reused after each complete group. +Although the interior native word mixes its roles, its completed endpoint +separates each helper and each productive port pair. Regrouping that completed +cover sweep by physical label h is therefore valid. Regrouping its interior +instructions would not follow from this argument and is not used. + +The rank/unrank routine covers the entire group, not an unspecified subset. +For a valid orthonormal prefix, its orthogonal complement W is nondegenerate +and nonalternating. Its characteristic vector w satisfies += for all x in W. There are 2^(s-1) norm-one choices in dimension s. +After choosing a norm-one row u, the new complement's characteristic vector +is w+u. This complement is alternating exactly when u=w. That excluded case +is possible only when s>1 is odd; the one-dimensional final row is allowed. +Every other complement is again nondegenerate and nonalternating. Induction +on s constructs an orthonormal basis for each such complement, giving the +exact row-choice count + +``` +2^(s-1) - 1_(s>1 and s odd). +``` + +The source solves the prefix equations and fixes the next row bits in +lexicographic order by exact affine solution counts, excluding just that +characteristic row. Every allowed row has the same suffix count by the +preceding induction. Mixed-radix rank/unrank is consequently mutually inverse +on all O(73,2). The bounded check independently enumerates the full groups +in dimensions 1 through 5 (1,2,6,48,720 matrices), compares every rank/unrank +value and checks every character there. Four labels in dimension 73 are +additional probes; the written induction, not those probes, covers dimension +73 and all its 2,628-bit labels. + +## Whole-call chronological retiming + +For each replica and each original idle child, define its allowed interval +from the **actual** execution schedule: after the last preceding scalar +observation of its pair and before the child's original idle event. A complete +local invocation on the productive pair is an observation; a bridge observes +both pairs. An idle unary C/translation is not a scalar observation. The +checker reconstructs all 7,200 intervals, including the zero-rank slots, from +all 10,802 actual events. For each replica the projected order is exactly the +original 30 pre-padding events, with the original pair, child, coefficient, +orientation and signed terminal data. All 3,240 actual local dispatches occur +exactly once, using only the three active providers. + +Every one of the 1,321,920 assignments passes the strict test + +``` +last_observation_event < complete_call_event < original_idle_event. +``` + +It also matches the original child pair/side, physical family, port, width, +literal compact offset and spectator completion. There are no productive/helper +aliases within a native invocation. A family may be borrowed by many successive +complete invocations; each such invocation has the separated endpoint already +proved. All intervening effects on that family in its interval are unary +translations or C factors, so the completed hosted factor commutes through +them to its original idle boundary. No factor is moved across a scalar +observation. This remains valid if another native word reads the dirty family +internally: that entire word is first replaced by its complete separated +endpoint. There is no interleaving inside an invocation. + +The fill offsets partition the **original** axis lists consecutively. The +checker verifies each offset before incrementing it by the provider's actual +helper width. At the original idle event, every positive suffix is present +exactly once with its original family and pending offset; every exhausted +suffix is absent. The complete accounting is + +``` +original idle axis mass = 17,418,240 +hosted axis mass = 10,694,160 +residual profile = {3:22788, 5:1620, 48:138492} +residual axis mass = 6,724,080. +``` + +Thus hosted factors times the residual equal the original idle C product +exactly. The original idle translation remains at its actual boundary even +when a suffix is fully hosted. No basis change, omitted tail, free helper copy +or terminal restoration is introduced. Bank padding has no families or +children in this construction. These statements hold for every physical +cover label by the preceding bijection and for every f by columnwise +multiplication. + +## Full original chronology and final cover correction + +It remains to identify the original global endpoint, including its signs and +Pauli translations. This checker independently derives it from the **physical +native pair endpoints**, rather than importing the old gauge checker's verdict. +For one column let F=C_[e0,...,e8], Q=C_q and D=F Q^-1. The two endpoints are + +``` +forward: (x,y) -> (D x, D y + F Q^-2 x) +backward: (x,y) -> (D x - F y, D y). +``` + +Their chart-conjugated factors and the actual entry/exit masks are substituted +at each of the nine stages. In a Fourier character z, C_v has phase +i^(v dot z mod 2). Its exponent is the complete polynomial modulo 4 + +``` +sum_(j in supp(v)) z_j - 2 sum_(j(Y,-X). The check proves 3,920 exact factor equalities +including every final role. It obtains M_final=I and +D_final=C_all D_initial. Hence the complete original chronology equals +C_all on each role. These are multiplicative identities of unary factors; +lifting each factor columnwise preserves them, while the scalar M remains +applied once. This proves the endpoint for every f>=1 without tensoring a +scalar matrix sum. + +For a physical cover matrix d with rows r_i, orthogonality gives + +``` +|d^T z| = |z| + sum_i (|r_i|-1) z_i (mod 4). +``` + +Indeed, expanding the parity polynomials above leaves the shown linear +terms; each quadratic coefficient is twice the overlap of two distinct rows +and vanishes modulo 4. Every row has odd weight. Put +delta_i=(|r_i|-1)/2 modulo 2. It follows exactly that + +``` +P_d C_all P_d^-1 = X_delta C_all. +``` + +The actual final event applies that row-weight mask to **every** live family, +so its involutive translation cancels X_delta. There is no missing constant +phase: all translations and C factors fix the uniform vector, and the +polynomial constant is zero. The same equation holds separately in every +column, proving the full corrected C_(73f) endpoint. + +## Evidence and limits + +hosting_admission.py is an independent stdlib traversal of every actual +assignment, owner chart, residual and event, plus the complete character +polynomial computation and bounded cover checks. It uses explicit exceptions +and its normal and optimized runs agree. Targeted mutations of the whole-call +window, original-axis offset and port owner are rejected. The prior physical +binding's independent duplicate-owner/dispatch/width/Z-map controls remain +preserved in PR4270; no new receipt claims to rerun them. + +The finite pass instantiates the exact-source hypotheses of this written +all-parameter proof. It is not a formal-kernel certificate, an exhaustive +enumeration of O(73,2), a production-size tape execution, an analytic estimate, +or administrative frontier admission. diff --git a/research/pooled-native-hosting-admission/HOSTING-PINS.json b/research/pooled-native-hosting-admission/HOSTING-PINS.json new file mode 100644 index 000000000..8222cf737 --- /dev/null +++ b/research/pooled-native-hosting-admission/HOSTING-PINS.json @@ -0,0 +1,26 @@ +{ + "files": { + "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json": { + "bytes": 4969, + "sha256": "66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b" + }, + "research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz": { + "bytes": 4705664, + "sha256": "511ef8e6f9d1519886a8a531d788af6ef51bfcf684172a15890895f66dbcf308" + }, + "research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz": { + "bytes": 6830608, + "sha256": "5455c120a121a7ec70897fb2c58e1988ce01d7172d6a5622519bea6b25efe8fe" + }, + "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz": { + "bytes": 29933, + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz": { + "bytes": 1124331, + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + } + }, + "schema": 1, + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887" +} diff --git a/research/pooled-native-hosting-admission/MACHINE-ADMISSION.md b/research/pooled-native-hosting-admission/MACHINE-ADMISSION.md new file mode 100644 index 000000000..4b7fb1b0b --- /dev/null +++ b/research/pooled-native-hosting-admission/MACHINE-ADMISSION.md @@ -0,0 +1,556 @@ +# Source-specific finite-control admission of the pooled machine + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Jose Manuel authored the retained physical controller, parking, +T74 compiler, actual-width root and primitive source, with the contributors +credited in their unchanged notices. This note supplies a source-specific +control-lowering argument, not authorship of those components. + +## Statement and exact premise cut + +Fix the exact pooled source at PR4270 head +`a929a3fa36301bdfcffe82afd37434dd9e3c4887` and canonical source +`12fa8c5c844be21bfefb38a19503fbd867a11244`. Apply the source-specific +[native theorem](NATIVE-ADMISSION.md) and [whole-call hosting theorem](HOSTING-ADMISSION.md) +to identify its complete groups. Retain only these earlier component contracts +at their stated complete-record interfaces: + +1. the completed ordinary B1 endpoint and tariff `tau=332353/332929`; +2. the completed Compact/monomial, signed scalar and Gaussian leaf algorithms, + including their exact-word/grid and return bills, and the single existing + `gaussian-normalization-stream/normalizer.py` primitive described below; +3. their fixed preallocated scratch inventories and compositional ownership + contracts. These contracts include all copies and final head returns. + +Then the *new pooled source-specific dispatcher, Count planning, bank access, +private release, recursive continuation and root wiring* admit a fixed +finite-tape controller. They require no further assumption called `U(S1)`, +no unbounded host integer selector, free seek or host recursive continuation. +The construction has precisely the complete endpoint and cost of the source +program under those component contracts. On the complete root domain in +PR4270 PHYSICAL-GLOBAL it retains + +``` +O_(q,b,B,source)(V g^.99827 log p) time, +O_(q,b,B,source)(V)+F_q occupied and visited cells. +``` + +The primitive endpoint/cost theorems in items 1–3 are the remaining *named +foundational dependencies* of this statement. Source retention does not prove +all of those mathematical theorems. In particular this note does not claim a +new proof of the entire ordinary BIT backend, Gaussian analytic estimates, +or formal-kernel verification. It removes the +separate uncertainty about how the reached pooled **control and wiring** are +implemented once the declared components are available. + +The initial factory constructs its tape inventory from source constants only: +`2q^2+100696842` owned tapes and the fixed borrowed input ports. Its expression +uses the fixed prime q, fixed pool capacities, rank/cover/source counts and +fixed header size; it receives no p, g, r or payload. Source compilation and +inventory construction both precede numerical input. Their enormous but finite +initialization cost and blank-origin marker writes belong to F_q/F_source. + +The production observer is `None`. Instrumented Python callbacks and meter +counters are observations outside the constructed controller. All numerical +arguments are finite, valid dense binary words with their declared markers; +this is the caller ABI. No parser for an arbitrary infinite or malformed tape +is being silently supplied. + +The exact root domain is `p>=2`, `1<=g<=floor(p^(997/1000))`, +`K=floor(g^(1/500))`, `0<=rho atom_width/fixed_power -> product +-> Count.product -> add`, needs fewer than16 additional operand/counter roles: +at most four root/bisection words, two power words and four Horner/add words +at once. Literal construction needs two, and encoded division needs four. +Thus fewer than70 slots suffice for planning, inside its actual256-slot pool. +None of these counts depends on a descriptor's numerical value. + +`ScratchPool.acquire` scans a fixed list of slots and tests its finite live +ownership map. Its physical `empty` check reads BLANK, steps once left to +LEFT, then steps right. The lease wrapper's meter differences are observer +data and can be erased. The runtime global-namespace adaptation is specialized +once at the finite source allocation sites by the compilation rule. The +elementary Count/pool argument above proves this part of the lowering; only +the old numerical primitives retain their own stated fixed-scratch contracts. + +Host type and nominal-module checks are static facts about the specialized +source, not payload tests. Completion sanity assertions may be erased only +when implied by the proved component ABI. For example the inherited ordinary +`RootSession.erase_work` compares a simulator dictionary with the two-tape +parking baseline. That equality is a consequence of its retained completed +ordinary return contract; it is not used here as a free inspection of an +unbounded physical tape. Alternatively a literal scan of the visited parking +region validates it in its paid ordinary/return bill. Neither interpretation +supplies a new pooled root or ordinary endpoint theorem. + +## 3. Actual finite and encoded state + +The production `Machine` has fixed mode/root flags, event, subgroup, cover, +program counter, target and child-rank selectors. The new values are bounded +by + +``` +events = 10802, subgroup < 322560, +cover < Gamma=|O(73,2)|, +pc < 65536, target < 731, rank < 73. +``` + +There are at most 31,632 instructions in an actual group, below the retained +PC bound. The header uses `1+14+19+2628+16+10+7=2695` bits. No numerical width +is written into those finite selector fields. Widths, row counts, field +lengths, precision, coefficient multiplicity and global root width remain on +Count tapes. `divide_small(73)` returns only a remainder in `{0,...,72}`; +that finite remainder is the source's left-leaf selector. + +`binding.group(event,subgroup,cover)` receives only bounded labels and never +payload. The matrices have fixed dimension 73. Its rank/unrank, Gaussian +elimination, phase/recipe keys, dictionaries and instruction lists have fixed +finite domains. They can all be tabulated into control by the compilation +rule. This charges neither a variable-sized matrix nor a payload seek as a +free action. All cover labels are allowed; the statement is not an enumeration +of Gamma. + +The new `ActiveWidthPlan` is reached with the actual divisor +`L=binding.families*binding.cover.size=322560 Gamma`. Its numerical operations +are Count copies, shifts, comparison, binary Horner products, long division, +fixed-exponent products and encoded root bisection. Their digit carries and +borrows are finite; the unrestricted quantities remain words. Binary Horner +multiplication and division have their standard prefix invariants. `fixed_power` +has a source-fixed exponent and capped encoded products. `coarse_depth` +strictly contracts the encoded width. All planning loops halt on valid finite +inputs and have polynomial descriptor cost; they do not enumerate the numeric +value of an exponential row count in host memory. + +Only finite pool/role allocation occurs before numerical input. During entry, +`sealed_constructors` prohibits a new physical Tape or Arena. Scope activation +is a finite specialization of known allocation sites into pool leases. It can +be statically monomorphized at those source sites; namespace monkey-patching +is not an operation of the resulting machine. The ordinary backend's own +allocation/refinement claims remain in its component contract. + +## 4. Complete bank access and continuation + +The bank layout is +`[prefix][family][cover][unused rows][complete within-row packet]`. +`BankPackets.gather` starts at the bank marker and scans every family and +cover in order. Unselected packets are skipped by encoded Counter; selected +ones are copied to fixed local roles. `scatter` performs another full scan, +copying every unselected packet and the new selected packets into a complete +replacement. `commit` then copies that return into the owned current bank and +disposes the old local work. The borrowed original root source is not used as +a mutable bank. Heads rewind by marker search, and each return is consumed +before reuse. + +Let V_node be the whole current bank. Every group therefore pays O(V_node) +for acquisition, replacement and return; its fixed source/cover multiplicity +changes only the constant. There is no per-field random access or omitted +scan in that bound. A complete child packet has volume V_node/L, including +all its spectators, arbitrary correlated data and r coefficient records. + +Before descent `primitive_boundary` requires all scalar/leaf/monomial/native +scratch closed and their protected outputs consumed. The child capsule copies +only the selected packet and its encoded descriptors. It keeps component_bits, +spacing, guard and the coefficient multiplicity unchanged, changes rows to the +exact unused quotient, width to `rank*columns`, and appends the literal remaining +axes to `after`. It then writes the finite header and parks the current fixed +roles. It enters internal `node` mode, not the public disk-valued root entry. + +There are 20 current/header/descriptor roles and 731 bank/private roles, hence +751 parked roles. `Parking` writes each body symbol in four binary bits, then +ROLE_END=13, and writes FRAME_END=12. Encoded bodies use only binary symbols, +so the delimiters are unambiguous. Its stack head remains at the physical top, +not at an encoded unbounded address. Restore walks backward to delimiters, +uses one reverse tape to recover the exact order, and restores roles in reverse +fixed role order. The older frame remains untouched. The two loops use marker +observations and unit moves; no frame length or stack position enters control. + +If B symbols are parked, a frame stores exactly `4B+751+1` symbols. The forward +and reverse scans take O(B+751) reads, writes and moves. The header is part of B; +its 2695 bits are paid. The proof works for every finite body word and nesting +depth. The bounded exhaustive symbol tests are only controls for this written +prefix-code/stack invariant. + +At return the child's output is first moved to a protected tape. Active roles +are rearmed and cleared, exactly one parent frame is restored, and the header +must identify the previous child instruction with its exact target and rank. +The complete result replaces that target; source-only group reconstruction +reinstates the bank selection. No buried ancestor is scanned during a child. +Numerical recursion uses this tape protocol and one interpreter loop, not the +Python call stack. + +## 5. Halting, grid, cleanup and asymptotic payment + +At an internal node `e>=73`, every child has width +`r floor(e/73)<=48 floor(e/73)=1). +``` + +The exact inequalities `2B0(73-48)>=s+E` and `E<=Ef` imply by induction +`A(e)<=2B0 e`. This covers parked parent values because they occur at prior +program points. The reserved-axis leaves, root phases and final normalization +add at most18g in total. The checked inequalities + +``` +32*73*B0^2=2, N>=1, 0<=D<=h; +it returns exact `((1-i)/2)^D z` on an integral common grid, preserves source +and descriptors, returns heads, and erases its ten fixed scratch roles and +work markers. Its complete tariff is O(2hN), including caller return copy. +Here D=g<=h and common-grid divisibility has just been proved. No pooled +root endpoint or recursive implementation is hidden in that primitive contract. + +For completeness, `grid_boundary.GridBoundary.expand` appends Delta low +zeros and Delta+1 high sign bits to every p+2-bit component. Its stored integer +therefore becomes `2^Delta` times the original integer, on the new grid, and +the value is unchanged. Every component and Gaussian record is traversed by +its encoded countdown. After the exact internal endpoint the source executes +`S_g`, `C^(tensor g)`, `S_g`, then `b^g`, where +`b=(1-i)/2` and S is diagonal `(1,i)` on the selected bit. The unary identity +`b S C S=[[1,1],[1,-1]]/2` proves the root endpoint by tensoring, including +the scalar b^g. Reserved leaves and restored row padding are part of this +same C tensor, by the internal/group endpoint above; their zero rows remain +zero by linearity and are checked before deletion. + +Finally `GridBoundary._truncated_component` records the OR of the discarded +Delta bits and copies the signed quotient. It increments that quotient only +when its sign is negative and the discarded OR is one, before checking the +final output sign-extension bits. For signed integer n this is exactly +truncation of `n/2^Delta` toward zero, including a quotient of -1 rounding to +zero. No recursive entry truncates. H0 has absolute row sum one, so the ideal +output is in the unit disk. Componentwise truncation decreases absolute +component values and has error less than2^-p per component, giving error +less than `sqrt(2) 2^-p` and a unit-disk output. The p+2-bit result has ample +signed headroom for components in [-1,1]. The grid scans, sticky/sign/carry +flags, return copy and erasure are all literal O(V) operations with the fixed +sixteen-role pool, independent of recursion depth. + +On the admitted root family, descriptor lengths are O(p), h=O(p), and actual +r satisfies `r>=2^(b(log2 p)^2)` with fixed b>0. For every fixed k, +`p^k/r<=2^(k^2/(4b))`. Hence the finite source's polynomial Count, planner, +validation and per-record setup is paid uniformly by the complete records. +The completed local primitive bills and all bank/stack scans yield exactly + +``` +O(V_node ((e log p)^tau+1)), tau=332353/332929. +``` + +No coefficient record is invented from a coarse label. The new controller +adds no positive-rank child. Thus PR4270's complete rank histogram and strict +moment remain unchanged, and its stopped-tree proof still gives `.99827`. +The outer proof's positive gap to `1/580` is unchanged. + +At a descent, parked numerical data are at most +`4(1+731/L)V_node` plus paid metadata. Successive active volumes decrease by L, +so all parked ancestors occupy at most + +``` +4(1+731/L)V/(1-1/L), +``` + +before the fixed current/capsule/output copies. Root padding enlarges volume +by less than two; the grid enlargement is a fixed source constant. Each role's +head visits at most a constant multiple of that volume plus its own polynomial +metadata. The fixed physical inventory and the stack therefore have both +occupied and visited space O(V)+F_q. Erasing a simulator byte array does not +assert deallocation of its host backing capacity. + +## 6. What has been discharged + +This is an all-parameter written controller/wiring refinement for the exact +pooled source, with a constructive finite-control compilation and a complete +physical ledger. It does not depend on executing the astronomical production +q/O(73,2) instance. The finite audit checks source identity, lowering side +conditions, literal tape/parking bodies and corruption witnesses. It is not +a formal-kernel proof or a certificate accepting every inherited theorem. + +There is no remaining *new pooled-controller* U(S1) premise. The separate +native and hosting obligations are proved by the companion documents and +compose through the exact interfaces above. The earlier named component +contracts and Gaussian analytic/outer-transfer estimates remain foundational +dependencies of the assembled conditional multiplication theorem. Renaming a +component contract as a checked theorem would not close a missing dependency. diff --git a/research/pooled-native-hosting-admission/MACHINE-PINS.json b/research/pooled-native-hosting-admission/MACHINE-PINS.json new file mode 100644 index 000000000..2fbd44c70 --- /dev/null +++ b/research/pooled-native-hosting-admission/MACHINE-PINS.json @@ -0,0 +1,12 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "archive": "frozen/machine/SOURCE-CLOSURE.tar.gz", + "archive_sha256": "1fc27e8e7d72780bc768847a503486c0133a1ee52a3445e6f6d456127cfc5d8c", + "archive_bytes": 685622, + "manifest": "frozen/machine/MANIFEST.json", + "manifest_sha256": "cb0fd17c3c3c9d50796a07ecb136e9339f190e11264da4129a269cdca9d0d157", + "files": 53, + "attribution": "Controller, T74, encoded stream/parking, actual-width root and primitive code by Jose Manuel with the credited source lineage; immutable bodies and notices preserved. This source-specific control-lowering audit is prepared for Ross Richardson with substantial OpenAI Codex assistance. Apache-2.0." +} diff --git a/research/pooled-native-hosting-admission/NATIVE-ADMISSION.md b/research/pooled-native-hosting-admission/NATIVE-ADMISSION.md new file mode 100644 index 000000000..688730283 --- /dev/null +++ b/research/pooled-native-hosting-admission/NATIVE-ADMISSION.md @@ -0,0 +1,309 @@ +# Source-specific native admission for the pooled providers + +The three actual pooled providers have the stated native endpoints for every +positive tensor multiplicity, with arbitrary dirty persistent inputs and with +their owned private work returned blank. This is a written all-parameter +algebra proof, supported by a complete finite certificate for the exact source +words and native recipes. It assumes exact child substitution and the literal +scalar/monomial/private-work semantics. Whole-call hosting, physical execution, +restoration tariffs, the recursive induction and the outer multiplication +bound are separate obligations of this package. This document alone makes no +new exponent claim and is not a formal-kernel verification. + +## Source identity and credit + +Scientific inputs remain those of PR4270 head +`a929a3fa36301bdfcffe82afd37434dd9e3c4887`; the frozen physical bundle and +`PHYSICAL-PINS.json` in `research/complex-pooled-full-admission` remain unchanged. +The exact native transport, emitter, local replay and Clifford primitives are +from canonical base `12fa8c5c844be21bfefb38a19503fbd867a11244`. + +The existing free-word tensor-lift result is reused from PR4184, exact head +`94b9ca9cf59ea6de346a59c92b414454bdde1de4`, package +`research/free-word-tensor-lift-audit`. PR4184 was prepared for ToikY with +substantial OpenAI Codex assistance. It attributes the representation argument +to Cinna Davis/PR4100, the actual words to Cinna Davis/PR4088, and the retained +free engines to Sagar Thakrar/PR3687 and roger-sato/PR3693. The source lineage, +notices and complete retained PR4184 package are preserved byte-for-byte in +`frozen/native/SOURCE-CLOSURE.tar.gz`; `MANIFEST.json` records original commit, +path, byte length, Git blob and SHA256 for every member. This work contributes +the binding to the active pooled native providers and the native recipe and +frame-gauge substitution proof, not a new free-word lift. + +`native_admission.py` authenticates both complete source archives before +execution, regenerates each canonical word with the unchanged +`bw_transport.run`, and regenerates both orientations with unchanged +`bw_emit.py`. Equality is equality of complete scientific JSON, independently +of gzip encoding: + +| Active pooled provider | PR4184 checked PR4088 export | Native persistent roles | +| --- | --- | ---: | +| `gauge44` | `THREE-base` | 632 | +| `extra` | `THREE-extra` | 632 | +| `extra-four` | `FOUR-extra` | 632 | + +Thus no unverified interchange of source words, compensated helpers or fourth +entry is used. The fourth audited export, `FOUR-base`, is retained and replayed +as part of the original complete PR4184 result; it is not an active pooled +provider in this construction. + +## Exact native input and output contract + +Work over a characteristic-zero field containing the Gaussian dyadics, for +example \(K=\mathbb Q(i)\). Fix a positive integer \(f\). Let each packet have +the internal space + +\[ + V_f=(K^{2^9})^{\otimes f}\otimes W, +\] + +where \(W\) is an arbitrary spectator factor. In the historical \(m=73\) +model, the 64 unused coordinates in every column are included in \(W\), up to +the fixed column-major/coordinate-major permutation. Extra spectator factors +are allowed as well. No independence of packet contents or tensor factors is +assumed: all statements are linear identities on the full direct sum of +packet spaces. + +There are 112 source packets \(x_q\), 112 target packets \(y_q\), and 408 +arbitrary dirty helper packets. The eight centre packets and 91 cleanup +packets are owned work, initially blank under the physical work ABI. They +return blank. The 632 persistent packets may be arbitrary and correlated. +The stronger underlying PR4184 word identity allows all 91 abstract private +cleanup inputs to be independent dirty variables and restores them; the +native implementation here specializes these inputs to zero. This does not +turn the eight centre `clear` operations into an arbitrary-workspace claim. + +Write + +\[ + C_q=\tfrac{1+i}{2}I+\tfrac{1-i}{2}X_q,\qquad + F=C_9=\prod_{j=0}^{8}C_{e_j},\qquad D_q=FC_q^{-1}. +\] + +Here \(q\) is the actual nonzero direction in the provider's port table. A +subscript \(f\) means the unary operator's \(f\)-fold tensor power, extended +by identity on \(W\); it never tensors the 632-role matrix. The source-bound +physical pair endpoints of the literal native orientations are + +\[ +\begin{array}{ll} +\texttt{forward}:& + (x_q,y_q)\longmapsto + (D_{q,f}x_q,\ D_{q,f}y_q+(FC_q^{-2})_f x_q),\\[2mm] +\texttt{backward}:& + (x_q,y_q)\longmapsto + (D_{q,f}x_q-F_fy_q,\ D_{q,f}y_q). +\end{array} +\tag{1} +\] + +The coefficient of the second term is one, and the backward minus sign occurs +once. In particular it is not \((-1)^f\). Although \(C_q^{-2}=X_q\), leaving +the product as written avoids hiding any factor. These are the actual local +endpoints before the whole-call controller applies its source-bound gauges +and correction. The word `backward` names the literal program; it is not a +claim that its full physical pair map is the inverse transpose of the first +line of (1). + +A helper whose native entrance and terminal frames have dimensions \(e\) +and \(u\) has residual width \(w=u-e\). The exact residual wrappers return +that helper as + +\[ + C_{[w],f}h\quad\text{on its first \(wf\) selected axes,} +\tag{2} +\] + +and restore all complementary axes identically. A plain cold/FULL helper has +\(w=9\) and residual \(F_fh\). The actual physical-family/cohort placement +of these selected axes is supplied by the hosting proof. Equations (1)–(2) +already include both helper wrappers, every zero-buffer inverse cleanup and +the declared native cleanup tail. + +## Reused universal free-word identity + +PR4184 independently pulls every one of 723 output functionals backward +through each of the four actual literal words in both orientations. Its +coefficients are exact fractions and its operator words reduce only adjacent +inverse letters. The fresh replay here reproduces its frozen result: +5784 output functionals, 6680 endpoint terms, and no surviving nonempty word. +There is no commutation, finite-order rule or one-column minimal polynomial. +On common labels the endpoints are + +\[ + (x,y,h,b)\mapsto(x,y+x,h,b),\qquad + (x,y,h,b)\mapsto(x-y,y,h,b). +\tag{3} +\] + +Let \(\mathcal A=\mathbb Q[F_{72}]\), the group algebra of the free group +on the 72 warp symbols. A word program is a finite product of elementary +role matrices over \(\mathcal A\). For any chosen invertible operators +\(K_1,\ldots,K_{72}\), define + +\[ + \rho_f(g_k)=K_k^{\otimes f}\otimes I_W. +\] + +The free universal property gives a group homomorphism, and linear extension +gives a unital rational algebra homomorphism. Applying it entrywise to the +proved finite elementary-matrix identity gives (3) on the full \(V_f\) +space for every positive \(f\). This argument does not infer an unbounded +statement from finitely many \(f\) tests. The separately checked dual word +is universal in its own free generators, so the actual unary warp assignment +of either native orientation is allowed. The native source deliberately +serializes the same physical warp record in both orientations; no extra +conjugation of that record is inserted here. + +Two distinctions are essential: + +\[ + \rho_f(g-I)=K^{\otimes f}-I, + \qquad \rho_f(cg)=cK^{\otimes f}. +\tag{4} +\] + +These are not \((K-I)^{\otimes f}\) and \(c^fK^{\otimes f}\). Role +ADD/SCALE coefficients, including initial corrections and signs, stay once. +Conversely a constant phase already inside a unary monomial is tensorized: +\((i^aM)^{\otimes f}=i^{af}M^{\otimes f}\). This keeps every +\(f\)-dependent phase, including phases of inverse wrappers. + +## Complete native recipe certificate + +Let \(\Gamma_U\) be the exact source `canonical_frame(9,U)`. Each supplied +directed child recipe is checked as + +\[ + \Gamma_V\Gamma_U^{-1}=L_{UV}C_{[r]}R_{UV}, + \qquad r=|\dim V-\dim U|. +\tag{5} +\] + +The apply order is right monomial, exact rank-\(r\) child, left monomial. +All source-listed recipes are checked, not merely recipes reached by one +orientation. The active provider inventories are 3069, 3069 and 3071 directed +children; both orientations together reach every one. The certificate also +checks all 224 endpoint adapters, all 180 serialized warp classes per +provider, every residual pair, and every serialized warp-generator recipe. +Duplicate mathematical cases across providers are cached using the exact +frame vectors and full recipe content; metadata coverage is checked before +deduplication. + +The checker decodes the supplied monomials with the pinned primitive +constructors; it never calls `lower_child` or generates replacement recipes. +A supplied operator and its reference are equal if their conjugation actions +agree on all 18 Pauli generators and a corresponding nonzero amplitude of +their zero-input columns agrees exactly, including Gaussian numerator and +dyadic denominator. This is a complete equality test: the quotient then +commutes with every \(X_j,Z_j\), whose commutant on \(K^{2^9}\) consists +only of scalars; one equal nonzero matrix coefficient fixes that scalar. +The primitive tableau rules follow directly by conjugating \(i^pX^xZ^z\) +through the literal diagonal, permutation, translation, phase and quarter-X +instructions. `zero_state` evaluates those same instructions in exact +Gaussian dyadics. It never uses floating point or hash equality as an +operator-equality test. + +The relevant references, with ordinary matrix apply order, are: + +\[ +\begin{aligned} + A_{q,\mathrm{source}}&=\Gamma_{\mathrm{start}(q)}C_q^{-1},\\ + A_{q,\mathrm{target}}&=\Gamma_{\mathrm{final}(q)}(FC_q^{-1})^{-1},\\ + W_{k,U,V}^{\epsilon}&=\Gamma_VK_k^{\epsilon}\Gamma_U^{-1},\\ + S_{E,U}&=\Gamma_U\Gamma_E^{-1}=L_{E,U}C_{[u-e]}R_{E,U}. +\end{aligned} +\tag{6} +\] + +For a source generator whose GF(2) matrix has columns \(G\), the actual +\(K_G\) is the permutation by \(G\), followed by the diagonal quadratic +phase with matrix \(I+G^{-T}G^{-1}\). This definition, including its scalar +phase, is compared to the serialized generator and physical warp records. +The residual pre-wrapper is \(R_{E,U}^{-1}\) and its post-wrapper is +\(L_{E,U}^{-1}\); (6) therefore gives exactly (2), including cold proper +terminal frames \(E=0\). A proper terminal recipe is never replaced by the +FULL terminal recipe sharing the same entrance. + +Every equality (5)–(6) is now an equality between fixed unary operators. +Taking its \(f\)-fold tensor power gives the required equality for every +positive \(f\), with all factors and scalar phases retained. Under the fixed +coordinate permutation, \(C_{[r]}^{\otimes f}\) is the rank-\(rf\) +coordinate child, with identity on its complement. This is the sole child +action needed by the native lift. It is smaller than the parent because all +positive native child ranks satisfy \(r\le8<73\). The recursive induction +must supply that exact child action on its actual hosted coordinate set. + +This does not assume `U(S1)` or lift a one-column 632-role native endpoint +matrix. The role-level cancellation is proved in the free group algebra. +The fixed nine-coordinate computation is used only to certify individual +unary recipe identities, to which tensor functoriality legitimately applies. + +## Frame gauge, private cleanup and endpoints + +At a common frame \(U\), represent a physical packet as +\(p=\Gamma_{U,f}z\). Every scalar gate applies the same rational coefficient +to its physical operands, so it applies the literal scalar gate to their +logical \(z\)'s. Equation (5) changes the frame without changing \(z\). +The warp identity in (6) changes \(z\) to \(K_{k,f}^{\epsilon}z\). +An owned centre copy, its complete descending/ascending child path and its +clear therefore realize exactly the emitted common-label centre macro. + +The original `bw_audit_local.local` is freshly replayed in both orientations +for each provider. Its four algebra/interval function definitions are +compiled unchanged from the authenticated AST, with assertions explicitly +enabled even under `python -O`. Module I/O and its NumPy matrix engine are +omitted; the warp callback instead invokes the separate exact certificate +above. The symbolic rows and cancellation rules, frame incidences, scalar +prefix calculation, wrappers, centre paths and 91 zero-buffer lifetimes are +unchanged. The replay begins with 632 independent dirty persistent symbols, +checks the full endpoint on every symbol and checks that every private row +is zero at return. + +In particular, this replay forbids *any* read or warp of a wrapped helper +before its pre-wrapper or after its post-wrapper. That includes zero-frame +premix reads. Hence, for a dirty helper \(h\), it is legitimate to choose +the initial logical variable +\(z=\Gamma_{E,f}^{-1}R_{E,U,f}^{-1}h\). There is no illicit movement of a +wrapper across a prefix that already reads the helper. The free-word result +restores \(z\), so the terminal physical helper after its post-wrapper is +\(L_{E,U,f}^{-1}\Gamma_{U,f}z=C_{[u-e],f}h\). + +For a source pair the initial logical variables are +\(z_x=C_{q,f}^{-1}x_q\), \(z_y=y_q\). Source entry adapters implement +those gauges; source exits are identity at FULL, while target exits apply +the inverse of the target adapter in (6). Substitute these logical variables +into each line of (3). The resulting physical endpoint is exactly (1). +All 91 private cleanup packets start zero and have identically zero output; +all eight centre packets are closed; all other tensor/spectator coordinates +are covered by the same operator identities. No zero dirt, product-state +assumption or one-column representation relation has been used. + +## Reproducible evidence and remaining boundary + +Run `python3 native_admission.py --check evidence/NATIVE-ADMISSION.json` from +this directory; the same command with `python3 -O` must give the identical +receipt. It uses only the standard library and the two authenticated local +source bundles. There is no live Git, network, solver or historical run-path +dependency. Normal execution is bounded by the finite 29-member source +closure and complete recipe inventories, independently of \(f\). + +The controls reject a child phase change invisible to its Pauli tableau, +swapped residual wrapper sides, a missing zero-buffer release, a missing +warp inverse cleanup, a missing helper post-wrapper and a helper read moved +before its pre-wrapper. The reused PR4184 controls independently forbid +commutative/fourth-power collapse and preserve the two terms of \(g-I\). +These controls test the delicate boundaries of the proof; they are not its +all-parameter argument. + +Discharged here are the source identity of all three pooled native providers, +their complete arbitrary-dirty persistent endpoints and owned-work cleanup, +every phase-inclusive native recipe, and their lift to every positive +\(f\) under exact child substitution. Retained premises are exact physical +scalar/monomial/work operations on a representable common grid; exact child +implementation on each selected coordinate set; whole-call placement and +hosting; paid controller and restoration costs; recursive storage and time; +and the outer multiplication transfer. Those premises must be discharged by +their owning proofs before calling \(\kappa=1/580\) admitted. Historical +model assumptions of the multiplication theorem remain explicit in the +package-level admission statement. diff --git a/research/pooled-native-hosting-admission/NATIVE-PINS.json b/research/pooled-native-hosting-admission/NATIVE-PINS.json new file mode 100644 index 000000000..ca03d6d1c --- /dev/null +++ b/research/pooled-native-hosting-admission/NATIVE-PINS.json @@ -0,0 +1,21 @@ +{ + "schema": 1, + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "canonical_base": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "prior_package": "research/complex-pooled-full-admission", + "prior_inputs": { + "PHYSICAL-PINS.json": "2ea958a9c87c5202113d84f176972de662fd87b45e5fde57c33a3251c7eeab53", + "frozen/physical-t74/SOURCE-BUNDLE.tar.gz": "91226b99943069f21d845c3242b54ba492418d1194422d04cf2569fd14cbb9ea" + }, + "source_archive": "frozen/native/SOURCE-CLOSURE.tar.gz", + "source_archive_sha256": "d1fd2fb89859d0dcabcd5b2f233a74c2bcb743a256434e180613c89ea7ef4ae0", + "source_manifest": "frozen/native/MANIFEST.json", + "source_manifest_sha256": "7ed9e75e51be2ace5e65d7c3ae992986f526eee579862f05856e4b2b8d5fcb0c", + "provider_map": { + "gauge44": "THREE-base", + "extra": "THREE-extra", + "extra-four": "FOUR-extra" + }, + "native_domain": "632 arbitrary dirty persistent inputs, 8 owned centre and 91 owned zero packets; every positive tensor multiplicity; all complete spectator factors.", + "scope": "Source-specific native algebra/recipe admission under exact child substitution; hosting, physical lowering and outer multiplication are separate dependent proofs." +} diff --git a/research/pooled-native-hosting-admission/README.md b/research/pooled-native-hosting-admission/README.md new file mode 100644 index 000000000..96500a0b1 --- /dev/null +++ b/research/pooled-native-hosting-admission/README.md @@ -0,0 +1,98 @@ +# Pooled native, hosting and controller admission + +This successor closes PR4270's source-specific pooled native/hosting/controller +obligations by written all-parameter proofs. Under the explicitly retained +foundational and modern analytic contracts, the full recursive and outer bound +remains + +``` +T(n)=O(n (log n)^(1-1/580)), space O(n)+F_q. +``` + +This is a conditional improvement, not an identical-premise transfer from +the selected legacy theorem. It is not a maintainer admission decision or a +selected-frontier update. PR4270's frozen sources and receipts remain unchanged. + +Read [ADMISSION.md](ADMISSION.md) for the theorem, exact retained hypotheses +and noncircular induction. Its three inputs are: + +* [NATIVE-ADMISSION.md](NATIVE-ADMISSION.md): the actual three providers in + both orientations, arbitrary correlated dirty inputs, phase-inclusive + native recipes, private cleanup and every positive tensor multiplicity. + It reuses and credits PR4184's free-word tensor result. +* [HOSTING-ADMISSION.md](HOSTING-ADMISSION.md): every actual whole-call window, + original axis and residual, every common-cover chart, complete signed + chronology and final correction. +* [MACHINE-ADMISSION.md](MACHINE-ADMISSION.md): constructive finite-control + lowering of the actual source, encoded extents, tape continuations, full + bank scans, exact halves, stock, cleanup and occupied/visited space. + +The fresh finite certificates instantiate the exact sources: 1,321,920 +helper assignments, 2,047,680 persistent owner entries, 6,489 helper charts, +1,008 data charts, all 162,900 positive residuals, 3,920 global phase-factor +identities and the complete native recipe inventories. The finite passes +support the written proofs; they do not alone imply an all-size theorem. + +The complete rank profile, including all restoration, is unchanged: + +``` +{1:8060040, 2:2310120, 3:751788, 4:327240, + 5:66420, 8:25920, 48:138492}. +``` + +The layer power is `.99827`, the complete outer power is `.99827519`, and +the strict gap `(1-1/580)-.99827519=1949/2900000000` pays the remaining +logarithm. The stronger legacy arithmetic candidate is not claimed here. + +## Reproduction + +From the repository root, using Python 3.12 and the standard library: + +``` +python3 -B scripts/research_package.py --package research/pooled-native-hosting-admission --check-only +python3 -B scripts/research_package.py --package research/pooled-native-hosting-admission +``` + +The eight registered commands run each of the four bounded checkers normally +and with `-O`, comparing the same deterministic receipts. They use explicit +exceptions; the native source's assertions are deliberately compiled enabled +inside its certificate. The hook isolates import caches. There is no live +GitHub, source-object cache, solver, historical run-directory or third-party +Python dependency in the mathematical replay. + +SOURCES.json and the local pin manifests bind the exact old inputs. Pending +PR4184 bytes and all machine source needed by the new certificate are retained +in self-contained authenticated exports, with original paths, hashes and +attribution. The archive's original PR commit is provenance, not a hidden +clean-checkout dependency. This package does not rerun PR4270's long finite +release or execute an astronomical production payload. + +## Review status + +Independent Astra AI review is recorded in REVIEW.md with the exact reviewed +source hashes, executed checks and limitations. Scientific acceptance of the +remaining primitive/modern analytic contracts and any frontier change require +separate review. No external publication or selected-record edit is part of +this local work. + +## Open next questions + +The structured questions are in TASK.json. + +* Can independent scientific review accept the complete conditional admission + at the explicit B_ordinary/P_elementary/G_modern/BHP premise cut? Start at + ADMISSION.md and trace one complete native-to-root-to-outer call. The blocker + is mathematical review of those retained contracts, not a missing pooled + helper or unpriced cleanup in the new construction. +* Can the retained modern Gaussian inverse/locality/rounding hypotheses be + proved at the actual asymptotic parameter family? Start with the phase-cell + gap and inverse estimates and retain BHP separately. A legacy resampling + hypothesis cannot be substituted: its theta/alpha condition fails here. + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Rohan Arun supplies the pooled fill; Cinna Davis supplies the +PR4088 words; yssite supplies the PR4180 admission architecture; the native +free-word result retains ToikY/PR4184, Sagar Thakrar and roger-sato's credit; +Gareth Davidson and Jose Manuel supply the retained charts and physical +controllers; Tekalign supplies the CRT converter. All retained source notices +and detailed dependency credit remain in the exports and PR4270. diff --git a/research/pooled-native-hosting-admission/REVIEW.md b/research/pooled-native-hosting-admission/REVIEW.md new file mode 100644 index 000000000..96ad53fbb --- /dev/null +++ b/research/pooled-native-hosting-admission/REVIEW.md @@ -0,0 +1,71 @@ +# Independent Astra AI review + +The user requested a gpt-6-astra sub-agent review before readiness. A separate +read-only Astra context reviewed the completed local proof, source and +retained premise boundary. This is independent-context AI review, not +independent human review, a formal proof or a maintainer decision. + +Its final conclusion was: + +> No remaining actionable mathematical finding in the amended local package. +> The source-specific conditional admission is supported at its explicit +> premise cut; kappa=1/580 survives the reviewed restoration, recursion, +> precision, storage and outer costs. + +## Finding and repair + +The initial internal ABI was too broad. Arbitrary h-bit inputs can overflow +under an exact C operation: `u=M-iM`, `v=M+iM`, `M=2^(h-1)-1` have representable +components, while one output's real numerator is 2M. ADMISSION and MACHINE +now separate arbitrary-input algebra over Gaussian dyadics from finite-width +execution with sufficient incoming height/divisibility and caller-tail +reserve. The whole-root height proof supplies that reserve to every reached +child. Astra explicitly rechecked and accepted this amendment. admission.py +retains exact counterexamples to the overbroad domain. + +The final review found the dependency order noncircular: free-group algebra, +phase-inclusive native recipes, complete separated endpoints, valid +whole-call hosting/common-cover transport, encoded fixed-controller +execution, smaller exact children and the guarded-root height proof. It +found no new pooled-root obligation concealed in the named B_ordinary, +P_elementary, G_modern and BHP premise cut. + +## Checks and scope + +Astra independently passed the normal native replay, amended machine replay +and final admission join on Python 3.14.6. Its hosting review independently +compared all 112 port bases and 1,008 data charts with the retained dispatcher, +reproduced 3,920 complete phase-factor identities, and checked the complete +small covers. It inspected the full hosting traversal and its predicates but +did not independently rerun all 1,321,920 assignments. It did not run optimized +variants, the historical full release or a production payload. + +The parent separately ran all eight registered commands, normally and with +`-O`, on Python 3.12.12. That source-bound local run completed successfully +at 2026-10-21T10:04:21Z, including the complete hosting traversal in both +variants. These are local checks, not hosted CI. + +The strongest supported wording is **source-specific conditional admission +of the pooled implementation, yielding kappa=1/580 under the explicitly +retained foundational and modern analytic contracts**. This does not imply +maintainer acceptance, an identical-premise legacy transfer, an unconditional +theorem or a selected-frontier update. + +## Exact reviewed SHA256 values + +| File | SHA256 | +| --- | --- | +| ADMISSION.md | a040c25eb15022c66ed01677ed44b3f5e2ae7a34099d776313bbc4c7d67787a5 | +| NATIVE-ADMISSION.md | dc6e40d78fd7df67642b21b5f6d7c13b824586d1ac5f65ed7d35e9263301b8fd | +| HOSTING-ADMISSION.md | e706da89148b9da1505b9b24fa6a92729604dd08ca0721dce421f474400b4d81 | +| MACHINE-ADMISSION.md | fa2af131803f5cf7e09e5bac6c09de1f15899bb5d903a291c2a5197e16c824b8 | +| admission.py | 63d3860cffb8b01d96695bfda8cb681ec15a5a0e8a3a96360b5f4fa2bd4292c7 | +| native_admission.py | 1c51363b6b17a9b4b82f26999d0ac1a59169dbb7f34850eadd48f212e9e77da3 | +| hosting_admission.py | 67cfca85a20136adab6d603b70e7ee3c740e115c13ff7cf9e9fde1541bd69d44 | +| machine_admission.py | e47bab3f1d9ef62c293e7a063ec5a6c07ad30cfecfe77425a8ead353547c4a4e | +| evidence/ADMISSION.json | ef465fe8303267b5b780dac1251d8ff96bc2b27214c4679e7548495ea19588e1 | + +All predecessor sources, selected records and hosted PRs were left unchanged +by the reviewer. The table binds the scientific proof/checker bytes reviewed; +this summary and the parent's final publication-byte preflight are separate +records. diff --git a/research/pooled-native-hosting-admission/SOURCES.json b/research/pooled-native-hosting-admission/SOURCES.json new file mode 100644 index 000000000..7b8bd8405 --- /dev/null +++ b/research/pooled-native-hosting-admission/SOURCES.json @@ -0,0 +1,183 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65", + "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "research/complex-pooled-full-admission/EVIDENCE.json", + "usage": "input", + "git_blob": "2aaa35ffc03d64a604ee047336583869c32d02ec", + "sha256": "78b97937f56b7989b9bf13c1889521fddb7cfeb68c5d8a3ed6a4a6f5d246ac9e", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/EVIDENCE.json" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-CHECK.md", + "usage": "input", + "git_blob": "eea9bc48649e61aba19c65284b676e35c9220eac", + "sha256": "f44591b102fd618b0fbe171c9b571f4e109735713beb5b29b9887a6f4fddea9b", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-CHECK.md" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json", + "usage": "input", + "git_blob": "1998af6f96f865bf5524804e70d1725460100503", + "sha256": "f35c851e78f4eba0df41fb937940acdfcae8048b74c9938eb6a9172f2253fe8d", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-DOMAIN.md", + "usage": "input", + "git_blob": "58886ad27da6f7a1865ff76be9dfe987fb021367", + "sha256": "280be120c31c88c7d9d906d040f0d851227dd06dc8657773455b0b42d6dddc55", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-DOMAIN.md" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json", + "usage": "input", + "git_blob": "dd5670e9880c4e8c8b8c66c7e7e92058e17af299", + "sha256": "6e066a1b7f5aa26ce2915ea67186a167614c87ca444c46c25e4a5c57d4c032c5", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-JOIN.md", + "usage": "input", + "git_blob": "50cf3eefd5a4198f011bf378c5d6ddd2319feb0a", + "sha256": "bfb4677ee82ffc070be880eca87af05fd096686b464dfd5268cee1b27afa453e", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-JOIN.md" + }, + { + "path": "research/complex-pooled-full-admission/OUTER-PINS.json", + "usage": "input", + "git_blob": "d3495e13e5c04699597cc01f2bfd6ca9f111851a", + "sha256": "5cd7e6c92aa5be34cb4f9fd2db475e90954c4bff0f9a2a980d319d2079086dc9", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/OUTER-PINS.json" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md", + "usage": "input", + "git_blob": "e7166dfacf698a056668adb3413bbac8996ffe0a", + "sha256": "2fa75b9af51d31f68b818aeca7f2cb9e9f9d940ebe509fdb29d77053e05f8218", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json", + "usage": "input", + "git_blob": "f824a30caf1a2cf573c6b6ce44710a41357c0446", + "sha256": "66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md", + "usage": "input", + "git_blob": "d7a349cc414a132849bb8db43b399f45eacbc4f4", + "sha256": "1d1f06c714f0f3e5e6ab660084191a080ce4a86c0dfef8022b57c00778085b97", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-PINS.json", + "usage": "input", + "git_blob": "7f27b989e6a7e153340da42386bf4cd339a26a69", + "sha256": "2ea958a9c87c5202113d84f176972de662fd87b45e5fde57c33a3251c7eeab53", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/PHYSICAL-PINS.json" + }, + { + "path": "research/complex-pooled-full-admission/RECURSION.md", + "usage": "input", + "git_blob": "898eae1172bac4369765dfedc0165365bd30939c", + "sha256": "5bdb640810a1a81fe5b47fbedbf61c3799b6028f0f25ebdde387fe4d18407f9a", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/RECURSION.md" + }, + { + "path": "research/complex-pooled-full-admission/UNIFORM-GAP.md", + "usage": "input", + "git_blob": "5bf4d1cd477a4be19fc0a4e65d3ff33addf04dee", + "sha256": "7891456ce2716b25399a7857737169ca82a68676b3b2c1565ca29c2105651f47", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/UNIFORM-GAP.md" + }, + { + "path": "research/complex-pooled-full-admission/evidence/ADMISSION-RESULT.json", + "usage": "input", + "git_blob": "75e6edb5a4993a168adc56a07a5c0b251d47b8cd", + "sha256": "90378c981ca4def5ea12432ef54cdf66324ec301fa8d489264a48923e89d478b", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/evidence/ADMISSION-RESULT.json" + }, + { + "path": "research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json", + "usage": "input", + "git_blob": "fecd414f5121a43680e76300e042f98e25d43910", + "sha256": "c3606f99d68fdef705d512341c65f1758eff3e4ec2b9f34f28d5f047192724a6", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json" + }, + { + "path": "research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json", + "usage": "input", + "git_blob": "bef3f066a28074340ba5081ba5fef6c625a558d9", + "sha256": "8258b918fc549a1e6554e80cba4f27edaf09dd7066e0e39a099efcefee009ff5", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json" + }, + { + "path": "research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json", + "usage": "input", + "git_blob": "93042adff35b8091f298b54f2da804af8004c36a", + "sha256": "782ef40f6e1a4fa5e88c3d8757ba064508d184aff6989aab6f1c57de7282897e", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json" + }, + { + "path": "research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz", + "usage": "input", + "git_blob": "49283533a468afe49ca12c03ecf95fcc5025688b", + "sha256": "511ef8e6f9d1519886a8a531d788af6ef51bfcf684172a15890895f66dbcf308", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz" + }, + { + "path": "research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz", + "usage": "input", + "git_blob": "d5a802e3167e1f097af7b1cc0580d39de5831343", + "sha256": "91226b99943069f21d845c3242b54ba492418d1194422d04cf2569fd14cbb9ea", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz" + }, + { + "path": "research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz", + "usage": "input", + "git_blob": "441878649a162a7fa1cb22106bcc44237bedffb7", + "sha256": "5455c120a121a7ec70897fb2c58e1988ce01d7172d6a5622519bea6b25efe8fe", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz" + }, + { + "path": "research/complex-pooled-full-admission/joint_bound.py", + "usage": "input", + "git_blob": "eaa2d5986517071f48fd64a5d793d877b34b8f8e", + "sha256": "c4740234bee2bab8292aeef7fb561246cff8a060ea6e96f0bc14a7b69c62042c", + "pin": "head:a929a3fa36301bdfcffe82afd37434dd9e3c4887:research/complex-pooled-full-admission/joint_bound.py" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "usage": "input", + "git_blob": "7a1db55a4d53ee99280be4f3ab7d29f7b2033adf", + "sha256": "d566cfb87b71639d4138e1f89b543e2dd6a7772070226a2a14c799a6835bf21e" + }, + { + "path": "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz", + "usage": "input", + "git_blob": "114808c32b1799da53524bdc25cea67efb60009e", + "sha256": "21297b20f1f2dc76eb9dd8124416068c3cb096bab9df17fa4da19bc68dfe082e" + } + ] +} diff --git a/research/pooled-native-hosting-admission/TASK.json b/research/pooled-native-hosting-admission/TASK.json new file mode 100644 index 000000000..6f621d64b --- /dev/null +++ b/research/pooled-native-hosting-admission/TASK.json @@ -0,0 +1,80 @@ +{ + "schema_version": 1, + "task_id": "uniform-transfer-audit", + "priority_revision": 7, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "original_card": { + "id": "uniform-transfer-audit", + "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test.", + "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision", + "4100", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Discharge PR4270 source-specific native, chronological hosting/common-cover and fixed-tape pooled-controller obligations by written all-parameter proofs, then join the complete recursive/outer cost at conditional kappa=1/580.", + "scope_change_reason": "The user assigned PR4270 and requested source-specific admission rather than the catalogue default PR4100 audit. The existing PR4184 free-word result is reused with exact bytes and credit; the new work supplies actual pooled native/recipe, hosting and controller implications.", + "bottleneck_link": "A pooled local/profile saving is not a multiplication improvement until the exact native, whole-family placement, recursive physical realization and full outer bills are supplied.", + "budget_minutes": 240, + "stop_rule": "Close the one assigned source-specific admission implication or record its first genuine obstruction, preserve exact sources and final Astra review, and do not push. Original UTC deadline2026-10-21T13:18:50Z, closeout12:58:50Z.", + "outcome": "completed", + "evidence": "ADMISSION.md and three companion written proofs, exact finite receipts in evidence/, normal and optimized bounded replays, and independent Astra AI review with exact scope and hashes. No production payload, unconditional theorem or frontier promotion.", + "author": "Ross Richardson", + "ai_assistance": "Substantial OpenAI Codex assistance. Separate mathematical specialist contexts supplied native and machine proofs; an explicitly requested gpt-6-astra context independently reviewed the final local proof boundary. AI review is not independent human or formal verification.", + "open_questions": [ + { + "question": "Can independent scientific review accept the complete conditional admission at the explicit B_ordinary/P_elementary/G_modern/BHP premise cut?", + "why_it_matters": "Source-specific supplier closure is different from scientific acceptance of retained primitive and modern analytic contracts or a selected-frontier update.", + "first_step": "Read ADMISSION.md, review each exact source and trace the complete native-to-root-to-outer call with all restoration and physical costs.", + "blocked_by": "Independent scientific review of the named retained contracts; no maintainer frontier authority is asserted." + }, + { + "question": "Can the modern Gaussian phase-cell inverse, locality and rounding estimates be proved on the actual asymptotic family?", + "why_it_matters": "They remain explicit hypotheses and are not the selected legacy assumptions applied unchanged.", + "first_step": "Audit gap(H)>=1/(8p) and norm(H^-1)<=8p on the actual production domain, then the coefficient/locality/rounding contracts; retain BHP separately.", + "blocked_by": "The modern analytic proof obligations. Legacy theta>p/alpha^4 fails this family." + } + ] +} diff --git a/research/pooled-native-hosting-admission/VERIFICATION.json b/research/pooled-native-hosting-admission/VERIFICATION.json new file mode 100644 index 000000000..4a928096f --- /dev/null +++ b/research/pooled-native-hosting-admission/VERIFICATION.json @@ -0,0 +1,21 @@ +{ + "schema": 1, + "status": "PASS_LOCAL_REGISTERED_PYTHON312_REPLAY", + "python": "3.12.12", + "registered_commands": 8, + "normal_and_optimized": true, + "started_utc": "2026-10-21T10:02:49.599570Z", + "finished_utc": "2026-10-21T10:04:21.517880Z", + "returncode": 0, + "source_and_context_rechecked": true, + "owned_process_cleanup_verified": true, + "checkpoint_fingerprint": "85ea61896c9c70eed818fc75eae0c6bf439d8dbf007b27a71b92fd88d24156df", + "checkpoint_log_sha256": { + "stderr.log": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "stdout.log": "a616bd9a248f538938b1c4ba99442a5eb359d41d1e8bac6158a1e7e46db0540f" + }, + "hosted_CI": false, + "historical_full_release_rerun": false, + "production_payload_executed": false, + "scope": "All8registerednative/hosting/machine/joinchecks; supports written conditional proof and exact sources, not scientific acceptance" +} diff --git a/research/pooled-native-hosting-admission/VERIFY.json b/research/pooled-native-hosting-admission/VERIFY.json new file mode 100644 index 000000000..446ea0250 --- /dev/null +++ b/research/pooled-native-hosting-admission/VERIFY.json @@ -0,0 +1,125 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-pooled-full-admission/EVIDENCE.json", + "research/complex-pooled-full-admission/OUTER-CHECK.md", + "research/complex-pooled-full-admission/OUTER-DOMAIN-PINS.json", + "research/complex-pooled-full-admission/OUTER-DOMAIN.md", + "research/complex-pooled-full-admission/OUTER-FACTORY-PINS.json", + "research/complex-pooled-full-admission/OUTER-JOIN.md", + "research/complex-pooled-full-admission/OUTER-PINS.json", + "research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md", + "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json", + "research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md", + "research/complex-pooled-full-admission/PHYSICAL-PINS.json", + "research/complex-pooled-full-admission/RECURSION.md", + "research/complex-pooled-full-admission/UNIFORM-GAP.md", + "research/complex-pooled-full-admission/evidence/ADMISSION-RESULT.json", + "research/complex-pooled-full-admission/evidence/OUTER-CHECK-PORTABLE.json", + "research/complex-pooled-full-admission/evidence/OUTER-DOMAIN.json", + "research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json", + "research/complex-pooled-full-admission/frozen/physical-t74/GLOBAL-BINDING.tar.xz", + "research/complex-pooled-full-admission/frozen/physical-t74/SOURCE-BUNDLE.tar.gz", + "research/complex-pooled-full-admission/frozen/pr4181/owner/FILL.json.gz", + "research/complex-pooled-full-admission/joint_bound.py", + "research/staged544-mixed-fourth-entry/owner/PLAN.json.gz", + "research/staged544-mixed-fourth-entry/owner/TEMPLATE.json.gz" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/native_admission.py", + "--check", + "{package}/evidence/NATIVE-ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Exact active word source equality; all native recipes, dirty endpoints and private cleanup; written all-f proof." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/native_admission.py", + "--check", + "{package}/evidence/NATIVE-ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Exact active word source equality; all native recipes, dirty endpoints and private cleanup; written all-f proof. Optimized run must match the same deterministic receipt." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/hosting_admission.py", + "--check", + "{package}/evidence/HOSTING-ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Every actual whole-call window, original helper axis, residual and chart; complete phase polynomial and cover controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/hosting_admission.py", + "--check", + "{package}/evidence/HOSTING-ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Every actual whole-call window, original helper axis, residual and chart; complete phase polynomial and cover controls. Optimized run must match the same deterministic receipt." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/machine_admission.py", + "--check", + "{package}/evidence/MACHINE-ADMISSION.json" + ], + "timeout_seconds": 60, + "checks": "Source-specific finite-control lowering side conditions, exact Tape/Count/HALF/Parking source and defect controls." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/machine_admission.py", + "--check", + "{package}/evidence/MACHINE-ADMISSION.json" + ], + "timeout_seconds": 60, + "checks": "Source-specific finite-control lowering side conditions, exact Tape/Count/HALF/Parking source and defect controls. Optimized run must match the same deterministic receipt." + }, + { + "argv": [ + "{python}", + "-B", + "{package}/admission.py", + "--check", + "{package}/evidence/ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Join exact companion receipts, complete profile and recursive/outer strict rational margins; preserve explicit retained hypotheses." + }, + { + "argv": [ + "{python}", + "-O", + "-B", + "{package}/admission.py", + "--check", + "{package}/evidence/ADMISSION.json" + ], + "timeout_seconds": 120, + "checks": "Join exact companion receipts, complete profile and recursive/outer strict rational margins; preserve explicit retained hypotheses. Optimized run must match the same deterministic receipt." + } + ] +} diff --git a/research/pooled-native-hosting-admission/admission.py b/research/pooled-native-hosting-admission/admission.py new file mode 100644 index 000000000..14b5a764f --- /dev/null +++ b/research/pooled-native-hosting-admission/admission.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Bind the source-specific proofs and reprice the complete conditional join. + +This is finite exact evidence for ADMISSION.md, not an automated scientific +acceptance decision. Prepared for Ross Richardson with OpenAI Codex assistance. +""" +import argparse +from collections import Counter +from fractions import Fraction as Q +from hashlib import sha256 +import gzip +import json +from pathlib import Path +import tarfile +import types + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +PRIOR = REPO / 'research/complex-pooled-full-admission' +PROFILE = {1:8060040, 2:2310120, 3:751788, 4:327240, + 5:66420, 8:25920, 48:138492} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def load(path): + return json.loads(path.read_bytes()) + + +def sha(raw): + return sha256(raw).hexdigest() + + +def authenticated(): + pins = load(HERE / 'ADMISSION-PINS.json') + for path, record in pins['files'].items(): + target = REPO / path + need(not target.is_symlink(), 'ordinary pinned file: ' + path) + raw = target.read_bytes() + need(len(raw) == record['bytes'] and sha(raw) == record['sha256'], 'join input pin: ' + path) + return pins + + +def complete_profile(native, host): + need(native['status'] == 'PASS_SOURCE_SPECIFIC_NATIVE_ALL_PARAMETER_ADMISSION', + 'native source-specific certificate') + need(host['status'] == 'PASS' and host['hosting']['calls'] == 3240, + 'complete source-specific hosting certificate') + total = Counter({int(r): n for r, n in host['hosting']['residual_profile'].items()}) + counts = host['hosting']['provider_counts'] + need(counts == {'gauge44':1568, 'extra':592, 'extra-four':1080}, 'actual provider selector') + for provider, multiplicity in counts.items(): + record = native['active_providers'][provider] + for rank, number in record['child_profile'].items(): + total[int(rank)] += multiplicity * number + need(set(record['local']) == {'forward', 'backward'}, 'both literal native orientations') + for direction in record['local'].values(): + need(direction['all_exact_columns'] == 632 and direction['private_work_erased'] + and direction['zero_buffers_returned_to_zero'] == 91, 'complete dirty input and private endpoint') + need(dict(total) == PROFILE, 'all native restoration and idle children in joined profile') + # Close the native-proof -> actual-global-provider source edge explicitly. + manifest = load(PRIOR / 'PHYSICAL-GLOBAL-PINS.json')['bundle'] + raw = (PRIOR / manifest['path']).read_bytes() + need(sha(raw) == manifest['sha256'], 'exact global bundle in join') + with tarfile.open(PRIOR / manifest['path']) as archive: + member = archive.extractfile('data/PHYSICAL-PROJECTION.json').read() + need(sha(member) == manifest['files']['data/PHYSICAL-PROJECTION.json']['sha256'], + 'exact physical provider projection') + projection = json.loads(member) + local_manifest = load(PRIOR / 'PHYSICAL-PINS.json')['bundle'] + local_path = PRIOR / local_manifest['path'] + need(sha(local_path.read_bytes()) == local_manifest['sha256'] == + native['prior_physical_bundle_sha256'], 'same exact local native bundle') + actual = {} + with tarfile.open(local_path) as archive: + for provider in native['active_providers']: + for name in ('CANONICAL-WORD.json.gz', 'LOCAL-PROGRAMS.json.gz', + 'CLIFFORD-RECIPES.json', 'RESIDUAL-ADAPTERS.json'): + path = 'native/' + provider + '/' + name + body = archive.extractfile(path).read() + need(sha(body) == local_manifest['files'][path]['sha256'], 'exact native member') + actual[provider, name] = body + for provider, record in native['active_providers'].items(): + physical = projection['local_providers'][provider] + regenerated = record['regenerated_scientific_json_sha256'] + for name, field in (('CANONICAL-WORD.json.gz', 'canonical_word_sha256'), + ('LOCAL-PROGRAMS.json.gz', 'local_programs_sha256'), + ('CLIFFORD-RECIPES.json', 'exact_local_clifford_recipe_sha256'), + ('RESIDUAL-ADAPTERS.json', 'residual_adapter_sha256')): + need(sha(actual[provider, name]) == physical[field], 'actual serialized native source') + for name in ('CANONICAL-WORD.json.gz', 'LOCAL-PROGRAMS.json.gz'): + scientific = json.loads(gzip.decompress(actual[provider, name])) + need(sha(json.dumps(scientific, sort_keys=True, separators=(',', ':')).encode()) == + regenerated[name], 'same complete scientific native JSON') + need(physical['physical_program_binding'] == regenerated['LOCAL-PROGRAMS.json.gz'], + 'native theorem is for actual global provider: ' + provider) + need(len(physical['widths']) == 408 and record['persistent_inputs_each_orientation'] == 632, + 'complete native role/hosting boundary') + return total + + +def rates(profile): + path = PRIOR / 'joint_bound.py' + module = types.ModuleType('authenticated_pooled_interval_arithmetic') + module.__file__ = str(path) + # Imports only stdlib; no source-adjacent import cache can replace this body. + exec(compile(path.read_bytes(), str(path), 'exec', optimize=0), module.__dict__) + sigma, alpha, eta, tau = Q('.99826995'), Q('.99827'), Q(1, 10**6), Q(332353,332929) + lower, upper = module.moment(profile, 73, 322560, 1-sigma) + need(lower <= upper < 0 and tau < sigma < alpha, 'strict complete moment and B1 ordering') + internal, leaf = sigma-eta*(sigma-tau), sigma+eta*(1-sigma) + phi, beta, kappa = 1-Q(997,1000)*(1-alpha), Q(41544341,41616125), Q(1,580) + need(internal < alpha and leaf < alpha and Q('.998') < alpha, + 'all stopped-tree and reservation powers') + need(500*(1-alpha) < 1 and beta < phi and Q('.9981') < phi, + 'failed-guard fallback, full router and Gaussian costs') + need((1-kappa)-phi == Q(1949,2900000000) > 0, 'remaining outer logarithm is paid') + expected = load(PRIOR / 'evidence/PHYSICAL-GLOBAL.json')['physical_layer_rate'] + need(list(map(str, (lower, upper))) == expected['moment_minus_one'] and + str(internal) == expected['internal_exponent'] and str(leaf) == expected['leaf_exponent'], + 'same complete invoice and exact guard/stopped-tree source') + return dict(sigma=str(sigma), tau=str(tau), alpha_layer=str(alpha), + moment_minus_one=list(map(str, (lower, upper))), + internal_exponent=str(internal), leaf_exponent=str(leaf), + Phi=str(phi), beta_router=str(beta), Gaussian_payload_power='9981/10000', + final_log_gap=str((1-kappa)-phi), kappa=str(kappa), + selected_kappa_comparison_only='0.001672660197076918') + + +def certificate(): + authenticated() + native = load(HERE / 'evidence/NATIVE-ADMISSION.json') + host = load(HERE / 'evidence/HOSTING-ADMISSION.json') + machine = load(HERE / 'evidence/MACHINE-ADMISSION.json') + need(machine.get('status', '').startswith('PASS_'), 'machine source-specific certificate') + profile = complete_profile(native, host) + costs = rates(profile) + # The old outer proof/evidence is retained, not rerun or broadened here. + outer = load(PRIOR / 'evidence/OUTER-DOMAIN.json') + need(outer['exact_exponents']['kappa'] == costs['kappa'] and + outer['exact_exponents']['final_log_gap'] == costs['final_log_gap'] and + not outer['numerical_payload_executed'] and not outer['production_native_constructors_executed'], + 'preserve precise prior outer evidence scope') + proof_hashes = {name:sha((HERE / name).read_bytes()) for name in + ('NATIVE-ADMISSION.md', 'HOSTING-ADMISSION.md', 'MACHINE-ADMISSION.md', 'ADMISSION.md')} + receipt_hashes = {name:sha((HERE / 'evidence' / name).read_bytes()) for name in + ('NATIVE-ADMISSION.json', 'HOSTING-ADMISSION.json', 'MACHINE-ADMISSION.json')} + # Real counterexample to an overbroad finite-width ABI. For C's first row, + # a*u+b*v=2M with a=(1+i)/2,b=(1-i)/2. Each input component fits h bits. + # Exact guarded execution requires spare denominator/magnitude budget. + overflow_controls = 0 + for width in range(2, 9): + maximum = (1 << (width-1)) - 1 + real = Q(maximum-(-maximum), 2) + Q(maximum+maximum, 2) + imaginary = Q(maximum+(-maximum), 2) + Q(maximum-maximum, 2) + need(real == 2*maximum > maximum and imaginary == 0, + 'fitting inputs alone do not imply a safe internal finite-width C call') + overflow_controls += 1 + return dict(schema=1, status='PASS_SOURCE_SPECIFIC_CONDITIONAL_ADMISSION_JOIN', + claim='Written source-specific pooled admission and conditional integer kappa=1/580; no frontier decision', + scientific_head='a929a3fa36301bdfcffe82afd37434dd9e3c4887', + profile=dict(sorted(profile.items())), rank_mass=sum(r*n for r,n in profile.items()), + costs=costs, written_proof_sha256=proof_hashes, finite_receipt_sha256=receipt_hashes, + discharged=['all-positive-f native operators and exact private cleanup', + 'complete chronological whole-family hosting and all-cover transport', + 'source-specific pooled fixed-controller and internal recursive realization'], + retained_hypotheses=['B_ordinary (including BIT H1-H5)', 'P_elementary', + 'G_modern (complete retained physical component and analytic contracts)', 'BHP'], + modern_premises_identical_to_selected_legacy=False, + internal_execution_domain='reachable guarded-root calls; incoming height a plus internal prefix allowance A(e) <= Delta, with caller tail reserve', + overbroad_h_bit_domain_counterexamples=overflow_controls, + production_payload_executed=False, formal_kernel_verified=False, + independent_human_admission=False, selected_frontier_changed=False) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path) + parser.add_argument('--check', type=Path) + args = parser.parse_args() + result = json.loads(json.dumps(certificate())) + if args.check: + need(result == load(args.check), 'fresh admission join equals recorded receipt') + raw = json.dumps(result, sort_keys=True, indent=2) + '\n' + if args.out: + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(raw) + print(raw, end='') + + +if __name__ == '__main__': + main() diff --git a/research/pooled-native-hosting-admission/evidence/ADMISSION.json b/research/pooled-native-hosting-admission/evidence/ADMISSION.json new file mode 100644 index 000000000..777db877c --- /dev/null +++ b/research/pooled-native-hosting-admission/evidence/ADMISSION.json @@ -0,0 +1,62 @@ +{ + "claim": "Written source-specific pooled admission and conditional integer kappa=1/580; no frontier decision", + "costs": { + "Gaussian_payload_power": "9981/10000", + "Phi": "99827519/100000000", + "alpha_layer": "99827/100000", + "beta_router": "41544341/41616125", + "final_log_gap": "1949/2900000000", + "internal_exponent": "6647060323670676329/6658580000000000000", + "kappa": "1/580", + "leaf_exponent": "19965399034601/20000000000000", + "moment_minus_one": [ + "-33989562751811586763128131904117409800226978209787909368775448862027064463490500701933615095451456395537816144932191/12886032106468850481583737274350967458813277931013019678285809874924520848150447758356921635997562811169399617949941104640", + "-606956477710921192198716641144953746432624610889069810156704443964769008276616083963100269561633149920318144962697/230107716186943758599709594184838704621665677339518208540818033480795015145543709970659314928527907342310707463391805440" + ], + "selected_kappa_comparison_only": "0.001672660197076918", + "sigma": "19965399/20000000", + "tau": "332353/332929" + }, + "discharged": [ + "all-positive-f native operators and exact private cleanup", + "complete chronological whole-family hosting and all-cover transport", + "source-specific pooled fixed-controller and internal recursive realization" + ], + "finite_receipt_sha256": { + "HOSTING-ADMISSION.json": "ef18f5987b7b72d566e90c355311b7b07d88825cfc8593b7c9694882d531ac83", + "MACHINE-ADMISSION.json": "8222741d411cbdf496c81ed28ff2ca8ac6ce878f4cd9c18e982ea4738275e7c9", + "NATIVE-ADMISSION.json": "22acf428574ba51c187b042fecd039d2cfc19d2c903d2df28f405e33640ff0ed" + }, + "formal_kernel_verified": false, + "independent_human_admission": false, + "internal_execution_domain": "reachable guarded-root calls; incoming height a plus internal prefix allowance A(e) <= Delta, with caller tail reserve", + "modern_premises_identical_to_selected_legacy": false, + "overbroad_h_bit_domain_counterexamples": 7, + "production_payload_executed": false, + "profile": { + "1": 8060040, + "2": 2310120, + "3": 751788, + "4": 327240, + "48": 138492, + "5": 66420, + "8": 25920 + }, + "rank_mass": 23431680, + "retained_hypotheses": [ + "B_ordinary (including BIT H1-H5)", + "P_elementary", + "G_modern (complete retained physical component and analytic contracts)", + "BHP" + ], + "schema": 1, + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "selected_frontier_changed": false, + "status": "PASS_SOURCE_SPECIFIC_CONDITIONAL_ADMISSION_JOIN", + "written_proof_sha256": { + "ADMISSION.md": "a040c25eb15022c66ed01677ed44b3f5e2ae7a34099d776313bbc4c7d67787a5", + "HOSTING-ADMISSION.md": "e706da89148b9da1505b9b24fa6a92729604dd08ca0721dce421f474400b4d81", + "MACHINE-ADMISSION.md": "fa2af131803f5cf7e09e5bac6c09de1f15899bb5d903a291c2a5197e16c824b8", + "NATIVE-ADMISSION.md": "dc6e40d78fd7df67642b21b5f6d7c13b824586d1ac5f65ed7d35e9263301b8fd" + } +} diff --git a/research/pooled-native-hosting-admission/evidence/HOSTING-ADMISSION.json b/research/pooled-native-hosting-admission/evidence/HOSTING-ADMISSION.json new file mode 100644 index 000000000..c325447a3 --- /dev/null +++ b/research/pooled-native-hosting-admission/evidence/HOSTING-ADMISSION.json @@ -0,0 +1,80 @@ +{ + "cover": { + "complete_small_groups": [ + { + "characters_each": 2, + "dimension": 1, + "matrices": 1 + }, + { + "characters_each": 4, + "dimension": 2, + "matrices": 2 + }, + { + "characters_each": 8, + "dimension": 3, + "matrices": 6 + }, + { + "characters_each": 16, + "dimension": 4, + "matrices": 48 + }, + { + "characters_each": 32, + "dimension": 5, + "matrices": 720 + } + ], + "full_cover_bits": 2628, + "full_cover_probes": 4, + "full_dimension": 73, + "universal_domain": "written proof, not exhaustive full-cover enumeration" + }, + "coverage": "finite exact source hypotheses; universal proof in HOSTING-ADMISSION.md", + "global_operator": { + "domain": "all 73-bit Fourier characters; multiplicative lift for every f>=1", + "exact_operator_factor_identities": 3920, + "ports": 112, + "scalar_role_dimension": 8 + }, + "hosting": { + "calls": 3240, + "data_charts": 1008, + "event_counts": { + "bank_padding_cover_sweep": 1, + "bridge": 3240, + "idle_cover_sweep": 3600, + "local_cover_sweep": 3240, + "terminal": 360, + "terminal_Y_translations": 360, + "translate_every_live_family": 1 + }, + "helper_charts": 6489, + "hosted_axis_mass": 10694160, + "hosted_helper_rows": 1321920, + "observation_windows": 7200, + "original_axis_mass": 17418240, + "persistent_owner_entries": 2047680, + "positive_residuals": 162900, + "provider_counts": { + "extra": 592, + "extra-four": 1080, + "gauge44": 1568 + }, + "rejecting_controls": [ + "wrong-whole-call-window", + "wrong-original-axis-offset", + "wrong-port-owner" + ], + "residual_profile": { + "3": 22788, + "5": 1620, + "48": 138492 + } + }, + "schema": 1, + "source_pins_sha256": "6a173be41ac019580ccb08cab791b7696fc7c52f150930038b45173286479c1a", + "status": "PASS" +} diff --git a/research/pooled-native-hosting-admission/evidence/MACHINE-ADMISSION.json b/research/pooled-native-hosting-admission/evidence/MACHINE-ADMISSION.json new file mode 100644 index 000000000..0a8fb04ba --- /dev/null +++ b/research/pooled-native-hosting-admission/evidence/MACHINE-ADMISSION.json @@ -0,0 +1,118 @@ +{ + "actual_level_divisor_bits": 2646, + "all_parameter_result": "Written constructive finite-control/encoded-data lowering of exact pooled controller and wiring, with full bank/stack/head bills on the admitted root and guarded reachable internal calls, relative to the named completed component contracts.", + "all_prefix_guard": { + "B_bits": 100001, + "E_exponent": 100000, + "common_grid_guard_exponent": 210000, + "complete_local_allowance_bits": 2667, + "maximum_group_instructions": 31632, + "rank_mass": 23431680, + "required_C0_bits": 200012, + "scalar_prefix_allowance": 10, + "subgroups_per_cover": 1575720 + }, + "all_primitive_theorems_scientifically_admitted": false, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "controls_rejected": [ + "runtime_head_coordinate", + "runtime_decoded_extent", + "physical_Tape_per_node", + "recursive_public_run", + "unchecked_private_release", + "missing_role_delimiter", + "wrong_restore_role_order", + "unchecked_scalar_half_parity", + "unchecked_Gaussian_half_parity" + ], + "cover_bits": 2628, + "elementary_Count_controls": { + "cases": 272, + "operand_domain": "0 <= a,b < 16", + "proof_scope": "Finite source regression for the elementary Count invariants written in MACHINE-ADMISSION.md; no unbounded claim follows from these cases alone." + }, + "exact_half_controls": { + "Gaussian_all_rows_cases": 17408, + "Gaussian_widths": [ + 2, + 3 + ], + "proof_scope": "Finite actual-source regression including every signed input in the declared widths; the all-width proof is the binary-prefix, parity and sign-extension induction.", + "scalar_cases": 248, + "scalar_widths": [ + 2, + 3, + 4, + 5, + 6 + ] + }, + "finite_labels": { + "dimension": 73, + "events": 10802, + "maximum_subgroups": 322560, + "packet_roles": 731, + "pc": 65536 + }, + "formal_kernel_proof": false, + "guarded_internal_arithmetic_ABI": "Reachable calls of the admitted ideal root; more generally input height t with t+A(e)<=Delta for the node and separately preserved caller/root-tail reserve. Arbitrary representable h-bit words are not all admitted.", + "header_bits": 2695, + "new_source_specific_controller_U_premise_required": false, + "parked_roles": 751, + "parking_controls": { + "body_alphabet": [ + 0, + 1, + 3, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13 + ], + "cases": 169, + "nested_depth": 3, + "observed_tape_actions": 42699, + "proof_scope": "Finite regression on actual authenticated Tape/Parking method bodies; arbitrary-length/depth correctness is the written marker and prefix-code induction.", + "single_role_all_words_length_at_most": 2 + }, + "production_payload_executed": false, + "proved_companion_inputs": [ + "NATIVE-ADMISSION.md: arbitrary-dirty ideal Gaussian-dyadic native/group operator identities under exact child substitution; finite-width height guards are proved in MACHINE-ADMISSION.md", + "HOSTING-ADMISSION.md: complete common-cover and chronological owner allocation" + ], + "remaining_component_contracts": [ + "Completed ordinary B1/Compact endpoints, all-input costs and fixed scratch", + "Signed scalar, Gaussian leaf and single existing normalization primitive endpoints and complete-return tariffs on their exact representable arithmetic domains" + ], + "runtime_sources": [ + "research/physical-complex-controller/machine.py", + "research/physical-complex-controller/parking.py", + "research/physical-complex-controller/bank_packets.py", + "research/physical-complex-controller/root_layer.py", + "research/physical-complex-controller/root_plan.py", + "research/physical-complex-controller/root_streams.py", + "research/physical-complex-controller/grid_boundary.py", + "research/physical-complex-controller/monomial_packets.py", + "research/physical-complex-controller/scalar_packets.py", + "research/t74-physical-layer/t74_machine.py", + "research/t74-retuned-physical-layer/active_plan.py", + "research/t74-retuned-physical-layer/active_root.py", + "research/t74-retuned-physical-layer/retuned_machine.py" + ], + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "scope": "The finite source and negative controls support the written all-parameter controller theorem; they do not convert every retained primitive or analytic contract into an admitted theorem.", + "source_archive_sha256": "1fc27e8e7d72780bc768847a503486c0133a1ee52a3445e6f6d456127cfc5d8c", + "source_control_inspection": { + "encoded_or_interpreter_while_loops": 21, + "planning_retained_wrapper_bound": 54, + "runtime_methods": 61, + "source_fixed_iteration_sites": 92 + }, + "source_files": 53, + "status": "PASS_POOLED_SOURCE_SPECIFIC_CONTROLLER_LOWERING_CERTIFICATE" +} diff --git a/research/pooled-native-hosting-admission/evidence/NATIVE-ADMISSION.json b/research/pooled-native-hosting-admission/evidence/NATIVE-ADMISSION.json new file mode 100644 index 000000000..9bebe8802 --- /dev/null +++ b/research/pooled-native-hosting-admission/evidence/NATIVE-ADMISSION.json @@ -0,0 +1,195 @@ +{ + "active_providers": { + "extra": { + "child_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "endpoint_adapters": 224, + "frames": 1155, + "listed_directed_child_recipes": 3069, + "listed_warp_recipes": 180, + "local": { + "backward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 95, + "prefix_l1_upper": "4091250694836343062220945773553/128", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "0a3c29d24e61d3f431b49d270a02068cdbc24e6ddcfdd9d3dfa6e5b822fa1c5e", + "zero_buffers_returned_to_zero": 91 + }, + "forward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 89, + "prefix_l1_upper": "202390250292205836325116416971/512", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "0a3c29d24e61d3f431b49d270a02068cdbc24e6ddcfdd9d3dfa6e5b822fa1c5e", + "zero_buffers_returned_to_zero": 91 + } + }, + "owned_centres": 8, + "owned_zero_buffers": 91, + "persistent_inputs_each_orientation": 632, + "pr4184_export": "THREE-extra", + "reached_directed_child_edges": 3069, + "regenerated_scientific_json_sha256": { + "CANONICAL-WORD.json.gz": "5fb702d44a4c8a785b1ee98e1c544756a9e821d0425d842cf8b882f10d445725", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177" + }, + "residual_recipe_pairs": 68 + }, + "extra-four": { + "child_profile": { + "1": 2489, + "2": 713, + "3": 227, + "4": 99, + "5": 20, + "8": 8 + }, + "endpoint_adapters": 224, + "frames": 1156, + "listed_directed_child_recipes": 3071, + "listed_warp_recipes": 180, + "local": { + "backward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 95, + "prefix_l1_upper": "4091250694836343062299211370801/128", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "0a3c29d24e61d3f431b49d270a02068cdbc24e6ddcfdd9d3dfa6e5b822fa1c5e", + "zero_buffers_returned_to_zero": 91 + }, + "forward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 89, + "prefix_l1_upper": "202390250292205836325116416971/512", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "0a3c29d24e61d3f431b49d270a02068cdbc24e6ddcfdd9d3dfa6e5b822fa1c5e", + "zero_buffers_returned_to_zero": 91 + } + }, + "owned_centres": 8, + "owned_zero_buffers": 91, + "persistent_inputs_each_orientation": 632, + "pr4184_export": "FOUR-extra", + "reached_directed_child_edges": 3071, + "regenerated_scientific_json_sha256": { + "CANONICAL-WORD.json.gz": "6a3bbd63a229da14c5067fcf11f4abc99940651651e4567d870388dfe725e606", + "LOCAL-PROGRAMS.json.gz": "a55f57ff6d2a9680c77930897372d0574c0222e29d9a88cfeadca4b023ee44f6" + }, + "residual_recipe_pairs": 68 + }, + "gauge44": { + "child_profile": { + "1": 2487, + "2": 713, + "3": 224, + "4": 102, + "5": 20, + "8": 8 + }, + "endpoint_adapters": 224, + "frames": 1155, + "listed_directed_child_recipes": 3069, + "listed_warp_recipes": 180, + "local": { + "backward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 95, + "prefix_l1_upper": "4091250694836343062220945773553/128", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "c24c39cf810290b4d73241b41fda4ca890ab93fac54516b839a05e7c6973b693", + "zero_buffers_returned_to_zero": 91 + }, + "forward": { + "all_exact_columns": 632, + "charged_payload_bits": 192, + "prefix_bits_upper": 89, + "prefix_l1_upper": "202390250292205836325116416971/512", + "private_work_erased": true, + "warp_events": 240, + "warp_recipe_equality_method": "all Pauli generators plus exact nonzero zero-column amplitude", + "warp_recipe_event_certificate_sha256": "c24c39cf810290b4d73241b41fda4ca890ab93fac54516b839a05e7c6973b693", + "zero_buffers_returned_to_zero": 91 + } + }, + "owned_centres": 8, + "owned_zero_buffers": 91, + "persistent_inputs_each_orientation": 632, + "pr4184_export": "THREE-base", + "reached_directed_child_edges": 3069, + "regenerated_scientific_json_sha256": { + "CANONICAL-WORD.json.gz": "c3348706d4bbf01e7909a53efc677e51aa6ebc1286846c1fa72f3d6a85f2e5da", + "LOCAL-PROGRAMS.json.gz": "6a1adb398b66cc67dcaec8ecca788ca5fcf9e5ee3646a413e8a375f64824c177" + }, + "residual_recipe_pairs": 68 + } + }, + "all_parameter_argument": "Q[F_72] substitution into unary tensor powers; fixed scalar role coefficients; exact frame/recipe tensor products, including scalar phases", + "discharged": [ + "exact source equality for three pooled native providers and both orientations", + "arbitrary dirty persistent inputs and complete private-work cleanup", + "phase-inclusive directed child, endpoint, warp and residual recipes", + "every positive tensor multiplicity under exact child substitution" + ], + "negative_controls_rejected": [ + "child_global_phase_invisible_to_tableau", + "residual_wrapper_sides_swapped", + "missing_private_zero_release", + "missing_warp_inverse_cleanup", + "missing_helper_post_wrapper", + "helper_read_before_pre_wrapper" + ], + "pr4184_head": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "prior_physical_bundle_sha256": "91226b99943069f21d845c3242b54ba492418d1194422d04cf2569fd14cbb9ea", + "retained_premises": [ + "exact reversible scalar/monomial/private-work implementation on a common grid", + "inductively correct child supplier on its actual hosted coordinate set", + "whole-call placement, paid hosting/controller/restoration and outer cost proofs" + ], + "reused_formal_pullback": { + "controls": { + "adjacent_inverse": true, + "commutative_collapse_rejected": true, + "difference_terms_remain_separate": true, + "finite_order_collapse_rejected": true + }, + "endpoint_terms": 6680, + "nonempty_surviving_words": 0, + "orientations_each": 2, + "output_functionals": 5784, + "providers": 4 + }, + "schema": 1, + "scope": "Written all-parameter native algebra proof plus finite complete recipe certificates; no formal-kernel proof or standalone outer/kappa assertion.", + "source_archive_sha256": "d1fd2fb89859d0dcabcd5b2f233a74c2bcb743a256434e180613c89ea7ef4ae0", + "status": "PASS_SOURCE_SPECIFIC_NATIVE_ALL_PARAMETER_ADMISSION", + "unique_exact_recipe_checks": { + "children": 3085, + "endpoint_adapters": 224, + "residual_pairs": 68, + "warp_generator_recipes": 60, + "warp_recipes": 156 + }, + "written_proof": "NATIVE-ADMISSION.md" +} diff --git a/research/pooled-native-hosting-admission/frozen/machine/MANIFEST.json b/research/pooled-native-hosting-admission/frozen/machine/MANIFEST.json new file mode 100644 index 000000000..887fd93ca --- /dev/null +++ b/research/pooled-native-hosting-admission/frozen/machine/MANIFEST.json @@ -0,0 +1,468 @@ +{ + "schema_version": 1, + "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "scientific_head": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "scope": "Exact source and primitive reference bytes for the new pooled control lowering theorem. Execution bodies retain their notices; finite checks do not prove every ordinary/Compact primitive contract.", + "files": [ + { + "path": "nested/cardinal_counts.py", + "bytes": 1861, + "sha256": "59ddeac102a0cc51fa49b15aae6aeb68cd68ed217fa974ce916372a177d2ec8f", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/cardinal_counts.py" + ] + }, + { + "path": "nested/cardinality.py", + "bytes": 3936, + "sha256": "505d5e560c5a507e6184edcc19a87cf1fed243eb34a5cb21fbe1e4fe017e7f22", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/vendor/cardinality.py" + ] + }, + { + "path": "nested/compact_counts.py", + "bytes": 5621, + "sha256": "71c19cfc186aaf0c159ec64ea1a5d58e1fc5fc093d50c7360247559261fad00d", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "compact_counts.py" + ] + }, + { + "path": "nested/counts.py", + "bytes": 1695, + "sha256": "00b476dbda0e8cc99886bf794439e1cb9e775f435f599a3557e99321fe084069", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/vendor/counts.py" + ] + }, + { + "path": "nested/encoded.py", + "bytes": 7305, + "sha256": "10ad2fa5902a48d49cf2b89a30b3f2711d63a6a43b9512a6427affcdf07335a7", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "encoded.py" + ] + }, + { + "path": "nested/records.py", + "bytes": 9888, + "sha256": "0c9c4b23e998597fb877bb1a29da69ac869b68262abe635b162b4dba9c69b372", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/vendor/records.py" + ] + }, + { + "path": "nested/scratch_pool.py", + "bytes": 5952, + "sha256": "41f1eb93652b7174c3b02f95f70e1a9ce2e2aed0a729e725167c8f226e65d8db", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "scratch_pool.py" + ] + }, + { + "path": "nested/session.py", + "bytes": 5874, + "sha256": "45ee809b27a69ca5576361922fd2760f568c9a98864d4c55c4fee3003ee3c9ad", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "session.py" + ] + }, + { + "path": "nested/stream.py", + "bytes": 5523, + "sha256": "c7dc7da5b00f27016982ada4c0416f8328568b00df16d97012f33d4b372d79b5", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/vendor/stream.py" + ] + }, + { + "path": "nested/words.py", + "bytes": 13794, + "sha256": "5c37f57708ba3131bdcb03139f9dbc29886bee44569c09cbba51b68f75acd7f9", + "origin_archive": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "member_chain": [ + "inputs/pr3055.tar", + "inputs/pr2899.tar", + "inputs/pr2809.tar", + "inputs/pr2753/predecessor/vendor/words.py" + ] + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md", + "bytes": 11566, + "sha256": "2fa75b9af51d31f68b818aeca7f2cb9e9f9d940ebe509fdb29d77053e05f8218", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/PHYSICAL-BRIDGE.md", + "git_blob": "e7166dfacf698a056668adb3413bbac8996ffe0a" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json", + "bytes": 4969, + "sha256": "66535e3e7aa509a079ec7bd6ffd3db83f577aa1b22103aaf21f03722e05acf9b", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL-PINS.json", + "git_blob": "f824a30caf1a2cf573c6b6ce44710a41357c0446" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md", + "bytes": 15402, + "sha256": "1d1f06c714f0f3e5e6ab660084191a080ce4a86c0dfef8022b57c00778085b97", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/PHYSICAL-GLOBAL.md", + "git_blob": "d7a349cc414a132849bb8db43b399f45eacbc4f4" + }, + { + "path": "research/complex-pooled-full-admission/PHYSICAL-PINS.json", + "bytes": 8433, + "sha256": "2ea958a9c87c5202113d84f176972de662fd87b45e5fde57c33a3251c7eeab53", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/PHYSICAL-PINS.json", + "git_blob": "7f27b989e6a7e153340da42386bf4cd339a26a69" + }, + { + "path": "research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json", + "bytes": 4359, + "sha256": "782ef40f6e1a4fa5e88c3d8757ba064508d184aff6989aab6f1c57de7282897e", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/evidence/PHYSICAL-GLOBAL.json", + "git_blob": "93042adff35b8091f298b54f2da804af8004c36a" + }, + { + "path": "research/complex-pooled-full-admission/evidence/PHYSICAL-LOCAL.json", + "bytes": 20899, + "sha256": "27359fe1d4fa0823a372b85c889fb6ace05d514ee3fb31dc4742fecdfa8a6a2d", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/evidence/PHYSICAL-LOCAL.json", + "git_blob": "071696a026e02953edb6d7901aa7e15b4d77dc4d" + }, + { + "path": "research/complex-pooled-full-admission/physical_bridge.py", + "bytes": 20039, + "sha256": "590c928e290fe8d7cbaa08bcd73fcac4fee6fe21aca193f5c41e3d612f57fd9a", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/physical_bridge.py", + "git_blob": "b005982c25deb56c24f82374d4a0416e8598b3b1" + }, + { + "path": "research/complex-pooled-full-admission/physical_global_bridge.py", + "bytes": 25996, + "sha256": "b9075451d35480be6252b95105b0d9456845bfc62b3f43df9b822b492ad40172", + "commit": "a929a3fa36301bdfcffe82afd37434dd9e3c4887", + "git_path": "research/complex-pooled-full-admission/physical_global_bridge.py", + "git_blob": "cb0d5301c62d8a0d82a488c2ff52bcb79985dc89" + }, + { + "path": "research/gaussian-normalization-stream/PROOF.md", + "bytes": 10121, + "sha256": "733862ab7afe5074c4aac2d3db25c1bfb01a7935cc584013024f287bda085c64", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/gaussian-normalization-stream/PROOF.md", + "git_blob": "4becf18cde48ecf83d0fccf164590a957c64ce77" + }, + { + "path": "research/gaussian-normalization-stream/normalizer.py", + "bytes": 6933, + "sha256": "2b0acaa831219faf3e7776969bdcffc3f0f9c608b15d6b4c343ff20cf6a50107", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/gaussian-normalization-stream/normalizer.py", + "git_blob": "5d1a0961ace6b7edccb26c05780623c5509a7597" + }, + { + "path": "research/physical-complex-compact/PROOF.md", + "bytes": 18626, + "sha256": "ec6395822ae500242f3fe5e2cf40caf9a7f9fa259d475d2c14970d951ff4df48", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-compact/PROOF.md", + "git_blob": "f65f38123ca0adb02f6ca69351cbfc933506e5cb" + }, + { + "path": "research/physical-complex-controller/PROOF.md", + "bytes": 15528, + "sha256": "471185621c0ecce295ffd327b1244aed234efe5ff05a804aaaa11316f1a8319e", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/PROOF.md", + "git_blob": "c505caecc7ced19a4efc35c423efedda9427bea5" + }, + { + "path": "research/physical-complex-controller/bank_packets.py", + "bytes": 7911, + "sha256": "83e2f80fb72c906ccc7857f2b5139758ca8a997b17f51a5db29e2bb3c1143477", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/bank_packets.py", + "git_blob": "defda707199e8eba83ee483daf5ae7acb642c43c" + }, + { + "path": "research/physical-complex-controller/cover.py", + "bytes": 4996, + "sha256": "d797daec10275f439f6019c596b89afbc32a7716cb657648adfcaae2408949da", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/cover.py", + "git_blob": "2b9b9df832a747bcb02505d5495f79d38deffa43" + }, + { + "path": "research/physical-complex-controller/grid_boundary.py", + "bytes": 7076, + "sha256": "55f32b8cfaa3482d5d62127ac90c2370fc0dc8122263815e1564ee95093ffccc", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/grid_boundary.py", + "git_blob": "387576fc2f0701709237430febed7ea5b730828b" + }, + { + "path": "research/physical-complex-controller/machine.py", + "bytes": 21396, + "sha256": "b648792a361fdf98597a2f56c634767508be8e818b82e482fbfc60b5c63cc855", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/machine.py", + "git_blob": "92f9467ffd3346d672a0e2c56f2508e33ed21689" + }, + { + "path": "research/physical-complex-controller/monomial_packets.py", + "bytes": 3514, + "sha256": "6856e80c13ebf3b6e9e0e142ed65420579b5a1b4892f23859d3c6e5f17a334b4", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/monomial_packets.py", + "git_blob": "5b4eaf49b3847cafa7bd99e7147c8818b248a021" + }, + { + "path": "research/physical-complex-controller/parking.py", + "bytes": 5314, + "sha256": "33e6d2a6fcdc648de31b374132bf885259eec9748bafa6facca3822a78427e94", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/parking.py", + "git_blob": "34bc6a0bd0daade7ccc69d0c236984f024d22ef4" + }, + { + "path": "research/physical-complex-controller/root_layer.py", + "bytes": 7214, + "sha256": "247b82feefecedc12142379fd7c9c6cdd5ac7e5309e443c4b4fa703d6b995c21", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/root_layer.py", + "git_blob": "389efd17af0f8d68711f0e7c6d8b6be65421e846" + }, + { + "path": "research/physical-complex-controller/root_plan.py", + "bytes": 8963, + "sha256": "494cad3edc376928684f380cd16568076b286a53bd763d910d49efa5b03f07c9", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/root_plan.py", + "git_blob": "78390164c3551bfcce8da6b0f23197a4048a7e5e" + }, + { + "path": "research/physical-complex-controller/root_streams.py", + "bytes": 5893, + "sha256": "b67daf3de591b6788220a016b0394cfe2cc8e94ffd41426bb2544ad578b715c8", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/root_streams.py", + "git_blob": "213144a6c905ac5dfbec9aaadc43f14eb4b1044d" + }, + { + "path": "research/physical-complex-controller/scalar_packets.py", + "bytes": 1062, + "sha256": "cc48f726325c000ab2304eb691feb950ff4abeab5c537d6165d5b3322dc45c35", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/scalar_packets.py", + "git_blob": "66ea778399423005695bdea1e43ef9dcde903402" + }, + { + "path": "research/physical-complex-controller/scalar_program.py", + "bytes": 5412, + "sha256": "4c005167b4c2fe0d98d2dd93b7f931b251259417ff4392b67ee0fbe290f6d48a", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/scalar_program.py", + "git_blob": "30ba678c7b828285d549e923b34e315e439b8452" + }, + { + "path": "research/physical-complex-controller/selected_binding.py", + "bytes": 11214, + "sha256": "d6583458d00e4933c3a3fd83cc376f21c059e9fc6aa338c00d66c1deeaa0e985", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-complex-controller/selected_binding.py", + "git_blob": "5fe097ff688f5304a45945054e9d4a4af05f13d8" + }, + { + "path": "research/physical-gaussian-leaf/PROOF.md", + "bytes": 12417, + "sha256": "29ebd43146f921077f980a408915ecc3a5199a07fcdadc624a8282c06b0b8104", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-gaussian-leaf/PROOF.md", + "git_blob": "e98db470cdb8bfc49e9da86c39c0d6ae16e92716" + }, + { + "path": "research/physical-gaussian-leaf/axis_stream.py", + "bytes": 2574, + "sha256": "40dea1c6fa41effd8e7a61f39a3a599e897370ca118e332ee5301a905dbb2998", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-gaussian-leaf/axis_stream.py", + "git_blob": "ba8230443fdb0370b72a7a617ba7d88eb23a9c37" + }, + { + "path": "research/physical-gaussian-leaf/coefficient_engine.py", + "bytes": 6770, + "sha256": "fff28cbc27b95ed546ac65f70279fa41a933421f1cd32b988ae8910632f0efcf", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-gaussian-leaf/coefficient_engine.py", + "git_blob": "dff2f099b60c23310a10665cd81e443282b249e8" + }, + { + "path": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "bytes": 1710080, + "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-gaussian-leaf/inputs/pr3087.tar", + "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd" + }, + { + "path": "research/physical-gaussian-leaf/signed_linear.py", + "bytes": 3624, + "sha256": "5b86afc33042e1c43eaa6957f94e0ebf403d1b07bb26d30ba89aa14d71f76078", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-gaussian-leaf/signed_linear.py", + "git_blob": "d17018a976ea4af15b6b5828a091d799435bacfc" + }, + { + "path": "research/physical-scalar-stream/PROOF.md", + "bytes": 12512, + "sha256": "c59d4e70ea6c6e3435fc5cd434b04126712100144b093dcbcf0d7ba7c4393000", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-scalar-stream/PROOF.md", + "git_blob": "a986ce46de15be0e8a5c50680faa7c1c4dc4a4a1" + }, + { + "path": "research/physical-scalar-stream/scalar_engine.py", + "bytes": 5065, + "sha256": "be74c74862ff2b152d3752cb887c6682ddf2d889bc9f16f6328e418618e4c8b6", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-scalar-stream/scalar_engine.py", + "git_blob": "aea19253f6a772047f22d2f0e1927b9bf319aba9" + }, + { + "path": "research/physical-scalar-stream/scalar_words.py", + "bytes": 3968, + "sha256": "f4293c5ea5a7b65be920997f2ff33ce046ae3d9707ecbcecb3bd163d821dfd00", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/physical-scalar-stream/scalar_words.py", + "git_blob": "36919dc569678656a1696f23454cba2d1fb0f393" + }, + { + "path": "research/selected-complex-layer-closure/PROOF.md", + "bytes": 23627, + "sha256": "43feda0342c07a9429699c3a44e8936a3f3fb57ce9b32f38ff3dc06ac887b265", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/selected-complex-layer-closure/PROOF.md", + "git_blob": "d7ec0d101405a5f099f55f6a73e9791731737fd0" + }, + { + "path": "research/t74-physical-layer/PROOF.md", + "bytes": 12834, + "sha256": "1054f13f3e370a2e5d5f5cbc0e767e84927d4879f4c7be54cccb9b9a6a58e8ba", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-physical-layer/PROOF.md", + "git_blob": "2a8bfe5d6d1599b859da9836ce4c2ff1de5d9036" + }, + { + "path": "research/t74-physical-layer/binding.py", + "bytes": 9991, + "sha256": "bd05a117aad3f696a108f0ce95287f1ea3a36603e3df8a2811e74138e73e1057", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-physical-layer/binding.py", + "git_blob": "468c0724ee950d91754045af67b5b980e6adbdb2" + }, + { + "path": "research/t74-physical-layer/compile_word.py", + "bytes": 11187, + "sha256": "1ae8eeedd1a3e8fea68762550d6f7c9495112785ed82bf824d8f82eba21f64a2", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-physical-layer/compile_word.py", + "git_blob": "345e7820ea0351e3801ffbb93050473213ec045f" + }, + { + "path": "research/t74-physical-layer/t74_machine.py", + "bytes": 3817, + "sha256": "3bc4c40f275852cea82dbdcf41b8e586bae2e599112ee073a367acc66f37ce83", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-physical-layer/t74_machine.py", + "git_blob": "27146d9f3961835afdf732aeb1f858ea16035ce6" + }, + { + "path": "research/t74-physical-layer/t74_root.py", + "bytes": 1384, + "sha256": "7bf9001c8fcaa3d9ac9883f3378aa747f39b373d9f88bfc47933797c25e562fd", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-physical-layer/t74_root.py", + "git_blob": "acfdd538c4e6d9b4c2b0c3ed2c8f6b0c2b87575d" + }, + { + "path": "research/t74-retuned-physical-layer/PROOF.md", + "bytes": 14261, + "sha256": "59da2c3223501da8228fb064201be81a809d4c3da19788692dbd5f5705fe016f", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-retuned-physical-layer/PROOF.md", + "git_blob": "728ff53e7217e34b463cfcf86cc81624ea9b1dd2" + }, + { + "path": "research/t74-retuned-physical-layer/active_plan.py", + "bytes": 5202, + "sha256": "e1092fdbb70df43f1d4fdb50f39a07a543d71c4ea9f9e8a50b790b81fd50223e", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-retuned-physical-layer/active_plan.py", + "git_blob": "c3a01cd8c4f52cab478aefacad60f64f60f1453a" + }, + { + "path": "research/t74-retuned-physical-layer/active_root.py", + "bytes": 1424, + "sha256": "5496bfeea5955b8b70f380e39461198a121ebc0ce8ad0aa1d0e58a9f3035ebd7", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-retuned-physical-layer/active_root.py", + "git_blob": "8f63fc094432692b7fd81aad14d937320fda4354" + }, + { + "path": "research/t74-retuned-physical-layer/retuned_machine.py", + "bytes": 3939, + "sha256": "d4a43288c554704406a355ae95f9cb1bc82d634b652f7e85ffc2269fa5daf87a", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-retuned-physical-layer/retuned_machine.py", + "git_blob": "f01b69888e53a81be986fd59f3e5e05f7a4e4087" + }, + { + "path": "research/t74-retuned-physical-layer/retuned_native.py", + "bytes": 890, + "sha256": "4b48f4a0d2900195201cdb8eaf715cb22460de391410e66bee5a6302fd1796dc", + "commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "git_path": "research/t74-retuned-physical-layer/retuned_native.py", + "git_blob": "7f51e925db0e4e6885107ad51e09f90b95757900" + } + ] +} diff --git a/research/pooled-native-hosting-admission/frozen/machine/SOURCE-CLOSURE.tar.gz b/research/pooled-native-hosting-admission/frozen/machine/SOURCE-CLOSURE.tar.gz new file mode 100644 index 000000000..0bd4ba8e8 Binary files /dev/null and b/research/pooled-native-hosting-admission/frozen/machine/SOURCE-CLOSURE.tar.gz differ diff --git a/research/pooled-native-hosting-admission/frozen/native/MANIFEST.json b/research/pooled-native-hosting-admission/frozen/native/MANIFEST.json new file mode 100644 index 000000000..34fab4831 --- /dev/null +++ b/research/pooled-native-hosting-admission/frozen/native/MANIFEST.json @@ -0,0 +1,239 @@ +{ + "schema": 1, + "role": "Retained PR4184 proof/source and exact native transport/emitter/audit/Clifford sources; no mathematical source edits.", + "files": [ + { + "path": "native-source/bw_audit_local.py", + "source_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_audit_local.py", + "bytes": 21135, + "sha256": "08d5864d9b77902fc5ab5a062a8ea843fe1e572243b8c580abb0a421b2e46d07", + "git_blob": "912a0c447c2ad34eb5ef3270e04ad0a73ca20a55" + }, + { + "path": "native-source/bw_emit.py", + "source_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_emit.py", + "bytes": 10012, + "sha256": "99b59a6fa3feda86785e4225157dcb1a6169d256cec4f5e0acc9cea7a701df76", + "git_blob": "6d47f63ab7a533941b3881bbfd3ae4dac5f76932" + }, + { + "path": "native-source/bw_transport.py", + "source_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/bw_transport.py", + "bytes": 17646, + "sha256": "9818e08b819310b40f1441b89be8c4369584a5b3fa5dfe9b86b1df9a7f5d6a76", + "git_blob": "08248542b18864c94a5ac050c8669f68519838e1" + }, + { + "path": "native-source/vendor/clifford/clifford_exact.py", + "source_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244", + "source_path": "research/staged544-mixed-fourth-entry/native/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py", + "bytes": 6824, + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2" + }, + { + "path": "pr4184/INDEPENDENT-REAL.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/INDEPENDENT-REAL.json", + "bytes": 4302, + "sha256": "171775fcdd362948a9625bb1df13e0cf3dd8c966e6c5e806d2202fe0c11ac5a0", + "git_blob": "710399699695219c8fbad2480c5f500d53af73a5" + }, + { + "path": "pr4184/INDEPENDENT-REVIEW.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/INDEPENDENT-REVIEW.md", + "bytes": 8469, + "sha256": "777be43b70a8cae58f55375eb0587e1f51e5b6d637e3ef13a1dcac461a48ebe3", + "git_blob": "424b0d0d671bd520daacd241b982224454097691" + }, + { + "path": "pr4184/INDEPENDENT.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/INDEPENDENT.json", + "bytes": 1978, + "sha256": "2a1c5191418fbb7525bee234de6f349d4306143e474dcea8cb76e907a42ea2e6", + "git_blob": "0ff2d2680321b34a8de5225337ae72c08ba441b4" + }, + { + "path": "pr4184/MUTATIONS.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/MUTATIONS.json", + "bytes": 1422, + "sha256": "fdcce4f7f49d826d1c62f0d979889bc13394697900d15278cab683cddf68a963", + "git_blob": "292c3e5dc6853431061b83e8bcafb295e09085ea" + }, + { + "path": "pr4184/PROOF.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/PROOF.md", + "bytes": 9907, + "sha256": "cc8ad3698a673fb225419a3636a39aa99a66c7a0676f12e329b1e76564fa1459", + "git_blob": "69c337a7704ce589798269ab4b8606189c070c4e" + }, + { + "path": "pr4184/README.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/README.md", + "bytes": 5098, + "sha256": "dafb6521f3782544fad354b3f660e9d36a484c137d6bb1a1805cc5fc29a752a6", + "git_blob": "e771a770b42ac458c39a02e34bb375325bf8024a" + }, + { + "path": "pr4184/RESULT.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/RESULT.json", + "bytes": 12163, + "sha256": "1c175123abd53b94b924b66e19782423365f604567ac15e85e544e9a194fdfee", + "git_blob": "694283a1d229220f78d7b5b08b78beae5a20bd3c" + }, + { + "path": "pr4184/SOURCE-PINS.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/SOURCE-PINS.json", + "bytes": 3473, + "sha256": "e9cf1c8a7ffd1abd017f83ce71b4b42775d01e306f4c4cad04c20d05b66630e9", + "git_blob": "349b9b3d8cc53bd584b5590909ec05d51877c2f2" + }, + { + "path": "pr4184/SOURCES.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/SOURCES.json", + "bytes": 5153, + "sha256": "e5de31571421f4535d714c7a865f38666bfe32c7325387fa06d52c07fddbee9f", + "git_blob": "c62604844a17b876cb3e260b5320c75923077cd9" + }, + { + "path": "pr4184/TASK.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/TASK.json", + "bytes": 5341, + "sha256": "11be5cef00bc266a3191b091e98f02d6f312dfe78c16f29abe0a131dbf790c08", + "git_blob": "7188a460330af2901c801b7b2104c912e1c6e161" + }, + { + "path": "pr4184/VERIFY.json", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/VERIFY.json", + "bytes": 2417, + "sha256": "a51a617b018aa7abd29daedd4d008d6ddc4524c8759fcc6afc07128a01dba0e1", + "git_blob": "f10c5fcfb965af3216ba69cb3ce1a3b16deeaa9c" + }, + { + "path": "pr4184/independent.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/independent.py", + "bytes": 6970, + "sha256": "ea27ffd296d59d9917b737b9651d363299a73d3d6b085aab2b9f10f6dd2897dc", + "git_blob": "789470e965edf3ae063809fe4e9a374eef300d23" + }, + { + "path": "pr4184/independent_real.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/independent_real.py", + "bytes": 9082, + "sha256": "baa769c0e98311b1c54ded90f08335f701e99d5a9e3b3061a94e984dff0b8156", + "git_blob": "d5dc57dff9200308a57a62bb850e61bd5220be63" + }, + { + "path": "pr4184/mutation_controls.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/mutation_controls.py", + "bytes": 4685, + "sha256": "f4f707dcb650aecdc177cd557bee8b83c62680ce6e030763a2fc7ecc773a1fff", + "git_blob": "4d15a09bde2e476cd55f49be794d90f673117446" + }, + { + "path": "pr4184/source/COMPLEX.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/COMPLEX.md", + "bytes": 12338, + "sha256": "853e1295850862752e4f854aa9e8b28f9ca6eaa9306e2af110b7b77526d1b5e1", + "git_blob": "c3be56fbfdb4fb29c1ace88cbcdfa7475fb6e343" + }, + { + "path": "pr4184/source/NOTICE.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/NOTICE.md", + "bytes": 2456, + "sha256": "1ba00cad41d7a1333da420bd23f078d09e28b7aa17cf5a8a89e54dd207123971", + "git_blob": "56c36d6f5900b2d6cd3169c8996b7b2018649fe9" + }, + { + "path": "pr4184/source/PROOF.md", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/PROOF.md", + "bytes": 7230, + "sha256": "3aa03a9ba64422474890c137d2b10ef830464712830fd469fe1b0e9538b24ebb", + "git_blob": "9c665b0442774b8c84116f51c3261d50dd5f8d2c" + }, + { + "path": "pr4184/source/inputs/FOUR-base.json.gz", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/inputs/FOUR-base.json.gz", + "bytes": 72668, + "sha256": "aecaddba48fdff6353a6511c3623346b05aa607e30103fb016604a2b1025ce95", + "git_blob": "65957e5ca322049d985f23fdc0bd8da07ffa4c2a" + }, + { + "path": "pr4184/source/inputs/FOUR-extra.json.gz", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/inputs/FOUR-extra.json.gz", + "bytes": 72665, + "sha256": "615093190aa5479034bb8acdd8925d7a910e082b84dec7df84b459b62421235a", + "git_blob": "1f3239c30e9343cf4e34b4371fcbeebb94a19011" + }, + { + "path": "pr4184/source/inputs/THREE-base.json.gz", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/inputs/THREE-base.json.gz", + "bytes": 72663, + "sha256": "df31495cff95a1e512da398f52841c6b5ade29067869b3d68b89d756a5641112", + "git_blob": "137793e275870db2161048405017b83dcc1824ee" + }, + { + "path": "pr4184/source/inputs/THREE-extra.json.gz", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/inputs/THREE-extra.json.gz", + "bytes": 72660, + "sha256": "9a28f7ef91938c0866e408eb06e03eb5f8e727a00b44eb936ddd5ed48704bd4c", + "git_blob": "7cce921b20dc0504cea954ab3297c5b55a9468dc" + }, + { + "path": "pr4184/source/vendor/audit_core.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/vendor/audit_core.py", + "bytes": 19364, + "sha256": "888679ca8502cdcb100420fe5382a052529a494bf76cb332928b86e62612b951", + "git_blob": "8b5e1d5f2a106402f036b63028ecef31a4e4c462" + }, + { + "path": "pr4184/source/vendor/audit_verify.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/vendor/audit_verify.py", + "bytes": 12382, + "sha256": "99971d3cc143cc894600e08c8cfbad3e8f537a544212f21dfbe4271cfa97354d", + "git_blob": "7f9fc1df424ae1d459616e49bda7a5dd17e40491" + }, + { + "path": "pr4184/source/verify.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/source/verify.py", + "bytes": 7514, + "sha256": "8dcb31e06abe2c92fca29a53d42a67f1b3358512b75b659e5fe2e0ba41e70cc8", + "git_blob": "816a7786a3570976ac86baf3b19ee798e6098895" + }, + { + "path": "pr4184/verify.py", + "source_commit": "94b9ca9cf59ea6de346a59c92b414454bdde1de4", + "source_path": "research/free-word-tensor-lift-audit/verify.py", + "bytes": 10398, + "sha256": "baefd583b2640d231f157521b8cbee5e8f9cce4d425727f75ec621abbe04c9ac", + "git_blob": "83443171b397074e1756b991698034e820532360" + } + ], + "attribution": "PR4184 free-word tensor audit by ToikY with OpenAI Codex assistance, crediting Cinna Davis/PR4100 and PR4088. Native sources retain Cinna Davis, icekylinx, DreamingOfClouds, Sagar Thakrar and all original source notices; new binding prepared for Ross Richardson with OpenAI Codex assistance." +} diff --git a/research/pooled-native-hosting-admission/frozen/native/SOURCE-CLOSURE.tar.gz b/research/pooled-native-hosting-admission/frozen/native/SOURCE-CLOSURE.tar.gz new file mode 100644 index 000000000..ccc84f29a Binary files /dev/null and b/research/pooled-native-hosting-admission/frozen/native/SOURCE-CLOSURE.tar.gz differ diff --git a/research/pooled-native-hosting-admission/hosting_admission.py b/research/pooled-native-hosting-admission/hosting_admission.py new file mode 100644 index 000000000..d1762d23a --- /dev/null +++ b/research/pooled-native-hosting-admission/hosting_admission.py @@ -0,0 +1,459 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent exact hosting/cover/gauge instantiation for the pooled source. + +The universal implication is proved in HOSTING-ADMISSION.md. This bounded +checker instantiates its hypotheses on every actual owner/event/port. It does +not enumerate the 73-dimensional cover or execute a production-size payload. +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +""" +from __future__ import annotations + +import argparse +from collections import Counter, defaultdict +from functools import lru_cache +import gzip +import hashlib +import json +from pathlib import Path +import tarfile +import types + +HERE = Path(__file__).resolve().parent +REPO = HERE.parents[1] +PRIOR = REPO / 'research/complex-pooled-full-admission' +BASE = REPO / 'research/staged544-mixed-fourth-entry/owner' +N = 73 + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def read_json(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def authenticate(): + pins = read_json(HERE / 'HOSTING-PINS.json') + for relative, entry in pins['files'].items(): + raw = (REPO / relative).read_bytes() + need(len(raw) == entry['bytes'] and digest(raw) == entry['sha256'], + 'hosting source pin: ' + relative) + manifest = read_json(PRIOR / 'PHYSICAL-GLOBAL-PINS.json')['bundle'] + members = {} + with tarfile.open(PRIOR / manifest['path']) as archive: + inventory = archive.getmembers() + need(len(inventory) == len(manifest['files']), 'global archive member count') + for member in inventory: + name = member.name + need(member.isfile() and name in manifest['files'] and name not in members, + 'unique regular authenticated member') + raw = archive.extractfile(member).read() + expected = manifest['files'][name] + need(len(raw) == expected['bytes'] and digest(raw) == expected['sha256'], + 'global archive member digest: ' + name) + members[name] = raw + return pins, members + + +def transpose(rows): + return tuple(sum(((rows[i] >> j) & 1) << i for i in range(len(rows))) + for j in range(len(rows))) + + +def act(rows, value): + return sum(((row & value).bit_count() & 1) << i for i, row in enumerate(rows)) + + +def orthogonal(rows): + return len(set(rows)) == len(rows) and all( + 0 <= r < 1 << len(rows) for r in rows) and all( + ((a & b).bit_count() & 1) == (i == j) + for i, a in enumerate(rows) for j, b in enumerate(rows)) + + +def port_basis(q): + # Construct the explicit orthogonal transvection on a permuted standard basis. + missing = next(i for i in range(9) if not (q >> i & 1)) + isotropic = q ^ (1 << missing) + order = list(range(N)) + order[0], order[missing] = order[missing], order[0] + return tuple((1 << i) ^ (isotropic if isotropic >> i & 1 else 0) for i in order) + + +def data_columns(basis, stage): + if not stage: + return tuple(1 << i for i in range(N)) + vectors = [basis[1 + i] ^ (1 << (9 + 8 * (stage - 1) + i)) for i in range(8)] + return tuple( + _xor([(1 << j)] + [v for v in vectors if v >> j & 1]) for j in range(N)) + + +def _xor(values): + result = 0 + for value in values: + result ^= value + return result + + +def observation_windows(projection, template): + calls = projection['calls'] + local = {e['stage']: e for e in template['recipe'] if e['kind'] == 'local'} + need(len(calls) == 3240 and [c['time'] for c in calls] == list(range(3240)), + 'complete indexed calls') + need(len(projection['execution_schedule']) == 10802, 'complete actual event inventory') + last = defaultdict(lambda: -1) + windows, positions = {}, {} + per_replica = defaultdict(list) + event_counts = Counter() + for index, event in enumerate(projection['execution_schedule']): + kind = event['kind'] + event_counts[kind] += 1 + source = template['execution_schedule'][event['source_event']] + need(kind == source['kind'], 'actual event kind matches original chronology') + if kind in ('bank_padding_cover_sweep', 'translate_every_live_family'): + need(index >= 10800, 'global suffix follows every replica') + continue + replica = event['replica'] + need(0 <= replica < 360 and event['replicas'] == [replica], 'single whole replica event') + per_replica[replica].append(event['source_event']) + for key in ('stage', 'pair', 'child_indices', 'from_level', 'to_level', + 'src', 'dst', 'coefficient', 'pairs'): + if key in source: + need(event[key] == source[key], 'literal chronological field: ' + key) + if kind == 'local_cover_sweep': + time = event['time'] + need(time not in positions, 'unique complete call dispatch') + call = calls[time] + spec = local[call['stage']] + need((call['replica'], call['stage'], call['pair'], call['orientation'], + call['provider_id']) == (replica, event['stage'], spec['pair'], + 'backward' if spec['reverse'] else 'forward', event['provider_id']), + 'complete call endpoint/source-event binding') + positions[time] = index + last[replica, call['pair']] = index + elif kind == 'bridge': + last[replica, event['src']] = last[replica, event['dst']] = index + elif kind == 'idle_cover_sweep': + for side, child in enumerate(event['child_indices']): + key = replica, child + need(key not in windows, 'unique original idle child boundary') + windows[key] = last[replica, event['pair']], index, event['pair'], side + elif kind in ('terminal_Y_translations', 'terminal'): + for pair in range(4): + last[replica, pair] = index + else: + raise ValueError('uncovered actual event') + need(set(positions) == set(range(3240)), 'all complete native events placed') + need(len(windows) == 360 * 20 and all( + per_replica[r] == list(range(30)) for r in range(360)), + 'each replica follows every original event exactly once') + need(event_counts == Counter(local_cover_sweep=3240, idle_cover_sweep=3600, + bridge=3240, terminal_Y_translations=360, terminal=360, + bank_padding_cover_sweep=1, translate_every_live_family=1), 'actual event counts') + return positions, windows, event_counts + + +def validate_host(row, ordinal, projection, phases, positions, windows, used, + chart_cache, sigmas, pairs, sides): + time, helper, replica, child, port, offset = row + need((time, helper) == divmod(ordinal, 408), 'one assignment per actual helper in order') + need(0 <= child < 18 and 0 <= replica < 360 and 0 <= port < 112, 'actual owner domain') + call = projection['calls'][time] + width = projection['local_providers'][call['provider_id']]['widths'][helper] + lower, upper, pair, side = windows[replica, child] + need(lower < positions[time] < upper, 'whole native call inside original observation-free window') + need((pair, side) == (pairs[str(child)], sides[str(child)]), 'original child role') + family = 896 * replica + (2 * pair + side) * 112 + port + owner_family, route_id = call['owners'][224 + helper] + need(owner_family == family, 'literal physical helper family') + route = projection['physical_owner_routes'][route_id] + typ, actual_child, actual_offset = route[:3] + actual_width = 9 if typ == 3 else route[3] + spectators = () if typ == 3 else tuple(route[4]) + need(typ in (3, 4) and (actual_child, actual_offset, actual_width) == + (child, offset, width), 'literal owner child/offset/width') + key = replica, child, port + need(used[key] == offset, 'consecutive original-axis partition') + axes = phases['recipes'][port]['idle_children'][child]['orthogonal_axes'] + need(offset + width <= len(axes), 'original idle capacity') + cache_key = port, child, offset, width, spectators + if cache_key not in chart_cache: + basis = port_basis(phases['recipes'][port]['q']) + active = tuple(axes[offset:offset + width]) + indices = tuple(basis.index(v) for v in active) + expected = tuple(i for i in range(N) if i not in indices)[:9 - width] + need(spectators == expected, 'literal spectator completion') + order = indices + spectators + tuple(i for i in range(N) + if i not in indices and i not in spectators) + chart = tuple(basis[i] for i in order) + need(orthogonal(chart) and chart[:width] == active, 'orthogonal chart has original axes') + chart_digest = digest(canonical(chart)) + need(sigmas.get(chart_digest) == list(chart), 'complete emitted helper chart binding') + chart_cache[cache_key] = chart_digest + used[key] += width + return key + + +def hosting(projection, phases, sigmas, fill, plan, template): + positions, windows, counts = observation_windows(projection, template) + calls = projection['calls'] + need(projection['m'] == 73 and projection['live'] == 322560 and + projection['physical'] == 323069, 'complete pooled physical namespace') + need(not projection['bank_padding']['children'] and not projection['bank_padding']['families'], + 'no missing bank padding child') + need(fill['columns'] == ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'] + and not fill['dispatch_overrides'], 'unchanged literal fill schema') + need(len(fill['rows']) == 1321920, 'all actual helpers assigned') + provider_counts = Counter() + data_chart_keys = set() + ports = projection['local_providers']['gauge44']['ports'] + need(phases['ports'] == 112 and len(phases['recipes']) == len(ports) == 112, + 'complete literal data port order') + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + need(recipe['port'] == port and q == ports[port] and 0 < q < 511 + and q.bit_count() % 2 == 1 and orthogonal(port_basis(q)), + 'complete original orthogonal port basis') + for call in calls: + owners = call['owners'] + need(len(owners) == len({o[0] for o in owners}) == 632 and + all(0 <= o[0] < 322560 for o in owners), 'complete distinct whole owner families') + provider_counts[call['provider_id']] += 1 + for role, (family, route_id) in enumerate(owners[:224]): + side, port = divmod(role, 112) + need(family == 896 * call['replica'] + 224 * call['pair'] + 112 * side + port and + projection['physical_owner_routes'][route_id] == [1, call['stage'], port], + 'productive families and literal route') + data_chart_keys.add((port, call['stage'])) + need(provider_counts == Counter(gauge44=1568, extra=592, **{'extra-four':1080}), + 'only three active providers in actual counts') + for port, stage in data_chart_keys: + need(orthogonal(data_columns(port_basis(phases['recipes'][port]['q']), stage)), + 'actual productive chart orthogonal') + used, charts = defaultdict(int), {} + for ordinal, row in enumerate(fill['rows']): + validate_host(row, ordinal, projection, phases, positions, windows, used, charts, + sigmas, plan['pairs'], plan['sides']) + need(set(charts.values()) == set(sigmas) and len(sigmas) == 6489, + 'all and only emitted helper charts reached') + remainders = {(r['replica'], r['child'], r['port']): r for r in projection['idle_children']} + need(len(remainders) == len(projection['idle_children']) == 162900, 'unique complete positive tails') + residual_profile, original_mass, hosted_mass = Counter(), 0, sum(used.values()) + for replica in range(360): + for child in range(20): + _, _, pair, side = windows[replica, child] + for port, recipe in enumerate(phases['recipes']): + key = replica, child, port + axes = recipe['idle_children'][child]['orthogonal_axes'] + original_mass += len(axes) + offset = used.get(key, 0) + rank = len(axes) - offset + need(rank >= 0, 'no original axis overallocated') + if rank: + need(key in remainders, 'every positive suffix paid') + row = remainders.pop(key) + need(row['pending_offset'] == row['hosted'] == offset and row['rank'] == rank + and row['family'] == 896 * replica + (2 * pair + side) * 112 + port + and row['replicas'] == 1, 'literal complete original-axis residual') + residual_profile[rank] += 1 + else: + need(key not in remainders, 'no extra zero tail') + need(not remainders and residual_profile == Counter({3:22788, 5:1620, 48:138492}), + 'complete unchanged priced residual histogram') + need(hosted_mass + sum(r * c for r, c in residual_profile.items()) == original_mass, + 'all original axes occur exactly once') + # Targeted controls rerun the local hypothesis predicate on actual data. + first = fill['rows'][0] + failures = [] + for name, mutate in ( + ('wrong-whole-call-window', lambda row: [row[0], row[1], calls[row[0]]['replica'], + 12, row[4], row[5]]), + ('wrong-original-axis-offset', lambda row: row[:5] + [row[5] + 1]), + ('wrong-port-owner', lambda row: row[:4] + [(row[4] + 1) % 112] + row[5:])): + try: + validate_host(mutate(first), 0, projection, phases, positions, windows, + defaultdict(int), {}, sigmas, plan['pairs'], plan['sides']) + except ValueError: + failures.append(name) + else: + raise ValueError('mutation accepted: ' + name) + return dict(calls=3240, persistent_owner_entries=3240 * 632, hosted_helper_rows=len(fill['rows']), + observation_windows=len(windows), original_axis_mass=original_mass, + hosted_axis_mass=hosted_mass, positive_residuals=162900, + residual_profile=dict(sorted(residual_profile.items())), helper_charts=len(sigmas), + data_charts=len(data_chart_keys), provider_counts=dict(provider_counts), + event_counts=dict(counts), rejecting_controls=failures) + + +@lru_cache(None) +def phase(axis): + support = tuple(i for i in range(N) if axis >> i & 1) + quadratic = sum(1 << (N * i + j) for i in support for j in support if i < j) + return tuple((axis >> i) & 1 for i in range(N)), quadratic + + +ZERO = ((0,) * N, 0) + + +def add(*values): + linear, quadratic = [0] * N, 0 + for coefficients, cross in values: + linear = [(x + y) % 4 for x, y in zip(linear, coefficients)] + quadratic ^= cross + return tuple(linear), quadratic + + +def scale(value, coefficient): + return tuple(coefficient * x % 4 for x in value[0]), value[1] if coefficient % 2 else 0 + + +def factor(axes, translation=0): + return add(scale(phase(translation), 2), *(phase(axis) for axis in axes)) + + +def phase_controller(phases, template): + checks = 0 + local = {e['stage']: e for e in template['recipe'] if e['kind'] == 'local'} + identity = [[int(i == j) for j in range(8)] for i in range(8)] + for port, recipe in enumerate(phases['recipes']): + q = recipe['q'] + basis = port_basis(q) + initial = [phase(q) if side == 0 else ZERO for _ in range(4) for side in range(2)] + gauges = initial[:] + matrix = [row[:] for row in identity] + + def shear(dst, src, coefficient): + matrix[dst] = [x + coefficient * y for x, y in zip(matrix[dst], matrix[src])] + + for event in template['execution_schedule']: + kind = event['kind'] + if kind == 'local_cover_sweep': + stage = event['stage'] + spec = local[stage] + x, y = 2 * spec['pair'], 2 * spec['pair'] + 1 + columns = data_columns(basis, stage) + rows = transpose(columns) + full = factor(columns[:9]) + cq = phase(act(rows, q)) + diagonal = add(full, scale(cq, -1)) + align = recipe['stage_alignment'][stage] + ex, ey, ox, oy = (scale(phase(align[k]), 2) for k in + ('entry_X', 'entry_Y', 'exit_X', 'exit_Y')) + gx, gy = add(diagonal, ex, ox, gauges[x]), add(diagonal, ey, oy, gauges[y]) + if spec['reverse']: + off = add(full, ey, ox, gauges[y]) + need(off == gx, 'exact physical backward scalar/gauge factor') + shear(x, y, -1) + else: + off = add(full, scale(cq, -2), ex, oy, gauges[x]) + need(off == gy, 'exact physical forward scalar/gauge factor') + shear(y, x, 1) + gauges[x], gauges[y] = gx, gy + checks += 1 + elif kind == 'idle_cover_sweep': + for side, child in enumerate(event['child_indices']): + entry = recipe['idle_children'][child] + role = 2 * event['pair'] + side + gauges[role] = add(gauges[role], factor(entry['orthogonal_axes'], entry['translation_after'])) + elif kind == 'bridge': + src, dst, coefficient = event['src'], event['dst'], event['coefficient'] + for target, source, c in ((2 * dst, 2 * src, coefficient), + (2 * src + 1, 2 * dst + 1, -coefficient)): + need(gauges[target] == gauges[source], 'exact global signed-bridge gauge') + shear(target, source, c) + checks += 1 + elif kind == 'terminal_Y_translations': + for pair in range(4): + gauges[2 * pair + 1] = add(gauges[2 * pair + 1], scale(phase(recipe['terminal_Y_translation']), 2)) + elif kind == 'terminal': + for pair in range(4): + x, y = 2 * pair, 2 * pair + 1 + gauges[x], gauges[y] = gauges[y], gauges[x] + matrix[x], matrix[y] = matrix[y], [-v for v in matrix[x]] + else: + need(kind in ('bank_padding_cover_sweep', 'translate_every_live_family'), 'phase event alphabet') + total = factor(1 << j for j in range(N)) + need(matrix == identity and gauges == [add(total, v) for v in initial], + 'all-port complete original chronology equals C_all') + checks += 8 + return dict(ports=len(phases['recipes']), exact_operator_factor_identities=checks, + scalar_role_dimension=8, domain='all 73-bit Fourier characters; multiplicative lift for every f>=1') + + +def cover_checks(members): + # Independent brute force constructs each small group; compare every source + # label and the correction on every character. This supplements the proof. + module = types.ModuleType('authenticated_cover') + source = members['source/research/physical-complex-controller/cover.py'] + exec(compile(source, '', 'exec'), module.__dict__) + results = [] + for dimension in range(1, 6): + cover = module.OrthogonalCover(dimension) + matrices = [] + + def extend(prefix): + if len(prefix) == dimension: + matrices.append(tuple(prefix)) + return + for vector in range(1 << dimension): + if vector.bit_count() % 2 and all(not ((vector & row).bit_count() % 2) for row in prefix): + extend(prefix + [vector]) + + extend([]) + need(len(matrices) == cover.size, 'independent complete small orthogonal group') + for ordinal, matrix in enumerate(matrices): + need(cover.unrank(ordinal) == matrix and cover.rank(matrix) == ordinal, + 'complete small cover rank/unrank equality') + delta = sum((((row.bit_count() - 1) // 2) & 1) << i for i, row in enumerate(matrix)) + for character in range(1 << dimension): + lhs = act(transpose(matrix), character).bit_count() % 4 + rhs = (character.bit_count() + 2 * ((delta & character).bit_count() % 2)) % 4 + need(lhs == rhs, 'exact all-character common-cover correction') + results.append(dict(dimension=dimension, matrices=len(matrices), characters_each=1 << dimension)) + full = module.OrthogonalCover(N) + probes = (0, 1, full.size // 2, full.size - 1) + for ordinal in probes: + need(full.rank(full.unrank(ordinal)) == ordinal, '73-dimensional endpoint/interior label probe') + return dict(complete_small_groups=results, full_dimension=N, full_cover_bits=full.size.bit_length(), + full_cover_probes=len(probes), universal_domain='written proof, not exhaustive full-cover enumeration') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output', type=Path) + parser.add_argument('--check', type=Path) + args = parser.parse_args() + pins, members = authenticate() + projection = json.loads(members['data/PHYSICAL-PROJECTION.json']) + phases = json.loads(members['data/DATA-PHASES.json']) + sigmas = json.loads(members['data/ACTUAL-SIGMAS.json']) + fill = read_json(PRIOR / 'frozen/pr4181/owner/FILL.json.gz') + plan, template = read_json(BASE / 'PLAN.json.gz'), read_json(BASE / 'TEMPLATE.json.gz') + result = dict(status='PASS', schema=1, + coverage='finite exact source hypotheses; universal proof in HOSTING-ADMISSION.md', + source_pins_sha256=digest((HERE / 'HOSTING-PINS.json').read_bytes()), + hosting=hosting(projection, phases, sigmas, fill, plan, template), + global_operator=phase_controller(phases, template), cover=cover_checks(members)) + result = json.loads(json.dumps(result)) + if args.check: + need(result == read_json(args.check), 'fresh hosting result equals recorded receipt') + if args.output: + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_bytes(json.dumps(result, sort_keys=True, indent=2).encode() + b'\n') + print(json.dumps(result, sort_keys=True, indent=2)) + + +if __name__ == '__main__': + main() diff --git a/research/pooled-native-hosting-admission/machine_admission.py b/research/pooled-native-hosting-admission/machine_admission.py new file mode 100644 index 000000000..bb4d6dece --- /dev/null +++ b/research/pooled-native-hosting-admission/machine_admission.py @@ -0,0 +1,458 @@ +#!/usr/bin/env python3 +"""Source/control certificate for the pooled physical glue, not every primitive theorem. + +Prepared for Ross Richardson with substantial OpenAI Codex assistance. +Apache-2.0. Source bodies and their contributor notices are preserved unchanged. +""" +import argparse +import ast +from collections import Counter +from hashlib import sha1, sha256 +import io +from itertools import product +import json +from pathlib import Path, PurePosixPath +import tarfile +from types import SimpleNamespace + +HERE = Path(__file__).resolve().parent +CANONICAL = '12fa8c5c844be21bfefb38a19503fbd867a11244' +SCIENTIFIC = 'a929a3fa36301bdfcffe82afd37434dd9e3c4887' +PREFIX = 'research/physical-complex-controller/' +RUNTIME = ( + PREFIX+'machine.py', PREFIX+'parking.py', PREFIX+'bank_packets.py', + PREFIX+'root_layer.py', PREFIX+'root_plan.py', PREFIX+'root_streams.py', + PREFIX+'grid_boundary.py', PREFIX+'monomial_packets.py', PREFIX+'scalar_packets.py', + 'research/t74-physical-layer/t74_machine.py', + 'research/t74-retuned-physical-layer/active_plan.py', + 'research/t74-retuned-physical-layer/active_root.py', + 'research/t74-retuned-physical-layer/retuned_machine.py') +FORBIDDEN_ATTRIBUTES = {'head','cells','position','to_int','decode','as_int','value','seek'} + + +def need(ok, why): + if not ok: + raise ValueError(why) + + +def digest(body): + return sha256(body).hexdigest() + + +def frozen(): + pins = json.loads((HERE/'MACHINE-PINS.json').read_bytes()) + need(pins['schema_version'] == 1 and pins['base_commit'] == CANONICAL + and pins['scientific_head'] == SCIENTIFIC, 'fixed machine source identities') + manifest_raw = (HERE/pins['manifest']).read_bytes() + need(digest(manifest_raw) == pins['manifest_sha256'], 'machine source manifest bytes') + manifest = json.loads(manifest_raw) + rows = {r['path']:r for r in manifest['files']} + need(len(rows) == len(manifest['files']) == pins['files'] == 53, 'complete unique source inventory') + raw = (HERE/pins['archive']).read_bytes() + need(len(raw) == pins['archive_bytes'] < 2**20 + and digest(raw) == pins['archive_sha256'], 'exact bounded machine source archive') + result = {} + with tarfile.open(fileobj=io.BytesIO(raw),mode='r:gz') as archive: + for member in archive.getmembers(): + path = PurePosixPath(member.name) + need(member.isfile() and not path.is_absolute() and '..' not in path.parts + and path.as_posix() == member.name and '\\' not in member.name + and member.name in rows and member.name not in result + and member.size < 2**22, 'declared regular contained machine source') + body = archive.extractfile(member).read() + row = rows[member.name] + need(len(body) == member.size == row['bytes'] and digest(body) == row['sha256'], + 'exact immutable machine member') + if 'git_blob' in row: + need(row['commit'] in {CANONICAL,SCIENTIFIC} and + sha1(b'blob '+str(len(body)).encode()+b'\0'+body).hexdigest() == row['git_blob'], + 'recorded machine Git blob identity') + result[member.name] = body + need(set(result) == set(rows), 'no omitted machine source member') + for name,row in rows.items(): + if 'origin_archive' not in row: + continue + body = result[row['origin_archive']] + for member_name in row['member_chain']: + with tarfile.open(fileobj=io.BytesIO(body)) as archive: + member = archive.getmember(member_name) + need(member.isfile(), 'exact nested source member') + body = archive.extractfile(member).read() + need(body == result[name], 'nested primitive copy equals exact reached source') + return result, pins + + +def method(tree, class_name, name): + classes = [n for n in tree.body if isinstance(n,ast.ClassDef) and n.name == class_name] + need(len(classes) == 1, 'one reached source class '+class_name) + values = [n for n in classes[0].body if isinstance(n,(ast.FunctionDef,ast.AsyncFunctionDef)) and n.name == name] + need(len(values) == 1, 'one reached source method '+class_name+'.'+name) + return values[0] + + +def inspect_runtime(body): + tree = ast.parse(body) + report = Counter() + for cls in (n for n in tree.body if isinstance(n,ast.ClassDef)): + for fun in (n for n in cls.body if isinstance(n,ast.FunctionDef) and n.name != '__init__'): + report['runtime_methods'] += 1 + for node in ast.walk(fun): + if isinstance(node,ast.Attribute): + need(node.attr not in FORBIDDEN_ATTRIBUTES, 'no runtime decoded data or head-coordinate service') + if isinstance(node,ast.Call): + need(not (isinstance(node.func,ast.Name) and node.func.id in {'Tape','Arena'}), + 'no new physical inventory inside runtime method') + if isinstance(node.func,ast.Name) and node.func.id == 'int': + need(len(node.args) == 1 and + (isinstance(node.args[0],ast.Compare) or + ast.unparse(node.args[0]) == 'self.root'), + 'integer conversion only from bounded flag/comparison') + need(not (isinstance(node.func,ast.Attribute) and isinstance(node.func.value,ast.Name) + and node.func.value.id == 'self' and node.func.attr == 'run'), + 'no recursive public host run call') + if isinstance(node,ast.While):report['encoded_or_interpreter_while_loops'] += 1 + if isinstance(node,(ast.For,ast.comprehension)):report['source_fixed_iteration_sites'] += 1 + return dict(report) + + +def source_contracts(files): + counts = Counter() + for name in RUNTIME: + counts.update(inspect_runtime(files[name])) + machine = ast.parse(files[PREFIX+'machine.py']) + enter = ast.unparse(method(machine,'Machine','enter_child')) + returned = ast.unparse(method(machine,'Machine','return_node')) + prepared = ast.unparse(method(machine,'Machine','prepare_child')) + need(enter.index('origin(tape)') < enter.index('self.parking.park()'), + 'parent roles rearmed before park') + need(returned.index('origin(tape)') < returned.index('self.parking.restore()'), + 'child roles rearmed before ancestor restore') + need('self.mode = \'node\'' in enter and 'self.root = False' in enter + and 'self.header.write' in prepared and 'self.pc + 1' in prepared, + 'internal node entry and literal parent continuation') + need("name == 'rows'" in prepared and "name == 'width'" in prepared + and "name == 'after'" in prepared and 'else self.c(name)' in prepared, + 'only prescribed child shape fields change') + t74 = ast.parse(files['research/t74-physical-layer/t74_machine.py']) + release = ast.unparse(method(t74,'T74Machine','release_zero_step')) + need(release.index('require_zero(') < release.index('.clear()'), + 'checked complete Z release before clearing') + loop = ast.unparse(method(t74,'T74Machine','run')) + need('sealed_constructors()' in loop and 'self.pool.empty()' in loop + and 'self.enter_child()' in loop and 'while True:' in loop, + 'sealed one-interpreter-loop runtime') + prior='research/complex-pooled-full-admission/' + bridge=ast.parse(files[prior+'physical_global_bridge.py']) + factory=next(n for n in bridge.body if isinstance(n,ast.FunctionDef) and n.name=='production_layer') + roots=[n for n in ast.walk(factory) if isinstance(n,ast.Call) + and isinstance(n.func,ast.Attribute) and n.func.attr=='ActiveWidthRoot'] + need(len(roots)==1 and len(roots[0].args)==3 and not roots[0].keywords, + 'production root constructor retains observer=None') + need("self.level_divisor" in files['research/t74-retuned-physical-layer/active_plan.py'].decode(), + 'actual plan uses passed row divisor') + plan=ast.parse(files['research/t74-retuned-physical-layer/active_plan.py']) + compute=method(plan,'ActiveWidthPlan','compute') + def retained_weight(node): + if isinstance(node,ast.FunctionDef) and node is not compute:return 0 + if isinstance(node,ast.For): + # The only retained-result loops have source-literal four-name schemas. + body=sum(retained_weight(x) for x in node.body) + if body: + need(isinstance(node.iter,(ast.Tuple,ast.List)),'retained wrappers only in fixed literal loops') + body*=len(node.iter.elts) + return retained_weight(node.iter)+body+sum(retained_weight(x) for x in node.orelse) + if isinstance(node,ast.While): + need(sum(retained_weight(x) for x in node.body)==0,'no retained wrapper in numerical planning loop') + return sum(retained_weight(x) for x in node.orelse) + own=int(isinstance(node,ast.Call) and isinstance(node.func,ast.Name) + and node.func.id in {'keep','literal','plus','times','scaled'}) + return own+sum(retained_weight(x) for x in ast.iter_child_nodes(node)) + retained=retained_weight(compute) + need(retained==54,'exact conservative all-branch planning wrapper bound') + counts['planning_retained_wrapper_bound']=retained + return dict(counts) + + +def tape_parking_classes(files, parking_body=None): + class Meter: + def __init__(self): + self.reads=self.writes=self.moves=0 + namespace={'BLANK':4,'LEFT':2,'RIGHT':3,'ZERO':0,'ONE':1,'RETURN':13,'Meter':Meter,'need':need} + tree=ast.parse(files['nested/records.py']) + tape=next(n for n in tree.body if isinstance(n,ast.ClassDef) and n.name=='Tape') + exec(compile(ast.Module(body=[tape],type_ignores=[]),'authenticated records.Tape','exec',optimize=0),namespace) + tree=ast.parse(parking_body or files[PREFIX+'parking.py']) + kept=[n for n in tree.body if isinstance(n,(ast.ClassDef,ast.FunctionDef,ast.Assign))] + exec(compile(ast.Module(body=kept,type_ignores=[]),'authenticated parking bodies','exec',optimize=0),namespace) + return namespace + + +def read_body(tape): + tape.rewind();out=[] + while tape.read()!=4: + out.append(tape.read());tape.step(1) + tape.rewind() + return tuple(out) + + +def write_body(tape, body): + need(tape.read()==4,'empty test role') + for symbol in body:tape.append(symbol) + tape.rewind() + + +def parking_case(namespace, frames): + Tape,Parking=namespace['Tape'],namespace['Parking'] + roles=tuple(Tape() for _ in frames[0]);park=Parking(roles) + for frame in frames: + for tape,body in zip(roles,frame):write_body(tape,body) + park.park() + need(all(read_body(t)==() for t in roles),'park consumes each role body') + for expected in reversed(frames): + park.restore() + need(tuple(read_body(t) for t in roles)==expected,'restore exact body/order and ancestor frame') + for tape in roles:tape.clear() + park.empty() + need(all(t.head==1 for t in roles) and park.stack.head==park.reverse.head==1, + 'root parking returns physical canonical heads') + need(all(all(s==4 for s in t.cells[1:]) for t in (*roles,park.stack,park.reverse)), + 'parking scratch is actually erased') + return sum(t.meter.reads+t.meter.writes+t.meter.moves for t in (*roles,park.stack,park.reverse)) + + +def bounded_parking(files): + ns=tape_parking_classes(files);alphabet=ns['BODY'] + words=[(),*((s,) for s in alphabet),*((a,b) for a in alphabet for b in alphabet)] + trials=work=0 + for body in words: + work+=parking_case(ns,((body,),));trials+=1 + # Nonidentical roles and nested frames expose reversal, delimiter and ownership errors. + for a in alphabet: + frames=(( (a,), (13,0,12) ),( (), (a,3) ),( (1,0,a), () )) + work+=parking_case(ns,frames);trials+=1 + return {'single_role_all_words_length_at_most':2,'body_alphabet':list(alphabet), + 'cases':trials,'nested_depth':3,'observed_tape_actions':work, + 'proof_scope':'Finite regression on actual authenticated Tape/Parking method bodies; arbitrary-length/depth correctness is the written marker and prefix-code induction.'} + + +def arithmetic_classes(files, scalar_body=None, linear_body=None): + ns=tape_parking_classes(files) + def load_nodes(body, names): + tree=ast.parse(body) + kept=[n for n in tree.body if isinstance(n,(ast.FunctionDef,ast.ClassDef)) and n.name in names] + need(len(kept)==len(names),'complete authenticated arithmetic definition selection') + exec(compile(ast.Module(body=kept,type_ignores=[]),'authenticated elementary arithmetic','exec',optimize=0),ns) + load_nodes(files['nested/stream.py'],{'Counter'}) + load_nodes(files['nested/cardinality.py'],{'Natural'}) + load_nodes(files['nested/counts.py'],{'Count'}) + ns['RetainedCount']=ns['Count'] + load_nodes(files['nested/cardinal_counts.py'],{'Count','positive'}) + load_nodes(files['nested/encoded.py'],{'compare','subtract','divide','product','fixed_power','atom_width'}) + load_nodes(files['nested/compact_counts.py'],{'power_two'}) + # ROWS is a fixed source literal, not a test-generated coefficient oracle. + linear=ast.parse(linear_body or files['research/physical-gaussian-leaf/signed_linear.py']) + rows=next(n for n in linear.body if isinstance(n,ast.Assign) + and any(isinstance(t,ast.Name) and t.id=='ROWS' for t in n.targets)) + exec(compile(ast.Module(body=[rows],type_ignores=[]),'authenticated Gaussian row signs','exec'),ns) + load_nodes(linear_body or files['research/physical-gaussian-leaf/signed_linear.py'], + {'CoefficientDomainError','transition','linear_word'}) + load_nodes(scalar_body or files['research/physical-scalar-stream/scalar_words.py'], + {'ScalarContractError','zero_word','require_zero','shifted'}) + return ns + + +def natural_value(count): + bits=read_body(count.tape) + need(bits and bits[-1]==3 and all(b in (0,1) for b in bits[:-1]),'canonical observed test Count') + need(len(bits)==2 or bits[-2]==1,'minimal observed test Count') + return sum(b<b)-(a=b: + difference=ns['subtract'](left,right) + need(natural_value(difference)==a-b,'actual Count borrow difference') + difference.close() + if b: + quotient,remainder=ns['divide'](left,right) + need((natural_value(quotient),natural_value(remainder))==divmod(a,b), + 'actual encoded long division') + quotient.close();remainder.close() + need(natural_value(left)==a and natural_value(right)==b,'Count borrowed inputs and heads restored') + for value in (left,right,summed,multiplied):value.close() + cases+=1 + for a in range(16): + value=Count.literal(a) + powered=ns['power_two'](value) + need(natural_value(powered)==1<>i)&1 for i in range(width)));return tape + + +def signed_value(tape,width): + bits=read_body(tape) + need(len(bits)==width and all(b in (0,1) for b in bits),'exact test signed output width') + return sum(b<=mass*gamma+E, + 'exact all-prefix height and final grid guard') + return {'status':'PASS_POOLED_SOURCE_SPECIFIC_CONTROLLER_LOWERING_CERTIFICATE', + 'base_commit':CANONICAL,'scientific_head':SCIENTIFIC, + 'source_archive_sha256':pins['archive_sha256'],'source_files':len(files), + 'runtime_sources':list(RUNTIME),'source_control_inspection':contracts, + 'cover_bits':gamma.bit_length(),'header_bits':header,'parked_roles':751, + 'finite_labels':{'events':10802,'maximum_subgroups':322560,'pc':65536,'packet_roles':731,'dimension':73}, + 'actual_level_divisor_bits':L.bit_length(),'parking_controls':observations, + 'elementary_Count_controls':count_observations,'exact_half_controls':half_observations, + 'all_prefix_guard':{'rank_mass':mass,'subgroups_per_cover':groups, + 'maximum_group_instructions':maximum_group,'scalar_prefix_allowance':10, + 'E_exponent':100000,'common_grid_guard_exponent':210000, + 'complete_local_allowance_bits':(groups*(maximum_group+1)*10*gamma).bit_length(), + 'B_bits':B.bit_length(),'required_C0_bits':(32*73*B*B).bit_length()}, + 'controls_rejected':negative, + 'all_parameter_result':'Written constructive finite-control/encoded-data lowering of exact pooled controller and wiring, with full bank/stack/head bills on the admitted root and guarded reachable internal calls, relative to the named completed component contracts.', + 'guarded_internal_arithmetic_ABI':'Reachable calls of the admitted ideal root; more generally input height t with t+A(e)<=Delta for the node and separately preserved caller/root-tail reserve. Arbitrary representable h-bit words are not all admitted.', + 'new_source_specific_controller_U_premise_required':False, + 'proved_companion_inputs':['NATIVE-ADMISSION.md: arbitrary-dirty ideal Gaussian-dyadic native/group operator identities under exact child substitution; finite-width height guards are proved in MACHINE-ADMISSION.md','HOSTING-ADMISSION.md: complete common-cover and chronological owner allocation'], + 'remaining_component_contracts':['Completed ordinary B1/Compact endpoints, all-input costs and fixed scratch','Signed scalar, Gaussian leaf and single existing normalization primitive endpoints and complete-return tariffs on their exact representable arithmetic domains'], + 'production_payload_executed':False,'formal_kernel_proof':False, + 'all_primitive_theorems_scientifically_admitted':False, + 'scope':'The finite source and negative controls support the written all-parameter controller theorem; they do not convert every retained primitive or analytic contract into an admitted theorem.'} + + +def main(): + parser=argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out',type=Path) + parser.add_argument('--check',type=Path) + args=parser.parse_args() + receipt=certificate() + if args.check: + need(json.loads(args.check.read_bytes())==receipt,'fresh machine receipt equals committed evidence') + if args.out:args.out.write_text(json.dumps(receipt,indent=2,sort_keys=True)+'\n') + print(receipt['status'],'sources',receipt['source_files'],'parking cases',receipt['parking_controls']['cases'], + 'controls',len(receipt['controls_rejected'])) + + +if __name__=='__main__':main() diff --git a/research/pooled-native-hosting-admission/native_admission.py b/research/pooled-native-hosting-admission/native_admission.py new file mode 100644 index 000000000..f185b946f --- /dev/null +++ b/research/pooled-native-hosting-admission/native_admission.py @@ -0,0 +1,458 @@ +"""Bind the three pooled native providers to an exact free-word and recipe proof. + +Prepared for Ross Richardson with OpenAI Codex assistance. Apache-2.0. +The free-word result is PR4184 (ToikY with Codex assistance), following +Cinna Davis's PR4100/PR4088 and the credited retained free-algebra engines. +This checker supplies source equality and exact native recipe substitution; +the unbounded tensor argument is written in NATIVE-ADMISSION.md. +""" +from pathlib import Path, PurePosixPath +from fractions import Fraction as Q +from collections import Counter +from functools import lru_cache +import argparse +import ast +import contextlib +import copy +import gzip +import hashlib +import io +import json +import sys +import tarfile +import tempfile +import types + +HERE = Path(__file__).resolve().parent +PROVIDERS = {'gauge44': 'THREE-base', 'extra': 'THREE-extra', 'extra-four': 'FOUR-extra'} +NATIVE_FILES = ('CANONICAL-WORD.json.gz', 'LOCAL-PROGRAMS.json.gz', + 'CLIFFORD-RECIPES.json', 'RESIDUAL-ADAPTERS.json') + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def blob(raw): + return hashlib.sha1(b'blob ' + str(len(raw)).encode() + b'\0' + raw).hexdigest() + + +def packed(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + +def recipe_bytes(record): + # Frame/port/operator metadata is checked at the source binding. The exact + # operator certificate is deduplicated only on its mathematical content. + return packed({key: record[key] for key in ('rank', 'left', 'right')}) + + +def load_json(path): + raw = path.read_bytes() + return json.loads(gzip.decompress(raw) if path.suffix == '.gz' else raw) + + +def authenticate_file(path, digest): + require(not path.is_symlink(), 'source symlink: ' + str(path)) + raw = path.read_bytes() + require(sha(raw) == digest, 'source digest mismatch: ' + str(path)) + return raw + + +def unpack(raw, inventory, root): + """Authenticate complete regular-file inventory before private extraction.""" + seen = set() + contents = {} + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:*') as archive: + for member in archive.getmembers(): + name = member.name + p = PurePosixPath(name) + require(member.isfile() and not p.is_absolute() and '..' not in p.parts, + 'unsafe archive member: ' + name) + require(name not in seen and name in inventory, 'unexpected archive member: ' + name) + seen.add(name) + data = archive.extractfile(member).read() + row = inventory[name] + require(len(data) == row['bytes'] and sha(data) == row['sha256'], + 'archive member changed: ' + name) + if 'git_blob' in row: + require(blob(data) == row['git_blob'], 'archive Git blob changed: ' + name) + contents[name] = data + require(seen == set(inventory), 'incomplete archive inventory') + for name, data in contents.items(): + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + return contents + + +def module_from(path, name): + """Always retain source assertions, including under python -O.""" + module = types.ModuleType(name) + module.__file__ = str(path) + previous = sys.modules.get(name) + sys.modules[name] = module + try: + exec(compile(path.read_bytes(), str(path), 'exec', optimize=0), module.__dict__) + finally: + if previous is None: + sys.modules.pop(name, None) + else: + sys.modules[name] = previous + return module + + +class Recipes: + """Decode supplied recipes; never invoke their synthesis routine.""" + def __init__(self, source): + self.m = module_from(source, '_pooled_native_exact_clifford') + self.checked = Counter() + + @lru_cache(None) + def frame(self, vectors): + return self.m.canonical_frame(9, vectors) + + @lru_cache(None) + def amplitude(self, circuit): + # Equal Pauli conjugation implies equality up to a scalar. A single + # exact nonzero amplitude of U|0> fixes that scalar, including phase. + vec, den = self.m.Op(9, self.m.identity(9), list(circuit)).zero_state() + for index, (real, imag) in enumerate(vec): + if real or imag: + while den and not (real & 1) and not (imag & 1): + real //= 2 + imag //= 2 + den -= 1 + return index, real, imag, den + raise ValueError('zero column of a Clifford operator') + + def equal(self, left, right): + return (left.tab == right.tab and + self.amplitude(tuple(left.circuit)) == self.amplitude(tuple(right.circuit))) + + @lru_cache(None) + def decode_bytes(self, raw): + record = json.loads(raw) + require(set(record) == {'quadratic_rows', 'linear_Z4', 'matrix_rows', 'offset', 'phase'}, + 'malformed monomial fields') + require(all(len(record[k]) == 9 for k in ('quadratic_rows', 'linear_Z4', 'matrix_rows')), + 'monomial dimension') + require(0 <= record['offset'] < 512 and record['phase'] in range(4), 'monomial scalar range') + m = self.m + return (m.diag(9, tuple(record['quadratic_rows']), tuple(record['linear_Z4'])) + .then(m.perm(9, tuple(record['matrix_rows']))) + .then(m.xgate(9, record['offset'])) + .then(m.Op(9, m.identity(9), [('phase', record['phase'])]))) + + def decode(self, record): + return self.decode_bytes(packed(record)) + + @lru_cache(None) + def k(self, columns): + m = self.m + rows = m.transpose(columns, 9) + inverse = m.inv(rows, 9) + it = m.transpose(inverse, 9) + quadratic = tuple((1 << i) ^ sum(m.parity(a & b) << j for j, b in enumerate(it)) + for i, a in enumerate(it)) + return m.perm(9, rows).then(m.diag(9, quadratic)) + + @lru_cache(None) + def child(self, old, new, raw): + record = json.loads(raw) + rank = abs(len(new) - len(old)) + require(record['rank'] == rank and rank > 0, 'child rank mismatch') + target = self.frame(old).adjoint().then(self.frame(new)) + actual = (self.decode(record['right']).then(self.m.fourier(9, range(rank))) + .then(self.decode(record['left']))) + require(self.equal(actual, target), 'exact child recipe mismatch') + self.checked['children'] += 1 + return True + + @lru_cache(None) + def endpoint(self, q, vectors, role, raw): + record = json.loads(raw) + require(record['rank'] == 0 and record['right'] is None, 'endpoint is not monomial') + old = self.m.cgate(9, q) + if role == 'target': + old = old.adjoint().then(self.m.fourier(9)) + else: + require(role == 'source', 'unknown endpoint role') + target = old.adjoint().then(self.frame(vectors)) + require(self.equal(self.decode(record['left']), target), 'exact endpoint recipe mismatch') + self.checked['endpoint_adapters'] += 1 + return True + + @lru_cache(None) + def warp(self, sign, columns, old, new, raw): + record = json.loads(raw) + require(record['rank'] == 0 and record['right'] is None, 'warp is not monomial') + k = self.k(columns) + k = k if sign == 1 else k.adjoint() + target = self.frame(old).adjoint().then(k).then(self.frame(new)) + require(self.equal(self.decode(record['left']), target), 'exact warp recipe mismatch') + self.checked['warp_recipes'] += 1 + return sha(raw) + + @lru_cache(None) + def residual(self, entrance, terminal, raw): + record = json.loads(raw) + width = len(terminal) - len(entrance) + require(record['rank'] == width > 0, 'residual width mismatch') + residual = self.frame(entrance).adjoint().then(self.frame(terminal)) + actual = (self.decode(record['right']).adjoint().then(residual) + .then(self.decode(record['left']).adjoint())) + require(self.equal(actual, self.m.fourier(9, range(width))), 'exact residual wrapper mismatch') + self.checked['residual_pairs'] += 1 + return True + + @lru_cache(None) + def warp_generator(self, columns, raw): + require(self.equal(self.decode(json.loads(raw)), self.k(columns)), 'warp generator recipe mismatch') + self.checked['warp_generator_recipes'] += 1 + return True + + +def replay_environment(source, canonical, recipes, checker): + # Preserve these four original function definitions verbatim as AST nodes. + # The omitted module plumbing loads NumPy and runs a separate 512-column + # matrix engine. Here each warp callback calls the separately exact recipe + # certificate above, including global phase. No algebraic rule is replaced. + wanted = {'contains', 'add_row', 'warp_row', 'local'} + tree = ast.parse(source.read_bytes()) + definitions = [node for node in tree.body if isinstance(node, ast.FunctionDef) and node.name in wanted] + require({node.name for node in definitions} == wanted, 'original local function inventory') + v, R = canonical['v'], canonical['R'] + n = 2 * v + R + entering = [r for r, f in enumerate(canonical['start']) if r >= 2 * v and f != 0] + hpe = {r for r in range(2 * v, n) if canonical['final'][r] != 1} + wrapped = sorted(set(entering) | hpe) + warp_table = {(r['sign'], r['op'], r['old'], r['new']): r for r in recipes['warps']} + + def warp_columns(op, f0, f1, columns, qmut=None): + require(qmut is None, 'unexpected warp mutation') + record = warp_table[(1 if op > 0 else -1, abs(op), f0, f1)] + require(record['G_columns'] == columns, 'warp callback columns mismatch') + return checker.warp(1 if op > 0 else -1, tuple(columns), tuple(canonical['frames'][f0]), + tuple(canonical['frames'][f1]), recipe_bytes(record)) + + env = dict(c=canonical, v=v, R=R, h=canonical['h'], n=n, frames=canonical['frames'], + levels={int(t): f for t, f in canonical.get('target_levels', {}).items()}, + entering=entering, hpe=hpe, wrapped=wrapped, plain=set(range(n)) - set(wrapped), + zb=canonical.get('zero_buffers', []), Q=Q, Counter=Counter, + hashlib=hashlib, json=json, warp_columns=warp_columns) + exec(compile(ast.Module(body=definitions, type_ignores=[]), str(source), 'exec', optimize=0), env) + return env + + +def check_provider(canonical, programs, recipes, residuals, checker, source): + c = canonical + require((c['v'], c['R'], c['h']) == (112, 408, 9), 'native provider dimensions') + require(set(programs) == {'forward', 'backward'}, 'both native orientations required') + frames = c['frames'] + edges = set(map(tuple, c['edges'])) | {(a, b) for f in c['center_frames'] for a, b in ((f, 0), (0, f))} + child_records = {(r['old'], r['new']): r for r in recipes['children']} + require(len(child_records) == len(recipes['children']) and set(child_records) == edges, + 'complete child recipe inventory') + for (old, new), r in child_records.items(): + checker.child(tuple(frames[old]), tuple(frames[new]), recipe_bytes(r)) + adapters = {(r['port'], r['role']): r for r in recipes['endpoint_adapters']} + require(len(adapters) == len(recipes['endpoint_adapters']) == 224 and + set(adapters) == {(i, role) for i in range(112) for role in ('source', 'target')}, + 'complete endpoint adapter inventory') + for (i, role), r in adapters.items(): + f = c['start'][i] if role == 'source' else c['final'][112 + i] + require(r['frame'] == f, 'endpoint frame mismatch') + checker.endpoint(c['ports'][i], tuple(frames[f]), role, recipe_bytes(r)) + wrecords = {(r['sign'], r['op'], r['old'], r['new']): r for r in recipes['warps']} + require(len(wrecords) == len(recipes['warps']) and set(wrecords) == set(map(tuple, c['warp_edges'])), + 'complete warp recipe inventory') + generator_columns = {r['op']: r['G_columns'] for r in c['warps']} + for (sign, op, old, new), r in wrecords.items(): + require(r['G_columns'] == generator_columns[op], 'warp recipe generator mismatch') + checker.warp(sign, tuple(generator_columns[op]), tuple(frames[old]), tuple(frames[new]), recipe_bytes(r)) + expected_residuals = {} + for r in range(224, 632): + entrance, terminal = c['start'][r], c['final'][r] + if terminal != 1: + expected_residuals['%d:%d' % (entrance, terminal)] = entrance, terminal + elif entrance != 0: + expected_residuals[str(entrance)] = entrance, terminal + require(set(residuals['recipes']) == set(expected_residuals), 'complete residual recipe inventory') + for key, (entrance, terminal) in expected_residuals.items(): + r = residuals['recipes'][key] + require(r['frame'] == entrance and r['vectors'] == frames[entrance] and + r['entrance_rank'] == len(frames[entrance]), 'residual entrance metadata') + if terminal != 1: + require(r['terminal'] == terminal and r['terminal_vectors'] == frames[terminal] and + r['terminal_rank'] == len(frames[terminal]), 'residual terminal metadata') + checker.residual(tuple(frames[entrance]), tuple(frames[terminal]), recipe_bytes(r)) + require(set(residuals['warps']) == {str(op) for op in generator_columns}, 'warp generator inventory') + for op, columns in generator_columns.items(): + r = residuals['warps'][str(op)] + original = next(w for w in c['warps'] if w['op'] == op) + require(all(r[k] == original[k] for k in ('op', 'G_columns', 'from_frame', 'to_frame')), + 'residual warp metadata') + checker.warp_generator(tuple(columns), packed(r['K'])) + env = replay_environment(source, c, recipes, checker) + local_results = {} + for name, back in (('forward', False), ('backward', True)): + profile, result = env['local'](programs[name], back) + require(dict(profile) == {int(r): count for r, count in c['local_profile'].items()}, 'native paid profile') + # This callback uses a phase-inclusive exact recipe certificate, not the + # original NumPy 512-column matrix hash. Name its evidence accurately. + result.pop('warp_columns_each_exact') + result['warp_recipe_event_certificate_sha256'] = result.pop('warp_product_sha256') + result['warp_recipe_equality_method'] = 'all Pauli generators plus exact nonzero zero-column amplitude' + local_results[name] = result + reached = set() + for events in programs.values(): + for e in events: + if e[0] == 'climb': + reached.add((e[3], e[4])) + elif e[0] == 'center': + reached.add((e[2], e[3])) + require(reached <= edges, 'uncovered reached native edge') + return {'persistent_inputs_each_orientation': 632, 'owned_centres': len(c['centers']), + 'owned_zero_buffers': len(c['zero_buffers']), 'frames': len(frames), + 'listed_directed_child_recipes': len(edges), 'reached_directed_child_edges': len(reached), + 'endpoint_adapters': len(adapters), 'listed_warp_recipes': len(wrecords), + 'residual_recipe_pairs': len(expected_residuals), 'local': local_results, + 'child_profile': c['local_profile']}, env + + +def negative_controls(canonical, programs, recipes, residuals, checker, env): + rejected = [] + + def reject(name, function): + try: + function() + except (AssertionError, ValueError, KeyError): + rejected.append(name) + else: + raise ValueError('negative control accepted: ' + name) + + child = copy.deepcopy(recipes['children'][0]) + child['left']['phase'] = (child['left']['phase'] + 1) % 4 + reject('child_global_phase_invisible_to_tableau', lambda: checker.child( + tuple(canonical['frames'][child['old']]), tuple(canonical['frames'][child['new']]), packed(child))) + r = copy.deepcopy(next(iter(residuals['recipes'].values()))) + entrance = tuple(canonical['frames'][r['frame']]) + terminal = tuple(canonical['frames'][r.get('terminal', 1)]) + r['left'], r['right'] = r['right'], r['left'] + reject('residual_wrapper_sides_swapped', lambda: checker.residual(entrance, terminal, packed(r))) + for name, predicate in ( + ('missing_private_zero_release', lambda e: e[0] == 'zero_buffer' and e[1] == 'free'), + ('missing_warp_inverse_cleanup', lambda e: e[0] == 'warp' and e[2] < 0 and e[3] == e[4] == 1), + ('missing_helper_post_wrapper', lambda e: e[0] == 'residual_adapter' and e[1] == 'post')): + events = copy.deepcopy(programs['forward']) + events.pop(next(i for i, e in enumerate(events) if predicate(e))) + reject(name, lambda events=events: env['local'](events, False)) + # The actual pre-wrapper order is a needed boundary premise. Move an actual + # wrapped-helper scalar read before its pre-wrapper without altering it. + wrapped = set(env['wrapped']) + events = copy.deepcopy(programs['forward']) + index = next(i for i, e in enumerate(events) if e[0] == 'scalar' and e[1][0] in ('add', 'copy') and + any(r[0] == 'L' and r[1] in wrapped for r in e[1][1:3])) + e = events.pop(index) + helper = next(r[1] for r in e[1][1:3] if r[0] == 'L' and r[1] in wrapped) + insert = next(i for i, e in enumerate(events) if e[0] == 'residual_adapter' and e[1] == 'pre' and e[2] == helper) + events.insert(insert, e) + reject('helper_read_before_pre_wrapper', lambda: env['local'](events, False)) + return rejected + + +def compute(): + pins = load_json(HERE / 'NATIVE-PINS.json') + require(pins['provider_map'] == PROVIDERS, 'active provider source map changed') + manifest_raw = authenticate_file(HERE / pins['source_manifest'], pins['source_manifest_sha256']) + manifest = json.loads(manifest_raw) + inventory = {row['path']: row for row in manifest['files']} + require(len(inventory) == len(manifest['files']) == 29, 'native source closure inventory') + source_raw = authenticate_file(HERE / pins['source_archive'], pins['source_archive_sha256']) + prior = HERE.parent.parent / pins['prior_package'] + prior_pins = json.loads(authenticate_file(prior / 'PHYSICAL-PINS.json', pins['prior_inputs']['PHYSICAL-PINS.json'])) + prior_raw = authenticate_file(prior / 'frozen/physical-t74/SOURCE-BUNDLE.tar.gz', + pins['prior_inputs']['frozen/physical-t74/SOURCE-BUNDLE.tar.gz']) + with tempfile.TemporaryDirectory(prefix='pooled-native-') as temporary: + root = Path(temporary) + unpack(source_raw, inventory, root / 'source') + unpack(prior_raw, prior_pins['bundle']['files'], root / 'prior') + source = root / 'source' + independent = module_from(source / 'pr4184/independent.py', '_pooled_native_pr4184') + formal = independent.compute() + require(formal == load_json(source / 'pr4184/INDEPENDENT.json'), 'fresh PR4184 pullback receipt differs') + transport = module_from(source / 'native-source/bw_transport.py', '_pooled_native_transport') + checker = Recipes(source / 'native-source/vendor/clifford/clifford_exact.py') + reports = {} + active = {} + for provider, export in PROVIDERS.items(): + actual = root / 'prior/native' / provider + generated = root / 'regenerated' / provider + with contextlib.redirect_stdout(io.StringIO()): + transport.run(source / 'pr4184/source/inputs' / (export + '.json.gz'), generated) + previous_argv, previous_path = sys.argv, sys.path.copy() + sys.argv = ['bw_emit.py', str(generated)] + try: + with contextlib.redirect_stdout(io.StringIO()): + module_from(source / 'native-source/bw_emit.py', '_pooled_native_emitter') + finally: + sys.argv, sys.path[:] = previous_argv, previous_path + equality = {} + for name in ('CANONICAL-WORD.json.gz', 'LOCAL-PROGRAMS.json.gz'): + require(load_json(generated / name) == load_json(actual / name), 'active native source equality: ' + provider + '/' + name) + equality[name] = sha(packed(load_json(actual / name))) + c, programs, recipes, residuals = (load_json(actual / name) for name in NATIVE_FILES) + result, env = check_provider(c, programs, recipes, residuals, checker, source / 'native-source/bw_audit_local.py') + result['pr4184_export'] = export + result['regenerated_scientific_json_sha256'] = equality + reports[provider] = result + active[provider] = c, programs, recipes, residuals, env + controls = negative_controls(*active['extra'][:4], checker, active['extra'][4]) + require(sum(row['outputs'] for rows in formal['providers'].values() for row in rows) == 5784, + 'complete PR4184 coverage') + return {'schema': 1, 'status': 'PASS_SOURCE_SPECIFIC_NATIVE_ALL_PARAMETER_ADMISSION', + 'source_archive_sha256': pins['source_archive_sha256'], + 'prior_physical_bundle_sha256': sha(prior_raw), + 'pr4184_head': '94b9ca9cf59ea6de346a59c92b414454bdde1de4', + 'reused_formal_pullback': {'output_functionals': 5784, 'endpoint_terms': 6680, + 'nonempty_surviving_words': 0, 'providers': 4, + 'orientations_each': 2, 'controls': formal['controls']}, + 'active_providers': reports, 'unique_exact_recipe_checks': dict(checker.checked), + 'negative_controls_rejected': controls, + 'all_parameter_argument': 'Q[F_72] substitution into unary tensor powers; fixed scalar role coefficients; exact frame/recipe tensor products, including scalar phases', + 'written_proof': 'NATIVE-ADMISSION.md', + 'discharged': ['exact source equality for three pooled native providers and both orientations', + 'arbitrary dirty persistent inputs and complete private-work cleanup', + 'phase-inclusive directed child, endpoint, warp and residual recipes', + 'every positive tensor multiplicity under exact child substitution'], + 'retained_premises': ['exact reversible scalar/monomial/private-work implementation on a common grid', + 'inductively correct child supplier on its actual hosted coordinate set', + 'whole-call placement, paid hosting/controller/restoration and outer cost proofs'], + 'scope': 'Written all-parameter native algebra proof plus finite complete recipe certificates; no formal-kernel proof or standalone outer/kappa assertion.'} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--out', type=Path) + parser.add_argument('--check', type=Path) + args = parser.parse_args() + result = compute() + raw = json.dumps(result, sort_keys=True, indent=2) + '\n' + if args.check: + require(args.check.read_text() == raw, 'native admission receipt differs') + if args.out: + require(not args.out.exists(), 'refuse to overwrite evidence') + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(raw) + print(result['status']) + print(json.dumps(result['unique_exact_recipe_checks'], sort_keys=True)) + + +if __name__ == '__main__': + main()