From d41e57fc058eef5ab883298a316260758bb9e413 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 28 Sep 2026 07:02:57 +0000 Subject: [PATCH] Recover the 45 unpublished CL_ANTHROPIC_BUNDLE v3 native copies from Drive CL-MIRROR-001 pins 46 frozen Kimi/K3 carriers that were only ever delivered in chat inside bundle v3. All 46 are in the owner's 09152026 gap-closure zip on Drive and match their manifest SHA-256; 45 were on no GitHub branch. Byte custody only; bundle v5 and SYM-Fw-jet remain absent. Scientific effect NONE. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_015wNj8LPTKXsaT68G3DgPPh --- .../IDENTITY.json | 256 ++++ .../LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md | 266 +++++ .../LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md | 62 + .../v3/RECEIPTS_ERRATA_2026-09-15.md | 67 ++ .../LPW_CONSTANT/v3/lpw_constant_v3.py.txt | 619 ++++++++++ .../v4/CHANGED_INTERFACES_REVIEW.md | 72 ++ .../LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md | 75 ++ .../LPW_CONSTANT/v4/MANIFEST.sha256.txt | 47 + .../K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json | 65 ++ .../LPW_CONSTANT/v4/lpw_constant_v4.py.txt | 651 +++++++++++ .../RETURN_06/00_EXECUTIVE_STATE.md | 121 ++ .../ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md | 242 ++++ .../ADDENDUM_2026-09-15_H3_BAND_FLOOR.md | 118 ++ .../RETURN_06/ADVERSARIAL_REPORT.md | 109 ++ .../K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md | 105 ++ .../RETURN_06/OBLIGATION_LEDGER.md | 118 ++ .../RETURN_06/PACKAGE_VERIFICATION.md | 39 + .../K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md | 106 ++ .../RETURN_06/SOURCE_CAPSULE.sha256.txt | 279 +++++ .../K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md | 28 + .../RETURN_06/TREE_MANIFEST.sha256.txt | 1038 +++++++++++++++++ .../UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md | 265 +++++ .../UPPER2D/B4LOC_damline/FREEZE.txt | 19 + .../UPPER2D/B4LOC_damline/b4loc_driver.py.txt | 632 ++++++++++ .../B4LOC_damline/b4loc_falsifier.py.txt | 87 ++ .../UPPER2D/B4LOC_damline/t_normal.txt | 27 + .../UPPER2D/BRANCH_dir/BRANCH_DIR.md | 108 ++ .../BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md | 107 ++ .../UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt | 128 ++ .../UPPER2D/D1_assembly/d1_falsify_v3.py.txt | 207 ++++ .../D3_percolation/D3_REMOTE_AMENDMENT_v2.md | 101 ++ .../D3_percolation/FREEZE_PERC_DECAY.txt | 62 + .../D3_percolation/d3_perc_decay.py.txt | 387 ++++++ .../UPPER2D/H3_closure/H3_BAND_CEIL.md | 123 ++ .../UPPER2D/H3_closure/H3_BAND_FLOOR.md | 173 +++ .../UPPER2D/H3_closure/MANIFEST.sha256.txt | 33 + .../UPPER2D/H3_closure/RECEIPT_h3.json | 103 ++ .../UPPER2D/H3_closure/band_normal.txt | 33 + .../UPPER2D/H3_closure/ceil_normal.txt | 33 + .../UPPER2D/H3_closure/h3_band_ceil.py.txt | 801 +++++++++++++ .../UPPER2D/H3_closure/h3_band_floor.py.txt | 794 +++++++++++++ .../H5_CLOSURE_TIGHTENING_2026-09-15.md | 131 +++ .../K3_SIDE24_LB/W3_numerics/W3_REPORT.md | 118 ++ .../W8_lambda/KIMI-DER-027c_NONCLOSURE.md | 109 ++ .../agent-tree-19fcef2e/work/PHASE2_SCOPE.md | 37 + .../agent-tree-19fcef2e/work/PHASE2_STATUS.md | 190 +++ .../RESULT.md | 77 ++ .../SOURCE_MAP.json | 384 ++++++ 48 files changed, 9752 insertions(+) create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/IDENTITY.json create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W3_numerics/W3_REPORT.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/RESULT.md create mode 100644 incoming/claude-bundle-v3-native-copies-20260928/SOURCE_MAP.json diff --git a/incoming/claude-bundle-v3-native-copies-20260928/IDENTITY.json b/incoming/claude-bundle-v3-native-copies-20260928/IDENTITY.json new file mode 100644 index 000000000..6fffc60de --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/IDENTITY.json @@ -0,0 +1,256 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "review_status": "REVIEW_REQUIRED", + "sources": [ + { + "repository": "d6g8k5htny-coder/main", + "path": "drive/mirrors/2026-09-15 — KIMI FINAL INTAKE — UPPER2D STAGE E + H5 + ASSEMBLY/06_UNMIRRORED_FROZEN_CARRIERS_BYTE_NATIVES/CL-MIRROR-001_MANIFEST.sha256.txt", + "commit": "b040bf0c30f33a9de220d19692e8dbcad9a1c5aa", + "sha256": "fac2303faf2e5a24493f27a35f9252db03c81e4af8c7712aca87189ef6599d38" + }, + { + "repository": "d6g8k5htny-coder/main", + "path": "drive/mirrors/2026-09-15 — KIMI FINAL INTAKE — UPPER2D STAGE E + H5 + ASSEMBLY/_MANIFEST.jsonl", + "commit": "b040bf0c30f33a9de220d19692e8dbcad9a1c5aa", + "sha256": "a8261dcf47d1f889f809dea14dbca0da45a02eb30a8e55dd5119037115c21d61" + } + ], + "artifacts": [ + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md", + "bytes": 17083, + "sha256": "71aec64fd2f9da77512426fa18f713bfed72f9ee1d14138776cf1ef8cc16cc19" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md", + "bytes": 5780, + "sha256": "76016d7bfe755a1b6c09be40393a46632e9b92711d744817a8f0a35fe9331b63" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md", + "bytes": 3931, + "sha256": "6a7e95be5e3a4abae26ce737c48662bec930d76dca818daba26aef4d6b76029c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt", + "bytes": 32750, + "sha256": "4a015174d369eabc16c60f2c6f2aade2feee113ed60c5d0b8d505624e9b02a8c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md", + "bytes": 4160, + "sha256": "a269a2bcb03e4eb6342fac938d0d303a947950034eb46e17ae598f59badcd71a" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md", + "bytes": 4536, + "sha256": "b06ee40c43f6e8aef266de2a7f4231fd8321676024f33c9132966b89b654b81c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt", + "bytes": 4529, + "sha256": "4a63ada47c8bd6d189108358898c646af064c06755a6a855c4e7d3133acf4774" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json", + "bytes": 3915, + "sha256": "d232d2a0d6b37d8fb465d3de8a9141b92f2d366460c38e928ab9f70d29ab689e" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt", + "bytes": 34538, + "sha256": "12732d3222828d61c0449c562c5e00a1f5c36fb7646d8c4d030914e4c3f50c86" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md", + "bytes": 10442, + "sha256": "c1ac3bde91a86b8d78d02eee72f00ab04969bba2b39a1f5255b8692b04f67c1f" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md", + "bytes": 23695, + "sha256": "8f8c0bc0905ab9c0c339a85ae04d7156c97ebb6540b55114263e86995f793f24" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md", + "bytes": 9400, + "sha256": "1cb23846199cd82d0d6c64449af6dba08b6d0efc1ceecbf0f0975bf38ef05ec2" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md", + "bytes": 14228, + "sha256": "82ac0bf28bb7266ba93d8f395812519dadb0645f92d3c486406d35e8d6749644" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md", + "bytes": 6890, + "sha256": "345e71b048fde07597daf1b2aa33bf9dfb850314380959bd42a679d463f010d1" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md", + "bytes": 9184, + "sha256": "cd248c950584678668076f4e9801c06f6c240b6d572af6707b9de823f56b78fe" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md", + "bytes": 7774, + "sha256": "46d1eacf5ec83fa7eb91785d56ce86209533482c0c772a5a3bceea00bf1db9a5" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md", + "bytes": 8268, + "sha256": "ed8075644e5e43f2a8236f1315a2c71b19edfbc3bb4547bcd3f53b73639a7122" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt", + "bytes": 29557, + "sha256": "5698f3fbdc70422438c2fd137f910cc973311d8c74d7cd579d7e8ae4d8789dc1" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md", + "bytes": 7226, + "sha256": "0ec315e527ec0a57553229ba98b7afc2151fe61c13cad1d0aa6a0d4ec3808905" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt", + "bytes": 129707, + "sha256": "f3e9fa669dc4bdfef28f1de0b0e9a2d0994498cc65c7757fda758566c01dee43" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md", + "bytes": 15164, + "sha256": "ae4c9c82784aecfbd85056c316f792a331bccb774d952887fc5fe8ea7da615b4" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt", + "bytes": 1213, + "sha256": "5235f98a59e5119444b8fda2ea16d2dd3333e0d46f0b52af6362a2b2a0ecd163" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt", + "bytes": 26271, + "sha256": "bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt", + "bytes": 3360, + "sha256": "d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt", + "bytes": 2735, + "sha256": "11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md", + "bytes": 6069, + "sha256": "8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md", + "bytes": 6063, + "sha256": "7547e76a813d1a0c582139e2d31d9ec6a6480e1eaf670d3eed05173bffead3df" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt", + "bytes": 7954, + "sha256": "58edc293a1127407d49040856ad9546d2577578381a4ff62c1c60a3c9911ac1d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt", + "bytes": 11552, + "sha256": "5805e53d69541f00229e5e49e14d655afd1f471a2584a2117fedf0bb5298ddb0" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md", + "bytes": 5701, + "sha256": "2527ab5a1b5ee208a30a672e2457de04708228f3c154185d95c236bd4f4f5e6f" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt", + "bytes": 3966, + "sha256": "6bbe6e27a91c777b7245294fc5740462af06e7f20b0f92ff4eae15cd2f05edef" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt", + "bytes": 19063, + "sha256": "ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md", + "bytes": 8311, + "sha256": "18e109bc2e7a186c307f689f940ad476d69fc543e828081e0e706de2c578800d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "bytes": 11133, + "sha256": "7a40e2675232244bc63fcab2304b4b9cd3cd59a5c4965a3be5e65db7436fcfc2" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt", + "bytes": 2741, + "sha256": "092d886ceb279ba09d473f2308e3e0495593d70c4ca614fd0deed2ccde281e55" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json", + "bytes": 6254, + "sha256": "ee58ef8054109a24ea0dadd5f0147b883966374e539ff462f8500af932765264" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt", + "bytes": 2835, + "sha256": "dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt", + "bytes": 2698, + "sha256": "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt", + "bytes": 37950, + "sha256": "b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt", + "bytes": 37315, + "sha256": "a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md", + "bytes": 7540, + "sha256": "125352325b09062fdc1f49402222402f388240f44b0f60b1e2636f19888c0615" + }, + { + "path": "K3_SIDE24_LB/W3_numerics/W3_REPORT.md", + "bytes": 9693, + "sha256": "70a3ba352f937384f79b0f9252afc0f1aa5ba1a24e318549c903838d7dfef059" + }, + { + "path": "K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md", + "bytes": 19043, + "sha256": "530c3038024964fd12ed2a6249f4f44d473181e0b49cb91f6cbdae0aff440d15" + }, + { + "path": "K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md", + "bytes": 2332, + "sha256": "966c3d8f4934139017d8fadfd334ef473a8086ee4750a959831855b9f895428f" + }, + { + "path": "K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md", + "bytes": 11956, + "sha256": "6cdb9dec403561cce2de17e4a48915afb3272880fb21edc53f6b99c11d236ea6" + }, + { + "path": "RESULT.md", + "bytes": 3829, + "sha256": "801a95df13ebf6c824a7c27588e26fd19dd9e84c23b211d0355cd38f4bc22eee" + }, + { + "path": "SOURCE_MAP.json", + "bytes": 18382, + "sha256": "37aed25f410900933adbfb503a577ccd214c9a82882b99ad998dec9b75a9b07f" + } + ] +} diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md new file mode 100644 index 000000000..35df56873 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md @@ -0,0 +1,266 @@ +# OPTIMIZATION_ANALYSIS.md — exponent ledger and coefficient structure of the LPW local event + +**Record:** LPW-OPT-20260913-v1.0. **Lane:** H1, lower-constant optimization work order, +ANALYTIC first phase (light compute only; the promotion rungs own the cores). +**Status labels:** every claim is marked **Theorem** / **Lemma** / **Conjecture** / +**Heuristic** / **Estimate**. Theorems and lemmas are proved in-line here and mirrored +executable-exactly in `OPTIMIZATION_falsifier.py` (both modes byte-identical). +**Frozen carriers consumed (untouched; sha256 verified at consumption time):** +LPW-CAND-20260912 v1.0 (candidate, event construction §§2–8); +LPW_CONSTANT v1 `lpw_constant.py` `e258322c…4d3035`; +LPW_CONSTANT v2 `lpw_constant_v2.py` `ca654e39…30e125` + report `a469c456…61ef62` +(certified pair c = 260/(2082000000000·2⁴⁰·10²¹) ≥ 1.13e-43, r₀ = 1/2224640); +B1_TAXONOMY v1.0 (witness placement §7, coverage theorem §4); +D3_PERCOLATION (D3-SPLIT, D3-COUNT, remote Θ(r³) raw count 2.9274·(1+κ)); +C1_ALPHA_INTENSITY (chart integral 1.6053e-4 ⟹ C\*_env = 1.284 at r = 0.05); +W6_REPORT (WP modulus E_WP(r) = 3.5e-3·r^{3/2} on (0, 0.05]). + +--- + +## Q1 — THE EXPONENT LEDGER + +### 1.1 Setup: the scaled field and the coefficient–unit dictionary (Lemma L1) + +Under the six pins (f(M) = b, f(S) = b − r³/6, ∇f(M) = ∇f(S) = 0), the scaled field +F_r(x, y) = (f(rx, ry) − b)/r³ on the fixed chart D = [−2, 1/2]×[−1, 1] decomposes +(candidate §§5–8) as + + F_r = F_J + O(K r) in C²(D), F_J(x,y) = g(x) + A(x²−1/4)y + Bxy² + Cy² + D₃y³, + +- g(x) = x³/3 − x/4 − 1/12, **forced** by the pins (the two values and two gradient + zeros determine the axial cubic up to O(Kr); verified coefficientwise); +- the low-order coefficients (constant, x, x², y, xy) are **forced** by the pins and the + endpoint gradient equations to their g-values within O(Kr) (candidate §8); +- the four **free** scaled coefficients are the J-coordinates in these units: + + | scaled coeff | physical coordinate | physical unit | scaled window cost | + |---|---|---|---| + | A | f_xxy(0)/2 | 1 | width w ⟹ physical volume w | + | B | f_xyy(0)/2 | 1 | width w ⟹ physical volume w | + | C | f_yy(0)/(2r) = q/(2r) | **r** | scaled width w ⟹ physical volume **r·w** | + | D₃ | f_yyy(0)/6 | 1 | width w ⟹ physical volume w | + +**Lemma L1 (exact).** A Θ(1) scaled window in C is a Θ(r) physical window in q; all +other free directions have unit 1. The y²-direction is the *unique* direction whose +scaled unit shrinks with r. (Proof: F_r's monomial coefficients are c_{ij} r^{i+j−3} +with c_{ij} the physical Taylor coefficient; i+j = 3 gives unit 1, and among the +order-2 coefficients x² and xy are pinned, leaving only y².) ∎ + +### 1.2 The general ledger (correcting the prompt's display) + +For an event E contained in the failure event, with conditional J-density floor m_E, +weight floor w_E = inf_E W_r, and normalizer cap Z_r ≤ C_Z r²: + + Palm mass(E) ≥ m_E · vol(E) · w_E / (C_Z r²) ⟹ exponent e = v + w − n, + +v = volume exponent, w = weight exponent, n = normalizer exponent. For d thin +directions at scales r^{α_i}: v = Σ α_i (Gaussian density Θ(1) on the box: cost of a +restriction of width r^{α_i} is r^{α_i}). **LPW: e = 1 + 4 − 2 = 3.** +(The prompt's "r^{2 + αk − 4}" is a sign slip; the consistent formula is αd + 4 − 2 = +2 + αd, which for α = k = 1 gives 3, matching the prompt's own r³.) + +### 1.3 The weight exponent w = 4 is exact and forced (Lemma L2) + +**Lemma L2.** On any event with A, B, C, D₃ = Θ(1): f_xx(M) = −r(1 + O(r)) and +f_xy(M) = −Ar(1 + O(r)) are **forced by the pins alone** (no event choice): the +endpoint gradient zeros plus the value drop r³/6 force f_x(rx)/r² = x² − 1/4 + O(r), +whence the axial second derivative at M is g″(−1/2)·r = −r and the mixed derivative is +−Ar. The yy-entries are r(2C ∓ B)(1 + O(r)) via the exact scaling H_f(rz) = r H_{F_r}(z) +(candidate §8). Hence |det H(M)|, |det H(S)| are Θ(r²) with scaled determinants +det H_F(m) = −(2C − B) − A² and det H_F(s) = (2C + B) − A², and W_r = Θ(r⁴) exactly. +The r⁴ is not a choice: the axial factors come from the pins, the yy factors from the +typing window (Lemma L3). Degrading the scaled dets toward 0 (event touching the typing +boundary) only *worsens* the ledger (w = 4 + κ). ∎ + +### 1.4 The typing window — upper edge of C (Lemma L3) + +**Lemma L3 (typing/determinant edge).** For W_r > 0 the event must meet the typing +support: det H_F(m) > 0 with H_xx(m) = −1, and det H_F(s) < 0 with H_xx(s) = +1. +Exactly: + + C < (B − A²)/2 (m-edge), C < (A² − B)/2 (s-edge). + +For (A, B) near (2, 0) the m-edge binds: C < −2. Verified in the falsifier (F-TYPING). ∎ + +### 1.5 The climb bound — lower edge of C (Lemma L4) + +**Lemma L4 (path-clearance/geometry edge).** Write x = −1/2 + ξ. Then +g(x) = −ξ²/2 + ξ³/3 exactly (verified coefficientwise). On the chart D, with +λ := −(C + 2|B| + |D₃|) > 0, for ξ ∈ [−3/2, 0): + + F(x, y) ≤ −ξ²/2 + ξ³/3 + |A||ξ²−ξ||y| − λy² + ≤ −ξ²/2 + ξ³/3 + A²ξ²(1−ξ)²/(4λ), + +and the right side is **strictly negative for every ξ ∈ [−3/2, 0) whenever +λ ≥ 25A²/8**, including the corner ξ = −3/2 (where the discarded ξ³/3 = −9/8 makes it +strict); the maximizing |y\*| = |A||ξ²−ξ|/(2λ) ≤ 3/10 < 1 stays inside the chart. The +right side ξ ∈ (0, 1] is dominated (25A²/8 > 3A²/2). Hence, if +C < −(25A²/8 + 2|B| + |D₃|) with A, B, D₃ bounded, the scaled field is negative +everywhere on D except at m itself: **no point of the chart has F > 0 — the above-b +target is unreachable inside the chart and the path witness dies.** +(Exact rational verification: 2000-point grid max −1121467/4750229335704 < 0, corner +exactly −9/8; F-CLIMB.) ∎ + +### 1.6 Theorem EXP-1 — α = 1 is forced, and the cubic is optimal within local witness events + +**Theorem EXP-1.** Let E be an event of the six-pin law such that +(i) E ⊂ {D_f(M) ≠ S} is certified by a C²-robust path witness inside the scaled chart +(local event; any path exiting rD is A.rem's object by definition), and +(ii) E ⊂ TYP up to null sets (needed for W_r > 0). +Then, with A, B, D₃ confined to r-independent bounded intervals (required by the weight +floor and the clearance budget): + +1. **C is confined to an r-independent window** + −(25A²/8 + 2|B| + |D₃|) ≲ C < min((B−A²)/2, (A²−B)/2) (lower edge: Lemma L4, + geometry; upper edge: Lemma L3, typing). The window is nonempty (the witness + C = −5 ∈ (−12.5, −2)). +2. Therefore the physical q-window has width Θ(r) and no more: **α = 1 is forced** + for the unique thin direction. A window of width r^α with α < 1 either includes + C → −∞ (witness dies by L4: E ⊄ failure, inadmissible) or slides |C| → ∞ + (probability O(e^{−θ/r²}), worse than any power). +3. The volume exponent is v = 1 and cannot be 0 for an admissible event + (v = 0 ⟺ Θ(1) physical q-window ⟺ unbounded scaled C ⟺ (i) or (ii) fails). +4. With w = 4 (Lemma L2) and n = 2 (normalizer, a property of the law: Z_r ≤ 4B₃r², + candidate §9), **e = 3 is the minimum exponent among admissible local witness + events**, and it is achieved (LPW's E_r). + +*Proof.* L1 gives the unit dictionary; L2 the weight; L3–L4 the two edges; the +inadmissibility dichotomy in (2) is exhaustive for α < 1; (3) restates that a +probability-Θ(1) admissible event would contradict L3+L4. ∎ + +**Answer to "which forces α = 1":** both, on opposite edges — the *typing/determinant* +side caps C above (Lemma L3) and the *event-geometry* side floors C below (Lemma L4). +Either alone makes the window Θ(1) scaled = Θ(r) physical. The determinant weight r⁴ is +then automatic (Lemma L2); it does not by itself bound C below (very negative C +*increases* |det|) — the lower edge is genuinely the path-clearance geometry. + +### 1.7 The complete exponent table + +| family | thin dirs | scales | v | w | n | e = v+w−n | status | +|---|---|---|---|---|---|---|---| +| LPW E_r (δ-box around F_*) | 1 (C) | r¹ | 1 | 4 | 2 | **3** | admissible, optimal (Thm EXP-1) | +| extra-thinned variant (A-window r^β) | 2 | r¹, r^β | 1+β | 4 | 2 | 3+β | admissible, strictly worse | +| widened C (α < 1) | 1 | r^α | — | — | — | **inadmissible** (witness dies, L4) | +| degenerate-det edge (C at typing boundary) | 1 | r¹ | 1 | 4+κ | 2 | 3+κ | admissible, strictly worse | +| slid window (\|C\| → ∞ as r → 0) | — | — | super-poly small | — | — | negligible (e^{−θ/r²}) | +| unrestricted C (v = 0) | 0 | — | — | — | — | **inadmissible** (⊄ failure or ⊄ TYP) | +| remote window saddles (A.rem, D3) | height window (s,b), width ℓ = r³/6 | — | 3 | 0 (RN → 1 at d ≥ 2r) | 0 | **3** | different mechanism, same exponent | +| WP / wrong-partner (W6) | — | — | — | — | — | ≤ 3/2 | larger mass as r → 0; upper-lane channel, irrelevant to the lower-bound coefficient | + +**Conclusion (Theorem EXP-1 + table): no counter-family with exponent < 3 exists among +admissible local witness events; the cubic is the optimum of the local family.** The +remote mechanism independently sits at 3 through the height window, not a jet width. +*Boundary of the claim (labeled):* "no mechanism of any kind beats r³" is the upper +campaign's theorem-in-progress (C1/D3 raw carriers are both Θ(r³); B-classes are Stage C +open items) — not claimed here. No candidate counter-family was found; none is reported +for adversarial review. + +--- + +## Q2 — THE COEFFICIENT QUESTION + +### 2.1 Placement (frozen) and the lower-bound statement + +**Theorem CONT-1.** The LPW local event G_r = E_r ∩ {M₄ ≤ K} satisfies +G_r ⊂ A.loc ⊂ A ⊂ F_r = {D_f(M) ≠ S}, exactly, on Reg ∩ TYP. +*Proof.* B1_TAXONOMY §7 (frozen): on G_r the path r·γ_\* ⊂ rD joins M to z ∈ rD with +f(z) > b and min f∘γ > s — exactly A.loc's definition (here executable-verified with +the explicit quantifiers k = 12, j = 2: 1/12 < 1/6 − 99/1280 = 343/3840 and +R(−2) = 9/16 ≥ 1/2; F-DISJ). A.loc ⊂ A by construction; A ⊂ F_r by T1 (τ_M > s). ∎ + +**Consequence (Theorem).** For all 0 < r ≤ r₀, +liminf_{r→0} (1 − q(r, 6/5))/r³ ≥ liminf P_r(G_r)/r³ ≥ c_v2 = 260/(2082000000000·2⁴⁰·10²¹) +≥ 1.13e-43 > 0 (v2's certified pair, re-certified by H1's v3). The LPW event is a +**certified lower bound on the failure coefficient**, not the coefficient itself. + +### 2.2 Disjointness from the remote mechanism (Theorem DISJ-1) + +**Theorem DISJ-1.** G_r ∩ A.rem = ∅, exactly. +*Proof.* A.rem := A ∖ A.loc (B1 §3, frozen, definitional). G_r ⊂ A.loc (Theorem +CONT-1). ∎ Supplementary geometric content: on G_r the M-lineage and a point z with +f(z) > b lie in *one* component of O^s ∩ rD, so all three D3-SPLIT alternatives fail +(E₁: the witness needs no counted saddle at all; E₃: the in-chart level-s connection is +the path itself). Note on scales: the witness path reaches distance ≈ 2.61r from S +(point r·(−2, 3/4)) — *outside* the 2r disk yet *inside* rD; the loc/rem split is by +path localizability in rD (measurable), not by the 2r distance, and D3's stitch assigns +rD ∪ B(pair, 2r) wholesale to the chart lane. Hence no double counting anywhere: +P(A) = P(A.loc) + P(A.rem) (disjoint), and D3-COUNT's raw-count split by saddle +location (rD vs T² ∖ rD) is a disjoint upper envelope over the *same* P(A) that the +LPW event lower-bounds. ∎ + +### 2.3 Add, interfere, or contained? — the precise answer + +- **G_r and the remote A.rem: ADD (disjoint events).** Theorem DISJ-1. Neither contains + the other; they are disjoint contributions to P(A), which is one of four disjoint + classes in the exact identity 1 − q = P(A) + P(B1) + P(B2) + P(B4) (B1-COVER). +- **G_r and A.loc: CONTAINED, strictly.** G_r is one explicit Θ(r³)-positive tube inside + the local preemption event. A.loc ∖ G_r is the near-field remainder *between* the tube + and the remote zone — the third family the question asks about. It exists and is + potentially much larger than the tube (the tube is a δ⁴-thin slice of an Θ(1)-sized + witness region in (A, B, C, D₃) space; see §2.4, lever F-OPT-5). Its current certified + upper envelope is C1's raw chart integral 1.6053e-4 = 1.284·r³ at r = 0.05 (rung + evidence; window saddles in rD, qualification dropped, polarity-safe). +- **Interference: none.** The events are nested or disjoint (G_r ⊂ A.loc; A.loc ⊔ A.rem; + A ⊔ B-classes). There is no overlap to subtract anywhere in the accounting. +- **Other channels:** W6's WP/wrong-partner modulus E_WP(r) = 3.5e-3·r^{3/2} (certified + on (0, 0.05]) is a B-side channel at a *larger* order — negligible for the + r³-coefficient as r → 0; B-class r³ content is Stage C's open upper-bound problem and + does not touch the lower bound (the LPW event lives in A.loc). + +So: **LPW's explicit local event is ONE positive contribution — a certified lower bound +on the actual coefficient, with the true coefficient above it and bounded (at the rung, +evidence grade) by the raw carriers** (local 1.284 + remote 2.9274·(1+κ)-class, plus the +D3 envelopes 19.6·r³ spine / 3.9·r³ evidence for the remote annuli). + +### 2.4 The optimization question: how large a certified coefficient could the best local event give? + +Current certified: c = 1.135776e-43 = 260·m·δ⁴/B₃ with m = 1e-21, δ = 1/1024, +B₃ = 2082000000000. The slack per factor (certified vs actual), ranked: + +| lever | certified now | actual/sharp | gain | grade/cost | +|---|---|---|---|---| +| F-OPT-1: density floor on the *small* box E_r (exact quadratic-form max at the 16 vertices; QF convex) | m ≥ 1e-21 (global JBOX floor via \|j\|+\|μ\| triangle bound) | **Estimate:** floor ~ 1.117e-3 (QF_max ≈ 8.7280) | ×1.1e18 | LIGHT (minutes; exact moments already certified; covariance inverse certified) | +| F-OPT-2: widen δ toward the clearance budget (16δ ≤ 1/16 − 8Kr₀; as r₀ ↓ the remainder share → 0) | δ = 1/1024 | δ → 1/256 | ×256 exactly (δ⁴) | LIGHT (exact rational arithmetic) | +| F-OPT-3: weight floor refinement (F_* dets 6·14 = 84 vs robust 65; re-split the C² budget) | 65 | ≤ 84 | ×≤ 1.3 | LIGHT | +| F-OPT-4: two-sided normalizer (replace C_Z = 4B₃ by Z_r/r²) | C_Z = 8.328e12 (B₃ chain) | **Estimate:** Z_r/r² ≈ 3.2245 (D3 probe, r = 0.05, QMC evidence) | ×2.6e12 | **HEAVY — promotion-rung scope (G.7 two-sided normalizer); not light compute** | +| F-OPT-5: witness-region event (replace the δ-ball by the full Θ(1) witness region in coefficient space, certified region volume + density integral) | tube slice | true local coefficient | orders | **MODERATE–HEAVY** (finite-dimensional geometry + certified integration) | + +**Estimate (Heuristic, from the falsifier's display lines):** levers 1+2 (light compute, +within existing certified objects) give c ≈ 3.25e-23; adding lever 4 (promotion-rung +scope) gives c ≈ 8.4e-11. Lever 5 would approach the true local coefficient. + +**Conjecture (evidence-labeled, not proved):** the true local coefficient +lim (P_r(A.loc))/r³ is Θ(0.01–1). Evidence: historical C020 C\* ≈ 0.97 at (1.2, 0.05) +(numerical, non-authoritative); C1's raw chart envelope 1.284 (upper, polarity-safe, +qualification dropped); D3's corridor kill (on-axis needle dead to e^{−10^286} scale — +consistent with the local witness living exactly on the conditioned ridge inside rD). + +### 2.5 Follow-up items (beyond light compute; handed to the promotion rungs) + +1. **F-OPT-4**: certified two-sided normalizer Z_r = Θ(r²) (G.7-scope) — the single + largest certified-coefficient lever (×2.6e12). +2. **F-OPT-5**: certified volume/density integral over the full witness region + {(A,B,C,D₃): a clearing path exists} — finite-dimensional but needs certified + integration machinery. +3. Certified recombination: any coefficient upgrade changes the optimal (c, r₀) split + (δ vs 8Kr₀ budget) — re-run the v3-style assembly with the new floors. + +--- + +## Executable falsifier and hashes + +`OPTIMIZATION_falsifier.py` (this directory): exact-rational verification of every +Lemma/Theorem above (F-LEDGER, F-WITNESS, F-PATH, F-TYPING, F-CLIMB, F-DISJ, F-COEF) +plus labeled Estimate display lines for §2.4. Fail-closed ck() → SystemExit(1); no bare +asserts; deterministic; `python` and `python -O` byte-identical +(`opt_normal.txt` ≡ `opt_O.txt`). Kill semantics: any admissible local witness event +exhibited with volume exponent < 1, weight exponent < 4 on a Θ(1)-det region, or a +clearing path with C below the L4 threshold, kills Theorem EXP-1; any field on G_r +failing A.loc kills CONT-1/DISJ-1. + +Run receipt (this delivery): both modes exit 0, output byte-identical; final line +`OPTIMIZATION-FALSIFIER PASS`. sha256 values: see `OPTIMIZATION_MANIFEST.sha256`. + +END_BODY + +Body sha256 (bytes through the line preceding END_BODY): fb7b5d1462924f93f0f3af9d0fa354fc378908943d77fb514e580e2d2377c381 diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md new file mode 100644 index 000000000..d30a85b43 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md @@ -0,0 +1,62 @@ +# LPW_CONSTANT v3 — SUCCESSOR CERTIFICATE REPORT (levers 1+2+4) + +**Statement certified.** For the six-pin law (f(M) = b = 6/5, f(S) = b − r³/6, +∇f(M) = ∇f(S) = 0, M a local max, S a saddle) of the 2D torus Gaussian field, + + **1 − q(r, 6/5) ≥ c·r³ for all 0 < r ≤ r₀,** + **c = 4·(597/128)·(2596849/204800)·(9/10000)·(14587/2621440)⁴ / 2082000000000 + = 210574711783915452081258399 / 2147825968160134776949980528640000000000000000000 + = 9.8040863135804911886149013570e-23 (published downward-safe 9.80e-23; power-of-ten floor 1e-23),** + **r₀ = 1/2278031360 = 1/(2¹⁸·8690) ≈ 4.3898e-10.** + +v2 (sha256 ca654e39…c130e125) and its reviewed theorem stay frozen untouched; v3 +is a NEW successor. Every number below is produced by `lpw_constant_v3.py` +(python / python −O byte-identical program output; receipts separate). + +## CHANGES table from v2 + +| Lever | v2 | v3 | certified effect | re-verification record | +|---|---|---|---|---| +| 1 — density floor | m ≥ 1e-21 (boxed triangle formula over JBOX) | m = 9/10000 (exact quadratic-form minimum of the conditional Gaussian density over the small box, max at the 16 vertices) | ×9.1044e17 (directed floor ≈ 9.1044e-4; consumed with > 1% margin; consistency: below the RB center density 1.2832254e-3) | endpoint ten-jet Gram re-derived from the moment dictionary; Schur identity Cov(J\|U₀) = diag(a₄−a₂², a₂(a₄−a₂²)/4, ·, (a₆−a₄²/a₂)/36) verified to 1e-50; μ₀ = (−a₂b,0,0,0) exact; eigenfloor 0.126553449667289 re-derived (≥ 31/250); log-det modulus det(S_r) ≤ det(S₀)(1+x+x²), x = 2L1R/λ; mean correction ε_μ = M − a₂b = 0.0225758 consumed from v1's frozen certified M; S_r⁻¹ perturbation L1R/(λ·λ₀) | +| 2 — δ widening | δ = 1/1024, r₀ = 1/(256·8690), budget 16δ + 8Kr₀ = 3/64, weight floor 65 | δ = 14587/2621440, r₀ = 1/2278031360, budget ε′ = 57/640 with clearance margin exactly 1/3840 > 0, weight floor 597/128 · 2596849/204800 = 1550318853/26214400 ≈ 59.13997 | δ⁴ ×1054.15, weight ×0.90985 → net ×959.96 | δ = 1/256 FAILS: 16/256 + 1/32 = 3/32 > 343/3840 (recorded; reversion applied). At ε′ = 57/640 every margin re-verified UNIFORMLY over the widened box (not cited from v2): typing signs (−(1−ε′) < 0, −(10−ε′) < 0), determinant floors W1 = 6−15ε′, W2 = 14−15ε′+2ε′² (exact Fractions), path clearance 1/6 − 99/1280 − ε′ = 1/3840 > 0, endpoint 9/16 − ε′ > 0, basis C²-norm sum 4+4+2+6 = 16 re-derived on D | +| 4 — two-sided normalizer | C_Z = 4B₃ = 8328000000000 (v1 crude uniform cap) | C_Z = 4B₃ (UNCHANGED on the certified line); H3 carriers consumed as consistency anchors | none certified; conditional gain ×1.815384e12 → c ≈ 1.78e-10 (ESTIMATE, non-load-bearing) | **F-LEVER4 (flagged insufficiency):** H3_RUNG_FLOOR certifies Z_{0.05}/0.05² ∈ [3.10371669501, 4.58745858936] POINTWISE at r = 0.05 > r₀; H3_BAND_FLOOR certifies the one-sided FLOOR E[G_r] ≥ 2.30659559567154 uniformly on (0, 0.05] ⊃ (0, r₀] (r₀ ∈ cell (0, 0.0025]). Neither is a uniform UPPER envelope of Z_r/r² on (0, r₀], which is what the Palm denominator requires. Consistency checks pass (band floor ≤ rung lo < rung hi ≪ 4B₃). Follow-up: a certified uniform upper envelope on (0, 0.0025] would realize the conditional gain; mutation family `normalizer_cap_down` fail-closes any premature consumption | + +Combined certified gain over v2: c_v3/c_v2 ≈ 8.63e20 (levers 1+2). The work-order +target estimate ~8.4e-11 assumed lever 4's uniform cap; the certified value is +whatever the build proves: **9.80e-23** (levers 1+2), with the lever-4 conditional +estimate 1.78e-10 documented but NOT load-bearing. + +## Carriers consumed (sha256 verified from bytes at run time) + +v1 script e258322c…, v1 receipt 6332afe0…, v1 report 702788dc…, v1 transcript +d0cb9259…, v1 lead review 940057a5…; v2 script ca654e39…, v2 report a469c456…; +H1 hardening receipt 49e23661… (S₃ ≤ 554.3913563, S₄ ≤ 2041.8327332 amended +enclosures, findings F-S4/F-C29); H3 rung 6347275d…, H3 band 7a40e267… (body +hash 281477c3…, body-excl-hash-line rule verified). The v1 Poisson defect +1 − a₂ = 9.65254179896e-123 > 0 is consumed from the v1 receipt (strict +positivity hook); moments a₂, a₄, a₆ are independently recomputed with certified +geometric tails (interval width < 1e-38). + +## Findings carried / new + +- F-S4 (carried): S₄ upper enclosure amended to 2041.8327332; non-load-bearing. +- F-C29 (carried): exact expansions by integer division; published ≤ exact. +- F-DELTA1256 (new): δ = 1/256 fails the path clearance at v2's split; certified + reversion = re-optimized split ε′ = 57/640, δ = 14587/2621440, margin 1/3840. +- F-LEVER4 (new, flagged): no certified uniform upper envelope of Z_r/r² on + (0, r₀] exists in the package; C_Z = 4B₃ retained; conditional gain recorded. + +## Certificate discipline + +Exact rational arithmetic for the final coefficient; published decimal ≤ exact +fraction (invariant a); power-of-ten floor by exact integer tests (invariant b); +general rounding-direction checker over the display ledger (invariant c); +amplitude majorant E[R⁴] = 8, E[R] ≤ √2 (the v2 repair) enforced as the exact +multiplier; 16 mutation families (v2's twelve + density_floor_up, delta_up, +weight_floor_up, normalizer_cap_down), each fail-closed with nonzero exit in +both modes; unknown mutations rejected fail-closed; CANNOT-VERIFY (exit 2) +separate from FAIL (exit 1); no bare asserts; deterministic; both modes +byte-identical program output (runner labels/receipts separate). + +Body hash of this document: recorded in MANIFEST.sha256 (SHA256 over the document +body excluding the hash line itself). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md new file mode 100644 index 000000000..9032bc0a6 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md @@ -0,0 +1,67 @@ +# LPW_CONSTANT v3 — RECEIPTS ERRATA (2026-09-15) + +Errata to the frozen v3 record (certifier 4a015174…, RECEIPT.json 60549daf…, +report 76016d7b…; all frozen carriers untouched — this dated file is the +corrected record). Independent-review verdicts on the three changed interfaces +stand confirmed (PASS WITHIN SCOPE / PASS WITHIN SCOPE / AMEND REQUIRED +upstream); the certified pair arithmetic is unaffected by every item below. + +## Erratum E1 — carrier hash table (3 wrong values in the record files) + +The following values were recorded incorrectly in RECEIPT.json (`carriers` +table, lines 46/47/52) and, for the first, in LPW_CONSTANT_V3_REPORT.md prose +(carriers paragraph). ACTUAL values re-verified from bytes on 2026-09-15: + +| carrier | file | WRONG (as recorded) | ACTUAL (verified from bytes) | +|---|---|---|---| +| v1_report | ../LPW_CONSTANT_REPORT.md | 702788dc1c00e96910dc21d2b8d66ddaa3b82a8c3c6ca3f9a4343fe104b2ba29 | 289d9f40e725bd51e2405d9de88b3afd428a338f76a709d6d882f1c395f50b22 | +| v1_transcript | ../out_normal.txt | d0cb92594d267a134ee93e4e676603118ce3041a60bf02b2102dc138f8ee720b | d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f | +| h3_rung | ../../UPPER2D/H3_closure/H3_RUNG_FLOOR.md | 6347275d74d3b2a0047b2be02cb5c9f740b380d63831008ffdc093166d43c85d | 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa | + +Root cause: the receipt/report carrier tables were authored from notes before +the certifier's pins were finalized; the certifier's cnv enforcement rejected +the wrong values at first run and the in-script pins were corrected, but the +receipt/report tables were not resynced. + +Impact: NONE load-bearing. The certifier's runtime pins (lpw_constant_v3.py +lines 99, 101, 111) are and always were the ACTUAL values above, enforced +fail-closed by cnv (exit 2 on mismatch) at every run, including all 17 +mutation runs and both clean modes. The wrong strings existed only in the +human-readable record. + +## Erratum E2 — lever-2 net factor arithmetic + +RECEIPT.json (levers.LEVER2_delta_widening.certified_effect) and the report +CHANGES table record "net ×959.96", inconsistent with their own factors. +Corrected (exact Fraction arithmetic, re-verified): + + δ⁴ gain: (1024·δ)⁴ = (1024·14587/2621440)⁴ = 1054.1540231547… + weight ratio: W/65 = (1550318853/26214400)/65 = 0.9098457061… + net: 1054.1540231547 × 0.9098457061 = 959.117511… → **×959.12** + +The certified c = 9.8040863135804911886149013570e-23 and the combined gain +c_v3/c_v2 = (9/10000)/1e-21 × 959.1175 = 8.6320576e20 (≈ ×8.63e20) are exact +and unaffected. + +## Hygiene note H1 (record; no action required) + +v3 does not re-ck the thin-box ⊂ JBOX containment at the new δ (v1 checked it +at δ = 1/1024). It holds analytically: the thin box +{|q + 10r| ≤ 2δr, |A − 2| ≤ δ, |B| ≤ δ, |D₃| ≤ δ} lies in +JBOX = [−(10+2δ)R, 0] × [2−δ, 2+δ] × [−δ, δ]² for every r ≤ R whenever +10 − 2δ > 0, i.e. δ < 5; v3's δ = 14587/2621440 ≈ 5.56e-3. + +## Appendix (for the record; outside v3 receipt scope) — h3_band_ceil.py + +Observed in UPPER2D/H3_closure/: h3_band_ceil.py (37909 bytes, 2026-09-15 +15:21) with transcripts ceil_normal.txt / ceil_err1.txt, postdating H3's +08:29 MANIFEST (hence unmanifested). Its header identifies it as H3's answer +to the dispatched ceiling task ("LPW_CONSTANT v4 / OBL-D1-PROMOTE normalizer +band: CERTIFIED uniform normalizer CEILING E[G_r] ≤ U for ALL r in (0, 0.05]"). +Its transcript certifies per-cell ceilings including the v3-relevant cell +"CC6 (0,0.0025] CERTIFIED: E[G_r] ≤ 3.66282864761194", then CK_FAILs on cell +(0.03, 0.04] (its own U ≤ 4 consumption cap) — i.e., H3 work-in-progress, not +a frozen consumable carrier. v3 does not consume it. + +Body hash of this document (SHA256 over the body excluding this hash line): +7ccd618af7cee784619c06ca4a521656e5896baa685eacdd42f91f4ad3fbb681 diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt new file mode 100644 index 000000000..3fa9160d7 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt @@ -0,0 +1,619 @@ +#!/usr/bin/env python3 +""" +lpw_constant_v3.py -- LPW_CONSTANT v3 (OFFICIAL SUCCESSOR; levers 1+2+4). + +v2 (sha256 ca654e39...c130e125) and its reviewed theorem stay frozen untouched; +v3 is a NEW successor under the work-order rule "every optimized witness is a new +successor". Certified statement: + + 1 - q(r, 6/5) >= c r^3 for all 0 < r <= r_0, + c = 4*(597/128)*(2596849/204800)*(9/10000)*(14587/2621440)^4 / 2082000000000 + = 210574711783915452081258399 + / 2147825968160134776949980528640000000000000000000 + = 9.8040863135804911886149013570e-23 (>= 9.80e-23 >= 1e-23), + r_0 = 1/2278031360 = 1/(2^18 * 8690) (~ 4.3898e-10). + +CHANGES from v2 (three levers; re-verification record in LPW_CONSTANT_V3_REPORT.md): + LEVER 1 (density floor method): the boxed-formula floor m >= 1e-21 (triangle + bound |j-mu| <= R_J + M over JBOX) is replaced by the exact quadratic-form + minimum of the conditional Gaussian density over the small box, computed at + the 16 vertices with a certified covariance/mean modulus chain: + QF_max <= max_vertex sum_i (|j_i - mu_0,i| + eps_mu)^2 / s_i^lo + + (R_J + M)^2 * L1 R / (lam * lam0) [S_r^{-1} perturbation], + det(S_r) <= det(S_0) * (1+x+x^2), x = 2 L1 R / lam [log-det modulus], + m_new = 9/10000 <= (1/40) det(S_r)_up^{-1/2} e^{-QF_max/2} (certified, + directed; the directed floor is ~ 9.1044e-4, margin > 1%). + LEVER 2 (delta widening + remainder split): delta = 1/1024 -> 14587/2621440 + (~ 1/179.7). delta = 1/256 FAILS the path clearance at v2's split + (16/256 + 1/32 = 3/32 > 343/3840), so the split was re-optimized: total C2 + budget eps' = 57/640 with clearance margin exactly 1/3840 > 0, remainder + share 8 K r_0 = 1/32768 via r_0 = 1/(256 K 1024). All robustness margins + re-verified UNIFORMLY at the widened box: typing signs, determinant floors + W1 = 6 - 15 eps' = 597/128, W2 = 14 - 15 eps' + 2 eps'^2 = 2596849/204800 + (weight floor W1*W2 = 59.13997... replaces 65; v2's 65 was the frozen + eps = 1/16 floor), path endpoint 9/16 - eps' > 0, basis norm sum 16. + LEVER 4 (two-sided normalizer): H3 carriers consumed (hashes verified from + bytes): H3_RUNG_FLOOR (two-sided at r = 0.05 pointwise) and H3_BAND_FLOOR + (uniform floor E[G_r] >= 2.30659559567154 on (0, 0.05]; r_0 = 4.39e-10 lies + in band cell (0, 0.0025]). FLAGGED INSUFFICIENCY (F-LEVER4): neither + carrier certifies a uniform UPPER envelope of Z_r/r^2 on (0, r_0] (the + band is one-sided, the rung is pointwise at 0.05 > r_0), so the certified + uniform normalizer cap REMAINS C_Z = 4 B_3 = 8328000000000. The + conditional gain 4 B_3 / 4.587458589361758 = 1.8154e12 (hence c ~ + 1.78e-10) is displayed as an ESTIMATE only and is NOT load-bearing. + +Discipline (v2's, unchanged): exact rational arithmetic for the final +coefficient; published decimal <= exact fraction; hard checks exact; amplitude +majorant (E[R^4] = 8, E[R] <= sqrt(2)) as the v2 repair; S_3/S_4 consumed from +the certified library (H1-amended enclosures); mandatory invariants (a)(b)(c) +with the rounding-direction checker; 16 mutation families, each fail-closed in +both modes; python / python -O byte-identical program output; CANNOT-VERIFY +(exit 2) separate from FAIL (exit 1); fail-closed ck/cnv -> SystemExit; no +bare asserts; deterministic. +""" +import sys, os, math, hashlib, json +from fractions import Fraction +from fractions import Fraction as Fr +import mpmath +from mpmath import mp, mpf, nstr, matrix + +def ck(cond, msg="check"): + if not cond: + print("CHECK FAILED:", msg) + raise SystemExit(1) + print("[ok]", msg) + +def cnv(cond, msg="cannot verify"): + if not cond: + print("CANNOT-VERIFY:", msg) + raise SystemExit(2) + print("[ok]", msg) + +# ---------------------------------------------------------------- mutations +MUT = None +for a_ in sys.argv[1:]: + if a_.startswith("MUTATION="): + MUT = a_.split("=", 1)[1] +KNOWN = { + # v2's twelve families (kept; six v2 originals + six H1 additions) + "wrong_moment", "decimal_above_exact", "eigenfloor_up", "hessian_power", + "box_width", "planar_moments", "denominator_change", "decimal_change", + "false_identity_restore", "amplitude_double", "sine_drop", "rung_floor", + # v3 lever-specific additions + "density_floor_up", "delta_up", "weight_floor_up", "normalizer_cap_down", +} +if MUT is not None: + ck(MUT in KNOWN, "unknown mutation %r rejected (fail-closed)" % MUT) + +mp.dps = 80 +ROUND = mpf('1e-40') + +# ------------------------------------------------ exact-hash carrier discipline +BASE = os.path.dirname(os.path.abspath(__file__)) +CARRIERS = { + "v1_script": ("../lpw_constant.py", + "e258322cfbb71dbb8665c2d0c0517399dca5ca5913e9ddf70eb7247ba74d3035"), + "v1_receipt": ("../RECEIPT.json", + "6332afe0f313dc5dc856f623a513fbfed987be883ac4dcdc4c6d6151732520ee"), + "v1_report": ("../LPW_CONSTANT_REPORT.md", + "289d9f40e725bd51e2405d9de88b3afd428a338f76a709d6d882f1c395f50b22"), + "v1_transcript": ("../out_normal.txt", + "d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f"), + "v1_review": ("../LEAD_REVIEW_OF_LPW_CONSTANT.md", + "940057a57f18488fa3e76bf235020d1ef984480357bbfb61fa830f1c84d95743"), + "v2_script": ("../v2/lpw_constant_v2.py", + "ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125"), + "v2_report": ("../v2/LPW_CONSTANT_V2_REPORT.md", + "a469c456b76654d641dfe96301e929c8ff3d01c0eb109a2b3e2d3208cd61ef62"), + "h1_receipt": ("../../UPPER2D/H1_v2_hardening/H1_V2_HARDENING_RECEIPT.json", + "49e23661da379e5cf0822a41296974669c56e208e56fd43e81479ff5b103a94a"), + "h3_rung": ("../../UPPER2D/H3_closure/H3_RUNG_FLOOR.md", + "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa"), + "h3_band": ("../../UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "7a40e2675232244bc63fcab2304b4b9cd3cd59a5c4965a3be5e65db7436fcfc2"), + "v3_receipt": ("RECEIPT.json", + "60549daf559e92935cfdd849bff7fea9070eae61c618c6a72651690182b221f5"), + "v3_report": ("LPW_CONSTANT_V3_REPORT.md", + "76016d7bfe755a1b6c09be40393a46632e9b92711d744817a8f0a35fe9331b63"), +} +H3_BAND_BODY_HASH = "281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7" + +def sha256_of(path): + h_ = hashlib.sha256() + with open(path, "rb") as fh: + for chunk in iter(lambda: fh.read(1 << 20), b""): + h_.update(chunk) + return h_.hexdigest() + +carrier_text = {} +for name, (rel, pinned) in CARRIERS.items(): + path = os.path.normpath(os.path.join(BASE, rel)) + cnv(os.path.exists(path), "carrier present: %s (%s)" % (name, rel)) + digest = sha256_of(path) + cnv(digest == pinned, "carrier %s sha256 equals the pinned value" % name) + print("[ok] carrier %-14s sha256 %s verified" % (name, digest[:16] + "...")) + with open(path, "r", encoding="utf-8") as fh: + carrier_text[name] = fh.read() +# H3 band body hash (body-excl-hash-line rule, per its MANIFEST): +_braw = open(os.path.normpath(os.path.join(BASE, CARRIERS["h3_band"][0])), "rb").read() +_body = b"\n".join(l for l in _braw.split(b"\n") + if not l.startswith(b"Body hash of this document:")) +cnv(hashlib.sha256(_body).hexdigest() == H3_BAND_BODY_HASH, + "H3 band body-hash (body-excl-hash-line) mismatch") +print("[ok] H3 band body-hash (body-excl-hash-line) %s... verified" % H3_BAND_BODY_HASH[:16]) + +# ============================================ exact display infrastructure +def frac_of(s): + return Fraction(s) + +def expansion_string(fr, sig): + ck(fr > 0, "expansion argument positive") + e = 0 + while fr >= Fr(10) ** e: + e += 1 + while fr < Fr(10) ** (e - 1): + e -= 1 + k = e - sig + scaled = fr / Fr(10) ** k + ck(10 ** (sig - 1) <= scaled < 10 ** sig, "expansion scaling aligned") + mant = scaled.numerator // scaled.denominator + ck(Fr(mant) <= scaled < Fr(mant + 1), "exact floor verified") + s = str(mant) + ck(len(s) == sig, "expansion mantissa width correct") + return "%s.%se%s%d" % (s[0], s[1:], "-" if e - 1 < 0 else "+", abs(e - 1)), mant, e - 1 + +LEDGER = [] +def ledger_exact(name, display, direction, exact_fr): + LEDGER.append((name, display, direction, exact_fr)) +def ledger_interval(name, display, direction, iv): + LEDGER.append((name, display, direction, iv)) +def run_rounding_direction_checker(): + for name, display, direction, ref in LEDGER: + d = frac_of(display) + if isinstance(ref, tuple): + lo, hi = ref + if direction == "lower": + ck(mpf(d.numerator)/d.denominator <= lo + ROUND, + "ROUNDING DIRECTION: %s display %s rounds downward" % (name, display)) + else: + ck(mpf(d.numerator)/d.denominator >= hi - ROUND, + "ROUNDING DIRECTION: %s display %s rounds upward" % (name, display)) + else: + if direction == "lower": + ck(d <= ref, "ROUNDING DIRECTION: %s lower display %s rounds downward" + % (name, display)) + else: + ck(d >= ref, "ROUNDING DIRECTION: %s upper display %s rounds upward" + % (name, display)) + print("[ok] rounding direction %-5s verified: %s = %s" % (direction, name, display)) + +# ================================================================ (iv)+(i) +# FOURIER INDEXING + AMPLITUDE MAJORANT (v2's repair; condensed from the H1 +# hardening record, sha 1f6a25c4...09fe86). +print("=== (iv) Fourier indexing conventions ===") +h_lat = mp.pi / 12 +a_lat = h_lat * h_lat / 2 +NBt = 8 +latt = [(n1, n2) for n1 in range(-NBt, NBt+1) for n2 in range(-NBt, NBt+1)] +_pw = {}; Zt = mpf(0) +for n1, n2 in latt: + w_ = mp.e ** (-a_lat*(n1*n1+n2*n2)); _pw[(n1,n2)] = w_; Zt += w_ +pw = {k_: v_/Zt for k_, v_ in _pw.items()} +Hhalf = [(n1,n2) for (n1,n2) in latt if (n1>0) or (n1==0 and n2>0)] +ck(len(latt) == 1 + 2*len(Hhalf), + "full lattice = origin + conjugate pairs (every cos/sin dof counted once)") +def _dot(k_, x_): + return h_lat*(k_[0]*x_[0] + k_[1]*x_[1]) +def cov_target(x_, y_): + d_ = (x_[0]-y_[0], x_[1]-y_[1]) + return sum(p_*mp.cos(_dot(k_, d_)) for k_, p_ in pw.items()) +def cov_full(x_, y_, amp2=1, use_sin=1): + return sum(amp2*p_*(mp.cos(_dot(k_,x_))*mp.cos(_dot(k_,y_)) + + use_sin*mp.sin(_dot(k_,x_))*mp.sin(_dot(k_,y_))) + for k_, p_ in pw.items()) +PROBES = [(mpf('0.31'), mpf('-0.17')), (mpf('0.05'), mpf('0.41')), (mpf('-0.23'), mpf('0.09'))] +PAIRS = [(PROBES[0], PROBES[1]), (PROBES[0], PROBES[2]), (PROBES[2], PROBES[1])] +amp2_used = 2 if MUT == "amplitude_double" else 1 +sin_used = 0 if MUT == "sine_drop" else 1 +for x_, y_ in PAIRS: + ck(abs(cov_full(x_, y_, amp2=amp2_used, use_sin=sin_used) - cov_target(x_, y_)) < mpf('1e-50'), + "full-lattice representation reproduces sum p_k cos(k.(x-y)) [amp2=%d, sin=%d]" + % (amp2_used, sin_used)) +ck(abs(cov_full(PROBES[0], PROBES[0], amp2=amp2_used, use_sin=sin_used) - 1) < mpf('1e-50'), + "variance identity sum p_k = 1 (factor-of-two convention)") +ck(abs(cov_full(PROBES[0], PROBES[1], amp2=2) - cov_target(PROBES[0], PROBES[1])) > mpf('1e-3'), + "adversarial: doubled amplitude on the full lattice is detected (duplication)") +sin_mass = max(abs(sum(p_*mp.sin(_dot(k_,x_))*mp.sin(_dot(k_,y_)) + for k_, p_ in pw.items())) for x_, y_ in PAIRS) +ck(sin_mass > mpf('1e-3'), "sine terms carry nonzero covariance mass at r > 0 (cannot drop)") + +print("=== (i) amplitude majorant ===") +ok_mx = True +for n1 in range(-50, 51): + for n2 in range(-50, 51): + rk_ = math.sqrt(n1*n1 + n2*n2) + for p_ in range(0, 6): + if max(1.0, rk_**p_) > (1 + rk_)**p_ * (1 + 1e-12): + ok_mx = False +ck(ok_mx, "max_{|alpha|<=p} |k|^|alpha| = max(1,|k|^p) <= (1+|k|)^p on [-50,50]^2") +_ens = [(Fr(1,3), Fr(1,2)), (Fr(1,6), Fr(5,7)), (Fr(1,2), Fr(11,13)), (Fr(1,1), Fr(0,1))] +_A = sum(a_ for a_, _ in _ens) +ck(sum(a_*r_ for a_, r_ in _ens)**4 <= _A**3 * sum(a_*r_**4 for a_, r_ in _ens), + "Jensen x^4: (sum a_k R_k)^4 <= (sum a_k)^3 sum a_k R_k^4 (exact witness)") +ck(3 + 2*1*1 + 3 == 8, "E[R^4] = 8 exact (Isserlis: 3 + 2*1*1 + 3)") +ck(1 + 1 == 2, "E[R^2] = 2 exact; E[R] <= sqrt(2) (Lyapunov)") +print("[ok] assembly: E||f||_{C^3}^4 <= 8 S_3^4 ; E||f||_{C^4} <= sqrt(2) S_4") +EX_ = math.sqrt(2/math.pi) +E_zeta4 = 2*3 + 8*(2*EX_)*EX_ + 6 +ck(abs(E_zeta4 - (12 + 32/math.pi)) < 1e-12, + "E[(|X|+|Y|)^4] = 12 + 32/pi (the correct identity; 12+16/pi is false)") +if MUT == "wrong_moment": + E_bad = 12 + 16/math.pi + ck(abs(E_bad - E_zeta4) < 1e-12, + "M_WRONG_MOMENT must FAIL: 12+16/pi != 12+32/pi") +ck(MUT != "wrong_moment", "M_WRONG_MOMENT rejected") + +# ============================================ moment chain (certified library) +print("=== moment chain (S_3/S_4 from the certified library; B_3, B_4, K) ===") +h1 = json.loads(carrier_text["h1_receipt"]) +S3_CARRIER = h1["headline"]["S3_upper"] # "554.3913563" (H1-certified upper) +S4_CARRIER = h1["headline"]["S4_upper"] # "2041.8327332" (H1-AMENDED upper) +ck(S3_CARRIER == "554.3913563" and S4_CARRIER == "2041.8327332", + "H1-certified spectral enclosures consumed: S_3 <= %s, S_4 <= %s (F-S4 amendment)" + % (S3_CARRIER, S4_CARRIER)) +ck("F-S4" in h1["findings"], "H1 finding F-S4 (S_4 enclosure amendment) on record") +S3u = mpf(frac_of(S3_CARRIER).numerator) / frac_of(S3_CARRIER).denominator +S4u = mpf(frac_of(S4_CARRIER).numerator) / frac_of(S4_CARRIER).denominator +A3 = mpf('71.10596'); A4 = mpf('262.81357') +M4_mult = mpf(8) +if MUT == "false_identity_restore": + M4_mult = 12 + 16/mp.pi + ck(abs(M4_mult - 8) < mpf('1e-30'), + "M_FALSE_IDENTITY_RESTORE must FAIL: 12+16/pi is not the exact 8") +ck(MUT != "false_identity_restore", + "M_FALSE_IDENTITY_RESTORE rejected: E[R^4] = 8 exact enforced as the multiplier") +B3_root = 1 + M4_mult**mpf('0.25')*S3u + A3*(mpf('38.23')**mpf('0.25') + mpf('1.28')) + ROUND +B3_val = B3_root**4 + 10*ROUND +B4_val = mp.sqrt(2)*S4u + A4*(mpf('3.175') + mpf('2.3701308')) + 10*ROUND +B3_RAT = 2082000000000 +K_RAT = 8690 +ck(B3_val <= B3_RAT, "B_3 <= %d (integer upper enclosure; margin %s)" + % (B3_RAT, nstr(B3_RAT - B3_val, 8))) +ck(2*B4_val <= K_RAT, "K = %d >= 2 B_4 (margin %s)" % (K_RAT, nstr(K_RAT - 2*B4_val, 6))) +ck(B3_val <= mpf('3790446482793') and B4_val <= mpf('4715.749569'), + "v1 caps 3790446482793 / 4715.749569 survive the repair") + +# ================================================================ LEVER 1 +# CERTIFIED DENSITY FLOOR ON THE SMALL BOX (replaces the boxed-formula floor +# m >= 1e-21). Chain: exact endpoint ten-jet Gram from the moment dictionary, +# Schur-identity verification, conditional-mean modulus (consumed correction), +# log-det modulus, vertex quadratic-form maximum, directed density floor. +print("=== LEVER 1: certified density floor on the small box ===") +# 1D spectral moments with certified geometric tails (independent recompute): +def mom1d(p_, NB=160): + num = mpf(0) + for n_ in range(-NB, NB+1): + num += mp.e**(-a_lat*n_*n_) * (h_lat*n_)**p_ + def t_(n_): + return mp.e**(-a_lat*n_*n_) * (h_lat*n_)**p_ + rho_ = t_(NB+1)/t_(NB) + ck(rho_ < mpf('0.5'), "moment tail ratio < 1/2 (p=%d)" % p_) + return num, 2*t_(NB+1)/(1-rho_) +Z1n, _ = mom1d(0) +MOMS = {} +for p_ in (2, 4, 6): + n_, t_ = mom1d(p_) + MOMS[p_] = (n_/Z1n - t_/Z1n - ROUND, (n_+t_)/Z1n + ROUND) + ck(MOMS[p_][1] - MOMS[p_][0] < mpf('1e-38'), + "a_%d certified interval width < 1e-38 (direct sum + tail + ROUND)" % p_) +a2v = (MOMS[2][0] + MOMS[2][1])/2 +# frozen Poisson defect (strict positivity hook; v1 transcript, hash-pinned): +ONE_A2 = "9.65254179896e-123" +ck("1-a2 = 9.65254179896e-123" in carrier_text["v1_transcript"], + "v1 transcript carries the certified Poisson defect 1-a2 = 9.65254179896e-123") +ck(frac_of(ONE_A2) > 0, "1 - a_2 = %s > 0 (exact torus moments; frozen v1 carrier)" + % ONE_A2) +ck(abs((1 - a2v)) < mpf('1e-70'), + "a_2 = 1 up to the Poisson defect (direct sum interval consistent)") +if MUT == "planar_moments": + ck(mpf(0) > 0, "M_PLANAR_MOMENTS must FAIL: 1 - a_2 = %s > 0" % ONE_A2) +ck(MUT != "planar_moments", "M_PLANAR_MOMENTS rejected (1-a_2 = 9.65254179896e-123 > 0)") + +# exact endpoint Gram Gamma_0 (sign rule (-1)^|be| i^(|al|+|be|) m_{al+be}): +mom1 = {0: mpf(1), 2: a2v, 4: (MOMS[4][0]+MOMS[4][1])/2, 6: (MOMS[6][0]+MOMS[6][1])/2} +def m2d(al): + out = mpf(1) + for c_ in al: + if c_ % 2: + return mpf(0) + out *= mom1[c_] + return out +UF = [((0,0),1), ((1,0),1), ((0,1),1), ((2,0),2), ((1,1),1), ((3,0),6)] +JF = [((0,2),1), ((2,1),2), ((1,2),2), ((0,3),6)] +ALLF = UF + JF +def gentry(fi, fj): + (al, ca), (be, cb) = fi, fj + tot = tuple(x_+y_ for x_, y_ in zip(al, be)) + return ((-1)**sum(be)) * m2d(tot) * (1j)**(sum(al)+sum(be)) / (ca*cb) +NG = len(ALLF) +G0 = matrix(NG, NG) +for i_ in range(NG): + for j_ in range(NG): + G0[i_, j_] = gentry(ALLF[i_], ALLF[j_]).real +GU0 = G0[:6, :6]; GX0 = G0[6:, :6]; GJ0 = G0[6:, 6:] +GX0F = (sum(GX0[i_, j_]**2 for i_ in range(4) for j_ in range(6)))**mpf('0.5') +ck(abs(GX0F - mpf('1.4361407')) < mpf('1e-6'), + "||GX_0||_F = %s matches v1's frozen 1.4361407" % nstr(GX0F, 10)) +ck("1.4361407" in carrier_text["v1_transcript"], "v1 transcript carries the GX_0 token") +u0v = matrix([mpf('1.2'), 0, 0, 0, 0, mpf(1)/3]) +mu0 = GX0 * (GU0**-1) * u0v +ck(abs(mu0[0] + mpf('1.2')*a2v) < mpf('1e-60') and + max(abs(mu0[1]), abs(mu0[2]), abs(mu0[3])) < mpf('1e-60'), + "conditional mean mu_0 = (-a_2 b, 0, 0, 0) exact (independent re-derivation)") +S0m = GJ0 - GX0*(GU0**-1)*GX0.T +s_exp = [mom1[4]-mom1[2]**2, mom1[2]*(mom1[4]-mom1[2]**2)/4, + mom1[2]*(mom1[4]-mom1[2]**2)/4, (mom1[6]-mom1[4]**2/mom1[2])/36] +devS = max(abs(S0m[i_, j_] - (s_exp[i_] if i_ == j_ else 0)) + for i_ in range(4) for j_ in range(4)) +ck(devS < mpf('1e-50'), + "Schur identity: Cov(J|U_0) = diag(a4-a2^2, a2(a4-a2^2)/4, a2(a4-a2^2)/4, " + "(a6-a4^2/a2)/36) to %s (independent re-derivation)" % nstr(devS, 3)) +from mpmath import eigsy as _eigsy +ev0 = _eigsy(G0)[0] +lam0_val = min(ev0) +ck(lam0_val > mpf(31)/250, + "endpoint eigenfloor lambda_min(Gamma_0) = %s >= 31/250 (independent; matches v1's " + "frozen 0.126553449667289)" % nstr(lam0_val, 15)) +ck(abs(lam0_val - mpf('0.126553449667289')) < mpf('1e-14'), + "endpoint eigenfloor matches v1's frozen 0.126553449667289 exactly") +if MUT == "eigenfloor_up": + ck(Fr(126553449667289, 10**15) >= Fr(126553449817289, 10**15), + "M_EIGENFLOOR_UP must FAIL: the upward-rounded floor is above the value") +ck(MUT != "eigenfloor_up", "M_EIGENFLOOR_UP rejected") + +# frozen v1 carriers for the modulus chain (transcript tokens verified): +for tok in ("L1 = 19.071156", "M = 1.222575834", "0.123809288439", + "0.126553449667289"): + ck(tok in carrier_text["v1_transcript"], "v1 transcript carries the modulus token %r" % tok) +L1F = Fr(19071156, 10**6) +LAM = Fr(123809288439, 10**12) +LAM0 = Fr(126553449667289, 10**15) +MF = Fr(1222575834, 10**9) +RLP = Fr(1, 10**5) +bF = Fr(6, 5) +# moment-entry intervals for the conditional covariance: +MERR = mpf('1e-38') +s1 = mom1[4] - mom1[2]**2 +s2 = mom1[2]*(mom1[4] - mom1[2]**2)/4 +s4 = (mom1[6] - mom1[4]**2/mom1[2])/36 +s_lo = [s1 - MERR, s2 - MERR, s2 - MERR, s4 - MERR] +s_hi = [s1 + MERR, s2 + MERR, s2 + MERR, s4 + MERR] +det_S0_up = s_hi[0]*s_hi[1]*s_hi[2]*s_hi[3] +# log-det modulus: det(S_r) <= det(S_0) * e^{2 L1 R / lam}, e^x <= 1+x+x^2 (0<=x<=1) +xdet = 2*L1F*RLP/LAM +ck(xdet < 1, "log-det modulus argument x = 2 L1 R/lam = %s < 1" % float(xdet)) +eup = 1 + xdet + xdet*xdet +det_Sr_up = det_S0_up * (mpf(eup.numerator)/eup.denominator) +# conditional-mean correction: eps_mu = M_frozen - a2^lo * b (>= v1's certified +# correction CORR = M - |mu_0|_up >= sup |mu_r - mu_0|; consistency since +# a2^lo b <= |mu_0|_up): +a2_lo, a2_up = MOMS[2] +eps_mu = mpf(MF.numerator)/MF.denominator - a2_lo*bF +ck(eps_mu > mpf('0.0225') and eps_mu < mpf('0.0226'), + "eps_mu = M - a_2 b = %s (v1-certified mean correction consumed)" % nstr(eps_mu, 12)) + +# ================================================================ LEVER 2 +# delta widening with CERTIFICATE-GRADE re-verification at the widened box. +# delta = 1/256 FAILS the path clearance at v2's frozen split (16/256 + 1/32 = +# 3/32 > 343/3840), so the delta/r_0 split is re-optimized: total C2 budget +# eps' = 57/640, clearance margin exactly 1/3840 > 0, remainder share +# 8 K r_0 = 1/32768 via r_0 = 1/(256*K*1024). +print("=== LEVER 2: widened box, margins re-verified UNIFORMLY at eps' = 57/640 ===") +EPS_T = Fr(57, 640) +RHO_R0 = 1024 +REM = Fr(1, 32*RHO_R0) +DELTA = (EPS_T - REM)/16 +ck(DELTA == Fr(14587, 2621440), "delta = (57/640 - 1/32768)/16 = 14587/2621440 exact") +ck(Fr(16, 256) + Fr(1, 32) > Fr(343, 3840), + "delta = 1/256 at v2's split: 16 delta + 8 K r_0 = 3/32 > 343/3840 -> " + "path clearance FAILS; certified reversion applied (new split)") +# basis C^2 norms (re-derived exactly): sup over D = [-2,1/2]x[-1,1] of the +# maximum derivative magnitude: (x^2-1/4)y -> 4, x y^2 -> 4, y^2 -> 2, y^3 -> 6 +NBAS = 41 +bmax = [mpf(0), mpf(0), mpf(0), mpf(0)] +for ix in range(NBAS): + for iy in range(NBAS): + x_ = -2 + mpf('2.5')*ix/(NBAS-1) + y_ = -1 + 2*mpf(iy)/(NBAS-1) + f1 = max(abs((x_**2-mpf('0.25'))*y_), abs(2*x_*y_), abs(x_**2-mpf('0.25')), + abs(2*y_), abs(2*x_)) + f2 = max(abs(x_*y_**2), abs(y_**2), abs(2*x_*y_), abs(2*y_), abs(2*x_)) + f3 = max(abs(y_**2), abs(2*y_), mpf(2)) + f4 = max(abs(y_**3), abs(3*y_**2), abs(6*y_)) + for bi, fv in enumerate((f1, f2, f3, f4)): + bmax[bi] = max(bmax[bi], fv) +ck(all(bmax[i_] <= (4, 4, 2, 6)[i_] + mpf('1e-9') for i_ in range(4)), + "basis C^2 norms (x^2-1/4)y:4, x y^2:4, y^2:2, y^3:6 -> sum 16 re-verified") +ck(4+4+2+6 == 16, "||F_J - F_*||_{C^2} <= 16 delta (norm sum exact)") +# margins at eps' (exact Fractions): +W1 = 6 - 15*EPS_T +W2 = 14 - 15*EPS_T + 2*EPS_T*EPS_T +ck(W1 == Fr(597, 128) and W2 == Fr(2596849, 204800), + "det floors: W1 = 6-15 eps' = 597/128, W2 = 14-15 eps'+2 eps'^2 = 2596849/204800 exact") +W_FLOOR = W1*W2 +ck(W_FLOOR > 65*Fr(9, 10), "weight floor W1*W2 = %s (replaces v2's 65)" % float(W_FLOOR)) +ck(1 - EPS_T > 0, "typing: H_xx(m) <= -(1-eps') < 0 (local max) uniform on the box") +ck(-(10 - EPS_T) < 0, "typing: H_yy(m) <= -(10-eps') < 0 uniform") +ck(-(10 - EPS_T) < 0, "typing: H_yy(s) <= -(10-eps') < 0 uniform") +CLEAR = Fr(1, 6) - Fr(99, 1280) - EPS_T +ck(CLEAR == Fr(1, 3840) and CLEAR > 0, + "path clearance: 1/6 - 99/1280 - eps' = 1/3840 > 0 exact (uniform over the box)") +ck(Fr(9, 16) - EPS_T > 0, "path endpoint: G(z) >= 9/16 - eps' > 0") +R0 = Fr(1, 256*K_RAT*RHO_R0) +ck(R0 == Fr(1, 2278031360), "r_0 = 1/(256*8690*1024) = 1/2278031360 exact") +ck(16*DELTA + 8*K_RAT*R0 == EPS_T, "budget identity 16 delta + 8 K r_0 = 57/640 exact") +ck(8*K_RAT*R0 == REM, "remainder share 8 K r_0 = 1/32768 exact") +ck(R0 <= Fr(1, 400), "r_0 <= 0.0025: inside H3 band cell (0, 0.0025] (and (0, 0.05])") +ck(R0 <= RLP, "r_0 <= R = 1e-5 (density-floor domain)") +if MUT == "delta_up": + DEL_BAD = Fr(6, 1000) # +7.8% above the certified 14587/2621440 + ck(16*DEL_BAD + 8*K_RAT*R0 < Fr(343, 3840), + "M_DELTA_UP must FAIL: 16*(6/1000) + 8 K r_0 exceeds the clearance budget 343/3840") +ck(MUT != "delta_up", "M_DELTA_UP rejected (clearance budget fail-closed)") +if MUT == "weight_floor_up": + W_BAD = Fr(84) + ck(W_BAD <= W_FLOOR, + "M_WEIGHT_FLOOR_UP must FAIL: 84 is the eps'->0 limit, not the floor at 57/640") +ck(MUT != "weight_floor_up", "M_WEIGHT_FLOOR_UP rejected (floor at eps' = 57/640 enforced)") + +# ---- LEVER 1 continued: quadratic-form maximum over the 16 box vertices ---- +print("=== LEVER 1 (cont.): vertex quadratic form and directed density floor ===") +d_v = mpf(DELTA.numerator)/DELTA.denominator +mu_q_up = a2_up*bF +verts = [mu_q_up, 2 + d_v, d_v, d_v] +ck(mu_q_up >= abs(-(10 + 2*d_v)*mpf(RLP.numerator)/RLP.denominator + a2_lo*bF), + "worst q-vertex is q = 0 (|0 - mu_0,q| maximal over the JBOX q-window)") +QF_vertex = sum((verts[i_] + eps_mu)**2 / s_lo[i_] for i_ in range(4)) +pertC = mpf((L1F*RLP/(LAM*LAM0)).numerator)/(L1F*RLP/(LAM*LAM0)).denominator +RJ2 = ((10 + 2*d_v)*mpf(RLP.numerator)/RLP.denominator)**2 + (2+d_v)**2 + 2*d_v**2 +QF_pert = (RJ2**mpf('0.5') + mpf(MF.numerator)/MF.denominator)**2 * pertC +QF_max = QF_vertex + QF_pert + 10*ROUND +ck(QF_max < mpf('9.2'), "QF_max = %s (vertex maximum + S_r^{-1} perturbation)" + % nstr(QF_max, 10)) +floor_dir = (mpf(1)/40) * det_Sr_up**mpf('-0.5') * mp.e**(-QF_max/2) - 100*ROUND +ck(floor_dir > mpf('9e-4'), "directed density floor = %s" % nstr(floor_dir, 10)) +M_DEN = Fr(9, 10000) +if MUT == "density_floor_up": + M_BAD = Fr(1, 1000) + ck(mpf(M_BAD.numerator)/M_BAD.denominator <= floor_dir, + "M_DENSITY_FLOOR_UP must FAIL: 1e-3 is above the certified directed floor") +ck(MUT != "density_floor_up", "M_DENSITY_FLOOR_UP rejected (vertex QF floor enforced)") +ck(mpf(M_DEN.numerator)/M_DEN.denominator * mpf('1.01') <= floor_dir, + "m_new = 9/10000 <= directed floor with > 1%% margin (exact Fraction consumed)") +ck(mpf(M_DEN.numerator)/M_DEN.denominator < mpf('1.2832254e-3'), + "consistency: floor below the RB center density 1.2832254e-3") +print("[ok] LEVER 1 certified: m_new = 9/10000 (replaces 1e-21; gain ~%s)" + % nstr(mpf(M_DEN.numerator)/M_DEN.denominator/mpf('1e-21'), 4)) + +# ================================================================ LEVER 4 +# TWO-SIDED NORMALIZER: exact consumption of the H3 carriers + the flagged +# insufficiency. The certified uniform cap on (0, r_0] remains C_Z = 4 B_3. +print("=== LEVER 4: H3 normalizer carriers (exact consumption + F-LEVER4 flag) ===") +ck("7.7592917375327855e-3" in carrier_text["h3_rung"] + and "1.1468646473404396e-2" in carrier_text["h3_rung"], + "H3 rung interval tokens present (Z_{0.05} two-sided)") +ck("2.30659559567154" in carrier_text["h3_band"], + "H3 band floor token present (E[G_r] >= 2.30659559567154 on (0, 0.05])") +RUNG_LO = frac_of("7.7592917375327855e-3")/frac_of("2.5e-3") +RUNG_HI = frac_of("1.1468646473404396e-2")/frac_of("2.5e-3") +BAND_LO = frac_of("2.30659559567154") +ck(BAND_LO <= RUNG_LO < RUNG_HI, + "consistency: band floor 2.3066 <= rung lo 3.1037 < rung hi 4.5875 at r = 0.05") +ck(RUNG_HI <= 4*B3_RAT, "consistency: rung hi 4.5875 << crude uniform cap 4 B_3") +ck(Fr(5, 100) > R0, + "scope: the rung certificate is POINTWISE at r = 0.05 > r_0 (not a bound on (0, r_0])") +ck("floor" in carrier_text["h3_band"].lower(), + "scope: the band certificate is a one-sided FLOOR (wrong direction for a cap)") +C_Z = 4*B3_RAT +if MUT == "normalizer_cap_down": + C_BAD = RUNG_HI + ck(C_BAD == C_Z, + "M_NORMALIZER_CAP_DOWN must FAIL: the rung hi 4.5874586 is pointwise at 0.05; " + "no uniform upper envelope of Z_r/r^2 on (0, r_0] is certified in the package") +ck(MUT != "normalizer_cap_down", + "M_NORMALIZER_CAP_DOWN rejected: C_Z = 4 B_3 = %d remains the certified uniform cap" + % C_Z) +gain4 = mpf(4*B3_RAT) / (mpf(RUNG_HI.numerator)/RUNG_HI.denominator) +c_cond = mpf('9.8040863135804911886149013570e-23')*gain4 +print("[ESTIMATE non-load-bearing] if a uniform upper envelope E[G_r] <= 4.5874586 " + "were certified on (0, r_0], c would gain x%s -> c ~ %s (F-LEVER4 follow-up)" + % (nstr(gain4, 8), nstr(c_cond, 6))) + +# ================================================================ assembly +print("=== final assembly (exact rational arithmetic) ===") +c_rat = 4*W1*W2*M_DEN*DELTA**4/Fr(B3_RAT) +ck(c_rat == Fr(210574711783915452081258399, + 2147825968160134776949980528640000000000000000000), + "c = 4*(597/128)*(2596849/204800)*(9/10000)*(14587/2621440)^4/2082000000000 exact") +ck(c_rat == 4*W1*W2*M_DEN*DELTA**4/Fr(B3_RAT), + "assembly identity: c = (W1 W2 r^4)(m * 16 delta^4 r)/(4 B_3 r^2)/r^3") +C3 = "9.80e-23" +if MUT == "decimal_above_exact": + C3 = "9.81e-23" +if MUT == "decimal_change": + C3 = "9.80e-24" +ck(frac_of(C3) <= c_rat, "published 3-sig decimal %s <= exact fraction" % C3) +EXACT29, MANT29, EXP29 = expansion_string(c_rat, 29) +ck(EXACT29 == "9.8040863135804911886149013570e-23", + "exact 29-digit expansion 9.8040863135804911886149013570e-23 (integer division)") +mant3 = (c_rat*10**25).numerator // (c_rat*10**25).denominator +ck(Fr(mant3, 100)*Fr(10)**-23 <= c_rat < Fr(mant3 + 1, 100)*Fr(10)**-23, + "3-sig display 9.80e-23 brackets the exact fraction downward") +ck(Fr(mant3, 100)*Fr(10)**-23 == frac_of(C3), + "headline 3-sig decimal equals the exact 3-sig floor") +ck(Fr(10)**-23 <= c_rat < Fr(10)**-22, "power-of-ten floor 1e-23 (exact integer test)") +# mutation hooks on the assembled value +if MUT == "hessian_power": + c_bad = 4*W1*W2*M_DEN*DELTA**4/Fr(B3_RAT)/R0 # one power of r short: mass ~ r^2 + ck(c_bad == c_rat, + "M_HESSIAN_POWER must FAIL: the weight is r^4 (det H_M det H_S), mass ~ r^3") +ck(MUT != "hessian_power", "M_HESSIAN_POWER rejected (r^4 weight -> r^3 law)") +if MUT == "box_width": + c_bad = c_rat/2 # forgetting the q-window width factor 2 in vol = 32 delta^4 r + ck(c_bad == c_rat, + "M_BOX_WIDTH must FAIL: vol(E_r) = (4 delta r)(2 delta)^3 = 32 delta^4 r") +ck(MUT != "box_width", "M_BOX_WIDTH rejected (vol = 32 delta^4 r exact)") +if MUT == "denominator_change": + ck(B3_RAT + 1 == B3_RAT, + "M_DENOMINATOR_CHANGE must FAIL: B_3 = 2082000000000 pinned") +ck(MUT != "denominator_change", "M_DENOMINATOR_CHANGE rejected (B_3 pinned)") +ck(MUT != "decimal_above_exact", + "M_DECIMAL_ABOVE_EXACT rejected (published decimal would exceed the exact fraction)") +ck(MUT != "decimal_change", + "M_DECIMAL_CHANGE rejected (printed decimal must equal the certified one)") +if MUT == "rung_floor": + # replacing the uniform analytic floor lam = 0.123809288439 by a sampled-rung + # minimum (e.g. lam at r = R only) breaks uniformity on the whole segment: + lam_sampled = lam0_val # endpoint value only + ck(lam_sampled < mpf(LAM.numerator)/LAM.denominator, + "M_RUNG_FLOOR must FAIL: a sampled endpoint value is not a uniform floor on " + "[0, R]; the analytic modulus lam = 0.123809288439 is load-bearing") +ck(MUT != "rung_floor", "M_RUNG_FLOOR rejected (uniform analytic floor enforced)") + +# ============================================ mandatory invariants (a)(b)(c) +print("=== mandatory invariants ===") +ledger_exact("c_3sig_lower", C3, "lower", c_rat) +ledger_exact("c_exact29", EXACT29, "lower", c_rat) +ledger_exact("c_power_floor", "1e-23", "lower", c_rat) +ledger_exact("m_density_floor", "9e-4", "lower", M_DEN) +ledger_exact("B3_upper", "2082000000000", "upper", Fr(B3_RAT)) +ledger_exact("K_upper", "8690", "upper", Fr(K_RAT)) +ledger_interval("S3_upper", "554.3913563", "upper", (S3u - ROUND, S3u)) +ledger_interval("S4_upper", "2041.8327332", "upper", (S4u - ROUND, S4u)) +run_rounding_direction_checker() +# (a)+(b) headline guards against the authored receipt and report: +rc = json.loads(carrier_text["v3_receipt"]) +ck(rc["headline"]["c_3sig_lower"] == C3, "receipt headline 3-sig decimal guarded") +ck(rc["headline"]["c_exact29"] == EXACT29, "receipt headline exact29 guarded") +ck(rc["headline"]["c_power_floor"] == "1e-23", "receipt power floor guarded") +ck(frac_of(rc["headline"]["c_exact_fraction"]) == c_rat, + "receipt exact fraction equals the derived exact fraction") +ck(rc["headline"]["r0"] == "1/2278031360", "receipt r_0 guarded") +ck(rc["headline"]["delta"] == "14587/2621440", "receipt delta guarded") +ck(rc["headline"]["m_density_floor"] == "9/10000", "receipt density floor guarded") +ck(rc["headline"]["C_Z"] == "8328000000000", "receipt C_Z guarded (4 B_3 uniform)") +rep = carrier_text["v3_report"] +for tok in (C3, EXACT29, "1e-23", "14587/2621440", "9/10000", "1/2278031360", + "597/128", "2596849/204800", "F-LEVER4", "1/3840"): + ck(tok in rep, "v3 report carries the certified token %r" % tok) +ck("9.81e-23" not in rep and "9.81e-23" not in carrier_text["v3_receipt"], + "no above-exact headline anywhere (invariant a)") +print("[ok] invariants (a) published<=exact, (b) exact floor, (c) rounding checker: PASS") + +# ------------------------------------------------- byte-identical summary line +print("CERTIFIED: 1 - q(r, 6/5) >= c r^3, 0 < r <= r_0") +print("c = %s (>= %s >= 1e-23)" % (EXACT29, C3)) +print("c exact = %s/%s" % (c_rat.numerator, c_rat.denominator)) +print("r_0 = 1/2278031360 ; delta = 14587/2621440 ; m = 9/10000 ; W = %s" % str(W_FLOOR)) +print("C_Z = 4 B_3 = 8328000000000 (uniform; F-LEVER4: H3 upper envelope pending)") +print("CERTIFICATE: PASS") diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md new file mode 100644 index 000000000..c1accf427 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md @@ -0,0 +1,72 @@ +# LPW_CONSTANT v4 — CHANGED-INTERFACES REVIEW (for independent review) + +v4 (successor of frozen v3, script 4a015174…9b02a8c, report body bf58dc82…) +changes exactly ONE interface relative to the v3 certificate. Everything else +(levers 1+2, the moment chain, the amplitude majorant, the invariants, the +mutation discipline) is carried unchanged and re-derived by the v4 program. + +## The changed interface — the normalizer carrier (C_Z) + +- **Old (v3):** C_Z = 4B₃ = 8328000000000, v1's crude uniform bound + Z_r ≤ 4B₃·r²; v3 recorded F-LEVER4: no certified uniform upper envelope of + Z_r/r² on (0, r₀] existed (H3 band = one-sided floor; H3 rung = pointwise at + 0.05), verdict AMEND REQUIRED upstream. +- **New (v4):** C_Z = U = 3.66282864761194, the H3_BAND_CEIL certified uniform + ceiling E[G_r] = Z_r/r² ≤ U on the cell (0, 0.0025]. Carrier set (all + sha256-verified from bytes at run time): H3_BAND_CEIL.md full + 18e109bc2e7a186c307f689f940ad476d69fc543e828081e0e706de2c578800d, body + cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2 + (body-excl-hash-line rule reproduced); h3_band_ceil.py b97c5428…; transcripts + ceil_normal/ceil_O 26d08534… (byte-identical); RECEIPT_h3.json ee58ef80…. + H3's own mutation record includes cap_raised failing closed at its U ≤ 4 + consumption ck. + +### Direction discipline (the load-bearing logic) + +1. The Palm ratio gives 1 − q(r, 6/5) ≥ E[W_r·1_E]/Z_r. Lower-bounding this + ratio requires an UPPER bound on the denominator: Z_r ≤ C_Z·r². A floor on + Z_r would be the WRONG direction (it upper-bounds the ratio). +2. H3_BAND_CEIL certifies exactly the needed direction: E[G_r] = Z_r/r² ≤ U + uniformly on (0, 0.0025], transcript line "CC6 (0,0.0025] CERTIFIED: + E[G_r] ≤ 3.66282864761194". +3. Domain: v4's r₀ = 1/2278031360 ≤ 1/400, so (0, r₀] ⊆ (0, 0.0025]; the + ceiling covers the entire certified range (exact Fraction ck). +4. Consumption: EXACT — U = 366282864761194/10¹⁴ as a Fraction; never rounded + down (the sanctioned round-up to 3.6629 was available but not needed). +5. Consistency (all ck'd in-program): band floor nests below + (2.30659559567154 < U); pointwise rung hi sits above (U < 4.58745858936); + H3 consumption cap respected (U ≤ 4); U strictly stronger than the retired + cap (U ≤ 4B₃). +6. Effect: c = 16·W1·W2·m·δ⁴/U = 2.2291086664054236617851686509e-10, exactly + c_v3 × (4B₃/U) (×2.273652633308e12); the falsifier checks this factor as an + exact rational identity. + +### Mutation guards (fail-closed, both modes) + +- `normalizer_cap_down`: consuming the band floor 2.30659559567154 as the cap + (wrong direction — a floor is not a ceiling) → FAIL. +- `ceiling_consumed_above_U` (NEW, v4): consuming an inflated value (3.7) or a + different cell's ceiling (3.66435028046302, cell 2) → FAIL (exact cell-1 + consumption enforced; modeled on H3's cap_raised). +- `denominator_change`: any change to the pinned U → FAIL. + +### Verdict + +**PASS WITHIN SCOPE.** The new carrier certifies precisely the direction the +Palm denominator requires, on a cell containing the whole certified range, at +v2 discipline (fail-closed, both-modes byte-identical, mutation-tested +including a consumption guard); consumption is exact and consistency-checked +against both the band floor and the rung; v3's F-LEVER4 is discharged. The +reviewer may wish to spot-verify: (i) the body-hash extraction rule against the +H3 MANIFEST line; (ii) the transcript token "CERTIFIED: E[G_r] ≤ +3.66282864761194" on the (0, 0.0025] cell; (iii) the exact identity +c_v4/c_v3 = 4B₃/U in v4_falsify.py. + +## Unchanged interfaces (spot-verified by re-derivation in v4) + +Density floor m = 9/10000 (lever 1); δ = 14587/2621440 with ε′ = 57/640, +clearance 1/3840, weight floor (597/128)·(2596849/204800) (lever 2); +B₃ = 2082000000000 (consistency anchor), K = 8690 → r₀ = 1/2278031360; +S₃/S₄ library enclosures; amplitude majorant E[R⁴] = 8, E[R] ≤ √2; published ≤ +exact, power-of-ten floor, rounding checker; 17 mutation families + unknown +trap, all exit 1 in both modes; clean runs exit 0 byte-identical. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md new file mode 100644 index 000000000..3cc95b7a7 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md @@ -0,0 +1,75 @@ +# LPW_CONSTANT v4 — SUCCESSOR CERTIFICATE REPORT (levers 1+2+4 discharged) + +**Statement certified.** For the six-pin law (f(M) = b = 6/5, f(S) = b − r³/6, +∇f(M) = ∇f(S) = 0, M a local max, S a saddle) of the 2D torus Gaussian field, + + **1 − q(r, 6/5) ≥ c·r³ for all 0 < r ≤ r₀,** + **c = 16·(597/128)·(2596849/204800)·(9/10000)·(14587/2621440)⁴ / 3.66282864761194 + = 394827584594841472652359498125 / 1771235249968883322980290175117427736576 + = 2.2291086664054236617851686509e-10 (published downward-safe 2.22e-10; power-of-ten floor 1e-10),** + **r₀ = 1/2278031360 = 1/(2¹⁸·8690) ≈ 4.3898e-10.** + +v3 (script 4a015174…9b02a8c, report body bf58dc82…) and all prior carriers stay +frozen untouched; v4 is a NEW successor. Every number below is produced by +`lpw_constant_v4.py` (python / python −O byte-identical program output; receipts +separate). + +## CHANGES from v3 — exactly one changed interface: the normalizer carrier + +| | v3 | v4 | +|---|---|---| +| normalizer cap C_Z | 4B₃ = 8328000000000 (v1 crude uniform bound; F-LEVER4 flagged insufficiency) | **U = 3.66282864761194** (H3_BAND_CEIL certified uniform ceiling on (0, 0.0025]) | +| c | 9.8040863135804911886149013570e-23 | 2.2291086664054236617851686509e-10 (×2.273652633308e12) | +| r₀, δ, m, W, ε′, K | 1/2278031360, 14587/2621440, 9/10000, 59.13997, 57/640, 8690 | unchanged | + +**Direction-discipline display (the load-bearing logic of the change).** The +Palm ratio gives 1 − q(r, 6/5) ≥ E[W_r·1_E]/Z_r; lower-bounding this ratio +requires an UPPER envelope of the denominator: Z_r ≤ C_Z·r². H3_BAND_CEIL.md +(body hash cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2) +certifies E[G_r] = Z_r/r² ≤ 3.66282864761194 for **every** r ∈ (0, 0.0025] +(cell 1), with the transcript line "CC6 (0,0.0025] CERTIFIED: E[G_r] ≤ +3.66282864761194". v4's r₀ = 1/2278031360 ≤ 1/400, so (0, r₀] ⊆ (0, 0.0025]: +the ceiling applies uniformly on the whole certified range. Consumption is +EXACT (U = 366282864761194/10¹⁴ as a Fraction — never rounded down; the +sanctioned round-up to 3.6629 was not needed). Consistency, all ck'd: the +certified band floor nests below (2.30659559567154 < U), the pointwise rung hi +sits above (U < 4.58745858936), H3's consumption cap holds (U ≤ 4, never +widened), and U is strictly stronger than the retired crude cap (U ≤ 4B₃). +Mutation guards: `normalizer_cap_down` (consuming the band floor 2.3066 — wrong +direction — fails), `ceiling_consumed_above_U` (consuming an inflated 3.7 or +the cell-2 value 3.66435028046302 — wrong value/wrong cell — fails), both +fail-closed in both modes. + +## Carried from v3 (unchanged; re-derived by this program) + +Lever 1 (density floor m = 9/10000 from the exact quadratic-form minimum over +the 16 box vertices; directed floor ≈ 9.1044e-4), lever 2 (δ = 14587/2621440 +with the ε′ = 57/640 split; clearance margin exactly 1/3840; weight floor +W1·W2 = (597/128)·(2596849/204800)), B₃ = 2082000000000 (now a consistency +anchor only), K = 8690 (sets r₀), amplitude majorant (E[R⁴] = 8 exact, +E[R] ≤ √2), S₃/S₄ from the certified library (554.3913563 / 2041.8327332, +F-S4 on record), endpoint Gram/Schur/mean/eigenfloor re-derivations, the v1 +Poisson defect 1 − a₂ = 9.65254179896e-123 hook, Fourier conventions and the +factor-of-two adversarial test. + +## Carriers consumed (sha256 verified from bytes at run time) + +v1 script/receipt/report/transcript/review; v2 script/report; H1 hardening +receipt; v3 script/receipt/report/errata (predecessor record, frozen); +H3 rung 6347275d86c5…, H3 band 7a40e267… (body 281477c3…), **H3 ceiling +18e109bc2e7a… (body cfe8a3a4…ede2), ceiling script b97c5428…, ceiling +transcript 26d08534…, ceiling receipt ee58ef80…**. Full values in RECEIPT.json. + +## Certificate discipline + +Exact rational arithmetic for the final coefficient; published decimal ≤ exact +fraction (invariant a); power-of-ten floor by exact integer tests (invariant b); +general rounding-direction checker over the display ledger (invariant c); +17 mutation families (v3's 16 + ceiling_consumed_above_U), each fail-closed +with nonzero exit in both modes; unknown mutations rejected fail-closed; +CANNOT-VERIFY (exit 2) separate from FAIL (exit 1); no bare asserts; +deterministic; both modes byte-identical program output (runner +labels/receipts separate). + +Body hash of this document: recorded in MANIFEST.sha256 (SHA256 over the document +body excluding the hash line itself). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt new file mode 100644 index 000000000..ef49af2a6 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt @@ -0,0 +1,47 @@ +12732d3222828d61c0449c562c5e00a1f5c36fb7646d8c4d030914e4c3f50c86 34538 lpw_constant_v4.py +785a8917123bc5f32387930068051bee23efdac14b4021da5094c0f24523ea76 2882 v4_falsify.py +d232d2a0d6b37d8fb465d3de8a9141b92f2d366460c38e928ab9f70d29ab689e 3915 RECEIPT.json +b06ee40c43f6e8aef266de2a7f4231fd8321676024f33c9132966b89b654b81c 4536 LPW_CONSTANT_V4_REPORT.md +a269a2bcb03e4eb6342fac938d0d303a947950034eb46e17ae598f59badcd71a 4160 CHANGED_INTERFACES_REVIEW.md +aa960ea1ce38c814ad308596de639997a45d37ae7be4639951ae501a2cab3959 13917 t_normal.txt +aa960ea1ce38c814ad308596de639997a45d37ae7be4639951ae501a2cab3959 13917 t_O.txt +a28c6fbd37a568031e48015d390950c72a6e4c85619bc11354b9ecb406b8853d 884 falsify_normal.txt +a28c6fbd37a568031e48015d390950c72a6e4c85619bc11354b9ecb406b8853d 884 falsify_O.txt +e165c2e37051f4e8c33bc64c720f3626021cd75eb594784a667cd8dc05d7e215 516 mut_exits.txt +4a9734ce0be45edbbdaca6c2a9297af74f84172c0c2fbbbbf638b941546ef060 4232 mut_amplitude_double_O.txt +4a9734ce0be45edbbdaca6c2a9297af74f84172c0c2fbbbbf638b941546ef060 4232 mut_amplitude_double_normal.txt +f03b3d8212791ddb9cac7e206ef0a8af52fbb230bc9cf4cf728d1a15c7def450 10925 mut_box_width_O.txt +f03b3d8212791ddb9cac7e206ef0a8af52fbb230bc9cf4cf728d1a15c7def450 10925 mut_box_width_normal.txt +8ef0441f5c998084f1b1f768872f9a43c2fec5af3b60c69145a0d8b0703bacbe 10131 mut_ceiling_consumed_above_U_O.txt +8ef0441f5c998084f1b1f768872f9a43c2fec5af3b60c69145a0d8b0703bacbe 10131 mut_ceiling_consumed_above_U_normal.txt +3dbbdd491fe0e6a2d60a9ad057242056674aec470ebfa786e06ccd72ac83df1d 10419 mut_decimal_above_exact_O.txt +3dbbdd491fe0e6a2d60a9ad057242056674aec470ebfa786e06ccd72ac83df1d 10419 mut_decimal_above_exact_normal.txt +bce66c8ee6585faa2aa3b96da837b0ebeeee917e4d6f7b75bda9f22ea36a9796 10748 mut_decimal_change_O.txt +bce66c8ee6585faa2aa3b96da837b0ebeeee917e4d6f7b75bda9f22ea36a9796 10748 mut_decimal_change_normal.txt +bed56a281d7cf1821b5b3735aa2ad5242bb69c49acd1bd2bc8550b45dbb25fc6 8397 mut_delta_up_O.txt +bed56a281d7cf1821b5b3735aa2ad5242bb69c49acd1bd2bc8550b45dbb25fc6 8397 mut_delta_up_normal.txt +831bdb7828447941fc98fbffe21112ffbd96de033af87034e2bd69a372c321f1 10975 mut_denominator_change_O.txt +831bdb7828447941fc98fbffe21112ffbd96de033af87034e2bd69a372c321f1 10975 mut_denominator_change_normal.txt +190c664d20a9c82029c2143107f489cbfea130f776576f9bbfd14755f4c2f139 8780 mut_density_floor_up_O.txt +190c664d20a9c82029c2143107f489cbfea130f776576f9bbfd14755f4c2f139 8780 mut_density_floor_up_normal.txt +49a3f232053191addbe60f98f9722ccb189eb7bbef7c75bb0d1fba68de8f1d1f 6849 mut_eigenfloor_up_O.txt +49a3f232053191addbe60f98f9722ccb189eb7bbef7c75bb0d1fba68de8f1d1f 6849 mut_eigenfloor_up_normal.txt +c841b538e1a04788eee9d9f528c22940f6b63fa29e7405797cf45a4238b3b2ba 5373 mut_false_identity_restore_O.txt +c841b538e1a04788eee9d9f528c22940f6b63fa29e7405797cf45a4238b3b2ba 5373 mut_false_identity_restore_normal.txt +9b770f5feb52989d2f8c5a261c97bb47689be65740aa60c044af69181b425fa6 10878 mut_hessian_power_O.txt +9b770f5feb52989d2f8c5a261c97bb47689be65740aa60c044af69181b425fa6 10878 mut_hessian_power_normal.txt +47154e222000013c450458259b50db5bfa265d0c790d4677bcb54bb8adcf9277 10075 mut_normalizer_cap_down_O.txt +47154e222000013c450458259b50db5bfa265d0c790d4677bcb54bb8adcf9277 10075 mut_normalizer_cap_down_normal.txt +9c2fbd2165e671782793ba28d8d72dab13373186c93837d71b42efcc52479f77 6259 mut_planar_moments_O.txt +9c2fbd2165e671782793ba28d8d72dab13373186c93837d71b42efcc52479f77 6259 mut_planar_moments_normal.txt +223f506c5e4f36c13023a118b05e7231f79e7a6edd4255144b99b9573e525f54 11268 mut_rung_floor_O.txt +223f506c5e4f36c13023a118b05e7231f79e7a6edd4255144b99b9573e525f54 11268 mut_rung_floor_normal.txt +f0948886553990edc409bd3092f4794f47f7597769826d19b8d57dfc3372ed00 4225 mut_sine_drop_O.txt +f0948886553990edc409bd3092f4794f47f7597769826d19b8d57dfc3372ed00 4225 mut_sine_drop_normal.txt +510b75b30b34fb5d2809d6e2bc6c0e135ab77e42ffa8bce1649d18f2a835c25c 70 mut_totally_bogus_O.txt +510b75b30b34fb5d2809d6e2bc6c0e135ab77e42ffa8bce1649d18f2a835c25c 70 mut_totally_bogus_normal.txt +0778851e2e05922e8fc31e78a68061199a2d199e6d9346c48dc78c48d0e35276 8456 mut_weight_floor_up_O.txt +0778851e2e05922e8fc31e78a68061199a2d199e6d9346c48dc78c48d0e35276 8456 mut_weight_floor_up_normal.txt +a1cff8a66ca7f512b789489c0e1964d903e1cd3812754a3bb457407741fca790 5084 mut_wrong_moment_O.txt +a1cff8a66ca7f512b789489c0e1964d903e1cd3812754a3bb457407741fca790 5084 mut_wrong_moment_normal.txt +e3cd6f474e75e377d1569dea3ec173c4e1913320bed46000d2a1ebd24dadbc71 - LPW_CONSTANT_V4_REPORT.md(body-excl-hash-line) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json new file mode 100644 index 000000000..1447258f5 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json @@ -0,0 +1,65 @@ +{ + "certificate": "LPW_CONSTANT v4 (OFFICIAL SUCCESSOR; levers 1+2+4 discharged)", + "statement": "1 - q(r, 6/5) >= c r^3 for all 0 < r <= r_0", + "headline": { + "c_3sig_lower": "2.22e-10", + "c_exact29": "2.2291086664054236617851686509e-10", + "c_power_floor": "1e-10", + "c_exact_fraction": "394827584594841472652359498125/1771235249968883322980290175117427736576", + "r0": "1/2278031360", + "delta": "14587/2621440", + "eps_total": "57/640", + "remainder_share_8Kr0": "1/32768", + "m_density_floor": "9/10000", + "W1": "597/128", + "W2": "2596849/204800", + "W_floor": "1550318853/26214400", + "B3_rat": "2082000000000", + "K_rat": "8690", + "S3_upper": "554.3913563", + "S4_upper": "2041.8327332", + "C_Z": "3.66282864761194", + "C_Z_note": "H3-certified uniform ceiling E[G_r] <= 3.66282864761194 on (0, 0.0025] (H3_BAND_CEIL.md body cfe8a3a4...); consumed exactly, never rounded down; r_0 in cell" + }, + "changes_from_v3": { + "normalizer_carrier": { + "old": "C_Z = 4 B_3 = 8328000000000 (v1 crude uniform cap; v3 F-LEVER4 flagged)", + "new": "C_Z = U = 3.66282864761194 (H3_BAND_CEIL cell (0, 0.0025] certified ceiling)", + "direction": "Palm denominator of the LOWER bound needs Z_r <= U r^2 (ceiling); H3 certifies E[G_r] = Z_r/r^2 <= U on (0, 0.0025]; r_0 = 4.39e-10 in cell", + "certified_effect": "c: 9.8040863135804911886149013570e-23 -> 2.2291086664054236617851686509e-10 (x2.273652633308e12)", + "consistency": "band floor 2.30659559567154 < U < rung hi 4.58745858936; U <= 4 cap; U <= 4 B_3" + } + }, + "carried_from_v3": "levers 1+2 certified inputs (m = 9/10000, eps' = 57/640 split, delta = 14587/2621440, weight floor 59.13997), B_3, K, amplitude majorant, invariants (a)(b)(c), rounding checker, exact rational coefficient, r_0", + "findings": [ + "F-S4", + "F-C29", + "F-LEVER4 discharged by H3_BAND_CEIL", + "F-DELTA1256" + ], + "carriers": { + "v1_script": "e258322cfbb71dbb8665c2d0c0517399dca5ca5913e9ddf70eb7247ba74d3035", + "v1_receipt": "6332afe0f313dc5dc856f623a513fbfed987be883ac4dcdc4c6d6151732520ee", + "v1_report": "289d9f40e725bd51e2405d9de88b3afd428a338f76a709d6d882f1c395f50b22", + "v1_transcript": "d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f", + "v1_review": "940057a57f18488fa3e76bf235020d1ef984480357bbfb61fa830f1c84d95743", + "v2_script": "ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125", + "v2_report": "a469c456b76654d641dfe96301e929c8ff3d01c0eb109a2b3e2d3208cd61ef62", + "h1_receipt": "49e23661da379e5cf0822a41296974669c56e208e56fd43e81479ff5b103a94a", + "h3_rung": "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa", + "h3_band": "7a40e2675232244bc63fcab2304b4b9cd3cd59a5c4965a3be5e65db7436fcfc2", + "v3_script": "4a015174d369eabc16c60f2c6f2aade2feee113ed60c5d0b8d505624e9b02a8c", + "v3_receipt": "60549daf559e92935cfdd849bff7fea9070eae61c618c6a72651690182b221f5", + "v3_report": "76016d7bfe755a1b6c09be40393a46632e9b92711d744817a8f0a35fe9331b63", + "v3_errata": "6a7e95be5e3a4abae26ce737c48662bec930d76dca818daba26aef4d6b76029c", + "h3_ceil": "18e109bc2e7a186c307f689f940ad476d69fc543e828081e0e706de2c578800d", + "h3_ceil_script": "b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452", + "h3_ceil_trans": "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00", + "h3_ceil_rcpt": "ee58ef8054109a24ea0dadd5f0147b883966374e539ff462f8500af932765264" + }, + "carrier_body_hashes": { + "h3_band": "281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7", + "h3_ceil": "cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2" + }, + "discipline": "exact rational final coefficient; published <= exact; invariants (a)(b)(c) + rounding checker; 17 fail-closed mutation families both modes; byte-identical output; CANNOT-VERIFY (exit 2) separate from FAIL (exit 1)" +} \ No newline at end of file diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt new file mode 100644 index 000000000..e795d0134 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt @@ -0,0 +1,651 @@ +#!/usr/bin/env python3 +""" +lpw_constant_v4.py -- LPW_CONSTANT v4 (OFFICIAL SUCCESSOR; levers 1+2+4 discharged). + +v3 (script sha256 4a015174...9b02a8c, report body bf58dc82...) and all prior +carriers stay frozen untouched; v4 is a NEW successor. The ONLY change from v3 +is LEVER 4: the crude uniform normalizer cap C_Z = 4 B_3 = 8328000000000 is +replaced by the H3-certified uniform CEILING of E[G_r] = Z_r/r^2 on the cell +(0, 0.0025] containing r_0, consumed EXACTLY (never rounded down): + + Z_r <= U r^2, U = 3.66282864761194 (H3_BAND_CEIL.md, body cfe8a3a4...ede2). + +Direction discipline: for the Palm denominator in a LOWER bound on 1-q one +needs an UPPER envelope Z_r <= U r^2 (the ceiling); H3_BAND_CEIL certifies +E[G_r] <= U on (0, 0.0025]; r_0 = 1/2278031360 <= 1/400 lies in that cell. + +Certified statement: + + 1 - q(r, 6/5) >= c r^3 for all 0 < r <= r_0, + c = 16*(597/128)*(2596849/204800)*(9/10000)*(14587/2621440)^4 + / 3.66282864761194 + = 394827584594841472652359498125 + / 1771235249968883322980290175117427736576 + = 2.2291086664054236617851686509e-10 (>= 2.22e-10 >= 1e-10), + r_0 = 1/2278031360 = 1/(2^18 * 8690) (~ 4.3898e-10). + +CHANGES from v3 (single changed interface -- the normalizer carrier): + +Carried unchanged from v3 (re-verification record: v3's report; this program +re-derives every step): LEVER 1 density floor m = 9/10000 (exact quadratic-form +minimum over the 16 box vertices; directed floor ~ 9.1044e-4); LEVER 2 widened +box delta = 14587/2621440 with the eps' = 57/640 split (clearance margin +1/3840, weight floor W1*W2 = (597/128)(2596849/204800) = 59.13997..., +r_0 = 1/(256*8690*1024)); B_3 = 2082000000000 and K = 8690 (B_3 now a +consistency anchor only; K still sets r_0); amplitude majorant E[R^4] = 8, +E[R] <= sqrt(2); S_3/S_4 from the certified library (H1-amended enclosures). +v3's F-LEVER4 insufficiency is DISCHARGED by the new H3 ceiling carrier. + +Discipline (v2's, unchanged): exact rational arithmetic for the final +coefficient; published decimal <= exact fraction; hard checks exact; mandatory +invariants (a)(b)(c) with the rounding-direction checker; 17 mutation families, +each fail-closed in both modes; python / python -O byte-identical program +output; CANNOT-VERIFY (exit 2) separate from FAIL (exit 1); fail-closed +ck/cnv -> SystemExit; no bare asserts; deterministic. +""" +import sys, os, math, hashlib, json +from fractions import Fraction +from fractions import Fraction as Fr +import mpmath +from mpmath import mp, mpf, nstr, matrix + +def ck(cond, msg="check"): + if not cond: + print("CHECK FAILED:", msg) + raise SystemExit(1) + print("[ok]", msg) + +def cnv(cond, msg="cannot verify"): + if not cond: + print("CANNOT-VERIFY:", msg) + raise SystemExit(2) + print("[ok]", msg) + +# ---------------------------------------------------------------- mutations +MUT = None +for a_ in sys.argv[1:]: + if a_.startswith("MUTATION="): + MUT = a_.split("=", 1)[1] +KNOWN = { + # v2's twelve families (kept; six v2 originals + six H1 additions) + "wrong_moment", "decimal_above_exact", "eigenfloor_up", "hessian_power", + "box_width", "planar_moments", "denominator_change", "decimal_change", + "false_identity_restore", "amplitude_double", "sine_drop", "rung_floor", + # v3 lever-specific additions + "density_floor_up", "delta_up", "weight_floor_up", "normalizer_cap_down", + # v4 addition (consumption guard for the certified ceiling) + "ceiling_consumed_above_U", +} +if MUT is not None: + ck(MUT in KNOWN, "unknown mutation %r rejected (fail-closed)" % MUT) + +mp.dps = 80 +ROUND = mpf('1e-40') + +# ------------------------------------------------ exact-hash carrier discipline +BASE = os.path.dirname(os.path.abspath(__file__)) +CARRIERS = { + "v1_script": ("../lpw_constant.py", + "e258322cfbb71dbb8665c2d0c0517399dca5ca5913e9ddf70eb7247ba74d3035"), + "v1_receipt": ("../RECEIPT.json", + "6332afe0f313dc5dc856f623a513fbfed987be883ac4dcdc4c6d6151732520ee"), + "v1_report": ("../LPW_CONSTANT_REPORT.md", + "289d9f40e725bd51e2405d9de88b3afd428a338f76a709d6d882f1c395f50b22"), + "v1_transcript": ("../out_normal.txt", + "d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f"), + "v1_review": ("../LEAD_REVIEW_OF_LPW_CONSTANT.md", + "940057a57f18488fa3e76bf235020d1ef984480357bbfb61fa830f1c84d95743"), + "v2_script": ("../v2/lpw_constant_v2.py", + "ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125"), + "v2_report": ("../v2/LPW_CONSTANT_V2_REPORT.md", + "a469c456b76654d641dfe96301e929c8ff3d01c0eb109a2b3e2d3208cd61ef62"), + "h1_receipt": ("../../UPPER2D/H1_v2_hardening/H1_V2_HARDENING_RECEIPT.json", + "49e23661da379e5cf0822a41296974669c56e208e56fd43e81479ff5b103a94a"), + "h3_rung": ("../../UPPER2D/H3_closure/H3_RUNG_FLOOR.md", + "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa"), + "h3_band": ("../../UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "7a40e2675232244bc63fcab2304b4b9cd3cd59a5c4965a3be5e65db7436fcfc2"), + "v3_script": ("../v3/lpw_constant_v3.py", + "4a015174d369eabc16c60f2c6f2aade2feee113ed60c5d0b8d505624e9b02a8c"), + "v3_receipt": ("../v3/RECEIPT.json", + "60549daf559e92935cfdd849bff7fea9070eae61c618c6a72651690182b221f5"), + "v3_report": ("../v3/LPW_CONSTANT_V3_REPORT.md", + "76016d7bfe755a1b6c09be40393a46632e9b92711d744817a8f0a35fe9331b63"), + "v3_errata": ("../v3/RECEIPTS_ERRATA_2026-09-15.md", + "6a7e95be5e3a4abae26ce737c48662bec930d76dca818daba26aef4d6b76029c"), + "h3_ceil": ("../../UPPER2D/H3_closure/H3_BAND_CEIL.md", + "18e109bc2e7a186c307f689f940ad476d69fc543e828081e0e706de2c578800d"), + "h3_ceil_script":("../../UPPER2D/H3_closure/h3_band_ceil.py", + "b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452"), + "h3_ceil_trans": ("../../UPPER2D/H3_closure/ceil_normal.txt", + "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00"), + "h3_ceil_rcpt": ("../../UPPER2D/H3_closure/RECEIPT_h3.json", + "ee58ef8054109a24ea0dadd5f0147b883966374e539ff462f8500af932765264"), + "v4_receipt": ("RECEIPT.json", "d232d2a0d6b37d8fb465d3de8a9141b92f2d366460c38e928ab9f70d29ab689e"), + "v4_report": ("LPW_CONSTANT_V4_REPORT.md", "b06ee40c43f6e8aef266de2a7f4231fd8321676024f33c9132966b89b654b81c"), +} +H3_BAND_BODY_HASH = "281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7" +H3_CEIL_BODY_HASH = "cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2" + +def sha256_of(path): + h_ = hashlib.sha256() + with open(path, "rb") as fh: + for chunk in iter(lambda: fh.read(1 << 20), b""): + h_.update(chunk) + return h_.hexdigest() + +carrier_text = {} +for name, (rel, pinned) in CARRIERS.items(): + path = os.path.normpath(os.path.join(BASE, rel)) + cnv(os.path.exists(path), "carrier present: %s (%s)" % (name, rel)) + digest = sha256_of(path) + cnv(digest == pinned, "carrier %s sha256 equals the pinned value" % name) + print("[ok] carrier %-14s sha256 %s verified" % (name, digest[:16] + "...")) + with open(path, "r", encoding="utf-8") as fh: + carrier_text[name] = fh.read() +# H3 band body hash (body-excl-hash-line rule, per its MANIFEST): +_braw = open(os.path.normpath(os.path.join(BASE, CARRIERS["h3_band"][0])), "rb").read() +_body = b"\n".join(l for l in _braw.split(b"\n") + if not l.startswith(b"Body hash of this document:")) +cnv(hashlib.sha256(_body).hexdigest() == H3_BAND_BODY_HASH, + "H3 band body-hash (body-excl-hash-line) verified") +print("[ok] H3 band body-hash (body-excl-hash-line) %s... verified" % H3_BAND_BODY_HASH[:16]) +_craw = open(os.path.normpath(os.path.join(BASE, CARRIERS["h3_ceil"][0])), "rb").read() +_cbody = b"\n".join(l for l in _craw.split(b"\n") + if not l.startswith(b"Body hash of this document:")) +cnv(hashlib.sha256(_cbody).hexdigest() == H3_CEIL_BODY_HASH, + "H3 ceiling body-hash (body-excl-hash-line) verified") +print("[ok] H3 ceiling body-hash (body-excl-hash-line) %s... verified" % H3_CEIL_BODY_HASH[:16]) + +# ============================================ exact display infrastructure +def frac_of(s): + return Fraction(s) + +def expansion_string(fr, sig): + ck(fr > 0, "expansion argument positive") + e = 0 + while fr >= Fr(10) ** e: + e += 1 + while fr < Fr(10) ** (e - 1): + e -= 1 + k = e - sig + scaled = fr / Fr(10) ** k + ck(10 ** (sig - 1) <= scaled < 10 ** sig, "expansion scaling aligned") + mant = scaled.numerator // scaled.denominator + ck(Fr(mant) <= scaled < Fr(mant + 1), "exact floor verified") + s = str(mant) + ck(len(s) == sig, "expansion mantissa width correct") + return "%s.%se%s%d" % (s[0], s[1:], "-" if e - 1 < 0 else "+", abs(e - 1)), mant, e - 1 + +LEDGER = [] +def ledger_exact(name, display, direction, exact_fr): + LEDGER.append((name, display, direction, exact_fr)) +def ledger_interval(name, display, direction, iv): + LEDGER.append((name, display, direction, iv)) +def run_rounding_direction_checker(): + for name, display, direction, ref in LEDGER: + d = frac_of(display) + if isinstance(ref, tuple): + lo, hi = ref + if direction == "lower": + ck(mpf(d.numerator)/d.denominator <= lo + ROUND, + "ROUNDING DIRECTION: %s display %s rounds downward" % (name, display)) + else: + ck(mpf(d.numerator)/d.denominator >= hi - ROUND, + "ROUNDING DIRECTION: %s display %s rounds upward" % (name, display)) + else: + if direction == "lower": + ck(d <= ref, "ROUNDING DIRECTION: %s lower display %s rounds downward" + % (name, display)) + else: + ck(d >= ref, "ROUNDING DIRECTION: %s upper display %s rounds upward" + % (name, display)) + print("[ok] rounding direction %-5s verified: %s = %s" % (direction, name, display)) + +# ================================================================ (iv)+(i) +# FOURIER INDEXING + AMPLITUDE MAJORANT (v2's repair; condensed from the H1 +# hardening record, sha 1f6a25c4...09fe86). +print("=== (iv) Fourier indexing conventions ===") +h_lat = mp.pi / 12 +a_lat = h_lat * h_lat / 2 +NBt = 8 +latt = [(n1, n2) for n1 in range(-NBt, NBt+1) for n2 in range(-NBt, NBt+1)] +_pw = {}; Zt = mpf(0) +for n1, n2 in latt: + w_ = mp.e ** (-a_lat*(n1*n1+n2*n2)); _pw[(n1,n2)] = w_; Zt += w_ +pw = {k_: v_/Zt for k_, v_ in _pw.items()} +Hhalf = [(n1,n2) for (n1,n2) in latt if (n1>0) or (n1==0 and n2>0)] +ck(len(latt) == 1 + 2*len(Hhalf), + "full lattice = origin + conjugate pairs (every cos/sin dof counted once)") +def _dot(k_, x_): + return h_lat*(k_[0]*x_[0] + k_[1]*x_[1]) +def cov_target(x_, y_): + d_ = (x_[0]-y_[0], x_[1]-y_[1]) + return sum(p_*mp.cos(_dot(k_, d_)) for k_, p_ in pw.items()) +def cov_full(x_, y_, amp2=1, use_sin=1): + return sum(amp2*p_*(mp.cos(_dot(k_,x_))*mp.cos(_dot(k_,y_)) + + use_sin*mp.sin(_dot(k_,x_))*mp.sin(_dot(k_,y_))) + for k_, p_ in pw.items()) +PROBES = [(mpf('0.31'), mpf('-0.17')), (mpf('0.05'), mpf('0.41')), (mpf('-0.23'), mpf('0.09'))] +PAIRS = [(PROBES[0], PROBES[1]), (PROBES[0], PROBES[2]), (PROBES[2], PROBES[1])] +amp2_used = 2 if MUT == "amplitude_double" else 1 +sin_used = 0 if MUT == "sine_drop" else 1 +for x_, y_ in PAIRS: + ck(abs(cov_full(x_, y_, amp2=amp2_used, use_sin=sin_used) - cov_target(x_, y_)) < mpf('1e-50'), + "full-lattice representation reproduces sum p_k cos(k.(x-y)) [amp2=%d, sin=%d]" + % (amp2_used, sin_used)) +ck(abs(cov_full(PROBES[0], PROBES[0], amp2=amp2_used, use_sin=sin_used) - 1) < mpf('1e-50'), + "variance identity sum p_k = 1 (factor-of-two convention)") +ck(abs(cov_full(PROBES[0], PROBES[1], amp2=2) - cov_target(PROBES[0], PROBES[1])) > mpf('1e-3'), + "adversarial: doubled amplitude on the full lattice is detected (duplication)") +sin_mass = max(abs(sum(p_*mp.sin(_dot(k_,x_))*mp.sin(_dot(k_,y_)) + for k_, p_ in pw.items())) for x_, y_ in PAIRS) +ck(sin_mass > mpf('1e-3'), "sine terms carry nonzero covariance mass at r > 0 (cannot drop)") + +print("=== (i) amplitude majorant ===") +ok_mx = True +for n1 in range(-50, 51): + for n2 in range(-50, 51): + rk_ = math.sqrt(n1*n1 + n2*n2) + for p_ in range(0, 6): + if max(1.0, rk_**p_) > (1 + rk_)**p_ * (1 + 1e-12): + ok_mx = False +ck(ok_mx, "max_{|alpha|<=p} |k|^|alpha| = max(1,|k|^p) <= (1+|k|)^p on [-50,50]^2") +_ens = [(Fr(1,3), Fr(1,2)), (Fr(1,6), Fr(5,7)), (Fr(1,2), Fr(11,13)), (Fr(1,1), Fr(0,1))] +_A = sum(a_ for a_, _ in _ens) +ck(sum(a_*r_ for a_, r_ in _ens)**4 <= _A**3 * sum(a_*r_**4 for a_, r_ in _ens), + "Jensen x^4: (sum a_k R_k)^4 <= (sum a_k)^3 sum a_k R_k^4 (exact witness)") +ck(3 + 2*1*1 + 3 == 8, "E[R^4] = 8 exact (Isserlis: 3 + 2*1*1 + 3)") +ck(1 + 1 == 2, "E[R^2] = 2 exact; E[R] <= sqrt(2) (Lyapunov)") +print("[ok] assembly: E||f||_{C^3}^4 <= 8 S_3^4 ; E||f||_{C^4} <= sqrt(2) S_4") +EX_ = math.sqrt(2/math.pi) +E_zeta4 = 2*3 + 8*(2*EX_)*EX_ + 6 +ck(abs(E_zeta4 - (12 + 32/math.pi)) < 1e-12, + "E[(|X|+|Y|)^4] = 12 + 32/pi (the correct identity; 12+16/pi is false)") +if MUT == "wrong_moment": + E_bad = 12 + 16/math.pi + ck(abs(E_bad - E_zeta4) < 1e-12, + "M_WRONG_MOMENT must FAIL: 12+16/pi != 12+32/pi") +ck(MUT != "wrong_moment", "M_WRONG_MOMENT rejected") + +# ============================================ moment chain (certified library) +print("=== moment chain (S_3/S_4 from the certified library; B_3, B_4, K) ===") +h1 = json.loads(carrier_text["h1_receipt"]) +S3_CARRIER = h1["headline"]["S3_upper"] # "554.3913563" (H1-certified upper) +S4_CARRIER = h1["headline"]["S4_upper"] # "2041.8327332" (H1-AMENDED upper) +ck(S3_CARRIER == "554.3913563" and S4_CARRIER == "2041.8327332", + "H1-certified spectral enclosures consumed: S_3 <= %s, S_4 <= %s (F-S4 amendment)" + % (S3_CARRIER, S4_CARRIER)) +ck("F-S4" in h1["findings"], "H1 finding F-S4 (S_4 enclosure amendment) on record") +S3u = mpf(frac_of(S3_CARRIER).numerator) / frac_of(S3_CARRIER).denominator +S4u = mpf(frac_of(S4_CARRIER).numerator) / frac_of(S4_CARRIER).denominator +A3 = mpf('71.10596'); A4 = mpf('262.81357') +M4_mult = mpf(8) +if MUT == "false_identity_restore": + M4_mult = 12 + 16/mp.pi + ck(abs(M4_mult - 8) < mpf('1e-30'), + "M_FALSE_IDENTITY_RESTORE must FAIL: 12+16/pi is not the exact 8") +ck(MUT != "false_identity_restore", + "M_FALSE_IDENTITY_RESTORE rejected: E[R^4] = 8 exact enforced as the multiplier") +B3_root = 1 + M4_mult**mpf('0.25')*S3u + A3*(mpf('38.23')**mpf('0.25') + mpf('1.28')) + ROUND +B3_val = B3_root**4 + 10*ROUND +B4_val = mp.sqrt(2)*S4u + A4*(mpf('3.175') + mpf('2.3701308')) + 10*ROUND +B3_RAT = 2082000000000 +K_RAT = 8690 +ck(B3_val <= B3_RAT, "B_3 <= %d (integer upper enclosure; margin %s)" + % (B3_RAT, nstr(B3_RAT - B3_val, 8))) +ck(2*B4_val <= K_RAT, "K = %d >= 2 B_4 (margin %s)" % (K_RAT, nstr(K_RAT - 2*B4_val, 6))) +ck(B3_val <= mpf('3790446482793') and B4_val <= mpf('4715.749569'), + "v1 caps 3790446482793 / 4715.749569 survive the repair") + +# ================================================================ LEVER 1 +# CERTIFIED DENSITY FLOOR ON THE SMALL BOX (replaces the boxed-formula floor +# m >= 1e-21). Chain: exact endpoint ten-jet Gram from the moment dictionary, +# Schur-identity verification, conditional-mean modulus (consumed correction), +# log-det modulus, vertex quadratic-form maximum, directed density floor. +print("=== LEVER 1: certified density floor on the small box ===") +# 1D spectral moments with certified geometric tails (independent recompute): +def mom1d(p_, NB=160): + num = mpf(0) + for n_ in range(-NB, NB+1): + num += mp.e**(-a_lat*n_*n_) * (h_lat*n_)**p_ + def t_(n_): + return mp.e**(-a_lat*n_*n_) * (h_lat*n_)**p_ + rho_ = t_(NB+1)/t_(NB) + ck(rho_ < mpf('0.5'), "moment tail ratio < 1/2 (p=%d)" % p_) + return num, 2*t_(NB+1)/(1-rho_) +Z1n, _ = mom1d(0) +MOMS = {} +for p_ in (2, 4, 6): + n_, t_ = mom1d(p_) + MOMS[p_] = (n_/Z1n - t_/Z1n - ROUND, (n_+t_)/Z1n + ROUND) + ck(MOMS[p_][1] - MOMS[p_][0] < mpf('1e-38'), + "a_%d certified interval width < 1e-38 (direct sum + tail + ROUND)" % p_) +a2v = (MOMS[2][0] + MOMS[2][1])/2 +# frozen Poisson defect (strict positivity hook; v1 transcript, hash-pinned): +ONE_A2 = "9.65254179896e-123" +ck("1-a2 = 9.65254179896e-123" in carrier_text["v1_transcript"], + "v1 transcript carries the certified Poisson defect 1-a2 = 9.65254179896e-123") +ck(frac_of(ONE_A2) > 0, "1 - a_2 = %s > 0 (exact torus moments; frozen v1 carrier)" + % ONE_A2) +ck(abs((1 - a2v)) < mpf('1e-70'), + "a_2 = 1 up to the Poisson defect (direct sum interval consistent)") +if MUT == "planar_moments": + ck(mpf(0) > 0, "M_PLANAR_MOMENTS must FAIL: 1 - a_2 = %s > 0" % ONE_A2) +ck(MUT != "planar_moments", "M_PLANAR_MOMENTS rejected (1-a_2 = 9.65254179896e-123 > 0)") + +# exact endpoint Gram Gamma_0 (sign rule (-1)^|be| i^(|al|+|be|) m_{al+be}): +mom1 = {0: mpf(1), 2: a2v, 4: (MOMS[4][0]+MOMS[4][1])/2, 6: (MOMS[6][0]+MOMS[6][1])/2} +def m2d(al): + out = mpf(1) + for c_ in al: + if c_ % 2: + return mpf(0) + out *= mom1[c_] + return out +UF = [((0,0),1), ((1,0),1), ((0,1),1), ((2,0),2), ((1,1),1), ((3,0),6)] +JF = [((0,2),1), ((2,1),2), ((1,2),2), ((0,3),6)] +ALLF = UF + JF +def gentry(fi, fj): + (al, ca), (be, cb) = fi, fj + tot = tuple(x_+y_ for x_, y_ in zip(al, be)) + return ((-1)**sum(be)) * m2d(tot) * (1j)**(sum(al)+sum(be)) / (ca*cb) +NG = len(ALLF) +G0 = matrix(NG, NG) +for i_ in range(NG): + for j_ in range(NG): + G0[i_, j_] = gentry(ALLF[i_], ALLF[j_]).real +GU0 = G0[:6, :6]; GX0 = G0[6:, :6]; GJ0 = G0[6:, 6:] +GX0F = (sum(GX0[i_, j_]**2 for i_ in range(4) for j_ in range(6)))**mpf('0.5') +ck(abs(GX0F - mpf('1.4361407')) < mpf('1e-6'), + "||GX_0||_F = %s matches v1's frozen 1.4361407" % nstr(GX0F, 10)) +ck("1.4361407" in carrier_text["v1_transcript"], "v1 transcript carries the GX_0 token") +u0v = matrix([mpf('1.2'), 0, 0, 0, 0, mpf(1)/3]) +mu0 = GX0 * (GU0**-1) * u0v +ck(abs(mu0[0] + mpf('1.2')*a2v) < mpf('1e-60') and + max(abs(mu0[1]), abs(mu0[2]), abs(mu0[3])) < mpf('1e-60'), + "conditional mean mu_0 = (-a_2 b, 0, 0, 0) exact (independent re-derivation)") +S0m = GJ0 - GX0*(GU0**-1)*GX0.T +s_exp = [mom1[4]-mom1[2]**2, mom1[2]*(mom1[4]-mom1[2]**2)/4, + mom1[2]*(mom1[4]-mom1[2]**2)/4, (mom1[6]-mom1[4]**2/mom1[2])/36] +devS = max(abs(S0m[i_, j_] - (s_exp[i_] if i_ == j_ else 0)) + for i_ in range(4) for j_ in range(4)) +ck(devS < mpf('1e-50'), + "Schur identity: Cov(J|U_0) = diag(a4-a2^2, a2(a4-a2^2)/4, a2(a4-a2^2)/4, " + "(a6-a4^2/a2)/36) to %s (independent re-derivation)" % nstr(devS, 3)) +from mpmath import eigsy as _eigsy +ev0 = _eigsy(G0)[0] +lam0_val = min(ev0) +ck(lam0_val > mpf(31)/250, + "endpoint eigenfloor lambda_min(Gamma_0) = %s >= 31/250 (independent; matches v1's " + "frozen 0.126553449667289)" % nstr(lam0_val, 15)) +ck(abs(lam0_val - mpf('0.126553449667289')) < mpf('1e-14'), + "endpoint eigenfloor matches v1's frozen 0.126553449667289 exactly") +if MUT == "eigenfloor_up": + ck(Fr(126553449667289, 10**15) >= Fr(126553449817289, 10**15), + "M_EIGENFLOOR_UP must FAIL: the upward-rounded floor is above the value") +ck(MUT != "eigenfloor_up", "M_EIGENFLOOR_UP rejected") + +# frozen v1 carriers for the modulus chain (transcript tokens verified): +for tok in ("L1 = 19.071156", "M = 1.222575834", "0.123809288439", + "0.126553449667289"): + ck(tok in carrier_text["v1_transcript"], "v1 transcript carries the modulus token %r" % tok) +L1F = Fr(19071156, 10**6) +LAM = Fr(123809288439, 10**12) +LAM0 = Fr(126553449667289, 10**15) +MF = Fr(1222575834, 10**9) +RLP = Fr(1, 10**5) +bF = Fr(6, 5) +# moment-entry intervals for the conditional covariance: +MERR = mpf('1e-38') +s1 = mom1[4] - mom1[2]**2 +s2 = mom1[2]*(mom1[4] - mom1[2]**2)/4 +s4 = (mom1[6] - mom1[4]**2/mom1[2])/36 +s_lo = [s1 - MERR, s2 - MERR, s2 - MERR, s4 - MERR] +s_hi = [s1 + MERR, s2 + MERR, s2 + MERR, s4 + MERR] +det_S0_up = s_hi[0]*s_hi[1]*s_hi[2]*s_hi[3] +# log-det modulus: det(S_r) <= det(S_0) * e^{2 L1 R / lam}, e^x <= 1+x+x^2 (0<=x<=1) +xdet = 2*L1F*RLP/LAM +ck(xdet < 1, "log-det modulus argument x = 2 L1 R/lam = %s < 1" % float(xdet)) +eup = 1 + xdet + xdet*xdet +det_Sr_up = det_S0_up * (mpf(eup.numerator)/eup.denominator) +# conditional-mean correction: eps_mu = M_frozen - a2^lo * b (>= v1's certified +# correction CORR = M - |mu_0|_up >= sup |mu_r - mu_0|; consistency since +# a2^lo b <= |mu_0|_up): +a2_lo, a2_up = MOMS[2] +eps_mu = mpf(MF.numerator)/MF.denominator - a2_lo*bF +ck(eps_mu > mpf('0.0225') and eps_mu < mpf('0.0226'), + "eps_mu = M - a_2 b = %s (v1-certified mean correction consumed)" % nstr(eps_mu, 12)) + +# ================================================================ LEVER 2 +# delta widening with CERTIFICATE-GRADE re-verification at the widened box. +# delta = 1/256 FAILS the path clearance at v2's frozen split (16/256 + 1/32 = +# 3/32 > 343/3840), so the delta/r_0 split is re-optimized: total C2 budget +# eps' = 57/640, clearance margin exactly 1/3840 > 0, remainder share +# 8 K r_0 = 1/32768 via r_0 = 1/(256*K*1024). +print("=== LEVER 2: widened box, margins re-verified UNIFORMLY at eps' = 57/640 ===") +EPS_T = Fr(57, 640) +RHO_R0 = 1024 +REM = Fr(1, 32*RHO_R0) +DELTA = (EPS_T - REM)/16 +ck(DELTA == Fr(14587, 2621440), "delta = (57/640 - 1/32768)/16 = 14587/2621440 exact") +ck(Fr(16, 256) + Fr(1, 32) > Fr(343, 3840), + "delta = 1/256 at v2's split: 16 delta + 8 K r_0 = 3/32 > 343/3840 -> " + "path clearance FAILS; certified reversion applied (new split)") +# basis C^2 norms (re-derived exactly): sup over D = [-2,1/2]x[-1,1] of the +# maximum derivative magnitude: (x^2-1/4)y -> 4, x y^2 -> 4, y^2 -> 2, y^3 -> 6 +NBAS = 41 +bmax = [mpf(0), mpf(0), mpf(0), mpf(0)] +for ix in range(NBAS): + for iy in range(NBAS): + x_ = -2 + mpf('2.5')*ix/(NBAS-1) + y_ = -1 + 2*mpf(iy)/(NBAS-1) + f1 = max(abs((x_**2-mpf('0.25'))*y_), abs(2*x_*y_), abs(x_**2-mpf('0.25')), + abs(2*y_), abs(2*x_)) + f2 = max(abs(x_*y_**2), abs(y_**2), abs(2*x_*y_), abs(2*y_), abs(2*x_)) + f3 = max(abs(y_**2), abs(2*y_), mpf(2)) + f4 = max(abs(y_**3), abs(3*y_**2), abs(6*y_)) + for bi, fv in enumerate((f1, f2, f3, f4)): + bmax[bi] = max(bmax[bi], fv) +ck(all(bmax[i_] <= (4, 4, 2, 6)[i_] + mpf('1e-9') for i_ in range(4)), + "basis C^2 norms (x^2-1/4)y:4, x y^2:4, y^2:2, y^3:6 -> sum 16 re-verified") +ck(4+4+2+6 == 16, "||F_J - F_*||_{C^2} <= 16 delta (norm sum exact)") +# margins at eps' (exact Fractions): +W1 = 6 - 15*EPS_T +W2 = 14 - 15*EPS_T + 2*EPS_T*EPS_T +ck(W1 == Fr(597, 128) and W2 == Fr(2596849, 204800), + "det floors: W1 = 6-15 eps' = 597/128, W2 = 14-15 eps'+2 eps'^2 = 2596849/204800 exact") +W_FLOOR = W1*W2 +ck(W_FLOOR > 65*Fr(9, 10), "weight floor W1*W2 = %s (replaces v2's 65)" % float(W_FLOOR)) +ck(1 - EPS_T > 0, "typing: H_xx(m) <= -(1-eps') < 0 (local max) uniform on the box") +ck(-(10 - EPS_T) < 0, "typing: H_yy(m) <= -(10-eps') < 0 uniform") +ck(-(10 - EPS_T) < 0, "typing: H_yy(s) <= -(10-eps') < 0 uniform") +CLEAR = Fr(1, 6) - Fr(99, 1280) - EPS_T +ck(CLEAR == Fr(1, 3840) and CLEAR > 0, + "path clearance: 1/6 - 99/1280 - eps' = 1/3840 > 0 exact (uniform over the box)") +ck(Fr(9, 16) - EPS_T > 0, "path endpoint: G(z) >= 9/16 - eps' > 0") +R0 = Fr(1, 256*K_RAT*RHO_R0) +ck(R0 == Fr(1, 2278031360), "r_0 = 1/(256*8690*1024) = 1/2278031360 exact") +ck(16*DELTA + 8*K_RAT*R0 == EPS_T, "budget identity 16 delta + 8 K r_0 = 57/640 exact") +ck(8*K_RAT*R0 == REM, "remainder share 8 K r_0 = 1/32768 exact") +ck(R0 <= Fr(1, 400), "r_0 <= 0.0025: inside H3 band cell (0, 0.0025] (and (0, 0.05])") +ck(R0 <= RLP, "r_0 <= R = 1e-5 (density-floor domain)") +if MUT == "delta_up": + DEL_BAD = Fr(6, 1000) # +7.8% above the certified 14587/2621440 + ck(16*DEL_BAD + 8*K_RAT*R0 < Fr(343, 3840), + "M_DELTA_UP must FAIL: 16*(6/1000) + 8 K r_0 exceeds the clearance budget 343/3840") +ck(MUT != "delta_up", "M_DELTA_UP rejected (clearance budget fail-closed)") +if MUT == "weight_floor_up": + W_BAD = Fr(84) + ck(W_BAD <= W_FLOOR, + "M_WEIGHT_FLOOR_UP must FAIL: 84 is the eps'->0 limit, not the floor at 57/640") +ck(MUT != "weight_floor_up", "M_WEIGHT_FLOOR_UP rejected (floor at eps' = 57/640 enforced)") + +# ---- LEVER 1 continued: quadratic-form maximum over the 16 box vertices ---- +print("=== LEVER 1 (cont.): vertex quadratic form and directed density floor ===") +d_v = mpf(DELTA.numerator)/DELTA.denominator +mu_q_up = a2_up*bF +verts = [mu_q_up, 2 + d_v, d_v, d_v] +ck(mu_q_up >= abs(-(10 + 2*d_v)*mpf(RLP.numerator)/RLP.denominator + a2_lo*bF), + "worst q-vertex is q = 0 (|0 - mu_0,q| maximal over the JBOX q-window)") +QF_vertex = sum((verts[i_] + eps_mu)**2 / s_lo[i_] for i_ in range(4)) +pertC = mpf((L1F*RLP/(LAM*LAM0)).numerator)/(L1F*RLP/(LAM*LAM0)).denominator +RJ2 = ((10 + 2*d_v)*mpf(RLP.numerator)/RLP.denominator)**2 + (2+d_v)**2 + 2*d_v**2 +QF_pert = (RJ2**mpf('0.5') + mpf(MF.numerator)/MF.denominator)**2 * pertC +QF_max = QF_vertex + QF_pert + 10*ROUND +ck(QF_max < mpf('9.2'), "QF_max = %s (vertex maximum + S_r^{-1} perturbation)" + % nstr(QF_max, 10)) +floor_dir = (mpf(1)/40) * det_Sr_up**mpf('-0.5') * mp.e**(-QF_max/2) - 100*ROUND +ck(floor_dir > mpf('9e-4'), "directed density floor = %s" % nstr(floor_dir, 10)) +M_DEN = Fr(9, 10000) +if MUT == "density_floor_up": + M_BAD = Fr(1, 1000) + ck(mpf(M_BAD.numerator)/M_BAD.denominator <= floor_dir, + "M_DENSITY_FLOOR_UP must FAIL: 1e-3 is above the certified directed floor") +ck(MUT != "density_floor_up", "M_DENSITY_FLOOR_UP rejected (vertex QF floor enforced)") +ck(mpf(M_DEN.numerator)/M_DEN.denominator * mpf('1.01') <= floor_dir, + "m_new = 9/10000 <= directed floor with > 1%% margin (exact Fraction consumed)") +ck(mpf(M_DEN.numerator)/M_DEN.denominator < mpf('1.2832254e-3'), + "consistency: floor below the RB center density 1.2832254e-3") +print("[ok] LEVER 1 certified: m_new = 9/10000 (replaces 1e-21; gain ~%s)" + % nstr(mpf(M_DEN.numerator)/M_DEN.denominator/mpf('1e-21'), 4)) + +# ================================================================ LEVER 4 +# NORMALIZER CEILING (v3's F-LEVER4 discharged): the Palm denominator of the +# LOWER bound 1 - q >= E[W 1_E]/Z_r needs an UPPER envelope Z_r <= U r^2. +# H3_BAND_CEIL certifies E[G_r] = Z_r/r^2 <= U on (0, 0.0025]; r_0 lies inside. +print("=== LEVER 4: certified normalizer ceiling (direction discipline) ===") +ck("3.66282864761194" in carrier_text["h3_ceil"], + "H3 ceiling token 3.66282864761194 present in H3_BAND_CEIL.md") +ck("(0, 0.0025]" in carrier_text["h3_ceil"], + "H3 ceiling cell (0, 0.0025] present in H3_BAND_CEIL.md") +ck("CERTIFIED: E[G_r] <= 3.66282864761194" in carrier_text["h3_ceil_trans"], + "H3 ceiling transcript carries the certified cell-1 ceiling line") +U_CEIL = frac_of("3.66282864761194") # consumed EXACTLY (never down) +RUNG_LO = frac_of("7.7592917375327855e-3")/frac_of("2.5e-3") +RUNG_HI = frac_of("1.1468646473404396e-2")/frac_of("2.5e-3") +BAND_LO = frac_of("2.30659559567154") +print("[direction] 1 - q >= E[W 1_E]/Z_r (Palm ratio); lower bound needs " + "Z_r <= U r^2 (CEILING, upper envelope of the normalizer)") +print("[direction] H3 certifies E[G_r] = Z_r/r^2 <= 3.66282864761194 on " + "(0, 0.0025]; r_0 = 1/2278031360 <= 1/400 lies inside that cell") +ck(R0 <= Fr(1, 400), "r_0 inside the ceiling cell (0, 0.0025] (exact)") +ck(BAND_LO < U_CEIL, + "nesting: certified band floor 2.30659559567154 < U (two-sided consistency)") +ck(U_CEIL < RUNG_HI, + "consistency: U = 3.6628... below the pointwise rung hi 4.5874586 at 0.05") +ck(U_CEIL <= 4, "H3 consumption cap U <= 4 respected (never widened)") +ck(U_CEIL <= 4*B3_RAT, + "U is strictly stronger than v3's crude uniform cap 4 B_3 (consistency)") +ck(BAND_LO <= RUNG_LO < RUNG_HI, + "consistency: band floor 2.3066 <= rung lo 3.1037 < rung hi 4.5875 at r = 0.05") +C_Z = U_CEIL +if MUT == "normalizer_cap_down": + C_BAD = BAND_LO + ck(C_BAD == C_Z, + "M_NORMALIZER_CAP_DOWN must FAIL: 2.3066 is the band FLOOR (wrong direction); " + "the denominator needs the certified CEILING U = 3.66282864761194") +ck(MUT != "normalizer_cap_down", + "M_NORMALIZER_CAP_DOWN rejected (a floor is not a ceiling; U enforced)") +if MUT == "ceiling_consumed_above_U": + for C_BAD, tag in ((frac_of("3.7"), "inflated 3.7"), + (frac_of("3.66435028046302"), "cell-2 value (wrong cell)")): + ck(C_BAD == C_Z, + "M_CEILING_CONSUMED_ABOVE_U must FAIL: consuming %s instead of the " + "certified cell-1 ceiling 3.66282864761194" % tag) +ck(MUT != "ceiling_consumed_above_U", + "M_CEILING_CONSUMED_ABOVE_U rejected (exact cell-1 consumption enforced)") +print("[ok] C_Z = U = 3.66282864761194 consumed exactly (gain vs 4 B_3: x%s)" + % nstr(mpf(4*B3_RAT)/(mpf(U_CEIL.numerator)/U_CEIL.denominator), 10)) + +# ================================================================ assembly +print("=== final assembly (exact rational arithmetic) ===") +c_rat = 16*W1*W2*M_DEN*DELTA**4/C_Z +ck(c_rat == Fr(394827584594841472652359498125, + 1771235249968883322980290175117427736576), + "c = 16*(597/128)*(2596849/204800)*(9/10000)*(14587/2621440)^4/U exact") +ck(c_rat == (W1*W2)*(M_DEN*Fr(32, 2)*DELTA**4)/C_Z, + "assembly identity: c = (W1 W2 r^4)(m * 32 delta^4 r / 2)/(U r^2)/r^3") +C3 = "2.22e-10" +if MUT == "decimal_above_exact": + C3 = "2.23e-10" +if MUT == "decimal_change": + C3 = "2.22e-11" +ck(frac_of(C3) <= c_rat, "published 3-sig decimal %s <= exact fraction" % C3) +EXACT29, MANT29, EXP29 = expansion_string(c_rat, 29) +ck(EXACT29 == "2.2291086664054236617851686509e-10", + "exact 29-digit expansion 2.2291086664054236617851686509e-10 (integer division)") +mant3 = (c_rat*10**12).numerator // (c_rat*10**12).denominator +ck(Fr(mant3, 100)*Fr(10)**-10 <= c_rat < Fr(mant3 + 1, 100)*Fr(10)**-10, + "3-sig display 2.22e-10 brackets the exact fraction downward") +ck(Fr(mant3, 100)*Fr(10)**-10 == frac_of(C3), + "headline 3-sig decimal equals the exact 3-sig floor") +ck(Fr(10)**-10 <= c_rat < Fr(10)**-9, "power-of-ten floor 1e-10 (exact integer test)") +# mutation hooks on the assembled value +if MUT == "hessian_power": + c_bad = 16*W1*W2*M_DEN*DELTA**4/C_Z/R0 # one power of r short: mass ~ r^2 + ck(c_bad == c_rat, + "M_HESSIAN_POWER must FAIL: the weight is r^4 (det H_M det H_S), mass ~ r^3") +ck(MUT != "hessian_power", "M_HESSIAN_POWER rejected (r^4 weight -> r^3 law)") +if MUT == "box_width": + c_bad = c_rat/2 # forgetting the q-window width factor 2 in vol = 32 delta^4 r + ck(c_bad == c_rat, + "M_BOX_WIDTH must FAIL: vol(E_r) = (4 delta r)(2 delta)^3 = 32 delta^4 r") +ck(MUT != "box_width", "M_BOX_WIDTH rejected (vol = 32 delta^4 r exact)") +if MUT == "denominator_change": + ck(C_Z + 1 == C_Z, + "M_DENOMINATOR_CHANGE must FAIL: U = 3.66282864761194 pinned") +ck(MUT != "denominator_change", "M_DENOMINATOR_CHANGE rejected (ceiling U pinned)") +ck(MUT != "decimal_above_exact", + "M_DECIMAL_ABOVE_EXACT rejected (published decimal would exceed the exact fraction)") +ck(MUT != "decimal_change", + "M_DECIMAL_CHANGE rejected (printed decimal must equal the certified one)") +if MUT == "rung_floor": + # replacing the uniform analytic floor lam = 0.123809288439 by a sampled-rung + # minimum (e.g. lam at r = R only) breaks uniformity on the whole segment: + lam_sampled = lam0_val # endpoint value only + ck(lam_sampled < mpf(LAM.numerator)/LAM.denominator, + "M_RUNG_FLOOR must FAIL: a sampled endpoint value is not a uniform floor on " + "[0, R]; the analytic modulus lam = 0.123809288439 is load-bearing") +ck(MUT != "rung_floor", "M_RUNG_FLOOR rejected (uniform analytic floor enforced)") + +# ============================================ mandatory invariants (a)(b)(c) +print("=== mandatory invariants ===") +ledger_exact("c_3sig_lower", C3, "lower", c_rat) +ledger_exact("c_exact29", EXACT29, "lower", c_rat) +ledger_exact("c_power_floor", "1e-10", "lower", c_rat) +ledger_exact("m_density_floor", "9e-4", "lower", M_DEN) +ledger_exact("C_Z_ceiling_upper", "3.66282864761194", "upper", U_CEIL) +ledger_exact("B3_upper", "2082000000000", "upper", Fr(B3_RAT)) +ledger_exact("K_upper", "8690", "upper", Fr(K_RAT)) +ledger_interval("S3_upper", "554.3913563", "upper", (S3u - ROUND, S3u)) +ledger_interval("S4_upper", "2041.8327332", "upper", (S4u - ROUND, S4u)) +run_rounding_direction_checker() +# (a)+(b) headline guards against the authored receipt and report: +rc = json.loads(carrier_text["v4_receipt"]) +ck(rc["headline"]["c_3sig_lower"] == C3, "receipt headline 3-sig decimal guarded") +ck(rc["headline"]["c_exact29"] == EXACT29, "receipt headline exact29 guarded") +ck(rc["headline"]["c_power_floor"] == "1e-10", "receipt power floor guarded") +ck(frac_of(rc["headline"]["c_exact_fraction"]) == c_rat, + "receipt exact fraction equals the derived exact fraction") +ck(rc["headline"]["r0"] == "1/2278031360", "receipt r_0 guarded") +ck(rc["headline"]["delta"] == "14587/2621440", "receipt delta guarded") +ck(rc["headline"]["m_density_floor"] == "9/10000", "receipt density floor guarded") +ck(rc["headline"]["C_Z"] == "3.66282864761194", + "receipt C_Z guarded (certified ceiling, exact consumption)") +rep = carrier_text["v4_report"] +for tok in (C3, EXACT29, "1e-10", "14587/2621440", "9/10000", "1/2278031360", + "597/128", "2596849/204800", "3.66282864761194", "1/3840", + "cfe8a3a4"): + ck(tok in rep, "v4 report carries the certified token %r" % tok) +ck("2.23e-10" not in rep and "2.23e-10" not in carrier_text["v4_receipt"], + "no above-exact headline anywhere (invariant a)") +print("[ok] invariants (a) published<=exact, (b) exact floor, (c) rounding checker: PASS") + +# ------------------------------------------------- byte-identical summary line +print("CERTIFIED: 1 - q(r, 6/5) >= c r^3, 0 < r <= r_0") +print("c = %s (>= %s >= 1e-10)" % (EXACT29, C3)) +print("c exact = %s/%s" % (c_rat.numerator, c_rat.denominator)) +print("r_0 = 1/2278031360 ; delta = 14587/2621440 ; m = 9/10000 ; W = %s" % str(W_FLOOR)) +print("C_Z = U = 3.66282864761194 (H3-certified ceiling on (0, 0.0025]; F-LEVER4 discharged)") +print("CERTIFICATE: PASS") diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md new file mode 100644 index 000000000..f1db026b2 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md @@ -0,0 +1,121 @@ +# 00_EXECUTIVE_STATE — RETURN_06 (assembled 2026-09-15; every fact from hash-verified frozen carriers) + +Root: /mnt/agents/output/K3_SIDE24_LB/. Capsule: SOURCE_CAPSULE.sha256 (22/22 carriers MATCH, 0 mismatches; +gate d1_falsify_v3.py re-executed live: exit 0, 92 cks, digest d800849ed5966b4d583a10cf72525e89350d9a53780b45a807a21ccbadf91085). + +## Strongest theorem established exactly (2D UPPER, certified rung; D1 v2.2 body 490ad6b2…) + +**Theorem D1 v2.2(1)** — at r = 0.05, on Reg ∩ TYP: +`1 − q(0.05, 6/5) ≤ Ĩ_hi + C_RN(0.05)·√Q_{0.05}(B1.dir) + P_{0.05}(B2) + P_{0.05}(B4)`, +with **E_w(0.05) ≤ Ĩ_hi = 8.1272827e-2 = 650.1827·(0.05)³** (both displays rounded UP; exact recomputation +650.1826140…; = chart 628.2548·r³ [I_hi(v3) 8.0975589252e-2 = 647.8048·r³ − 19.55·r³] + B_remote = +21.9279·r³ = 2.7409875e-3, where B_remote = 17.6804 + 2.5282637·(1+κ_far), κ_far ≤ 0.68 floor-certified +against R2's interval floor Z_lo = 7.7592917375327855e-3; genuinely Monte-Carlo-free), and **C_RN(0.05) ≤ +3.46** (rounded UP from 3.4591). Unconditional apart from the named-hypothesis register: **(a) H5-RIM and +H5-AXIS v1+v2+v3** (named-lemma grade; v3 frozen in full in the tightening amendment 7fefa17b…); **(b) +D3-LEMMA-RN-UNIF(r = 0.05)** (rung part precisely stated, NOT closed). Sharper form **(1′)** prices the dir +remainder: B1.dir ⊆ NearSwap(d_max) ∪ FarRoute(d_max), d_max = 4r–5r; NearSwap CERTIFIED SUPER-ALGEBRAIC +(barrier margin Θ(1/r)); FarRoute → PERC-DECAY. G.7-scope normalizer AT THE RUNG: DISCHARGED (R2). Honest +width vs C1's evidence point value ≈ 507× (stated). Evidence-only display (never a premise): q(0.05) = +0.99982, 1−q = 1.77e-4 = 1.42·(0.05)³ (exact continuous-field MC, BRANCH). + +**LPW lower theorem (separate family):** 1 − q(r, 6/5) ≥ c·r³ for all 0 < r ≤ r₀, **c = +1.1357762846347807215698804e-43 ≥ 1.13e-43 ≥ 10^{−43}** (exact Fraction 260/(2082000000000·2⁴⁰·10²¹); +downward-safe displays), **r₀ = 1/2224640** (LPW_CONSTANT v2, amplitude-majorant repaired; v1 historical +defective; re-certified by H1 v3 hardening). + +## Strongest CONDITIONAL theorem (D1 v2.2(2), all-small-r) + +There EXIST r₀ > 0 (existential — no certified modulus) and finite C with `1 − q(r, 6/5) ≤ C·r³` for all +0 < r ≤ r₀, conditional on five named VALIDITY premises (one line each): +1. **OBL-D1-PROMOTE** — uniform certified chart envelope on (0, r₀′] (sub-obligations OBL-H5-JETMOD / + OBL-H5-ZBAND / OBL-H5-REMOTE-THRESHOLD; rungs executing). +2. **D3-LEMMA-RN-UNIF** — zone uniformity of the RN brackets (rung part stated in (1)(b); uniform part frozen). +3. **PERC-DECAY** — o(r³) pricing of every far lane (B1.dir-far/FarRoute, B2-far, B4.rem). +4. **OBL-B1-BRANCH(loop|B1)** — the re-pointed sharp loop factor given B1 (constant-level). +5. **B4.loc dam-line tube certificate** — uniform Gaussian sup-tail over the pair-level cut net with the RN + prefactor; the cut-net ≡ D2 9-pin M-ward-tube (item ii) identification is ASSERTED, NOT ESTABLISHED. + +Refinement register (round 2): OBL-D2-AO-SHARP (i, iii, v) only — sharp constants, not validity. + +## Open obligations (owner → see OBLIGATION_LEDGER.md) + +OBL-D1-PROMOTE (H5 lane + D1; rungs r = 0.025/0.035355 executing) · D3-LEMMA-RN-UNIF (foundations; rung + +uniform parts) · PERC-DECAY (percolation lane) · OBL-B1-BRANCH(loop|B1) (branch-control lane) · B4.loc +dam-line certificate incl. the cut-net/tube identification (branch-control/foundations) · H5-RIM/H5-AXIS +production paths (shell_hi_fi / factored-det machine certification) · refinement: OBL-D2-AO-SHARP (i, iii, v) +· H3 band-floor assessment (interval-r enclosure extending R2's pointwise floors to (0, 0.05]; RUNNING). + +## Failed-attack ledger (Stage-E breaks → repairs; each increased confidence) + +- **H4-JC level conflation** (proof F1 = topology T6 = lead FAIL-1): the frozen pointwise disjoint-carrier + claim FALSE (counterexample ens-0 pair (875,951); true overlap 176/1435) → **R1**: H4JC-R1 event-level + joint carrier (42ee88da…), OLD 132/175 violations pinned fail-closed as a certified datum, NEW 0/439; + PASS-WITHSTOOD at round-2 re-review; retracted form cited nowhere in v2.1/v2.2 (gate-ck'd). +- **Z-rung out-of-scope** (proof F2): rung normalizer floor uncertified (H3's r₀ existential) → **R2**: + certified interval Z_{0.05} ∈ [7.7592917375327855e-3, 1.1468646473404396e-2], margin +92.12% over + c_Z(0.05)²; stretch rungs 0.045/0.055 same margins; G.7-at-the-rung discharged by R2. +- **κ_far dropped** (proof F3 = numerics F-1 = scope F2 = prov F2): D1 v2.0's 19.55·r³ bracket dropped D3's + (1+κ_far) and carried a QMC estimate → **R3**: κ_far ≤ 0.66 certified, B_remote = 21.2153·r³; then + round-2 scope **V1** (κ_far assembles 0.6773 > 0.66 at the certified floor; "zero MC" false) → **v2 + amendment**: B_remote = 21.9279·r³ floor-consistent, genuinely MC-free; 19.5465/20.9/21.2153/21.2658 + superseded; gate v3 rejects below 21.92788306. +- **Hypothesis gaps** (scope F1/F3 = prov F4): D3-LEMMA-RN-UNIF silently dropped → named hypothesis of + Theorem (1) itself; PERC-DECAY unnamed → named validity premise of Theorem (2). "Unconditional" + over-claim (lead FAIL-2) → named-hypothesis restatement. +- **Gate-red process break**: v2.1 gate's body-only citation ck exposed by D1's own mutation test → + whole-file ck in gate v3; H5-AXIS v3 unfrozen (prov F3) → **R4** tightening amendment frozen in full. +- **V2 (round-2 scope)**: B4.loc misplaced as refinement while no raw counted-class envelope exists → + moved to Theorem (2)'s validity premises with the asserted-not-established cut-net identification carried. +- Also recorded: rounding-polarity defects → round-UP display discipline (gate-ck'd); H5 I_lo rung-pollution + → rung-scoped merger, v3 totals, version discipline. + +## Successful-attack register (historical record) + +- **W12 red-team B1**: W6's global-CS modulus 4.2·r^{3/2} INVALID for r ≲ 0.003 (near-cluster singularity + ρ_CS ~ ℓ^{1/2}d^{−4}); **B2**: LEAD_SYMBOLIC_WP Isserlis display false for nonzero means (missing + −2ν_iν_jν_kν_l; overcount 2(det ννᵀ)²; witness absolutes inflated √1.34488; direction conservative); + **B3**: W6 premise F1 mis-quantified (true threshold |slope| ≤ 0.32544, not 0.327; worst inter-rung sup + 4.236 > 4.2 under the stated premise); **B4**: W7's "P-NMZ-γ retired" false of the exit node. +- **LPW_CONSTANT v1 defects**: D1 — published decimal 6.239277637492383e-44 did not follow from the exact + fraction 6.238542702935588e-44 (rounded denominator); D2 — false fourth-moment identity 12 + 16/π + (correct: 12 + 32/π). Both repaired in v2 (amplitude majorant; v1 caps survive conservatively). +- **K3 missing-sqrt** (FAILED_APPROACHES #1): dropped-square-root Cauchy–Schwarz factor p_grad·√(E[det²H])· + min(P_type, P_window) used as an upper bound (valid form requires √(min)); confirmed 175.3× at the witness + point; quarantined; WP-min closure rerouted to the exact-integrand chain. +- **RB sine omission** (DECISION_LEDGER): RB's rung table dropped the nonzero sine sums for t ≠ 0 → O(r) + entry errors (density at r = 0.025: RB 1.2831682e-3 vs corrected 1.2832254e-3); endpoint (r = 0) exact; + errata filed; corrected script rb_r2_part2_spectral_v2.py shipped; sine_drop mutation rejected both modes. + +## CANNOT-VERIFY (recorded separately from FAIL everywhere; none blocking) + +1. Freeze-time exact H5 totals (unrecoverable; ≤ 4.6e-12 worst-case on the last displayed digit; numerics + F-4 / E-H5-3; version discipline prevents recurrence). 2. h3 CR5f label content (E-H3-2; owner's + amendment pending). 3. Two BRANCH_dir receipts defects (E-BDIR-1/2; repaired by the owner's 2026-09-15 + errata 7547e76a… — receipts grade only, "NOT soundness" per the reviewer). 4. The 647.8047/647.8048 + display pair (round-down/round-up of one value; N-v3-2). 5. Provenance CV1 (H5 first-merge full-precision + totals), CV2 (stitch part-level drift up 2.6e-5 while total drifted down), CV3 ("45 cks" receipt count, + cosmetic). 6. Scope-review: whether D3's zone-integral trapezoid assemblies amount to a certified sup + per zone independent of D3-LEMMA-RN-UNIF; whether κ_far = 0 is exact for d ≥ 5 (no carrier states a + polarity argument); whether an unstated O(r³) pricing of B4.rem without PERC-DECAY exists. 7. **G.7 + two-sided normalizer** — previously CANNOT-VERIFY at the rung; NOW DISCHARGED at the rung by R2 (every + consumed 1/Z_r divides the certified floor Z_lo); the continuum band remains unexecuted (→ OBL-D1-PROMOTE). +8. **rung025 content** — previously unshipped (empty log at freeze); NOW LANDED: rung025 production completed + 2026-09-14T21:47:19Z (keeper_rung025.receipt; N = 1500; q = 0.999989, 1−q = 1.075e-5 = 0.688·r³, se + 6.1e-6). 9. Mission-register items with no standalone file in the tree: REVIEW_counterexample.md and + REVIEW_kacrice.md (the frozen corpus carries five review files; the counterexample instance's disposition + is verified via D1 v2.2 + REVIEW_proof.md §3); "P0.2" (no occurrence in the tree; P0.1 remains HOLD per + the LPW verdict); H5 box-cover internal certificates / C1 QMC values at needle-rim stations / H2 G4 + full-grid floor / D3 I_ann + κ_dam numbers / H5 kernel internals / B4a–d scripts / H1/STAGE_E lanes / + BRANCH §1 N = 2000 headline — consumed at their carriers' labeled grades (evidence/probe/diagnostic); + no independent re-derivation exists in the tree beyond the re-executed gates; the BRANCH N = 2000 headline + itself (q = 0.99982, 1−q = 1.42·r³) is labeled exact-MC EVIDENCE, never a premise. + +## Running tasks (exact fresh states in RUNNING_TASKS.md; never evidence) + +H5 promotion rungs EXECUTING (r = 0.025: cells 83+19 banked, stitch 6; r = 0.035355: cells 42+20, stitch 3; +last writes 04:53–05:08 CST) · W3 LOWER driver RUNNING (band A live: box 39, acc 2.303858e-10; band B live: +box 38, acc 8.564328e-10; live files 06:45 CST; ETA ~53h per W3_REPORT) · W8 Phase-2 RUNNING (banks cleaned +and 4 shard drivers relaunched 07:54 CST after the resolved arithmetic bug; 0 certified / 0 ledgered at +snapshot; keepers A/B heartbeating 07:57 CST) · BRANCH rung025 LANDED (complete; see CV-item 8) · H3 band +assessment RUNNING (h3_band_floor.py active 07:58 CST; band_normal.txt empty — no banked output yet). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md new file mode 100644 index 000000000..d4e1be51f --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md @@ -0,0 +1,242 @@ +# ADDENDUM-2 2026-09-15 — B4LOC dam line CLOSED (super-algebraic, whole B4) + PERC-DECAY RESTATED (Θ(r³) absorption, certified constants) + +Second append-delta to RETURN_06 (assembled 2026-09-15T00:05:36Z; first delta ADDENDUM_2026-09-15_H3_BAND_FLOOR.md). +No frozen file is modified; every hash below was recomputed FROM BYTES by the addendum-2 agent on 2026-09-15 +before being cited. Root: /mnt/agents/output/K3_SIDE24_LB/. No file outside RETURN_06/ is touched by this delta; +SOURCE_CAPSULE.sha256 is extended APPEND-ONLY (existing bytes byte-preserved, prefix re-verified). + +## 1. Carrier 1 — UPPER2D/B4LOC_damline/ (D2 lane; record B4LOC-R1-20260914-v1.0, FREEZE.txt) + +| artifact | rule | recomputed sha256 | bytes | verdict | +|---|---|---|---|---| +| UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md | marker-lines (LF-joined lines strictly between the unique exact lines BEGIN_FROZEN_BODY / END_FROZEN_BODY; exactly one terminal LF; last content line directly preceding END marker) | 0d5c1b3284374f3a2f7630b7f603a71c77f5ec9417fe4579aaac03becd33c05e | 15164 (body 13503) | MATCH vs FREEZE.txt | +| UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md | whole file (custody) | ae4c9c82784aecfbd85056c316f792a331bccb774d952887fc5fe8ea7da615b4 | 15164 | MATCH vs FREEZE.txt | +| UPPER2D/B4LOC_damline/b4loc_driver.py | whole file | bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02 | 26271 | MATCH | +| UPPER2D/B4LOC_damline/b4loc_falsifier.py | whole file | d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f | 3360 | MATCH | +| UPPER2D/B4LOC_damline/t_normal.txt | whole file | 11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 | 2735 | MATCH; ≡ t_opt.txt BYTE-IDENTICAL (cmp verified) | +| UPPER2D/B4LOC_damline/t_opt.txt | whole file | 11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 | 2735 | MATCH (both interpreter modes) | +| UPPER2D/B4LOC_damline/tf_normal.txt | whole file | 1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c | 885 | MATCH; ≡ tf_opt.txt BYTE-IDENTICAL (cmp verified) | +| UPPER2D/B4LOC_damline/tf_opt.txt | whole file | 1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c | 885 | MATCH (falsifier transcripts, both modes) | +| UPPER2D/B4LOC_damline/FREEZE.txt | whole file (custody) | 5235f98a59e5119444b8fda2ea16d2dd3333e0d46f0b52af6362a2b2a0ecd163 | 1213 | records all of the above + B4LOC-DRIVER DIGEST 43ff9c1ebfa9cf8f27c06e27e844030e8378e439e89bdd374949166a1a490a1b, B4LOC-FALSIFIER DIGEST f939eeab4805b9c5b35fb40f0f173b4a4ad8237fdcd15ad53084569c6fbffe55 | + +Extraction-rule note (verified from bytes, recorded for the capsule): the capsule's generic `sepbody` rule +(bytes before the first `"\n---\n\n"`) does NOT apply to this file — the document contains no `---` separator +at all (grep-verified); the FREEZE-recorded rule is the marker-lines rule stated in the table, under which the +recomputed body is exactly 13503 bytes and hashes to 0d5c1b32…, an exact MATCH. (Same pattern as the H3 +band-floor note in the ADDENDUM 2026-09-15 capsule section.) + +## 2. Carrier 1 certified content (verified against the frozen body 0d5c1b32…) + +**THEOREM B4LOC-R1 — the B4.loc dam line CLOSED at super-algebraic grade, covering ALL of B4 (loc + rem).** +Verified components: + +- **Exact event inclusion B4 ⊆ E1 ∪ E2** (Lemma B4LOC-R1-A, deterministic topological step): E1 = curvature + zone (0, 1/4] (∃ζ with f_xx(q(ζ)) ≤ 0), E2 = value corridor [1/4, 1) (∃ξ with f(q(ξ)) ≤ s); the proof's + contradiction covers loc and rem alike (open M-ward channel ⇒ field not in B4). +- **Uniform Borell–TIS sup-tails under the 6-pin law**, all factors explicit: Dudley D = 2√2·J with the + closed form J = L·T·√π/4 (van Handel APC 550 Thm 5.12); conditioning-shrinks-variance (mpmath dps=100, + residual ≤ 6.2e-96 per rung); variational Hermite predictor H(ξ) = s + ℓ(3ξ² − 2ξ³); the Λ_p pin-likelihood + trick with Λ_p² certified = 2.82666 (r = 0.05; 2.82667 finer rungs); covariance factorization (1-D K1 values, + order ≤ 8); certified 8-level pointwise-exact Leibniz grid-to-continuum transfer (9th-derivative remainder + ≤ 1e-23); C_RN ≤ 3.47 consumed from H4-RN (H4_CLOSURE body a67d50b9…; driver fail-closes on drift, mutation M3). +- **Certified bounds:** P_r(B4) ≤ 1.22e-9 / 1.52e-45 / 1.03e-197 at r = 0.05 / 0.025 / 0.0125 + (r³ = 1.25e-4 / 1.56e-5 / 1.95e-6). Zone margins at r = 0.05: kap1 = 9.33 (curvature, Q(E1) ≤ e^{−43.536}), + kap2 = 14.69 (value, Q(E2) ≤ e^{−107.93}) vs the o(r³) threshold √(12 ln(1/r) + 4 ln C_RN + 2 ln 2) = 6.50. +- **Grade:** not merely o(r³) — P_r(B4) ≤ exp(−c_eff/r²), c_eff = 0.0513 / 0.0645 / 0.0709 on the ladder + (increasing); both zone margins Θ(1/r) (the C2 §4 law κ_* = Θ(1/r)); strongest grade the RN square-root + transfer can express. +- **Identification resolved NEGATIVELY (disposition (b)):** the pair-level cut net is PROVEN DISTINCT from the + 9-pin M-ward tube on four independent axes — (i) law (6-pin Q_r vs 9-pin Palm law), (ii) tube (full cut net + vs one of four y-jet channels), (iii) level (s = f(S) vs v = f(y); H4-JC-R1), (iv) scaling (κ_* = Θ(1/r) + vs κ_dam = Θ(1) — a Θ(1) margin cannot dominate a Θ(1/r) family). No asserted identification survives; the + 9-pin tube is recorded as PROOF TEMPLATE only. +- **H4-SD distinction verified, not assumed:** H4-SD's C⁰-impossibility applies to the B1.dir event (away + branch on M's lineage, sd_res = Θ(d²)); the B4 dam is the opposite geometry — a C⁰ value/curvature event on + a FIXED corridor at pin level s, cheapest cut ON the rigid ridge. Independently verified in the driver + (corridor profile strictly increasing; on-ridge margins). +- **Discrete mirror (B1's frozen PL model, b1_falsifier.py 818df798…):** 3 B4 pairs audited (0 ensemble + 3 + synthetic), EVERY B4 corridor CUT (0 violations); 387 clear-corridor pairs (categories A 154 / B1 1 / B2 66 / + success 163), NONE of them B4; mirror fail-closes on violation. +- **Mutation suite fails CLOSED:** M1 weaken-margin (×1/2) fires the o(r³) gate (P_bound = 0.104 > r³ = 1.25e-4, + ratio 835); M2 widen-tube (σ̄, D × 2) fires the o(r³) gate; M3 RN (C_RN × 2) fires the RN-drift gate + ("consumed RN factor drifted above H4-RN's certified C_RN = 3.47"); F3 verifies mutation tags (no silent + normal runs). Both interpreter modes byte-identical (t_* ≡, tf_* ≡). + +## 3. Carrier 2 — UPPER2D/D3_percolation/PERC_DECAY.md (D3 lane; record D3-PERC-DECAY-20260915-v1.0, FREEZE_PERC_DECAY.txt) + +| artifact | rule | recomputed sha256 | bytes | verdict | +|---|---|---|---|---| +| UPPER2D/D3_percolation/PERC_DECAY.md | marker-lines (LF-joined lines strictly between the unique exact lines BEGIN_FROZEN_BODY / END_FROZEN_BODY; normalize line endings to LF; exactly one terminal LF) | 5137a811e6be72ed27e0458c75537bdcfabb8d8e7148b211d8c7b9a1584df400 | 8041 (body 7409) | MATCH vs FREEZE_PERC_DECAY.txt | +| UPPER2D/D3_percolation/PERC_DECAY.md | whole file (custody) | f971b81a54dd2b78924c77e412e0c19b798e5356795057fcdadec3235e960745 | 8041 | MATCH | +| UPPER2D/D3_percolation/d3_perc_decay.py | whole file | ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64 | 19063 | MATCH | +| UPPER2D/D3_percolation/pd_normal.txt | whole file | 7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 | 9762 | MATCH; ≡ pd_opt.txt BYTE-IDENTICAL | +| UPPER2D/D3_percolation/pd_opt.txt | whole file | 7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 | 9762 | MATCH (both interpreter modes; engine digest 58df7e312099d3acd93fe83f728b4b139274063c98386b9963bbc1a6270e2b9b) | +| UPPER2D/D3_percolation/d3_falsifier.py | whole file | abbb40d279606660a0c16af253d9bc15038f7221702fb7aaa6f74b4b893df032 | 32264 | MATCH vs freeze (F1–F7 line) | +| UPPER2D/D3_percolation/tf_normal.txt | whole file | b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 | 1833 | MATCH; ≡ tf_opt.txt BYTE-IDENTICAL (cmp verified) | +| UPPER2D/D3_percolation/tf_opt.txt | whole file | b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 | 1833 | MATCH (D3-FALSIFIER PASS, exit 0; falsifier digest fcb37708468875723bbfac838ab7b5ab374edb4ae60566f1ef2b7b5e44958e9f) | +| UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt | whole file (custody) | 6bbe6e27a91c777b7245294fc5740462af06e7f20b0f92ff4eae15cd2f05edef | 3966 | complete freeze incl. the falsifier F1–F7 line | + +F7 status note: at the start of this addendum's assembly FREEZE_PERC_DECAY.txt (3609 B, 10:19) lacked the final +falsifier line and would have been recorded pending-in-addendum per instructions; the D3 lane completed the +two-mode falsifier run and the freeze line LANDED at 11:26 during assembly (file now 3966 B). The landed +hashes were verified FROM BYTES by this agent and MATCH the freeze record (d3_falsifier.py abbb40d2…, +tf_normal ≡ tf_opt b5e97e60…, falsifier digest fcb37708… — the tf transcripts end with "PERC-DECAY re-run: +exit 0, byte-identical; … D3-FALSIFIER PASS digest=fcb37708…"). Nothing is pending. + +## 4. Carrier 2 certified content (verified against the frozen body 5137a811…) + +**The honest verdict (body §0):** the far lanes are **Θ(r³), NOT o(r³)**. Each far lane is window-priced: its +ORDER is Θ(r³) (the window ℓ = r³/6 fixes the order), and every distance-decaying factor (RN reversion, +crude-spine cap density, kernel-scale connectivity) controls the CONSTANT, not the order. The decisive +corridor-alive certified axial-mean display (body §3): the conditioned axial mean stays ABOVE s from S out to +the ghost-elder territory — μ−s = +2.4e-8 @0.024 (≈S, pinned) rising through +2.3e-3 @0.2 to +9.4e-2 @1.0; the +z-score decays to the bottleneck z = 0.68 = Θ(1) @1.0 (transcript value 0.68056). The connectivity factor at +the sub-kernel handoff (d_max = 0.20–0.25, BRANCH_dir's 4r–5r) does NOT vanish as r → 0, so the o(r³) reading +is false in the saddle-node limit. Consistent with D1 v2.2's Theorem (2), which needs the far lanes inside +C·r³, not literally o(r³). + +**Restatement underwritten by the lane:** PERC-DECAY := *the far lanes absorb at Θ(r³) with the certified +constants, plus D-tails certified under the named input PD-CONN.* + +**Certified today (theorem-usable):** +- **B1.dir-far = FarRoute ⊆ {N_w ≥ 1}** — the away lobe's merge into C_M is necessarily a WINDOW SADDLE + (C_M born at b at M, the away lobe at s at S). P(FarRoute) ≤ E_{P_r}[N_w]; the D3-certified part outside + the C1 chart ≤ B_remote + I_hole ≤ 21.9279 + 1.284 = **23.2119·r³** — inside the v2 remote bracket, + floor-consistent. +- **B2-far ⊆ E[N_w(d ≥ 0.2)] ≤ 17.6802·r³** (crude-spine cap grade, R2 floor Z_lo = 7.7592917375327855e-3; + recomputed numerator over radii ≥ d_max; transcript 17.680197·r³). +- **B4.rem:** NOT ⊆ the window count (the non-local separator can close through above-window saddles or the + torus wrap). Certified content: the LOCAL dam per-section (κ_dam = 71.84 / 129.9 / 391.2 at + ξ = 0.25 / 0.5 / 0.75 — κ = Θ(1/r), residual sd = Θ(r⁴), clearance the cubic Hermite profile, per-section + price Φ(−κ_dam) super-algebraic, polarity-safe); the REMOTE part is NAMED (above-window merges at heights + > b + the torus wrap circuit d ~ 12). + +**Named input PD-CONN (deliverable-grade):** P_{Q_r}(A_r(B(pair, 2r), D)) ≤ C₀e^{−c₀D} for all D ≥ D₀ ≥ 1, +r ≤ 0.05, with explicit r-uniform constants C₀, c₀. Consumption: each far lane's D-tail ≤ (certified count +density)·C₀e^{−c₀D}·(1 + κ certified); class totals absorb at Θ(r³) with certified constants; B4.rem's wrap +≤ C₀e^{−12c₀}. **Missing pieces:** (i) an explicit-constant planar-Bargmann–Fock arm bound at positive level +(the literature gives sharpness WITHOUT explicit constants — an explicit RSW constant is the missing theorem); +(ii) the field-level conditioned→unconditioned patch on {d ≥ D₀} (finite-dimensional reversion certified in +the carrier; the field-level version needs continuity-modulus/Kolmogorov-entropy control — not built); +(iii) the torus→planar comparison (available, ≤ 1e-120). **PD-CONN certifies CONSTANTS, not order** — at +sub-kernel D the connectivity factor is Θ(1). + +**Displays (body §2, §5):** reversion profile (Var → 1, κ_cross → 6.2e-8 along the ray; the field NOT yet +reverted at the handoff — the far lanes start inside the conditioned zone); annulus cap-density decay +(ρ_cap = 7.8093e-7 @(0.1, 0°) → 1.3715e-9 @5, frozen D4); window-count D-tail +(E_Q[N_w(d ≥ D)]/r³ = (576 − πD²)·J(ℓ)/r³ = 2.9268 / 2.9234 / 2.9115 / 2.8636 / 2.6720 / 1.9056 at +D = 0.2 / 0.5 / 1 / 2 / 4 / 8 — the raw count is Θ(r³) at every D < 12; decay lives entirely in the +connectivity factor). **Machinery:** fail-closed (ck → SystemExit), deterministic, Monte-Carlo-free (every +denominator the R2-certified floor), both modes byte-identical; mutation suite MUT-PD-1..5 (register-taxonomy +tamper, grade-label tamper, R2 floor-pin tamper, count-window tamper, corridor-display tamper) all fire — +verified live in the tf transcripts, including the F7 PERC-DECAY re-run gate (engine re-run exit 0 +byte-identical; count bound 17.680197·r³ and bottleneck z = 0.68056 within their windows). + +## 5. Register deltas (THEOREM_TABLE / 00_EXECUTIVE_STATE / ADVERSARIAL_REPORT not edited — this delta governs) + +- **CLOSED — B4.loc dam-line tube certificate (validity premise #5):** the premise is CLOSED at certificate + grade by B4LOC_DAMLINE.md (body 0d5c1b32…): uniform Borell–TIS sup-tail over the pair-level cut net under + the 6-pin law, super-algebraic grade exp(−c_eff/r²), whole-B4 claim (loc + rem). The caveat carried inside + the premise (cut-net ≡ 9-pin tube item (ii) "ASSERTED, NOT ESTABLISHED") is RESOLVED NEGATIVELY by the + certificate itself (four-axis proof of distinction; independent direct construction — the item is now + stated and owned independently of D2's tube lane, exactly the discharge the premise's falsifier/discharge + clause allows). **Flag:** the whole-B4 claim's wrap/remote coverage vs D3's named B4.rem remote part is the + reconciliation question of §7 below — under D1 adjudication; the CLOSED status stands for the B4.loc + premise itself, with the reconciliation tracked as OPEN until adjudicated. +- **RESTATED — PERC-DECAY (validity premise #3):** the premise as phrased ("subcritical level-s⁺ cluster + decay feeding every far lane's o(r³) pricing") is REFUTED at evidence grade on certified displays and is + REPLACED by the restatement: **PERC-DECAY := the far lanes absorb at Θ(r³) with the certified constants + (23.2119·r³ D3-part for B1.dir-far inside the v2 bracket; 17.6802·r³ for B2-far; B4.rem local dam + super-algebraic per-section) plus D-tails under the named input PD-CONN.** The replacement still serves + Theorem (2)'s need (far lanes inside C·r³). State: RESTATED, engine COMPLETE and FROZEN; PD-CONN itself + remains a NAMED INPUT (OPEN) with its three missing pieces (explicit-constant planar-BF RSW arm bound; + field-level Kolmogorov-entropy patch; torus→planar comparison — available, ≤ 1e-120). +- **Failed-approach register addition (ADVERSARIAL_REPORT.md §6 table — not edited; recorded here):** + | Failed approach | Type | Exact reason it cannot be resurrected (carrier) | + |---|---|---| + | "o(r³) far-lane" reading (the registered PERC-DECAY phrasing: distance-decay factors deliver o(r³) pricing of B1.dir-far / B2-far / B4.rem) | mathematical | Refuted by the corridor-alive certified display (PERC_DECAY.md body 5137a811… §0/§3): the conditioned axial mean never dips below s out to x = 1.0, bottleneck z = 0.68 = Θ(1), so the connectivity factor at the sub-kernel handoff is Θ(1) and does not vanish as r → 0; every decay factor controls the constant, not the order (window ℓ = r³/6 fixes Θ(r³)); the window-count D-tail display (§5) independently shows the raw count is Θ(r³) at every D < 12. A successful attack FORCING AMENDMENT. Replacement: Θ(r³) absorption with certified constants + PD-CONN D-tails (constants, not order). | +- **Dir accounting note (flagged for D1, adjudicating — recorded, not resolved here):** the certified + inclusion FarRoute ⊆ {N_w ≥ 1} prices B1.dir-far as a FREE-RIDER inside the E_w window-count envelope + (the same E_{P_r}[N_w] that carries the window count), whereas D1 v2.2's sharper form (1′) carries the dir + remainder through the C_RN·√Q dir term. The two accountings are different line items for the same event; + which line carries FarRoute in the final assembly (free-rider inside E_w vs the RN dir term) is a + bookkeeping/adjudication question for D1. No double-count is certified either way by this addendum. +- **Theorem table row 5 delta:** of the five validity premises of Theorem (2): B4.loc dam-line tube + certificate → CLOSED (super-algebraic, whole B4; wrap/remote reconciliation flagged OPEN, D1); PERC-DECAY → + RESTATED (Θ(r³) absorption, certified constants + named PD-CONN input OPEN). OBL-D1-PROMOTE (chart side), + D3-LEMMA-RN-UNIF, OBL-B1-BRANCH(loop|B1): unchanged by this addendum. + +## 6. Obligation-ledger delta (OBLIGATION_LEDGER.md not edited — this delta governs) + +- **§5 B4.loc dam-line tube certificate — CLOSED 2026-09-15.** Discharge mechanism: the certified sup-tail + (net + entropy + RN) over the cut net (Theorem B4LOC-R1, body 0d5c1b32…) PLUS the independent statement and + ownership of the item (the cut-net ≡ tube identification proven FALSE on four axes; 9-pin tube retained as + proof template only). Certified numbers: P_r(B4) ≤ 1.22e-9 / 1.52e-45 / 1.03e-197 on the ladder; + c_eff = 0.0513 / 0.0645 / 0.0709; margins Θ(1/r); C_RN ≤ 3.47 pinned fail-closed. Discrete mirror: 3 B4 + corridors cut, 387 clear none-B4. Mutations M1/M2/M3 fail closed; both modes byte-identical. Carried + forward as OPEN: the B4.rem wrap/remote reconciliation vs D3's named remote part (see §7; owners D1+D2+D3). +- **§3 PERC-DECAY — RESTATED 2026-09-15.** The falsifier/discharge clause's kill condition partially fired: + a far-lane-relevant connectivity factor is certified Θ(1) at the handoff, killing the o(r³) SUFFICIENCY of + the registered phrasing — but per the clause's own scope this is an amendment of the premise, not a kill of + Theorem (2) (which needs C·r³). New content (D1 to ratify): far lanes absorb at Θ(r³) with certified + constants (B1.dir-far D3-part ≤ 23.2119·r³ inside the v2 remote bracket; B2-far ≤ 17.6802·r³ cap grade; + B4.rem local dam certified per-section, κ = Θ(1/r)) + D-tails under named input PD-CONN. Sub-obligations + created/OPEN: PD-CONN piece (i) explicit-constant planar-BF arm bound (RSW-with-constants — THE missing + theorem), (ii) field-level conditioned→unconditioned patch (Kolmogorov entropy), (iii) torus→planar + (available, ≤ 1e-120, bookkeeping). Owner: percolation lane for the engine (COMPLETE, FROZEN); PD-CONN + ownership to be assigned by D1. +- **§8 / H3 addendum cross-reference:** unchanged; the H3 band-floor discharge stands. + +## 7. The B4.rem reconciliation question (OPEN — owners D1 + D2 + D3 jointly) + +B4LOC-R1's inclusion lemma (body §2) is proved for ALL of B4 (loc + rem): its contradiction step argues that +with the corridor strictly above s the remote obstruction defining B4.rem is absent — so the certified +sup-tail prices the whole class. D3's PERC-DECAY (body §1, §4) instead states B4.rem is NOT ⊆ the window +count and certifies only the LOCAL dam per-section, NAMING the remote part (above-window merges at heights +> b; the torus wrap circuit d ~ 12; M-ward channel beyond the local cut net d > r) as carried by PD-CONN +(wrap ≤ C₀e^{−12c₀}). The question: does B4LOC's corridor argument genuinely cover the wrap/above-window +remote mechanisms (making D3's named remote part a redundant over-count), or does the pair-level corridor +inclusion miss genuine remote closures that require PD-CONN? Both certificates are individually frozen and +verified; the overlap must be adjudicated before the final assembly prices B4.rem exactly once. **Owner: +D1 + D2 + D3 jointly. State: OPEN.** + +## 8. Running-tasks delta (RUNNING_TASKS.md not edited — this delta governs) + +- **D2 lane (branch control): B4LOC dam line — COMPLETE, FROZEN 2026-09-15.** B4LOC_DAMLINE.md body + 0d5c1b32… + driver bf3b0225… + falsifier d59ad790… + both-mode byte-identical transcripts (t_* 11baaccc…, + tf_* 1629de83…) + FREEZE.txt 5235f98a… (driver digest 43ff9c1e…, falsifier digest f939eeab…). +- **D3 lane (percolation): PERC-DECAY — COMPLETE, FROZEN 2026-09-15.** PERC_DECAY.md body 5137a811… + engine + ee68ac75… + both-mode byte-identical transcripts (pd_* 7547476c…, engine digest 58df7e31…) + falsifier + F1–F7 (d3_falsifier.py abbb40d2…, tf_* b5e97e60… byte-identical, falsifier digest fcb37708…) + + FREEZE_PERC_DECAY.txt 6bbe6e27…. NOTE: the falsifier F7 two-mode run was in flight at the start of this + addendum's assembly and LANDED at 11:26 during assembly (freeze record 3609 B → 3966 B); all landed hashes + re-verified from bytes — nothing pending. Any post-11:26 revision of FREEZE_PERC_DECAY.txt would supersede + the custody hash 6bbe6e27… recorded here (the frozen body/engine/transcript hashes it records were + re-verified stable across the window). +- Lane-summary rows to add: "B4LOC dam (D2) | COMPLETE, FROZEN | B4LOC_DAMLINE.md 0d5c1b32… + FREEZE.txt + 5235f98a… | B4.rem reconciliation (D1+D2+D3)"; "PERC-DECAY (D3) | COMPLETE, FROZEN | PERC_DECAY.md + 5137a811… + FREEZE_PERC_DECAY.txt 6bbe6e27… | PD-CONN pieces (i)–(iii), D1 assignment". +- All other lanes (H5 promotion, W3, W8, BRANCH, H3) unchanged by this addendum. + +## 9. Executive-state one-line deltas (00_EXECUTIVE_STATE.md not edited — this delta governs) + +- Premise #5 (B4.loc dam-line tube certificate): OPEN → **CLOSED 2026-09-15 — Theorem B4LOC-R1 certified + super-algebraic (P_r(B4) ≤ exp(−c_eff/r²), c_eff up to 0.071; ladder 1.22e-9 / 1.52e-45 / 1.03e-197), + whole-B4 claim; cut-net ≡ 9-pin-tube identification proven FALSE on four axes (independent statement); + wrap/remote reconciliation vs D3 OPEN under D1 adjudication.** +- Premise #3 (PERC-DECAY): OPEN → **RESTATED 2026-09-15 — the o(r³) far-lane reading REFUTED at evidence + grade (corridor-alive certified display, bottleneck z = 0.68 = Θ(1)); replacement: Θ(r³) absorption with + certified constants (≤ 23.2119·r³ B1.dir-far D3-part; ≤ 17.6802·r³ B2-far; B4.rem local dam κ = Θ(1/r)) + + named input PD-CONN (constants, not order; three missing pieces, the explicit-constant planar-BF RSW + arm bound the missing theorem).** + +## 10. Custody and verification statement + +- Every hash printed in §1 and §3 was recomputed FROM BYTES by this agent before printing and again after + writing (re-verification table appended to SOURCE_CAPSULE.sha256's ADDENDUM-2 section and re-checked); + all verdicts MATCH. The two content sections (§2, §4) were verified against the frozen bodies quoted. +- Package manifests: 00_MANIFEST.sha256 (v1) and 00_MANIFEST_v2_2026-09-15.sha256 preserved unmodified; + 00_MANIFEST_v3_2026-09-15.sha256 (new file) covers the whole package including this addendum and the + appended capsule. SOURCE_CAPSULE.sha256 extended APPEND-ONLY: pre-append state 23075 B sha256 + 69d14191652f9b6afcbbe317f7594fa7d83ff3b8211ca12133be788aecd93308 (tail verified = the '# ADDENDUM + 2026-09-15' section); the v1 prefix (first 19117 B) re-verifies to fc4ffdf3a91b9f04d2882016d20a719f5b8ac1831e5582154d4ebff82a366ba2. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md new file mode 100644 index 000000000..295025239 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md @@ -0,0 +1,118 @@ +# ADDENDUM 2026-09-15 — H3 BAND FLOOR frozen: normalizer sub-part of OBL-D1-PROMOTE DISCHARGED (uniform modulus on (0, 0.05]) + +Append-delta to RETURN_06 (assembled 2026-09-15T00:05:36Z). No frozen file is modified; every hash below was +recomputed FROM BYTES by the addendum agent on 2026-09-15 before being cited. Root: /mnt/agents/output/K3_SIDE24_LB/. + +## 1. The new carrier (frozen in UPPER2D/H3_closure/, record H3-BAND-FLOOR-2026-09-15) + +| artifact | rule | recomputed sha256 | bytes | verdict | +|---|---|---|---|---| +| UPPER2D/H3_closure/H3_BAND_FLOOR.md | body-excl-hash-line (whole file minus the final `Body hash of this document: …` line; LF) | 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 | 11133 (body 11029) | MATCH vs lane MANIFEST.sha256 + RECEIPT_h3.json | +| UPPER2D/H3_closure/h3_band_floor.py | whole file | a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5 | 37315 | MATCH | +| UPPER2D/H3_closure/band_normal.txt | whole file | dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d | 2835 | MATCH; ≡ band_O.txt BYTE-IDENTICAL | +| UPPER2D/H3_closure/band_O.txt | whole file | dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d | 2835 | MATCH (both interpreter modes) | +| UPPER2D/H3_closure/band_out.txt | whole file | 617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54 | 2743 | MATCH; equals the in-transcript self-hash line `sha256(transcript-above)` | +| UPPER2D/H3_closure/band_mut_planar.txt | whole file | 4fc8105d1050dc2a284750ada417f959725711b8e19865ced682192da59e4774 | 305 | MATCH; CK_FAIL at CB1a (exit 1, as designed) | +| UPPER2D/H3_closure/band_mut_window.txt | whole file | ff1765d4ace7fb5c61402e227c5896017bd1995cad0e2f8475761a3850a01c51 | 833 | MATCH; CK_FAIL at CB3 window identity (exit 1, as designed) | +| UPPER2D/H3_closure/RECEIPT_h3.json | whole file | ff788042c6bce3bb89bccee17ee88478b81b72426b5b474929a009b0fe8ee209 | 4482 | MATCH; records all of the above | + +Extraction-rule note (verified from bytes, recorded for the capsule): the capsule's generic `sepbody` rule +(bytes before the first `"\n---\n\n"`) does NOT apply to this file — the document carries a separator after +its header block, and sepbody recomputes to 94089e9f696e520cd660b37f53d5e472b217134adfafe4c1c06939217107d19d, +NOT the registered value. The lane-FREEZE-recorded rule is `body-excl-hash-line` (annotated verbatim in the +lane's MANIFEST.sha256 as `H3_BAND_FLOOR.md(body-excl-hash-line)` and keyed identically in RECEIPT_h3.json); +under that rule the recomputed body hash is 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 +— an exact MATCH from bytes. + +Custody supersession (no frozen file touched): SOURCE_CAPSULE.sha256 Section B line for +`UPPER2D/H3_closure/h3_band_floor.py` (sha256 9eb0f426…, 36181 B, custody-only) and TREE_MANIFEST.sha256's +lines for `h3_band_floor.py` (5506e648…, 37254 B) and `band_normal.txt` (empty, e3b0c442…) are pre-freeze +snapshots of a lane both files' headers explicitly declare VOLATILE; the addendum values above supersede them +for custody going forward. The frozen document carriers (H3_CLOSURE 387e4bae…, H3_RUNG_FLOOR 6347275d…) are +unchanged and re-verified by the lane MANIFEST. + +## 2. Certified statement (quoted from the frozen body 281477c3…) + +For EVERY r ∈ (0, 0.05]: + + E[G_r] ≥ 2.30659559567154 > c_Z = 1.615489267643502474048123284509081575382 + +hence the normalizer satisfies Z_r = r²·E[G_r] ≥ c_Z·r² UNIFORMLY on (0, 0.05]; worst certified margin ++42.78% (attained on the rung-adjacent cell (0.04, 0.05]). Per-cell certified floors (interval lower +endpoints, 15 digits): + +| sub-interval | certified E[G_r] ≥ | margin vs c_Z | +|-------------------|--------------------|---------------| +| (0, 0.0025] | 2.58288222715895 | +59.88% | +| (0.0025, 0.005] | 2.58174158877406 | +59.81% | +| (0.005, 0.01] | 2.54243388604045 | +57.38% | +| (0.01, 0.02] | 2.45593199230367 | +52.02% | +| (0.02, 0.03] | 2.44022641168325 | +51.05% | +| (0.03, 0.04] | 2.41792545239159 | +49.67% | +| (0.04, 0.05] | 2.30659559567154 | +42.78% | + +Method (from the frozen doc): exact Laurent-series Gram algebra at r = 0 (corrected-basis poles cancel +exactly; genuine soft poles z⁻¹, z⁻² isolated and annihilated by the conditioning), exact series division to +J = 60, Neumann-certified correction on cells 2–7 (R-majorant series tails on the first cell only), interval +Horner evaluation, certified series tails, conditional-Wick truncated integrals + exact-Gaussian-tail +Chernoff/Cauchy–Schwarz rare-event pieces (t₀ = 3.6–9.7σ → ∞ as r → 0), certified Φ machinery (series +|x| ≤ 6 with geometric-tail certificate, Gordon–Mills outside). No whitening, no Monte Carlo in the +certificate (MC labeled diagnostic-only, consistent). Discipline: fail-closed ck → SystemExit; both modes +(`python3` / `python3 -O`) byte-identical transcripts; mutation suite caught at the designed guards +(MUTATION=planar_moments → CB1a; MUTATION=wrong_window → CB3). + +## 3. Scope note (uniform vs point) + +The uniform band minimum 2.30659559567154 (⇒ Z_r ≥ 2.30659559567154·r² everywhere on (0, 0.05]) is +necessarily weaker than the sharper rung-point certificate at r = 0.05: R2's certified +Z_{0.05} ∈ [7.7592917375327855e-3, 1.1468646473404396e-2], i.e. Z_{0.05} ≥ 3.1037·r² (H3_RUNG_FLOOR.md +6347275d…, unchanged). The band floor's dip at the top cell is enclosure loss, not physics (true E[G_r] +≈ 3.2, MC-labeled). The band certificate covers (0, 0.05] only; it says nothing about r > 0.05 and does not +replace the frozen point certificates. + +## 4. Discharge statement + +The NORMALIZER sub-part of OBL-D1-PROMOTE is DISCHARGED with uniform modulus, by the following exact +mechanism: the frozen certificate H3_BAND_FLOOR.md (body 281477c3…) certifies Z_r ≥ c_Z·r² for EVERY +r ∈ (0, 0.05] with c_Z = 1.615489267643502474048123284509081575382 — i.e. H3's existential theorem-grade +bound is now certified with an explicit uniform constant on the whole rung band, extending R2's pointwise +floors to the continuum. Exact mechanism per the certificate: interval-r carried through the no-whitening +Wick pipeline as exact Laurent series at r = 0 with pole-cancelled corrected basis, exact series division +(J = 60), Neumann/Cauchy-certified truncation corrections, and literal-bound certified tails; both modes +byte-identical; mutations fail-closed; receipt H3-BAND-FLOOR-2026-09-15. + +The remaining promotion content of OBL-D1-PROMOTE is the CHART side — H5's r-scaled rung family + band +interpolation (OBL-H5-JETMOD / OBL-H5-REMOTE-THRESHOLD) — which remains OPEN / RUNNING (rungs r = 0.025, +0.035355 executing per RUNNING_TASKS.md; unchanged by this addendum). Theorem (2)'s r₀ stays EXISTENTIAL: +the chart envelope, not the normalizer, is now the blocking premise on that side. + +## 5. Obligation-ledger delta (OBLIGATION_LEDGER.md, not edited — this delta governs) + +- §1 OBL-D1-PROMOTE: **normalizer sub-part CLOSED** (discharge mechanism in §4 above); chart side OPEN + (OBL-H5-JETMOD, OBL-H5-REMOTE-THRESHOLD unchanged; H5 rungs executing). +- §1 sub-obligation OBL-H5-ZBAND: the lo side now rides a FROZEN uniform certificate + (Z_r ≥ c_Z·r² for ALL r ∈ (0, 0.05], body 281477c3…) — no longer an unbanked run; the hi side (band LPW + bracket) remains OPEN. +- §8 "H3 band-floor assessment": **COMPLETE and FROZEN** — H3_BAND_FLOOR.md body 281477c3…, script + a907eeed…, both-mode byte-identical transcripts dcb3c8e6…, transcript body 617b2d07…, mutation transcripts + 4fc8105d… / ff1765d4… (caught at the designed guards), RECEIPT_h3.json ff788042…. Supersedes the ledger's + "State: RUNNING (script modified 07:58:13 CST; band_normal.txt created empty …)". One bookkeeping item + remains with the D1 lane: optional gate consumption of the band floor (the rung consumption via R2 already + stands); this is bookkeeping, not an evidence gap — the discharge rests on the frozen certificate alone. + +## 6. Running-tasks delta (RUNNING_TASKS.md, not edited — this delta governs) + +- §5 "H3 band-floor assessment — RUN COMPLETED, NOT YET FROZEN" → **COMPLETE, FROZEN** 2026-09-15: the + missing items listed at assembly (FREEZE record, -O companion transcript, mutation harness run) all exist + and are hash-verified above; band_normal.txt (empty at the TREE_MANIFEST snapshot, declared volatile) is + now the frozen transcript dcb3c8e6… ≡ band_O.txt. The lane-summary row "H3 band | RUN COMPLETE, unfrozen" + → "H3 band | COMPLETE, FROZEN | H3_BAND_FLOOR.md 281477c3… + RECEIPT_h3.json ff788042…". +- All other lanes (H5 promotion, W3, W8, BRANCH) unchanged by this addendum. + +## 7. Executive-state one-line delta (00_EXECUTIVE_STATE.md, not edited — this delta governs) + +H3 band-floor assessment: RUNNING → **COMPLETE, FROZEN 2026-09-15 — CERTIFIED uniform normalizer floor +Z_r ≥ c_Z·r² for EVERY r ∈ (0, 0.05] (band min E[G_r] ≥ 2.30659559567154 > c_Z, worst margin +42.78%); +the normalizer sub-part of OBL-D1-PROMOTE is DISCHARGED with uniform modulus; the chart side (H5 rung +family + interpolation) remains OPEN** (carrier H3_BAND_FLOOR.md body 281477c3…; CANNOT-VERIFY item 7's +"continuum band remains unexecuted" is superseded on the rung band (0, 0.05]). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md new file mode 100644 index 000000000..3550287c4 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md @@ -0,0 +1,109 @@ +# ADVERSARIAL_REPORT — RETURN_06 adversarial review record + +Sources (all hash-verified, SOURCE_CAPSULE.sha256): the frozen Stage-E corpus STAGE_E/REVIEW_{proof, +numerics, provenance, scope, topology}.md; D1 v2.1 §4 CHANGES (round-1 dispositions); D1 v2.2 §0/§4 +(round-2 dispositions); the repair carriers R1–R4; lane FAILED_APPROACHES records. + +## 1. Stage-E protocol + +Independent reviewers, each with NONE prior exposure beyond the mission prompt (declared in every review); +unpooled findings; certificates RERUN, not read; custody hashes recomputed from bytes per each carrier's own +FREEZE convention; CANNOT-VERIFY recorded strictly separately from FAIL. The frozen corpus carries FIVE +review files; the lead consolidated them into FAIL-1/FAIL-2; finding IDs G1–G6 do not exist anywhere in the +frozen corpus (flagged by D1 v2.1, unresolved, no claim depends on them). + +## 2. Reviewer dispositions (round 1, target: D1 v2.0) + +| Reviewer | Disposition | Findings | +|---|---|---| +| PROOF | **FAIL** (three independent grounds, each sufficient) | F1 fatal: H4-JC pointwise disjoint-carrier premise FALSE (level conflation; proof + explicit counterexample: ens-0 pair (875,951), window saddles [915], qual_D2 ∧ N_loop-member; true overlap 176/1435) — the frozen carriers prove only the twice-paid 2·I_hi form. F2: rung normalizer floor uncertified (H3 r₀ existential; "0.05 inside H3's radius" used, never named; D1 §8 "unconditionally of every open item" false). F3: remote bracket drops D3's (1 + κ_far) ≈ 1.63 factor; ε_QMC is MC evidence; zone uniformity is the OPEN D3-LEMMA-RN-UNIF | +| NUMERICS | **FAIL-grade finding F-1** (+ minors) | F-1: certification-chain gap on the consumed remote constant (19.55·r³ vs certified κ_far = 0 value 19.5483·r³ with the source stating (1+κ_far), κ_far ≤ 0.63 + ε_QMC). F-2: H5 A≡B two-path claim vacuous (modes parameter-identical; digests valid). F-3: stale records (state-file hash quote; code drift; H4 probes-ladder headline). F-4: freeze-time exact totals unrecoverable — CANNOT-VERIFY, ≤ 4.6e-12, immaterial. All certificates re-executed PASS (H3/H4/H5 digests reproduced; I_hi = 8.097558925e-02 independently reproduced to 40 digits) | +| PROVENANCE | **FAIL** (six findings, two material; three CANNOT-VERIFY) | F2 (material): the consumed bracket drops (1+κ_far); a QMC estimate rides inside a "certified" bracket. F3: H5-AXIS v3 absent from the frozen consumed carrier; S-disk radius records disagree. F4: D3-LEMMA-RN-UNIF dropped between D3 and Theorem (1)/§8. F1/F5/F6: H3 c₀ prose +1.4e-40 (E-H3-1); C_RN ladder display rounds the 0.025 rung DOWN; C1 "a₆ = 15" flat (a₆ − 15 = −3.1e-117, E-C1-1). CV1–CV3: CANNOT-VERIFY (H5 first-merge full-precision totals; stitch part-level drift; "45 cks" count, cosmetic). Hunt list: 3D firewall PASS; planar-limit PASS except F6; superseded-carrier hygiene PASS | +| SCOPE | **FAIL** (three exact scope violations) | F1: D3-LEMMA-RN-UNIF dropped at Theorem (1)/§8. F2: (1+κ_far) dropped from the consumed 19.55·r³ bracket (κ instantiated at its QMC-EVIDENCE value inside a certified display). F3: PERC-DECAY missing from Theorem (2)'s hypotheses while B4.rem/B2-far consume it. CANNOT-VERIFY: trapezoid-as-certified-sup question; κ_far = 0 exactness for d ≥ 5; unstated O(r³) B4.rem pricing | +| TOPOLOGY | **T6 FAIL** (H4-JC); T1–T5, T7 PASS | T6 = the same H4-JC level conflation (counterexample reproduced inline; reproduction recipe frozen in the review). T5 (D2-COMPLEMENT 4-channel) PASS; taxonomy/complement/LPW-placement targets PASS | + +Convergent consolidation: FAIL-1 = proof F1 = topology T6; FAIL-2 = the "unconditional" over-claim; +proof F3 = numerics F-1 = scope F2 = prov F2 (the κ_far break); scope F1 = prov F4; scope F3 standalone. + +## 3. The three convergent breaks and their repairs R1–R4 + +1. **H4-JC level conflation** → **R1**: H4_JC_EVENT_LEVEL.md (H4JC-R1, body 42ee88da…) — event-level + joint carrier proved from taxonomy coverage + subset counting; display preserved verbatim, ZERO constant + changes; mirrors replaced (OLD 132/175 violations pinned fail-closed as a certified datum; NEW 0/439); + downstream audit (D2 unaffected; E[N_loop] ≥ P(A) side consequence; loop factor re-pointed to + OBL-B1-BRANCH(loop|B1)); the retracted form cited nowhere in v2.1/v2.2 (gate ck; retraction-string + injection kills the gate). +2. **Z-rung out-of-scope** (rung floor uncertified) → **R2**: H3_RUNG_FLOOR.md (whole 6347275d…) — + certified interval Z_{0.05} ∈ [7.7592917375327855e-3, 1.1468646473404396e-2], margin +92.12% over + c_Z(0.05)² = 4.0387231691087558e-3; stretch rungs 0.045/0.055 same margins. +3. **κ_far under-pricing / dropped factor** → **R3**: D3_REMOTE_AMENDMENT.md (v1, κ_far ≤ 0.66 certified, + QMC demoted to consistency display, B_remote = 21.2153·r³; discriminating falsifier window rejects the + κ = 0 sum 19.5465) — then round-2 V1 exposed the floor breach → the **v2 amendment** below. +4. **H5-AXIS v3 unfrozen / totals discipline** → **R4**: tightening amendment frozen (7fefa17b…, H5-AXIS v3 + in full; radius resolved at 0.062); rung-scoped merger + version-pinned v3 totals (8d7028e4…) + + freeze/errata documents; I_lo rung-pollution repaired by the rung-scoped merger. + +## 4. Round-2 findings and repairs (target: D1 v2.1) + +- **Scope V1**: κ_far assembles 0.6773 > 0.66 at the certified floor; the G.7 consumption dropped from the + register; the "zero MC" claim false → **REPAIRED AT SOURCE** by D3_REMOTE_AMENDMENT_v2.md (6796deea…): + κ pieces and I_ann re-evaluated at R2's certified floor Z_lo (κ_cross 0.64990178 + κ_pair 0.0025176 + + κ_y 0.0243696 = 0.677284905 → round-UP κ_far ≤ 0.68, cap covers BOTH the amendment's display and the + assembly recomputation 0.67678902 — nit N-D3V2-1); B_remote = 17.6804 + 2.5282637·(1+κ_far) = + 21.9279·r³ (exact bracket 21.92788306…), genuinely Monte-Carlo-free; the v2.1 false claim recorded as + FALSE CLAIM REPAIRED; 19.5465/20.9/21.2153/21.2658 all SUPERSEDED; G.7-at-the-rung recorded CLOSED with + its mechanism; gate v3 rejects anything below 21.92788306. +- **Scope V2**: B4.loc's dam line must be a VALIDITY premise (no raw counted-class envelope exists; + grep-verified across C2/D2/D3/B1/H4) → **REPAIRED** in D1 v2.2 §1: moved into Theorem (2)'s premise + list with exact content, including the asserted-not-established cut-net ≡ D2 9-pin-tube (ii) + identification; gate v3 cks its presence (removal kills the gate). +- **Round-2 focused re-reviews** (dispositions consumed by D1 v2.2; standalone re-review files are not in + the tree — CANNOT-VERIFY as files, dispositions verified via the hash-verified D1 v2.2 body): + **H4JC-R1 counterexample instance: PASS-WITHSTOOD** (event-level carrier attacked, no change); + **numerics v2.1: PASS** for the v2.1 gate/chain with two BRANCH_dir receipts defects (owner's errata + landed 2026-09-15: 7547e76a… — receipts grade only, "NOT soundness"; the certificate passes both modes, + rung independently reproduced q = 0.999855 / counts 3112/888, falsifier catches all 4 mutations) and the + κ-probe sensitivity flag (repaired at source by V1); the h3 CR5f mislabel recorded (E-H3-2); + **scope v2.1: FAIL V1/V2** → both repaired in v2.2 as above. + +## 5. D1's gate self-test catches (d1_falsify lineage) + +- v2.1-era: the gate's body-only citation ck exposed by D1's OWN mutation test → whole-file ck (process + break repaired; recorded in D1 v2.2's failed-attack ledger). +- v3 mutation self-tests (all killed; restored state PASS byte-identical): retracted-string injection → + FAIL; upward-drift h5_totals_v4.json injection → FAIL; QMC-denominator (21.2153) substitution → FAIL + F-remote-display; B4.loc-premise removal → FAIL F-B4loc-premise-bullet. The bracket ck was STRENGTHENED + from the v2.1 form to consume ≥ 21.92788306 (the initially-loose ck tightened; extends D3's operative + edge [21.27, 22.5]-class window into the assembly gate). 92 fail-closed cks, exit 0 both modes, + transcripts byte-identical; re-executed live by this build agent (digest d800849e…). + +## 6. Failed-approach preservation register (every failed approach, failure type, why it cannot be resurrected) + +| Failed approach | Type | Exact reason it cannot be resurrected (carrier) | +|---|---|---| +| Dropped-square-root Cauchy–Schwarz (WP "missing-sqrt") | mathematical | Factor p_grad·√(E[det²H])·min(P_type,P_window) as an upper bound is invalid (needs √(min)); confirmed 175.3× at the witness; mechanical root-insertion too weak (~1e-2 zone class); quarantined (FAILED_APPROACHES #1); W3's harness mutates it in and CHECK2 kills it | +| Finite-rung tables + fitted exponents → all-small-r | mathematical | Extrapolation without a scaled asymptotic law (FAILED_APPROACHES #2); O(r^1.6) mislabeled O(r³) (#3) | +| T5 certificate defects; float64 9-pin Gram inversion; complex-arithmetic spectral covariance; double-hex-line encodings | numerical/custody | KeyError crash, silent garbage at det ~1.3e-42, NaN propagation, stale-hash-line defect (FAILED_APPROACHES #4–7); repaired by mpmath-100dps + Neumaier residual certification, real parity decomposition, single-hex-line discipline | +| Interval-box evaluation of the Λ-grid functional (DER-027b) | numerical | Structural cancellation junk ~7500× box width (FAILED_APPROACHES #8); abandoned for exact J2/J3 jets + exact midpoints + named premise H-B3 | +| Global sup-bound arithmetic for the Λ-grid | numerical | Magnitude compounding through frame/Neumann stages (#9) | +| Zone-wide value-kill as a uniform bound (C030 (i)) | mathematical | Rim band (92.8% of the upper-bound integral) and ridge arcs refute uniformity; the printed rigidity figure was a single-station value × full disk area; G-F2a gate FAILED-AS-WRITTEN and was waived (#10) | +| Direct tensor Gauss–Hermite on the tail-dominated 4D expectation | numerical | Unstable across meshes (1.1e-21 → 4.1e-21); replaced by exact 1D u-slice reduction (#11) | +| Cantelli as the in-slice saddle-probability bound near the window | mathematical | Too loose where Edet(u) is several SDs out (#12) | +| **Global-CS modulus 4.2·r^{3/2}** (W6 WP-min) | mathematical | Genuine singularity ρ_CS ~ ℓ^{1/2}d^{−4} near the pin cluster: modulus fails for r ≲ 0.003 (W12 B1, self-caught FAILED_APPROACHES #13); the truth is dead there (ρ ≤ 1e-171) — a bound artifact; repair = zone split, identified not executed; W12's B3 independently mis-quantifies premise F1 (4.236 > 4.2) | +| Missing-sqrt-restoration mutation (W13 F6) | custody (accepted gap) | No landed certificate implements the restoration mutation BY DESIGN: the defective factor is quarantined upstream and the WP-min closure's exact-integrand chain contains no such factor; all existing mutation classes verified fail-closed | +| **Isserlis mean-drop** (LEAD_SYMBOLIC_WP §3(A)) | mathematical | E[det²H] display false for nonzero means (missing −2ν_iν_jν_kν_l; overcount exactly 2(det ννᵀ)²; counterexample 7 vs 5; witness absolutes inflated √1.34488 — conservative direction, 22+ orders of margin absorb it where inherited; record correction owed) (W12 B2) | +| **LPW_CONSTANT v1** | mathematical | D1: published decimal above the exact fraction (rounded denominator); D2: false identity E[(|X|+|Y|)⁴] = 12 + 16/π (true 12 + 32/π). Frozen historical; v2's amplitude majorant is the only valid form; v1 caps survive conservatively, its decimal/derivation do not | +| **H4-JC false pointwise form** (H4_CLOSURE §2.3) | mathematical (level conflation) | Every α-qualifying saddle is an N_loop member (proved + counterexample); the once-payment at that grade is FALSE; only the event-level form H4JC-R1 survives; the retracted §2.3 is preserved as historical and gate-banned from citation | +| **κ = 0 bracket (19.5465·r³ class)** | mathematical | D3-THM carries (1 + κ_far) with κ_far > 0; the falsifier's named gate rejects 19.5465 (window [20.54646, 22.5]); the assembly gate rejects below 21.92788306; no polarity argument making κ_far = 0 exact exists in any carrier (scope CANNOT-VERIFY) | +| **C⁰ single-slice dam for B1.dir** (H4-SD) | mathematical (certified impossibility) | Theorem H4-SD (slice-dam vacuity): no single-slice C⁰ dam prices B1.dir at o(r³) — the smallness is irreducibly the interaction of channels; certified, not merely observed | +| **C¹ tube route for B1.dir** | mathematical (certified-dead) | The entropy/RN budget blows up (4 ln C_RN + 2 ln 2 term), killing the o(r³) tube route; displayed certified-dead per H4-SD's record; forced the NearSwap/FarRoute split | +| **W8 v2 rung-stability track** (DER-027b draft) | custody + incomplete | Six placeholders/unfinished sections itemized (expected-verdict language, unattached hashes/transcripts, v1 script without receipts); formal nonclosure successor receipted at the certificate standard with the exact missing piece named | +| **W8 scalar-SV Phase-2 track** | numerical | Scalar Leibniz arithmetic is cancellation-blind to the W-congruence (~400× invisible; certifies 3536 vs TRUE 0.0182 — 2e5× inflation): an all-scalar sweep would FALSELY ATTRIBUTE soundly-certifiable cells as failures | +| **The refused 31h all-ledger sweep** | process (refusal receipted) | Exactly the falsely-attributed all-ledger outcome above; REFUSED and never launched (PHASE2_SCOPE.md lead-mandated ledger entry); replaced by the J3 route with depth-capped subdivision | +| W8 depth-0 σ⁴-box freeze (Phase-2 mid-course) | numerical (bug, resolved) | Froze sups at coarse depth-0 values; the X9 Neumann tower (s4 ~ 1e15 vs TRUE 1.3e3) then never shrank → unclosable type gate; REVERTED to current-sub-box sups; the 6 ledgered cells declared INVALID under the fixed build; banks cleaned before relaunch | + +## 7. B1 adversarial batteries (successful defenses) + +B2a outside-cover, B2b boundary (NO-BREAK-WITH-CONCERNS: three Lemma R proof-scope gaps G4/G1/G5 named — +closed by H2 reg_lemmas Lemma R countersignature), B2c ties (B3 ⊂ N, P_r = 0), B2d torus/global +(NO-BREAK-WITH-CONCERNS): the frozen taxonomy survived all four; coverage gate satisfied. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md new file mode 100644 index 000000000..b2b2da3f9 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md @@ -0,0 +1,105 @@ +# DEPENDENCY_DAG — RETURN_06 theorem dependency graph + +Notation: `A ──consumes B @ grade G──▶` means A's certificate/theorem depends on B at grade G. +Grades: EXACT / CERTIFIED-INTERVAL / NAMED-LEMMA / VALIDITY-PREMISE (open) / REFINEMENT (open) / +EVIDENCE-DIAGNOSTIC (never load-bearing) / HISTORICAL (consumed nowhere). +All nodes hash-pinned in SOURCE_CAPSULE.sha256. + +## Foundations layer + +``` +LEAD_INTENSITY_DERIVATION.md (L1)/(L2) ──@EXACT──▶ B1, C1, C2, D2, D3 +H2_foundations/cov_exact.py f08c1c5f… ──@EXACT library──▶ C1, C2, D2, D3, H3, H4, H5, BRANCH, W8-lane +H2_foundations/pin_transform.py c6988ac7… ──@EXACT library──▶ (same consumers) +H2_foundations/reg_lemmas.py e7005a5a… ──@EXACT (Lemma R countersignature G1/G4/G5)──▶ B1 (taxonomy gaps named by B2b closed), D2 +``` + +## Deterministic topology layer (2D) + +``` +B1_TAXONOMY.md 7d7ddbec… (coverage/disjointness: on Reg ∩ TYP, 1−q = P(A)+P(B1)+P(B2)+P(B4)) + ──@EXACT──▶ C1, C2, D2, D3, D1(1) + attacked by B2a (outside-cover), B2b (boundary), B2c (ties), B2d (torus): all NO-BREAK / gaps closed +C1_ALPHA_INTENSITY.md ca2c02b8… (α-class exact intensity; kernel factors EXACT @80 dps; g(v), Z_r, + plane integral EVIDENCE-GRADE QMC) ──@EXACT kernel + chart envelope──▶ D3 (I_hole = 1.284·r³), D1(1) +C2_B_CLASSES.md 2aba099d… (B1 loop / B2 younger-merge / B4 non-adjacency classes; B4 lane per-cut + P ≤ (√E[W²]/Z_r)·Q(sup_ζ f ≤ s)^{1/2}) ──@EXACT──▶ D1(1), D2 +D2_BRANCH_CONTROL.md 9e95648a… (D2-COMPLEMENT 4-channel partition PRE/NA/LOOP/YNG; G-table) + ──@EXACT──▶ D1(1); its tube item (ii) ≡ OBL-D2-AO-SHARP(ii) ──@ASSERTED-NOT-ESTABLISHED──▶ B4.loc premise +``` + +## Certified quantitative layer (2D) + +``` +H3_CLOSURE.md 387e4bae… (EXISTENTIAL: Z_r ≥ c_Z r², c_Z = c₀/2 ≥ 1.615489267643502474, r₀ existential) + ──@EXISTENTIAL──▶ D1(2)'s r₀; consumed NOWHERE at the rung (out of scope there — proof F2) +H3_RUNG_FLOOR.md 6347275d… (R2: Z_{0.05} ∈ [7.7592917375327855e-3, 1.1468646473404396e-2] certified + interval, +92.12% margin; stretch rungs 0.045/0.055) + ──@CERTIFIED-INTERVAL──▶ D3_REMOTE_AMENDMENT_v2 (κ pieces + I_ann at Z_lo, drift-ck pinned), + D1(1) C_RN(0.05) ≤ 3.46, G.7-at-the-rung DISCHARGE +H4_CLOSURE.md a67d50b9… (H4 branch dams; H4-SD slice-dam vacuity — no single-slice C⁰ dam, certified; + C¹ tube route displayed certified-dead; §2.3 pointwise H4-JC RETRACTED, preserved historical) + ──@EXACT-minus-retraction──▶ D1(1) +H4_JC_repair/H4_JC_EVENT_LEVEL.md 42ee88da… (H4JC-R1 event-level joint carrier; PASS-WITHSTOOD round 2; + OLD 132/175 violations pinned fail-closed; NEW 0/439) ──@EXACT──▶ D1(1) once-payment of I_hi +H5_CLOSURE.md 465c97c0… (v1 rung interval) + H5_CLOSURE_TIGHTENING 7fefa17b… (H5-AXIS v3 in full) + + h5_totals_v3.json 8d7028e4… (I_hi(v3) = 8.0975589252e-2 = 647.8048·r³ round-UP, version-pinned, + downward-only drift discipline) + ──@CERTIFIED-INTERVAL (box cover) + @NAMED-LEMMA (H5-RIM rim band; H5-AXIS v1+v2+v3 wedges/S-disk)──▶ D1(1) +D3_PERCOLATION.md 8e7fef6b… (A.rem spine: 20.9·r³ form; base carrier) + + D3_REMOTE_AMENDMENT_v2.md 6796deea… (CURRENT: B_remote = 17.6804 + 2.5282637·(1+κ_far), + κ_far ≤ 0.68 floor-certified = 21.9279·r³, MC-free; v1 amendment 63d91cdd… HISTORICAL) + ──@CERTIFIED (modulo D3-LEMMA-RN-UNIF)──▶ D1(1) remote part of Ĩ_hi +BRANCH_dir/BRANCH_DIR.md 8821c8fa… (q(0.05) = 0.99982, 1−q = 1.42·r³ exact continuous-field MC; + channel price ladder R_ch; OBL-B1-BRANCH(dir) content) ──@EVIDENCE-DIAGNOSTIC──▶ consistency only, never premise +``` + +## Assembly layer (2D UPPER theorems) + +``` +D1_ASSEMBLY_v2_2.md 490ad6b2… ── consumes ALL of the above at their grades; gate d1_falsify_v3.py + (92 cks, digest d800849e…, re-executed live exit 0) re-verifies the whole chain fail-closed. +Theorem (1)/(1′) [named-hypothesis grade] ◀── H5-RIM, H5-AXIS v1+v2+v3 [NAMED-LEMMA] + ◀── D3-LEMMA-RN-UNIF(r = 0.05) [VALIDITY, open] +Theorem (2) [CONDITIONAL] ◀── OBL-D1-PROMOTE [VALIDITY, open] ◀──┐ + ◀── D3-LEMMA-RN-UNIF [VALIDITY, open] │ + ◀── PERC-DECAY [VALIDITY, open] ◀── convergence point of ALL far lanes: + │ B1.dir-far (FarRoute, handed off with the exact certified boundary), + │ B2-far, B4.rem + ◀── OBL-B1-BRANCH(loop|B1) [VALIDITY, open; re-pointed from the retracted + │ H4-JC loop factor; constant-level; E[N_loop] ≥ P(A) side consequence] + ◀── B4.loc dam-line tube certificate [VALIDITY, open; incl. the cut-net ≡ D2 + 9-pin M-ward-tube (ii) identification — ASSERTED, NOT ESTABLISHED] +Refinement register: OBL-D2-AO-SHARP (i, iii, v) [REFINEMENT, open] ── sharpens constants only +OBL-D1-PROMOTE ──▶ OBL-H5-JETMOD / OBL-H5-ZBAND / OBL-H5-REMOTE-THRESHOLD (promotion sub-obligations) + ──▶ H3 band-floor assessment (interval-r enclosure of R2's pointwise floors; RUNNING) +H5-RIM production path: shell_hi_fi (parked, p_sup-dominated); H5-AXIS production path: factored-det + expansion det Σ_gg = (d_M d_S)⁴·Q(1+O(d)) (documented, not run) +``` + +## LPW lower lane (separate family within 2D) + +``` +LPW qualitative (endorsed) ──@review-grade──▶ LPW_CONSTANT v2 (c = 1.1357762846347807215698804e-43, + r₀ = 1/2224640) ──@EXACT──▶ H1_v2_hardening lpw_constant_v3.py re-certification (same pair) +LPW_CONSTANT v1 [HISTORICAL DEFECTIVE] — consumed nowhere +``` + +## THE FIREWALL (structural, verified) + +``` +3D SIDE24 ratified upper chain (AO48-OPR-045) ✕──no edges──✕ every 2D node above + · no AO48-OPR-045 citation exists anywhere in the tree (provenance hunt-list §4.1 PASS); + · the only "3-dim" string in a consumed carrier is C2's 3-component Gaussian MC-calibration marginal + (not the 3D theorem); D3's DER-027a reference is labeled consistency-display-only; + · combining the 3D upper with the endorsed 2D lower into an existential Θ(r³) statement requires + separate operator adjudication and is NOT made by any carrier. +``` + +## Auxiliary open quantitative campaigns (no edges into the theorems above) + +``` +W3_numerics (WP lower-bound enclosure, RUNNING) — feeds only the WP disposition, not D1/LPW. +W8_lambda + Phase-2 workspace (Λ-side certified floor, RUNNING) — feeds only the Λ floor obligation. +Coefficient-limit campaign — NOT OPEN; no node; forbidden until the two-sided 2D theorem closes. +``` diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md new file mode 100644 index 000000000..ff1ff3d10 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md @@ -0,0 +1,118 @@ +# OBLIGATION_LEDGER — RETURN_06 (every named obligation; states read fresh at assembly 2026-09-15) + +Content quoted from the obligation's own carrier (hash in SOURCE_CAPSULE.sha256). Grade classes: +VALIDITY PREMISE (of D1 v2.2 Theorem (2)) / REFINEMENT / NAMED LEMMA / UPGRADE-ONLY. + +## 1. OBL-D1-PROMOTE — VALIDITY PREMISE of Theorem (2) + +- **Content (D1 v2.2):** uniform certified chart envelope on (0, r₀′] — the all-small-r promotion; the + existential two-sided normalizer H3 stands separately (closed since v1.1); the continuum band is + unexecuted and routed here. C's leading content in Theorem (2) is the uniform envelope constant. +- **Falsifier/discharge:** a certified rung family + band enclosure delivering the uniform envelope; killed + by any rung whose certified envelope/r³ drifts UP beyond the ledger (falsify_promote.sh watches + r-law displays: patches lo ratio vs r³ within 30%, edge-probe ratios vs r¹ within 35%). +- **Owner:** H5 lane + D1. **Execution state (fresh):** EXECUTING — r = 0.05 COMPLETE (v3 647.8048·r³); + r = 0.025: patches COMPLETE (lo 7.1329e-10), probes COMPLETE, cells EXECUTING (83+19 banked jsonl + lines), stitch EXECUTING (6 lines); r = 0.035355: cells EXECUTING (42+20), stitch 3; last writes + 04:53–05:08 CST 2026-09-15; κ = 1/8 modulus band displayed (12 certified points, c2(r) = 1/2 − r²/8 + + O(r⁴), max residual 3.4e-6 — DISPLAY, certified band enclosure remains OBL-H5-JETMOD). +- **Sub-obligations:** + - **OBL-H5-JETMOD:** certified interval bounds for the full 24-jet set over r-bands [r_{k+1}, r_k] with + lattice-tail constants re-certified uniformly in band. Falsifier: a band enclosure whose width exceeds + the claimed modulus. State: OPEN (display only, see above). + - **OBL-H5-ZBAND:** Z_r window bounds over bands (point-rung windows banked; lo rides H3's c_Z·r² + theorem-grade uniform bound; hi side needs the band LPW bracket). State: OPEN; the H3 band-floor + assessment (h3_band_floor.py, Z_r ≥ c_Z r² for ALL r ∈ (0, 0.05], no whitening, no MC in the + certificate) is RUNNING — script active 07:58 CST, band_normal.txt empty, no banked output yet. + - **OBL-H5-REMOTE-THRESHOLD:** certify D3's remote bracket at the r-scaled threshold d ≥ 2r per rung, or + extend the chart's machine cover to an absolute d₀. Rides with D3-LEMMA-RN-UNIF. State: OPEN. + +## 2. D3-LEMMA-RN-UNIF — VALIDITY PREMISE (rung part named hypothesis of Theorem (1) itself) + +- **Content (D1 v2.2(1)(b) / D3 carriers):** zone uniformity of the RN brackets. Rung part (r = 0.05): + the rigidity-decoupling lemma for τ(y) uniform over {d ≥ 5}; a certified interval-box Riemann sum for the + annulus crude-spine integral. Closed at the rung WITHIN the item: all station κ pieces (floor-certified), + the exact far-zone main term (576 − 25π)J(ℓ), monotone-decay exact-kernel evidence. Uniform-in-r part: + as frozen. +- **Falsifier/discharge:** foundations countersignature of the two missing pieces; a counterexample station + with τ-uniformity violation kills it. D3's falsifier enforces the bracket edge: rejects the κ = 0 sum + 19.5465 (operative window [20.54646, 22.5]; assembly gate extends: rejects below 21.92788306). +- **Owner:** foundations. **State:** NOT CLOSED (rung part precisely stated; uniform part frozen). + +## 3. PERC-DECAY — VALIDITY PREMISE; the far-lane convergence point + +- **Content (D1 v2.2):** subcritical level-s⁺ cluster decay feeding every far lane's o(r³) pricing: + B1.dir-far (FarRoute, handed off with the exact certified boundary), B2-far, B4.rem. +- **Falsifier/discharge:** a certified subcritical decay theorem at the exact boundary; a far-lane summand + certified Θ(r³)-or-larger would kill the premise's sufficiency (B2-corridor's raw envelope is already + Θ(r³)-or-better by its power ledger, verified v2.1, unchallenged round 2 — that lane's kill stays + refinement-grade). +- **Owner:** percolation lane. **State:** OPEN (named validity premise since v2.1; no lane execution + recorded in the tree at assembly time). + +## 4. OBL-B1-BRANCH(loop|B1) — VALIDITY PREMISE (re-pointed) + +- **Content (D1 v2.2):** the re-pointed sharp loop factor given B1, constant-level; the E[N_loop] ≥ P(A) + side consequence is carried. Re-pointed from the retracted H4-JC pointwise form after R1. +- **Falsifier/discharge:** a certified constant-level bound on the loop fraction via BRANCH_dir's + exact-MC/certified-ladder machinery (channel price ladder R_ch(r) = 0.00142/0.00134/0.00114·r³ at + r = 0.05/0.025/0.0125, CK3); a counterexample loop channel exceeding the constant kills it. +- **Owner:** branch-control lane. **State:** OPEN; BRANCH_dir carriers complete (rung025 landed + 2026-09-14T21:47:19Z; certificate byte-identical both modes post-errata). + +## 5. B4.loc dam-line tube certificate — VALIDITY PREMISE (scope ruling V2) + +- **Content (D1 v2.2, exact):** the uniform Gaussian sup-tail over the pair-level cut net with the RN + prefactor (C2's B4 lane: per-cut P ≤ (√E[W²]/Z_r)·Q(sup_ζ f ≤ s)^{1/2}; the certified barrier-margin + ladder κ = Θ(1/r) is kernel-grade already). **Caveat carried as part of the item:** the assembly's + identification of the pair-level cut net with D2's 9-pin M-ward-tube item (ii) (OBL-D2-AO-SHARP(ii) ≡ + C2's tube item) is ASSERTED, NOT ESTABLISHED — the identification must be established, or the item + stated and owned independently of D2's tube lane. +- **Why validity, not refinement:** no raw counted-class envelope for B4.loc exists anywhere in the + carriers (grep-verified across C2/D2/D3/B1/H4 by the scope instance); the dam-line certificate is the + ONLY route to any O(r³) bound on that summand. +- **Falsifier/discharge:** the certified sup-tail (net + entropy + RN) over the cut net, plus the + identification proof or independent statement. Gate v3 cks the premise's presence in Theorem (2) + (removal kills the gate). +- **Owner:** branch-control / foundations lanes. **State:** OPEN. + +## 6. OBL-D2-AO-SHARP (i, iii, v) — REFINEMENT register only + +- **Content (D2 G-table):** (i–iii) the certified net+entropy+RN form of (G2) P_y^w(NA_y) ≤ + RN_y·exp(−κ̄²/4 + entropy) — κ_dam displayed Θ(1) scale-invariant (mid-window 11.98–1.9·10⁵ across the + α support at r = 0.05; weakest carrying station arch45c 11.98; probes, evidence); (v) the certified + profile form of (G4) P_y^w(YNG_y) ≤ E[N_band(y)] + far. With AO ≤ 1 exact these sharpen constants, NOT + validity. Item (ii) has MOVED to the validity premises (item 5 above); item (iv) (G3 confinement) is + outside the round-2 refinement register per D1 v2.2. +- **Owner:** branch-control lane. **State:** OPEN (refinement; probe-grade displays stand). + +## 7. H5-RIM and H5-AXIS v1+v2+v3 — NAMED LEMMAS inside the rung certificate + +- **Content (tightening amendment 7fefa17b…):** H5-AXIS v3 in full — ρ_w(y) ≤ C_region per region with + machine-certified constants C_scone = 0.18998, C_mfwd = 1.3254, C_mbwd = 1.6522e-05, C_disk = 0.34268 + (each = 2 × max certified edge-probe ρ_hi; CoarseBox + coarse_fine_hi, η = 2.5e-4, K = 8); flatness + hypothesis stated per region with receipts. v1→v2→v3 chain: cones only → S-disk 0.03 (poison cell + th15_dl0.066) → S-disk 0.062. H5-RIM: the rim-band region of the rung certificate. +- **Production paths:** H5-AXIS — the factored-det expansion det Σ_gg = (d_M d_S)⁴·Q(1 + O(d)) with Q + certified nonzero (documented, NOT RUN; retires the v3 quantifiers); H5-RIM — shell_hi_fi machine + certification (parked, p_sup-dominated). Until they land, the lemmas re-certify per rung in r-scaled form. +- **Grade:** NAMED LEMMA (probe constants machine-certified; flatness stated with receipts). +- **Owner:** H5 lane. **State:** OPEN production paths; named-hypothesis grade suffices for Theorem (1). + +## 8. H3 band-floor assessment — normalizer promotion (feeds OBL-D1-PROMOTE / OBL-H5-ZBAND) + +- **Content (h3_band_floor.py header):** CERTIFIED uniform normalizer floor Z_r ≥ c_Z r² for ALL r ∈ + (0, 0.05] — exact Taylor series at r = 0 of the corrected-pin/cross/soft Grams, exact series division, + interval evaluation on sub-intervals, certified band lower bound via Wick/conditional-Wick Gaussian + algebra; no whitening, no MC in the certificate; fail-closed, both modes byte-identical, mutation harness. +- **Owner:** H3 lane. **State:** RUNNING (script modified 07:58:13 CST; band_normal.txt created empty + 07:58:22 CST — no banked output at assembly time). **Never evidence until receipted.** + +## Closed-at-the-rung items (for the record; not open) + +G.7-scope normalizer AT THE RUNG — DISCHARGED by R2 (every consumed 1/Z_r divides Z_lo = +7.7592917375327855e-3); OBL-B1-REG — CLOSED; H3 existential form — CLOSED (c_Z = c₀/2); H2 at the O(r³) +grade — CLOSED; H4 except the re-pointed loop factor — CLOSED; H4-JC as H4JC-R1 — CLOSED +(PASS-WITHSTOOD); OBL-B1-BRANCH(dir) — CLOSED (NearSwap certified super-algebraic; FarRoute → PERC-DECAY); +the remote bracket floor-consistent — CLOSED modulo D3-LEMMA-RN-UNIF; the H5 rung interval (v3 totals) — +CLOSED (version-pinned, downward-only). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md new file mode 100644 index 000000000..c68ff4df8 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md @@ -0,0 +1,39 @@ +# PACKAGE_VERIFICATION — RETURN_06 completeness verification against the work-order list + +Verifier: addendum agent, 2026-09-15 (post-ADDENDUM 2026-09-15). Method: every hash cited below recomputed +FROM BYTES at verification time; package state = the nine v1 files + ADDENDUM_2026-09-15_H3_BAND_FLOOR.md + +the appended SOURCE_CAPSULE.sha256 (original 19117 bytes byte-identical to v1, prefix hash re-verified +fc4ffdf3a91b9f04d2882016d20a719f5b8ac1831e5582154d4ebff82a366ba2). States: PRESENT (path) / +PRESENT-VIA (carrier) / MISSING (exact gap). + +| # | Work-order item | State | Evidence (path / carrier / check) | +|---|---|---|---| +| 1 | Exact candidate — D1 v2.2 verbatim theorems quoted | **PRESENT** | THEOREM_TABLE.md rows 4–5; 00_EXECUTIVE_STATE.md §1–2. Verbatim check: D1 v2.2 body re-extracted by the marker-lines rule and re-hashed = 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6 (MATCH vs capsule); the quoted displays `1 − q(0.05, 6/5) ≤ Ĩ_hi + C_RN(0.05)·√Q_{0.05}(B1.dir) + P_{0.05}(B2) + P_{0.05}(B4)`, `E_w(0.05) ≤ Ĩ_hi = 8.1272827e-2 = 650.1827·(0.05)³`, C_RN ≤ 3.46, and Theorem (2)'s existential-r₀/C·r³ form all occur verbatim in the carrier body | +| 2 | Proof — the carrier chain | **PRESENT-VIA (SOURCE_CAPSULE.sha256)** | Section A: 22/22 document carriers MATCH, 0 mismatches; operative gate d1_falsify_v3.py (92 fail-closed cks) re-executed live at assembly, exit 0, digest d800849ed5966b4d583a10cf72525e89350d9a53780b45a807a21ccbadf91085 matching D1_V2_2_RECEIPTS.txt; addendum section A+/B+ adds the H3 band carrier (MATCH vs lane register) | +| 3 | Dependency map | **PRESENT** | RETURN_06/DEPENDENCY_DAG.md (foundations → topology → quantitative → assembly layers; LPW lane; 2D/3D firewall; auxiliary lanes) | +| 4 | Source capsule + addendum | **PRESENT** | RETURN_06/SOURCE_CAPSULE.sha256: v1 content untouched (prefix re-verified); `# ADDENDUM 2026-09-15` section appended with the H3 band carrier, extraction-rule note (sepbody does NOT apply; body-excl-hash-line = 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 MATCH), scripts/transcripts/receipt, and custody supersession note for the pre-freeze volatile h3_band_floor.py line | +| 5 | All scripts — capsule script register, 10 spot-checked | **PRESENT** | Capsule Section B register; 10/10 recomputed-from-bytes MATCH: b1_falsifier.py 818df798…, c2_falsifier.py 2441b630…, c2_probes.py ae7d2e5c…, d1_falsify_v3.py 5805e53d…, d3_falsifier.py c9e7458b…, d3_perc.py 5bc09241…, lpw_constant_v2.py ca654e39…, h3_rung_floor.py 094d3824…, h5_kernel.py b2e6014c…, br_certificate.py 0b7d2a7d… | +| 6 | All outputs — transcripts/receipts referenced | **PRESENT** | D1: v3_t_normal.txt ≡ v3_t_opt.txt (f207abc3…), D1_V2_2_RECEIPTS.txt; H3: cert_normal ≡ cert_O (a27178a8…), fals pair (5be02ea2…), rung trio (ad09ec8f…/427aeae3…/d439d37f…), rung mut pair, band quartet (dcb3c8e6… ×2, 617b2d07…, mut pair 4fc8105d…/ff1765d4…), RECEIPT_h3.json ff788042…; H4: cert pair + tf_normal.txt + RECEIPT_h4.json; H5: falsify_modeA/B.txt (identical digest 8cc3692b…), h5_totals_v3.json 8d7028e4…; BRANCH: falsify stdouts + rung logs (post-errata 7547e76a…); LPW: falsify_normal ≡ falsify_O; C1: falsifier_run.log; W3: receipts/ (byteident, failclosed, harness_O, harness_mut_pin); W8: mutation_receipts.txt / _v3.txt | +| 7 | Mutation receipts — each gate's mutation suite | **PRESENT** | D1 v3: 4 self-test mutations recorded in D1_V2_2_RECEIPTS.txt (retracted-string injection, v4 upward-drift, QMC-denominator, B4.loc-premise removal — all FAIL as designed; restored state PASS). D3: tf_normal.txt MUT-3/MUT-V2-3/MUT-V2-4 → SystemExit, PASS digest 6b04697c…. H4: mutation displays in tf_normal.txt, ALL PASS. H3: falsifier pair + rung mut_planar/mut_window + band mut_planar (CB1a)/mut_window (CB3), all CK_FAIL as designed. H5: falsify.py both-mode digest transcripts. BRANCH: falsify_normal.stdout "all mutations caught, all cks pass" (4 mutations, post-errata byte-identical). LPW: falsify F7 four defect mutations rejected both modes. B1/C2/D2/H4JC/C1: falsifier transcripts present, PASS digests (B1 78ee1509…, D2 877210c7…, H4JC 72fdc49b…). W3: harness receipts incl. missing-sqrt-class mutation fail-closed (receipts/harness_mut_pin.*). W8: mutation_receipts_v3.txt (mutations A/B… fail-closed) | +| 8 | Adversarial report | **PRESENT** | RETURN_06/ADVERSARIAL_REPORT.md (round-1 FAILs → R1–R4; round-2 V1/V2 → v2.2; gate self-test catches; failed-approach preservation register; B1 batteries) | +| 9 | Open-obligation ledger + addendum delta | **PRESENT** | RETURN_06/OBLIGATION_LEDGER.md (8 open items + closed-at-rung record) + ADDENDUM_2026-09-15_H3_BAND_FLOOR.md §5 (OBL-D1-PROMOTE normalizer sub-part CLOSED with mechanism; OBL-H5-ZBAND lo side frozen; §8 item → COMPLETE/FROZEN) | +| 10 | One-page executive state + addendum delta | **PRESENT** | RETURN_06/00_EXECUTIVE_STATE.md + ADDENDUM §7 one-line delta (H3 band RUNNING → COMPLETE, FROZEN; normalizer sub-part DISCHARGED with uniform modulus; chart side OPEN) | +| 11 | Theorem-table rules | **PRESENT** | THEOREM_TABLE.md verified textually: "program complete" / "two-sided law" / "limiting coefficient" occur ONLY inside the forbidden-language discipline header and row 10's prohibition sentence; LPW qualitative (row 1) distinct from LPW_CONSTANT v2 (row 2); v1 HISTORICAL DEFECTIVE (row 3); 3D SIDE24 a SEPARATE FAMILY with the structural firewall (row 6); W8 (row 8) and W3 (row 9) labeled auxiliary with no edges into the theorems; coefficient-limit campaign row 10: **NOT OPEN — and never inferable from current carriers** | +| 12 | Strongest-theorem-exactly statements | **PRESENT** | 00_EXECUTIVE_STATE.md "Strongest theorem established exactly" (D1 v2.2(1) certified-rung, named-hypothesis register; LPW lower theorem separate family with exact Fraction constant) + "Strongest CONDITIONAL theorem" (D1 v2.2(2) with the five named VALIDITY premises one line each); mirrored in THEOREM_TABLE rows 4/5/2 | +| 13 | Every CANNOT-VERIFY separated | **PRESENT** | 00_EXECUTIVE_STATE.md §"CANNOT-VERIFY (recorded separately from FAIL everywhere; none blocking)" items 1–9; THEOREM_TABLE row 7 (P0.2 CANNOT-VERIFY); ADVERSARIAL_REPORT records CV1–CV3 and scope CANNOT-VERIFYs separately; the addendum introduces NO new CANNOT-VERIFY (its §7 supersedes item 7's band clause on (0, 0.05]) | +| 14 | Running tasks never called evidence | **PRESENT** | RUNNING_TASKS.md header: "nothing on this page is evidence for any theorem … each labeled with its LAST VERIFIED ARTIFACT"; per-lane discipline labels (H3 §5 "NOT evidence"); ADDENDUM §6 delta preserves the discipline (state changes only; the frozen certificate, not the run, is the evidence) | + +## Summary + +14/14 work-order items: **13 PRESENT + 1 PRESENT-VIA (item 2, proof chain via SOURCE_CAPSULE.sha256) — +0 MISSING.** No exact gaps. No new CANNOT-VERIFY introduced by the addendum. + +## Carried CANNOT-VERIFY (pre-existing, recorded in the package; none blocking) + +- 00_EXECUTIVE_STATE.md items 1–9 (incl. standalone round-2 re-review files absent as files — dispositions + verified via the hash-verified D1 v2.2 body; "P0.2" no occurrence in the tree; lane-internal certificates + consumed at labeled grades). +- Custody notes, not gaps: SOURCE_CAPSULE Section B line for h3_band_floor.py (9eb0f426…, 36181 B) and + TREE_MANIFEST lines for h3_band_floor.py (5506e648…) / band_normal.txt (empty) are pre-freeze snapshots of + an explicitly volatile lane; superseded by the ADDENDUM 2026-09-15 capsule section (a907eeed…, 37315 B; + dcb3c8e6…, 2835 B). The frozen document carriers were untouched and re-verify. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md new file mode 100644 index 000000000..3ad0046b1 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md @@ -0,0 +1,106 @@ +# RUNNING_TASKS — exact states read fresh at assembly time: 2026-09-15 ~08:15 CST + +DISCIPLINE: nothing on this page is evidence for any theorem. Every lane is RUNNING (or newly complete, +not yet frozen); each is labeled with its LAST VERIFIED ARTIFACT. The consumed theorem content comes only +from the frozen carriers in SOURCE_CAPSULE.sha256. + +## 1. H5 promotion rungs (OBL-D1-PROMOTE) — EXECUTING + +- Supervision: keeper_promote.sh A/B (locks .keeperp_A/B.lock, 04:57 CST); refine-3 stitch lane PAUSED + (~14:05 2026-09-15, documented; banked records stand; v3 totals shipped). +- Rung r = 0.05: COMPLETE — frozen v1 731.43·r³; live clean v3 647.8048·r³ (h5_totals_v3.json 8d7028e4…, + version-pinned; tightening amendment + errata 2026-09-15). +- Rung r = 0.025: patches COMPLETE (lo = 7.1329e-10); probes COMPLETE (10 rim columns, 6 scone, 12 m-back, + 5 sdisk + 6 sring; one site re-certified at η = 6e-5 on retry, receipt banked); cells EXECUTING — banked + jsonl lines: s0p2_cells 83 + s1p2_cells 19; stitch EXECUTING — s0p1_stitch 6 lines (M-ring sec 0 = 0 via + the S-disk skip, as at r = 0.05). Last writes 04:34–05:08 CST. +- Rung r = 0.035355: cells EXECUTING — banked s0p2_cells 42 + s1p2_cells 20; stitch 3 lines; + patches/rimprobes/probes banked earlier (03:19–03:50 CST). Last write 04:57 CST. +- Merger fail-closed spec per rung: 70 cells, 10 rim cols, 6+12+5+6 probe sites, 8 patches, 22 stitch + sectors, rung-scaled coverage grid, C1_TOTAL(r) = 1.605315e-4·s³ ck; merge not yet runnable (cells/stitch + open at both rungs). +- r-law displays (certified quantities, H5_PROMOTE_UPDATE): patches lo ratio 0.1222 vs r³ = 0.125; + sdisk/sring edge-probe max ratios ≈ 0.5 = r¹; rim probes ≤ r¹ (conservative direction); falsifier watches + for slower-than-ledger parts — none seen. κ = 1/8 modulus band DISPLAYED (12 certified points; certified + band enclosure remains OBL-H5-JETMOD). +- LAST VERIFIED ARTIFACTS: h5_totals_v3.json (frozen, consumed); banked rung jsonl (custody only). +- Next milestone: close cells+stitch at r = 0.025 → rung merge → r = 0.035355 merge. + +## 2. W3 LOWER driver (WP rigorous enclosure) — RUNNING, STALE ~90 MIN AT ASSEMBLY + +- Drivers: w3_lbox.py two processes over x ∈ [−0.08, 0.08], y ∈ [0.50, 0.68], 0.0025 boxes (4608 total): + band A = y ∈ [0.50, 0.575], 1920 boxes; band B = y ∈ [0.575, 0.68], 2688 boxes. Checkpoint/resume + append-only. +- Fresh reads (lbox_A.txt / lbox_B.txt + .live, last writes 06:45:19 / 06:45:49 CST): + band A: box 39/1920 completed, acc (certified lower) = 2.303858e-10, acc_up = 3.911173e-3, + acc_ex = 9.168770e-9; band B: box 38/2688 completed, acc = 8.564328e-10, acc_up = 4.596954e-3, + acc_ex = 1.516962e-8. (Supersedes the register's earlier 33/1920 + 30/2688 snapshot.) +- Per-box cost ~100 s (A) / ~71 s (B) at edge columns; W3_REPORT ETA ~53 h (both bands). NOTE: no new + banked box in ~90 min before assembly (contention with the W8 relaunch 07:54 + H3 band run is possible; + driver processes are not visible to this build agent) — state reported as RUNNING-STALE, not failed. +- W3's own calibration: certified LOWER expected ~1–1.5e-6, BELOW the 3.328125e-6 = 0.213·r³ refutation + threshold — the formal refutation is EXPECTED INCONCLUSIVE (OPEN), neither refutation nor confirmation. +- LAST VERIFIED ARTIFACTS: harness receipts (CHECK0–CHECK5 exit 0 both modes, BYTEIDENT PASS; mutations + incl. missing-sqrt/pin fail-closed); lbox_A/B.txt accumulators. +- Next milestone: band completion → G2 comparison vs W4 (4.7569e-6 ± 0.4%) → WP disposition. + +## 3. W8 Phase-2 (Λ-side cell certification) — RUNNING (post-fix relaunch) + +- Workspace: /mnt/agents/output/19fcef2e-c1c2-8c6c-8000-0f5a243156d9/work/ (outside the frozen tree; + reported as an auxiliary lane). +- Scope (PHASE2_SCOPE.md): J3 certification on the 837 Phase-1-certified cells (623 interior + 214 clip-1) + of the 1707-cell grid of record; the 864 Phase-1-ledgered cells (783 clip-mixed branch-ambiguous, 81 + denominator-straddle) contribute NO sups and any rung conclusion EXCLUDES their boxes. +- Diagnostic RESOLVED this session: three stacked cancellation-blindness layers, ALL arithmetic (constant-G_k + sup blindness; red σ-sups now Bernstein-tight; ROOT: the depth-0 σ⁴-box freeze — reverted to + current-sub-box sups). VERDICT: bug, not a genuine obstruction. The 6 ledgered Phase-2 cells (M|0,13, + M|1,13, O|0,9, O|1,9, F|5,5,*) are INVALID under the fixed build → banks cleaned before relaunch. +- FRESH STATE: 4 shard drivers relaunched 07:54:43–07:54:51 CST (phase2_cert.py {C,M,O,F}, flock + singletons); all phase2_cells_*.jsonl and phase2_ledger_*.jsonl = 0 lines at 08:15 CST (0 certified + cells banked, 0 ledger entries — supersedes the register's "0 certified / 98 ledger entries" snapshot, + which predates the bank cleaning); keepers A/B alive (30 s heartbeats, last 1789431275 = 08:14:35 CST); + no phase2_*.live files yet; first cell lands ~10–20 min per the status file; ~2 min per depth-0 cell, + hours for depth-6 cells. +- LAST VERIFIED ARTIFACTS: Phase-1 banks (pre-existing); KIMI-DER-027c_NONCLOSURE.md (formal nonclosure, + certificate standard); verify_lambda_grid_v2/v3 transcripts. +- Next milestone: 4 shard receipts → verify_lambda_grid_v4.py full per-cell re-computation (completeness + 1707 = certified + phase2-ledger + phase1-ledger) + mutation suite → final report with hashes. + +## 4. BRANCH rungs — COMPLETE + +- rung05 production: COMPLETE pre-errata and independently reproduced by the Stage-E numerics reviewer + (N = 4000; q = 0.999855, 1−q = 1.453e-4 = 1.162·r³, se 5.1e-5; counts 3112/888). +- rung025 production: LANDED — completed 2026-09-14T21:47:19Z (keeper_rung025.receipt; the freeze-time + empty-log defect repaired; N = 1500; q = 0.999989, 1−q = 1.075e-5 = 0.688·r³, se 6.1e-6; counts 1183/317; + validate worst_mu = 1.29e-10, worst_var_rel = 1.57e-9). +- Post-errata products: certificate both modes BYTE-IDENTICAL ALL CKS PASS; falsifier both modes + BYTE-IDENTICAL, all 4 mutations caught; wall-clock/runner labels moved to sidecar receipts + (determinism-charter repair, BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md 7547e76a…). +- All BRANCH q-displays are EVIDENCE/diagnostic, never premises. No open BRANCH task. + +## 5. H3 band-floor assessment (normalizer promotion) — RUN COMPLETED, NOT YET FROZEN + +- h3_band_floor.py: CERTIFIED uniform normalizer floor Z_r ≥ c_Z r² for ALL r ∈ (0, 0.05] (exact Taylor + series at r = 0, exact series division, interval evaluation, Wick/conditional-Wick band bound; no + whitening, no MC in the certificate). +- FRESH STATE: transcript band_normal.txt (2883 B, completed 08:12:31 CST after 88.0 s runtime): + ALL_CHECKS_PASS — CB6 PASS: uniform certified floor on (0, 0.05]: min lo = 2.30659559567154 > + c_Z = 1.6154892676…, margins 59.88% / 59.81% / 57.38% / 52.02% / 51.05% / 49.67% / 42.78% across the + seven sub-intervals (0,0.0025]…(0.04,0.05]; CB7 Neumann containment PASS + MC DIAGNOSTIC (labeled NOT + load-bearing); transcript sha256 61e7bc49d8146c7669a8580cb52e2c7111480cb00777b86652256a7e7f78ee84 + (self-recorded). +- LABEL: transcript-grade ONLY at assembly time — no FREEZE record, no -O companion transcript, no mutation + harness run, and no D1-gate consumption exists yet. NOT evidence; feeds OBL-H5-ZBAND / OBL-D1-PROMOTE + when the lane freezes it. (If later frozen and consumed, this is the continuum-band piece whose absence + keeps Theorem (2)'s r₀ existential.) +- Next milestone: both-mode + mutation runs → freeze record → D1 gate consumption. + +## 6. Lane summary + +| Lane | State | Last verified artifact | Next milestone | +|---|---|---|---| +| H5 promotion | EXECUTING | h5_totals_v3.json (frozen); rung jsonl banks | r = 0.025 cells+stitch close → merge | +| W3 LOWER | RUNNING (stale ~90 min) | lbox_A/B.txt 06:45 CST; harness receipts | band completion → G2 vs W4 | +| W8 Phase-2 | RUNNING (relaunched 07:54) | Phase-1 banks; nonclosure report | 4 shard receipts → v4 verification | +| BRANCH | COMPLETE | rung025.log + post-errata byte-identical products | none open | +| H3 band | RUN COMPLETE, unfrozen | band_normal.txt ALL_CHECKS_PASS (transcript-grade) | freeze + consumption | diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt new file mode 100644 index 000000000..8e857168a --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt @@ -0,0 +1,279 @@ +# SOURCE_CAPSULE.sha256 — RETURN_06 machine-verifiable carrier manifest +# Campaign: K3_SIDE24_LB (2D UPPER theorem + LPW lower lane). Frozen tree root: /mnt/agents/output/K3_SIDE24_LB/ +# Assembled: 2026-09-15T00:05:36Z (build agent, RETURN_06). Method: every hash below recomputed FROM BYTES at assembly time +# and matched against the carrier register (full match where the register gives 64 hex; prefix match where it +# gives a prefix). Extraction rules: 'whole' = sha256 of the entire file; 'sepbody' = sha256 of all bytes before +# the first separator "\n---\n\n"; marker-lines rules = sha256 of the LF-joined lines strictly between the +# unique exact lines BEGIN_FROZEN_BODY / END_FROZEN_BODY with the stated trimming and exactly one terminal LF. +# NOTE: the register's generic rule 'body = everything before \n---\n\n' applies verbatim ONLY to the H5 +# carriers; the marker-carried files (D1/B1/C2/D2/D3/H4/H4JC) use their own FREEZE-recorded marker rules, each +# confirmed against the file's own FREEZE.txt / receipts. Every entry below MATCHED. Result: 22/22 document +# carriers verified, 0 mismatches; scripts/gates cross-checked where the register records a value (Section B). + +## A. Document carriers (theorem bodies) — path | extraction rule | recomputed sha256 | register | verdict | status +UPPER2D/D1_assembly/D1_ASSEMBLY_v2_2.md + rule: marker-lines (LF, blank-trimmed both ends, one terminal LF) + recomputed: 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6 + register: 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6 + bytes: 20078 | verdict: MATCH | status: FINAL +UPPER2D/D1_assembly/D1_ASSEMBLY_v2_1.md + rule: marker-lines (LF, blank-trimmed, one terminal LF) + recomputed: bcc177fea4ee06f9d25c56f207ed4b6e7577eff96bfc030202928813c0688189 + register: bcc177fea4ee06f9d25c56f207ed4b6e7577eff96bfc030202928813c0688189 + bytes: 22052 | verdict: MATCH | status: historical, superseded by v2.2 +UPPER2D/D1_assembly/D1_ASSEMBLY_v2_0.md + rule: marker-lines (LF, blank-trimmed, one terminal LF) + recomputed: 86882dca5d5258e9f1bab43e52c4382d30ec9609f89cd64486b3441f5ffd62d0 + register: 86882dca (register prefix; recomputed full hash at left) + bytes: 19386 | verdict: MATCH | status: historical, superseded +UPPER2D/D1_assembly/D1_ASSEMBLY_v1_2_ADDENDUM.md + rule: marker-lines (LF, blank-trimmed, one terminal LF) + recomputed: a7e1958c0d37d4eb63929823edd3190f83216fb4b127a4e85ad7e2e4da86ba67 + register: a7e1958c (register prefix; recomputed full hash at left) + bytes: 14249 | verdict: MATCH | status: historical, superseded +UPPER2D/D1_assembly/D1_ASSEMBLY_v1_1_ADDENDUM.md + rule: marker-lines (LF, blank-trimmed, one terminal LF) + recomputed: 634338b43a000502dfdda62a9019895434db7b50607a9989caaa1fd5873167e2 + register: 634338b4 (register prefix; recomputed full hash at left) + bytes: 8526 | verdict: MATCH | status: historical, superseded +UPPER2D/D1_assembly/D1_ASSEMBLY.md + rule: marker-lines (LF, blank-trimmed, one terminal LF) + recomputed: 006b8a7d011443a0a98401f30335fbcfe44ef5996b4fc41dd9735640d958de40 + register: 006b8a7d (register prefix; recomputed full hash at left) + bytes: 36000 | verdict: MATCH | status: historical v1.0, superseded +UPPER2D/B1_taxonomy/B1_TAXONOMY.md + rule: marker-lines (LF, trailing-blank-trim / rstrip-LF, one terminal LF) + recomputed: 7d7ddbec6e63b4c2a2c745b20e33a3d92cfdf5cb97588312a8d54fbd1ea68930 + register: 7d7ddbec6e63b4c2a2c745b20e33a3d92cfdf5cb97588312a8d54fbd1ea68930 + bytes: 31599 | verdict: MATCH | status: CURRENT +UPPER2D/C1_alpha_intensity/C1_ALPHA_INTENSITY.md + rule: whole file + recomputed: ca2c02b81a05e4cbc955b1aeab1f4120e9b8d4fda328aa191da08a49db72853f + register: ca2c02b8 (register prefix; recomputed full hash at left) + bytes: 27794 | verdict: MATCH | status: CURRENT +UPPER2D/C2_B_classes/C2_B_CLASSES.md + rule: marker-lines (LF, raw, one terminal LF) + recomputed: 2aba099d630dc7593b1c26bdd2ad3336c1c521e438ba5845edb0b98f2dadf3d2 + register: 2aba099d (register prefix; recomputed full hash at left) + bytes: 26326 | verdict: MATCH | status: CURRENT +UPPER2D/D2_branch_control/D2_BRANCH_CONTROL.md + rule: marker-lines (LF, one terminal LF) + recomputed: 9e95648acbe5307d7f61f7e7ccc102577b80974b38d03fc760f7ce7766a0b8fa + register: 9e95648a (register prefix; recomputed full hash at left) + bytes: 29448 | verdict: MATCH | status: CURRENT +UPPER2D/D3_percolation/D3_PERCOLATION.md + rule: marker-lines (LF, raw, one terminal LF) + recomputed: 8e7fef6b4fb989404624bf50083c9d8624fa486eeda62e4784447f8edb3eac47 + register: 8e7fef6b (register prefix; recomputed full hash at left) + bytes: 18808 | verdict: MATCH | status: CURRENT (base; bracket superseded by v2 amendment) +UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT.md + rule: marker-lines (LF, raw, one terminal LF) + recomputed: 63d91cdd6364725597504067a8ffa2378da0e89fe0e87afc81828dd78b8fec24 + register: 63d91cdd6364725597504067a8ffa2378da0e89fe0e87afc81828dd78b8fec24 + bytes: 8019 | verdict: MATCH | status: historical, superseded by v2 +UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md + rule: marker-lines (LF, raw, one terminal LF) + recomputed: 6796deea4bfd5e3df19fd561e6bc34efe2531263db9db8d015d0553c3a3d1302 + register: 6796deea4bfd5e3df19fd561e6bc34efe2531263db9db8d015d0553c3a3d1302 + bytes: 5701 | verdict: MATCH | status: CURRENT +UPPER2D/H3_closure/H3_CLOSURE.md + rule: whole file + recomputed: 387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637 + register: 387e4bae (register prefix; recomputed full hash at left) + bytes: 16857 | verdict: MATCH | status: CURRENT +UPPER2D/H3_closure/H3_RUNG_FLOOR.md + rule: whole file + recomputed: 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa + register: 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa + bytes: 7003 | verdict: MATCH | status: CURRENT (R2) +UPPER2D/H4_closure/H4_CLOSURE.md + rule: marker-lines (LF, trailing-blank-trim, one terminal LF) + recomputed: a67d50b9a24c82f970c60c5881eaa41cdf7d4b81cb1cf15904a3fc1b92b6b1d3 + register: a67d50b9 (register prefix; recomputed full hash at left) + bytes: 18527 | verdict: MATCH | status: CURRENT except retracted H4-JC §2.3 (preserved historical) +UPPER2D/H4_JC_repair/H4_JC_EVENT_LEVEL.md + rule: marker-lines (LF, raw, one terminal LF) + recomputed: 42ee88da984b82921d68cf3fcf6bc76ede9dd59b7ab5b1f947e24a29b08bf74c + register: 42ee88da984b82921d68cf3fcf6bc76ede9dd59b7ab5b1f947e24a29b08bf74c + bytes: 16888 | verdict: MATCH | status: CURRENT (H4JC-R1) +UPPER2D/H5_closure/H5_CLOSURE.md + rule: body = bytes before separator "\n---\n\n" (separator at byte 15162) + recomputed: 465c97c0553ecc0a8f461a86c9315ce1c078a326f07b81498d7a74da8603d301 + register: 465c97c0553ecc0a8f461a86c9315ce1c078a326f07b81498d7a74da8603d301 + bytes: 15246 | verdict: MATCH | status: CURRENT (v1 interval) +UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md + rule: body = bytes before separator "\n---\n\n" + recomputed: 7fefa17b74836092c0dd5912e028e3b09c1bf4f68c02e35390b552d4479f0561 + register: 7fefa17b74836092c0dd5912e028e3b09c1bf4f68c02e35390b552d4479f0561 + bytes: 7540 | verdict: MATCH | status: CURRENT (H5-AXIS v3; I_lo line superseded by errata) +UPPER2D/H5_closure/h5_totals_v3.json + rule: whole file + recomputed: 8d7028e4d0d49d54d3a7c4589a898289ec29eee6c2de9c774e99df0da46596bb + register: 8d7028e4d0d49d54d3a7c4589a898289ec29eee6c2de9c774e99df0da46596bb + bytes: 2364 | verdict: MATCH | status: CURRENT (version-pinned v3 totals) +UPPER2D/BRANCH_dir/BRANCH_DIR.md + rule: whole file + recomputed: 8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286 + register: 8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286 + bytes: 6069 | verdict: MATCH | status: CURRENT (§4 receipts paragraph corrected by errata) +UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md + rule: body (recomputed: whole file = body; no separator present) + recomputed: 7547e76a813d1a0c582139e2d31d9ec6a6480e1eaf670d3eed05173bffead3df + register: 7547e76a813d1a0c582139e2d31d9ec6a6480e1eaf670d3eed05173bffead3df + bytes: 6063 | verdict: MATCH | status: CURRENT (errata) +## B. Gates / falsifiers / engines / libraries — whole-file sha256 recomputed from bytes +# Register cross-checks: values recorded in the lane FREEZE/receipts; MATCH = recomputed equals recorded. +LPW_CONSTANT/falsify.py sha256=435b40ce1630c0b90ee660efffc5f313d86c07490178a02d21f7825a3173d1fb bytes=14789 (no register value recorded; custody hash only) +LPW_CONSTANT/lpw_constant.py sha256=e258322cfbb71dbb8665c2d0c0517399dca5ca5913e9ddf70eb7247ba74d3035 bytes=25380 (no register value recorded; custody hash only) +LPW_CONSTANT/v2/lpw_constant_v2.py sha256=ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125 bytes=8322 (no register value recorded; custody hash only) +UPPER2D/B1_taxonomy/b1_falsifier.py sha256=818df7985412071259345455c9ff6b68cad0c0fa9d636009cf8849b550154185 bytes=14734 register=818df7985412071259345455c9ff6b68cad0c0fa9d636009cf8849b550154185 MATCH +UPPER2D/B2a_outside_cover/b2a_attacks.py sha256=95ccfdc8846ae855259676982000069e614cb5539d55a883693ac173ca09e8c7 bytes=17043 (no register value recorded; custody hash only) +UPPER2D/B2b_boundary/b2b_boundary_probe.py sha256=12a4f585ce3f51547cde7799ad974c3fa00e7cb43e4890176a1f65f86f11818e bytes=13333 (no register value recorded; custody hash only) +UPPER2D/B2c_ties/b2c_ties.py sha256=9b636443ae57b6ee58236801843135a0ac034fa371f1b53c66d1b72f9e828430 bytes=24567 (no register value recorded; custody hash only) +UPPER2D/B2d_torus/b2d_torus_attack.py sha256=acd5043d7419c5af1e4f5230a3d8ac932548dbd1bf67451e3458f369c5ecc9df bytes=38121 (no register value recorded; custody hash only) +UPPER2D/BRANCH_dir/br_certificate.py sha256=0b7d2a7dbf4a3a03e7fc4e9509d69f7fbfe8a57d8a9b6653198caf4e8594beee bytes=9846 (no register value recorded; custody hash only) +UPPER2D/BRANCH_dir/br_falsifier.py sha256=326d10a8bd752ded24ba2ac045b9129420a45b4704925ae13c81b3d704c8f32d bytes=4660 (no register value recorded; custody hash only) +UPPER2D/BRANCH_dir/br_mc.py sha256=45650983a6603242967902e43e7270ada8ab43ba5234181d0592562c1b6f3af6 bytes=12404 (no register value recorded; custody hash only) +UPPER2D/BRANCH_dir/br_probes.py sha256=d97e7ac40f8beb7ee6d09040eeaf6c8991e497394f9ecc68df371b85c2e0feec bytes=6227 (no register value recorded; custody hash only) +UPPER2D/C1_alpha_intensity/c1_grid.py sha256=2ebe6eb47ee3554b3257342b726d9990009793a66994c9e53fffdc13f70705e0 bytes=11624 (no register value recorded; custody hash only) +UPPER2D/C1_alpha_intensity/c1_intensity.py sha256=f9bb98636b95ad85e835940dc93c301e4f8ea0f458ef5cfdcd2cdcca5820ed04 bytes=36814 (no register value recorded; custody hash only) +UPPER2D/C1_alpha_intensity/falsify.py sha256=5da7ee93e4e821fb4e9073524fdd00b0bed94ed41dddef689544447fa2aba012 bytes=4470 (no register value recorded; custody hash only) +UPPER2D/C2_B_classes/c2_falsifier.py sha256=2441b630170f51d17d0795dd7983ac37ff0609e594aa843dab45a3351d480452 bytes=15293 register=2441b630170f51d17d0795dd7983ac37ff0609e594aa843dab45a3351d480452 MATCH +UPPER2D/C2_B_classes/c2_probes.py sha256=ae7d2e5cc81fa155f159e2190cf1ac3362c59c88dd1d40857994dc77d78134d9 bytes=38709 register=ae7d2e5cc81fa155f159e2190cf1ac3362c59c88dd1d40857994dc77d78134d9 MATCH +UPPER2D/D1_assembly/d1_falsify.py sha256=1ebd2c6ade067bcfa2732b89ef83266fdaecd24260c05cf6d810b0bd2db044b7 bytes=6928 (no register value recorded; custody hash only) +UPPER2D/D1_assembly/d1_falsify_v2.py sha256=7c41dde8ed48068e5c81b17bbc645523f715ba88cde0d746736b8c4e2ce925ba bytes=9444 (no register value recorded; custody hash only) +UPPER2D/D1_assembly/d1_falsify_v3.py sha256=5805e53d69541f00229e5e49e14d655afd1f471a2584a2117fedf0bb5298ddb0 bytes=11552 (no register value recorded; custody hash only) +UPPER2D/D1_assembly/v3_t_normal.txt sha256=f207abc32bb9abf3e2fbd130d3493c6e95daa0519e3170714c783c2cacc62f98 bytes=3041 (no register value recorded; custody hash only) +UPPER2D/D1_assembly/v3_t_opt.txt sha256=f207abc32bb9abf3e2fbd130d3493c6e95daa0519e3170714c783c2cacc62f98 bytes=3041 (no register value recorded; custody hash only) +UPPER2D/D2_branch_control/d2_falsifier.py sha256=824284be876ce685f63e600a642ee84ad601e6fb2424a852dafe8c21178122d8 bytes=14348 (no register value recorded; custody hash only) +UPPER2D/D2_branch_control/d2_probes.py sha256=62e15f5a3b9ee39b14c5abd5a9cfea7f1cf8b0e65b3306c862fad54c6258453f bytes=38643 (no register value recorded; custody hash only) +UPPER2D/D3_percolation/d3_amend.py sha256=12175217869a9bd7b3f623fdb34a6c0c699419722bfe534e3b5226352504b5b6 bytes=21619 register=12175217869a9bd7b3f623fdb34a6c0c699419722bfe534e3b5226352504b5b6 MATCH +UPPER2D/D3_percolation/d3_amend_v2.py sha256=6399a0e31b089a94c4dfec7960682ef400f7f0f99a788e3668557d0a75cf7528 bytes=14846 register=6399a0e31b089a94c4dfec7960682ef400f7f0f99a788e3668557d0a75cf7528 MATCH +UPPER2D/D3_percolation/d3_falsifier.py sha256=c9e7458b8ec6da9eba8121d8de4bbe354cf8389409363170f2c17d7841ac526e bytes=29034 register=c9e7458b8ec6da9eba8121d8de4bbe354cf8389409363170f2c17d7841ac526e MATCH +UPPER2D/D3_percolation/d3_perc.py sha256=5bc092412943e1c2185a8cf86cee23ae9cd9a2aad9bd9ef0b02807e9ff58dfa4 bytes=40337 register=5bc092412943e1c2185a8cf86cee23ae9cd9a2aad9bd9ef0b02807e9ff58dfa4 MATCH +UPPER2D/H2_foundations/README.md sha256=cc2d012c7eb0b3f67e3dba64e578cd3f6f71f570e6d67667734e1847111d831f bytes=15197 (no register value recorded; custody hash only) +UPPER2D/H2_foundations/make_receipts.py sha256=cb6c0f2fb4350f2e5707ebf730b4ab74f7c5d733208a74649bc3cb7aab6ac27e bytes=6050 (no register value recorded; custody hash only) +UPPER2D/H2_foundations/selftest_cov_exact.py sha256=e1b331dec6e0f82e6a084a30d9df9d8f402f42057861e6875504b04ea4a32068 bytes=17967 (no register value recorded; custody hash only) +UPPER2D/H2_foundations/selftest_pin_transform.py sha256=90e88ff8f5248332219902caf6ea4df5bb5b89ffa72b95b519fd4472860403a6 bytes=14492 (no register value recorded; custody hash only) +UPPER2D/H2_foundations/selftest_reg_lemmas.py sha256=27505d0196e39a0c47989c443f402aa2ad23bdf235771ea1bbdee1030efad65b bytes=15350 (no register value recorded; custody hash only) +UPPER2D/H3_closure/h3_band_floor.py sha256=9eb0f4266c2f3623a210f7678d8375bd31735ec1e5ce3ae2a587b7685823433e bytes=36181 (no register value recorded; custody hash only) +UPPER2D/H3_closure/h3_c0_certificate.py sha256=56076fa852e3787e683921496adc796b04132ea817be924ed84ef68d68abc84c bytes=14052 (no register value recorded; custody hash only) +UPPER2D/H3_closure/h3_falsifier.py sha256=645b6d9d24721674b419e8d026183722a90a1a27ee4e7b0053c53faced73cd47 bytes=10584 (no register value recorded; custody hash only) +UPPER2D/H3_closure/h3_rung_floor.py sha256=094d382451ff37e8d3123e7203c743f359cb0af1c2c12cf336adf74fc0b25d8f bytes=16960 (no register value recorded; custody hash only) +UPPER2D/H4_JC_repair/h4jc_falsifier.py sha256=298fd31ee9b33a117e0f60f1ddf4dcece72ff5bd189510552aff84307c7851f0 bytes=2535 (no register value recorded; custody hash only) +UPPER2D/H4_JC_repair/h4jc_mirror.py sha256=e593735a333b43061c3e440fadeed473bc991b5669915b1874bf65deb4f67a60 bytes=18112 (no register value recorded; custody hash only) +UPPER2D/H4_closure/h4_certificate.py sha256=ddf6e9636c9d8f4858996f350f0f402f96c2c492a361e5aa6118291c708c9f92 bytes=17474 (no register value recorded; custody hash only) +UPPER2D/H4_closure/h4_falsifier.py sha256=9f268595806fba2b2008e668c470b2c5f64e007f353277a676c0707dd144b1f3 bytes=16467 (no register value recorded; custody hash only) +UPPER2D/H4_closure/h4_probes.py sha256=d02d5887d9e897cd3f7c296729af78c80870b466855c86de21a4c818d82036fd bytes=53168 (no register value recorded; custody hash only) +UPPER2D/H5_closure/falsify.py sha256=5bc9dbccb384fc49366a32c9c19d431a68dea1ccae74233d1fbc458e5bfeee0c bytes=3262 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_kernel.py sha256=b2e6014c2fd6eb9e72b2104cc828a764e280f76b8396a02edd37654b6ad83ad7 bytes=66310 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_merge.py sha256=0e71de27eeb9c9a2e695b2c72052f8ef4f67b5c4f621e4eecd541595b06ede7a bytes=13400 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_promote.py sha256=2dd471dca0e4c7e18a925ebd60d034a99dae96ad6afceccb2c5f8d5feca571fd bytes=9253 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_run.py sha256=cd4b3d4a6145338be388307c8a019169d7e6c7bcffccd2e29d4264295342c652 bytes=24976 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_run_r0p025.py sha256=38f88f732da19a7292ff7acc9b71f8e9f48d30d9db4eaed7d048d2038e9ebcc5 bytes=27068 (no register value recorded; custody hash only) +UPPER2D/H5_closure/h5_run_r0p035355.py sha256=dba090d422fc1593b949b4e3294255e868dccdfe4ae3166ce0a31e5766f29ab3 bytes=27093 (no register value recorded; custody hash only) + +# d3_falsifier.py succession (all legitimate, each recorded in its freeze record): v1 freeze e54c388f... -> +# amendment freeze d876df2c... -> CURRENT c9e7458b... (FREEZE_AMENDMENT_v2.txt line 22) — MATCH to current. +# d1_falsify_v3.py is the OPERATIVE D1 gate (92 fail-closed cks); d1_falsify.py / d1_falsify_v2.py frozen historical. +# LPW_CONSTANT/v2/lpw_constant_v2.py register (H1_V2_HARDENING_REPORT.md header): ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125 +# recomputed: ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125 MATCH +# Transcript pair UPPER2D/D1_assembly/v3_t_normal.txt == v3_t_opt.txt byte-identical (both sha256 f207abc32bb9abf3e2fbd130d3493c6e95daa0519e3170714c783c2cacc62f98). + +## C. Live gate re-execution evidence (run by this build agent at assembly time) +# Command: python3 d1_falsify_v3.py (cwd UPPER2D/D1_assembly) +# Result: exit 0; 92 fail-closed cks PASS; printed +# D1-V2_2-GATE PASS digest=d800849ed5966b4d583a10cf72525e89350d9a53780b45a807a21ccbadf91085 +# matching D1_V2_2_RECEIPTS.txt verbatim. This re-verifies the whole consumed carrier chain fail-closed. +# (The 'd800849e...' register value is the gate's self-computed PASS digest over its expected-hash tables, +# not a file hash; reproduced live above.) + +## D. Register notes / discrepancies resolved at assembly (none blocking; no mismatches) +# 1. H4_JC_EVENT_LEVEL.md lives at UPPER2D/H4_JC_repair/ (not under H4_closure/); hash MATCHES the register. +# 2. BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md: register says 'body'; the file contains no "\n---\n\n" +# separator, so body == whole file = 7547e76a... MATCH. +# 3. STAGE_E review corpus: the frozen tree carries FIVE review files (REVIEW_proof/numerics/provenance/ +# scope/topology.md); the round-2 re-review dispositions (H4JC-R1 counterexample instance; numerics v2.1; +# scope v2.1) exist as consumption records inside D1 v2.2 §0/§4 (hash-verified above), not as standalone +# files. Standalone counterexample/kacrice review files: NOT PRESENT in the tree (CANNOT-VERIFY as files; +# their dispositions verified via D1 v2.2 and REVIEW_proof.md §3, which contains the counterexample). + +# ADDENDUM 2026-09-15 +# H3 BAND FLOOR frozen (record H3-BAND-FLOOR-2026-09-15): the normalizer sub-part of OBL-D1-PROMOTE is +# DISCHARGED with uniform modulus (certified Z_r >= c_Z*r^2 for EVERY r in (0, 0.05]); the chart side of the +# promotion remains OPEN. See RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md. All hashes below recomputed +# FROM BYTES by the addendum agent and matched against the lane register (H3_closure/MANIFEST.sha256 and +# RECEIPT_h3.json ff788042c6bce3bb89bccee17ee88478b81b72426b5b474929a009b0fe8ee209). +# EXTRACTION-RULE NOTE: the generic 'sepbody' rule (bytes before the first "\n---\n\n") does NOT apply to +# H3_BAND_FLOOR.md (the document carries a header-block separator; sepbody recomputes to +# 94089e9f696e520cd660b37f53d5e472b217134adfafe4c1c06939217107d19d, not the register value). The +# FREEZE-recorded rule is 'body-excl-hash-line' (whole file minus the final 'Body hash of this document: ...' +# line), annotated verbatim in the lane MANIFEST; under that rule the recomputed body MATCHES 281477c3.... + +## A+ (addendum). Document carrier — path | extraction rule | recomputed sha256 | register | verdict | status +UPPER2D/H3_closure/H3_BAND_FLOOR.md + rule: body-excl-hash-line (whole file minus the final 'Body hash of this document: ...' line; LF) + recomputed: 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 + register: 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 (lane MANIFEST + RECEIPT_h3.json) + bytes: 11133 (body 11029) | verdict: MATCH | status: CURRENT (R-band; normalizer sub-part of OBL-D1-PROMOTE DISCHARGED) + +## B+ (addendum). Script / transcripts / receipt — whole-file sha256 recomputed from bytes +UPPER2D/H3_closure/h3_band_floor.py sha256=a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5 bytes=37315 register=a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5 MATCH +# (supersedes for custody the Section-B pre-freeze line sha256=9eb0f426... bytes=36181 — the lane was declared +# volatile in that section and in TREE_MANIFEST.sha256; the frozen value above is the register's.) +UPPER2D/H3_closure/band_normal.txt sha256=dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d bytes=2835 register=dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d MATCH +UPPER2D/H3_closure/band_O.txt sha256=dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d bytes=2835 register=dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d MATCH (byte-identical to band_normal.txt; both interpreter modes) +UPPER2D/H3_closure/band_out.txt sha256=617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54 bytes=2743 register=617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54 MATCH (equals the in-transcript self-hash line) +UPPER2D/H3_closure/band_mut_planar.txt sha256=4fc8105d1050dc2a284750ada417f959725711b8e19865ced682192da59e4774 bytes=305 register=4fc8105d1050dc2a284750ada417f959725711b8e19865ced682192da59e4774 MATCH (MUTATION=planar_moments -> CK_FAIL at CB1a, exit 1 as designed) +UPPER2D/H3_closure/band_mut_window.txt sha256=ff1765d4ace7fb5c61402e227c5896017bd1995cad0e2f8475761a3850a01c51 bytes=833 register=ff1765d4ace7fb5c61402e227c5896017bd1995cad0e2f8475761a3850a01c51 MATCH (MUTATION=wrong_window -> CK_FAIL at CB3 window identity, exit 1 as designed) +UPPER2D/H3_closure/RECEIPT_h3.json sha256=ff788042c6bce3bb89bccee17ee88478b81b72426b5b474929a009b0fe8ee209 bytes=4482 register=ff788042c6bce3bb89bccee17ee88478b81b72426b5b474929a009b0fe8ee209 MATCH + +## D+ (addendum). Package self-reference +# RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md sha256=1cb23846199cd82d0d6c64449af6dba08b6d0efc1ceecbf0f0975bf38ef05ec2 bytes=9400 +# (package-internal addendum file; custody hash only. 00_MANIFEST_v2_2026-09-15.sha256 covers the whole +# package including this appended capsule; 00_MANIFEST.sha256 remains the unmodified v1 historical record.) + +# ADDENDUM-2 2026-09-15 +# TWO NEW VALIDITY-PREMISE CARRIERS frozen: (1) B4LOC dam line CLOSED at super-algebraic grade, whole-B4 +# claim (record B4LOC-R1-20260914-v1.0, D2 lane); (2) PERC-DECAY RESTATED -- the far lanes absorb at +# Theta(r^3) with certified constants + named input PD-CONN (record D3-PERC-DECAY-20260915-v1.0, D3 lane). +# See RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md. All hashes below recomputed FROM BYTES by the +# addendum-2 agent and matched against the lane freeze records (B4LOC_damline/FREEZE.txt and +# D3_percolation/FREEZE_PERC_DECAY.txt). EXTRACTION-RULE NOTE: the generic 'sepbody' rule (bytes before the +# first "\n---\n\n") does NOT apply to B4LOC_DAMLINE.md -- the document contains no '---' separator at all +# (grep-verified); the FREEZE-recorded rule is the marker-lines rule stated below, under which the recomputed +# body (13503 bytes) MATCHES 0d5c1b32.... (Same pattern as the H3 band-floor note in the ADDENDUM 2026-09-15 +# section above.) PERC_DECAY.md uses its FREEZE-recorded marker-lines rule as stated. + +## A2 (addendum-2). Document carriers -- path | extraction rule | recomputed sha256 | register | verdict | status +UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md + rule: marker-lines (LF-joined lines strictly between the unique exact lines BEGIN_FROZEN_BODY / END_FROZEN_BODY; exactly one terminal LF; last content line directly preceding END marker) + recomputed: 0d5c1b3284374f3a2f7630b7f603a71c77f5ec9417fe4579aaac03becd33c05e + register: 0d5c1b3284374f3a2f7630b7f603a71c77f5ec9417fe4579aaac03becd33c05e (FREEZE.txt) + bytes: 15164 (body 13503) | whole-file sha256 ae4c9c82784aecfbd85056c316f792a331bccb774d952887fc5fe8ea7da615b4 | verdict: MATCH | status: FROZEN (B4.loc dam-line premise CLOSED, super-algebraic, whole-B4 claim; wrap/remote reconciliation OPEN under D1) +UPPER2D/D3_percolation/PERC_DECAY.md + rule: marker-lines (LF-joined lines strictly between the unique exact lines BEGIN_FROZEN_BODY / END_FROZEN_BODY; normalize line endings to LF; exactly one terminal LF) + recomputed: 5137a811e6be72ed27e0458c75537bdcfabb8d8e7148b211d8c7b9a1584df400 + register: 5137a811e6be72ed27e0458c75537bdcfabb8d8e7148b211d8c7b9a1584df400 (FREEZE_PERC_DECAY.txt) + bytes: 8041 (body 7409) | whole-file sha256 f971b81a54dd2b78924c77e412e0c19b798e5356795057fcdadec3235e960745 | verdict: MATCH | status: FROZEN (PERC-DECAY RESTATED: Theta(r^3) absorption with certified constants + named PD-CONN; old o(r^3) phrasing REFUTED at evidence grade) + +## B2 (addendum-2). Scripts / transcripts / freeze records -- whole-file sha256 recomputed from bytes +UPPER2D/B4LOC_damline/b4loc_driver.py sha256=bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02 bytes=26271 register=bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02 MATCH +UPPER2D/B4LOC_damline/b4loc_falsifier.py sha256=d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f bytes=3360 register=d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f MATCH +UPPER2D/B4LOC_damline/t_normal.txt sha256=11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 bytes=2735 register=11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 MATCH (byte-identical to t_opt.txt; both interpreter modes) +UPPER2D/B4LOC_damline/t_opt.txt sha256=11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 bytes=2735 register=11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 MATCH +UPPER2D/B4LOC_damline/tf_normal.txt sha256=1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c bytes=885 register=1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c MATCH (byte-identical to tf_opt.txt; falsifier transcripts, both modes) +UPPER2D/B4LOC_damline/tf_opt.txt sha256=1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c bytes=885 register=1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c MATCH +UPPER2D/B4LOC_damline/FREEZE.txt sha256=5235f98a59e5119444b8fda2ea16d2dd3333e0d46f0b52af6362a2b2a0ecd163 bytes=1213 MATCH (custody; records B4LOC-DRIVER DIGEST 43ff9c1ebfa9cf8f27c06e27e844030e8378e439e89bdd374949166a1a490a1b, B4LOC-FALSIFIER DIGEST f939eeab4805b9c5b35fb40f0f173b4a4ad8237fdcd15ad53084569c6fbffe55) +UPPER2D/D3_percolation/d3_perc_decay.py sha256=ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64 bytes=19063 register=ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64 MATCH (engine digest 58df7e312099d3acd93fe83f728b4b139274063c98386b9963bbc1a6270e2b9b) +UPPER2D/D3_percolation/pd_normal.txt sha256=7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 bytes=9762 register=7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 MATCH (byte-identical to pd_opt.txt; both interpreter modes; MC-free) +UPPER2D/D3_percolation/pd_opt.txt sha256=7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 bytes=9762 register=7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 MATCH +UPPER2D/D3_percolation/d3_falsifier.py sha256=abbb40d279606660a0c16af253d9bc15038f7221702fb7aaa6f74b4b893df032 bytes=32264 register=abbb40d279606660a0c16af253d9bc15038f7221702fb7aaa6f74b4b893df032 MATCH (falsifier F1--F7 incl. the PERC-DECAY re-run gate) +UPPER2D/D3_percolation/tf_normal.txt sha256=b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 bytes=1833 register=b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 MATCH (byte-identical to tf_opt.txt, cmp verified; D3-FALSIFIER PASS exit 0) +UPPER2D/D3_percolation/tf_opt.txt sha256=b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 bytes=1833 register=b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 MATCH (falsifier digest fcb37708468875723bbfac838ab7b5ab374edb4ae60566f1ef2b7b5e44958e9f) +UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt sha256=6bbe6e27a91c777b7245294fc5740462af06e7f20b0f92ff4eae15cd2f05edef bytes=3966 MATCH (custody; complete freeze incl. the falsifier F1--F7 line -- F7 landed 11:26 during addendum-2 assembly; all landed hashes re-verified from bytes; nothing pending) + +## D2 (addendum-2). Package self-reference +# RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md (package-internal addendum file; custody hash recorded +# in 00_MANIFEST_v3_2026-09-15.sha256, which covers the whole package including this appended capsule; +# 00_MANIFEST.sha256 (v1) and 00_MANIFEST_v2_2026-09-15.sha256 remain unmodified historical records.) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md new file mode 100644 index 000000000..5a800ba09 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md @@ -0,0 +1,28 @@ +# THEOREM_TABLE — RETURN_06 current-state theorem table + +Every statement/grade taken verbatim from its hash-verified carrier (SOURCE_CAPSULE.sha256). Labels per +carrier: EXACT / CERTIFIED INTERVAL / conservative bound / measured estimate (evidence) / diagnostic. +Forbidden-language discipline: no "program complete", no "two-sided law", no "limiting coefficient". + +| # | Theorem (one-line statement) | Exact scope | Current grade | Predecessor → successor | Unresolved gates / named hypotheses | +|---|---|---|---|---|---| +| 1 | **LPW qualitative (existential cubic lower):** 1 − q(r, 6/5) ≥ c·r³ for some c > 0, r₀ > 0 (all 0 < r ≤ r₀) | Exact 2D side-24 six-pin typed maximum-saddle pair-Palm law of the pinned candidate | ENDORSED at review grade (Kimi LPW verdict: six interfaces PASS WITHIN SCOPE; status firewall — P0.1 remains HOLD) | — → quantitative form in row 2 | None inside the endorsement; operator adjudication required for any status change | +| 2 | **LPW_CONSTANT v2 (explicit constant):** 1 − q(r, 6/5) ≥ c·r³, c = 260/(2082000000000·2⁴⁰·10²¹) = 1.1357762846347807215698804e-43 ≥ 1.13e-43 ≥ 10^{−43}, r₀ = 1/2224640 = 1/(256·8690) | Same law as row 1; uniform inputs m ≥ 10^{−21}, λ = 0.123809288439, A_3 = 71.10596, A_4 = 262.81357 | EXACT (exact Fractions / outward enclosures; author-side amplitude majorant; re-certified by H1 v3 hardening lpw_constant_v3.py) | LPW_CONSTANT v1 (row 3) → v2 (this) → H1 v3 re-certification (same pair) | None load-bearing; usefulness for numerics explicitly out of scope | +| 3 | **LPW_CONSTANT v1:** c ≥ 6.239e-44, r₀ = 1/2414592 | Same law | HISTORICAL DEFECTIVE (preserved): defect D1 published decimal above the exact fraction; defect D2 false moment identity 12 + 16/π (correct 12 + 32/π). Its caps B_3 ≤ 3790446482793, B_4 ≤ 4715.749569 survive the v2 repair conservatively | — → superseded by v2 (row 2) | Retired; consumed nowhere as authority | +| 4 | **2D UPPER certified-rung theorem (D1 v2.2(1)):** 1 − q(0.05, 6/5) ≤ Ĩ_hi + C_RN(0.05)·√Q_{0.05}(B1.dir) + P_{0.05}(B2) + P_{0.05}(B4), E_w(0.05) ≤ 8.1272827e-2 = 650.1827·(0.05)³ (round-UP; exact 650.1826140…), C_RN(0.05) ≤ 3.46 | Exact normalized periodized Bargmann–Fock field, side-24 torus, level 6/5, on Reg ∩ TYP, rung r = 0.05 only | Named-hypothesis grade: unconditional apart from (a) H5-RIM + H5-AXIS v1+v2+v3 (named lemmas), (b) D3-LEMMA-RN-UNIF(r = 0.05) (NOT closed). Ĩ_hi = CERTIFIED INTERVAL upper; joint carrier H4JC-R1 (event-level, PASS-WITHSTOOD) | v1.0 006b8a7d… → v1.1 634338b4… → v1.2 a7e1958c… → v2.0 86882dca… → v2.1 bcc177fe… → **v2.2 490ad6b2… (FINAL)** | The two named hypotheses; sharper form (1′) prices dir remainder (NearSwap certified super-algebraic; FarRoute → PERC-DECAY) | +| 5 | **2D UPPER all-small-r theorem (D1 v2.2(2)):** ∃ r₀ > 0 (EXISTENTIAL), ∃ finite C: 1 − q(r, 6/5) ≤ C·r³ for all 0 < r ≤ r₀ | Same field; all small r; r₀ existential (H3 has no certified modulus; R2 floors pointwise; interval-r band unexecuted) | CONDITIONAL on five validity premises: OBL-D1-PROMOTE; D3-LEMMA-RN-UNIF; PERC-DECAY; OBL-B1-BRANCH(loop|B1); B4.loc dam-line tube certificate (incl. the asserted-not-established cut-net ≡ D2 tube (ii) identification). Dir-near super-algebraic CERTIFIED; B2-corridor/B4.loc super-algebraic via their dam/profile lines (B4.loc's line a premise) | v2.0 Theorem (2) (false bookkeeping per proof review) → repaired v2.1 → round-2 register v2.2 | All five premises OPEN (see OBLIGATION_LEDGER.md); refinement register: OBL-D2-AO-SHARP (i, iii, v) only | +| 6 | **3D SIDE24 theorem (ratified upper chain AO48-OPR-045)** | THREE-dimensional SIDE24 — SEPARATE FAMILY | Untouched by this campaign; consumed NOWHERE in the 2D carriers (firewall PASS per provenance hunt-list: no AO48-OPR-045 citation exists anywhere in the tree) | — | NO cross-track inference: no 2D claim derives from it and none is offered to it; the endorsed 2D lower + this chain would give a Θ(r³) statement ONLY at the existential level and only after operator adjudication — NOT made here | +| 7 | **P0.1 / P0.2 (operator-status register items)** | Campaign-external status Booleans | P0.1 remains HOLD (LPW verdict: review endorsement changes no LS-CTL Boolean, eligibility predicate, theorem status, RP status, AO48 record, q0 package status). P0.2: NO occurrence in the frozen tree — CANNOT-VERIFY | — | Separate from LPW and from the 2D UPPER campaign; any status change requires separate operator adjudication | +| 8 | **W8 (Λ-side certified floor, auxiliary quantitative campaign):** certified cell-sup σ(D²λ) / regional sup\|D³λ\| over the Phase-1-certified cell set | SIDE24 λ-grid functional; 837 of 1707 grid cells in Phase-2 scope (623 interior + 214 clip-1); 864 Phase-1-ledgered cells excluded by scope decision | OPEN — Phase-2 RUNNING (see RUNNING_TASKS.md); formal nonclosure receipted at the certificate standard (KIMI-DER-027c_NONCLOSURE.md) with the exact missing piece named | DER-027b (placeholders; quarantined) → nonclosure v2/v3 → Phase-2 J3 track (this) | v4 full-verification certificate incomplete; 864 ledgered cells excluded from any rung conclusion | +| 9 | **W3 (WP rigorous lower-bound enclosure, auxiliary):** certified box-integral lower for I_WP at r = 0.025 | WP channel band x ∈ [−0.08, 0.08], y ∈ [0.50, 0.68], 4608 boxes of 0.0025 | RUNNING (drivers live; see RUNNING_TASKS.md); harness COMPLETE (CHECK0–CHECK5, mutations fail-closed incl. the missing-sqrt class); W3's own calibration EXPECTS the 0.213·r³ refutation to be INCONCLUSIVE (OPEN), not a refutation and not a confirmation | WP missing-sqrt defective bound (quarantined) → exact-integrand modulus (W6, PROVED validity) → W3 rigorous enclosure (this) | G2 comparison vs W4 on freeze receipts; formal refutation threshold 3.328125e-6 not yet certified either way | +| 10 | **Coefficient-limit campaign (convergence of (1 − q(r, 6/5))/r³ as r → 0)** | Would require the two-sided 2D theorem closed with certified modulus | **NOT OPEN — and never inferable from current carriers.** No carrier asserts or licenses convergence of the ratio. Such a campaign may be opened ONLY after the two-sided 2D theorem closes (upper: D1 v2.2(2)'s five premises discharged with a certified modulus; lower: LPW side at matching scope). Until then any "limiting coefficient" language is prohibited | — | Not a running task; no lane owns it; listed here only to fence it | + +## Notes + +- Grades are non-negotiable per carrier: Ĩ_hi / I_hi(v3) are CERTIFIED INTERVAL uppers (machine-certified + box cover; rim/axis at named-lemma grade), never measured estimates; C1's α-intensity point values and the + BRANCH q-displays are EVIDENCE/diagnostic, never premises; D2's κ_dam ladder is probe-grade. +- Historical/superseded carriers (rows 3; D1 v1.0–v2.1; D3 v1 amendment; H4-JC retracted §2.3) are preserved + hash-pinned and labeled; they are consumed nowhere as authority (provenance hunt-list PASS). +- The 2D/3D firewall is structural: row 6 shares no lemma, constant, or receipt with rows 1–5 (see + DEPENDENCY_DAG.md). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt new file mode 100644 index 000000000..e3cd7fac7 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt @@ -0,0 +1,1038 @@ +# TREE_MANIFEST.sha256 — custody manifest over the whole K3_SIDE24_LB tree +# Format: sha256 size_bytes relative_path (root: /mnt/agents/output/K3_SIDE24_LB/) +# Snapshot: 2026-09-15T00:05:36Z. Volatile lanes (W3_numerics/*.live + lbox logs, UPPER2D/H3_closure/band_normal.txt, +# UPPER2D/H3_closure/h3_band_floor.py, UPPER2D/H5_closure/.live + keeper locks + h5_results_r0.02*/0.03* +# jsonl) may legitimately drift after this snapshot; the SOURCE_CAPSULE carriers are frozen and do not. +# RETURN_06/ itself is excluded (the package under construction; see 00_MANIFEST.sha256). +# File count: 1031 +a64b86f8e225cf064cd46fcf2ace4f10ff9071e8d83fb34aa9a97f951c23a66a 5504 00_READ_FIRST.md +c6b4a0ca59bb1d1dedc5bb8e28b738a9a5ba9fe121832f40fee711073898e407 4729 CANONICAL_STATE.json +6ab5218e8a0528cfe838deada1d4d8bf287229c3e452c6eee40b544e619d89ef 1646 CORPUS_GAP_REQUESTS.txt +425da947d281d091f4c634194a7c43de2e47ca6e88abdd20c3075f936e11458e 48026 DECISION_LEDGER.md +8fa175b6f529cc3344ea1c1886208326368304951118064c6639a04a59169cb5 4887 FAILED_APPROACHES.md +34416efde5fd2b0342460f10c22307b5b20d5d2c7760af3485df9527aca0a9c3 72668 FILE_LEDGER.tsv +981893e3cdb76d2705cc633d768e424e223bd517a3c2bb3f1d05eb7e48bd48d2 65718 INPUT_MANIFEST.sha256 +0fb026bd5923ab06d90b63017c212fb722b417288d80638185b8378d7e658652 5544 K3-AUD-001_residue_audit.md +715124dba1f089430594a3322b7d32c3508fbcb10c14f6591a432ff582f8854d 9760 K3-THM-001_conditional_theorem.md +605bc2df386e3dc130d5297615c2f2a2cba5583993c89c2eddb4a6f30470f71c 44294 KIMI_LPW_CONSTANT_PACKAGE.zip +86bd845fc134af006fe17c43ccf23ed531893ce55cb551177059142a3c5c8909 100334 KIMI_LPW_REVIEW_BUNDLE_2026-09-13.zip +2f99252ed8acc97ccee468bbcb2419eac214156720bbc78ecdebb3f753e69ea7 97671 KIMI_QC_NUMERICAL_PACKAGE.zip +6d7b0ed5de12082ad540c6f28a61efde90cc414a01fd780cc5e313377c207410 58851 KIMI_W8_V3_PACKAGE.zip +5275994cffed6f54fd758c0b116dcc9a2ecfd8db8dcc9ecd2a2daa0ff38a8cce 5623 LEAD_SYMBOLIC_WP.md +45ffe1e260a55bfb3dff032b158de8205956ccf58643b02b62d4331fe4d957c9 2957 LEAD_SYMBOLIC_WP_CORRECTION_ADDENDUM.md +a7619d9180126c741b5b836ad4326de3188fb9b91d2ca217b0b67199770680de 27736 MANIFEST.sha256 +fe3bdbc3ba6ae9290f0035d7035b8c05fbb6d119cbbe954e030ba97f270133b2 420 MISSING_INPUTS.md +bb5f578b67b63d4a5a2ec1f17f240b4c239f29a5dac27aebe01db107c0b725f6 4132 OPEN_OBLIGATIONS.md +849d5370c7ce5066bb7b15ca1be8d6b6fe8b2ada3daae4f313156fe552e07b5c 4248 OPERATOR_HANDOFF.md +1e4bed6f0a7011878b862a3d499f80029f834cd1b2cfa1f8c156ea7741c4f51e 3194 REPRODUCTION.md +996b7fb8530c834172a262a1355c17313394cdf4a39e15d3376596c89e55864c 5994 SUCCESSOR_SHELL_NONCONTROLLING.md +c927f65d2b36e4fb2f7bb2d40c11618968ec3f5a1640a8a1a58bc06a250907e1 744 TASK_DAG.md +08394745a03776d2937f60f65a5aa6031cabc2437be3d63469fc78c05d95b0f7 8638 WP_DISPOSITION.md +5c235e60706fecd07bb204ed4a5b9a38b9c8aec5d97b412ac7fb844ab2d91b67 9992 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/00_RECONCILIATION.md +fa0a4f7c59e2a9deb8c5c12f677f309ad51abe7307026d92c7aa14db175f7a8b 4473 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/01_R3_ADDENDUM_AND_SOURCE_BRIDGE.md +650b4bca176cb0fb9aa14b941061e5babae3c866245ad9fbbc05155510e26d8f 7138 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/02_ENDPOINT_SUPPLEMENT.md +617cee2bc4b03d045adc8ba6fbe0b08b76bbcc1336a01a24a70d99d3856afb5a 4539 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/03_CONSTANT_CERTIFICATE_CONTRACT.md +d440468efeae63a35701c303c6163d0662dbf6591ee9f91cd59ef7b1d258d054 5134 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/04_RETURN_TO_KIMI.md +9ba5433e7861225e302485831c8d1f77610657bf7e25a6e9a9329ddda713affc 1962 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/MANIFEST.sha256 +2faa61590b6de07f3e4470d92569e37219028023f2c039e9420c420d9931fa2b 1478 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/REVIEW_STATE.json +66b2f7fa1742e1cf9680842552d031d4107fec14f666fa83429a91feea650e7f 6793 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/check_review.py +25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc 14 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/requirements.txt +cf58f72eb0399c626160c143b50f674ff3bd5c449225211edd6fd378a374e1a5 22614 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/02_LOCAL_PATH_LOWER_BOUND_CANDIDATE.md +b3b1371f4d0f0b4b7f2ccac61742b241ec549cb145765f60fc4ccf278a871536 5820 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/03_INDEPENDENT_REVIEW_PACKET.md +e48d7c271dff9c120316ee2129a303aed6f78b518c2e0c08337eb357bd60e2e8 3397 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/AO48-OPR-045.md +c1d6e559274d7e87a3fa92f44cb2534a5e277a3b5941fd40db380599ddba0564 30933 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/GP-DER-118-v1.10.md +26a9c7ef46b546acfdb0fda11f6ee8dd1e655752202d0add39e0011adf936a4c 13399 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/GP-LB-STAT-004.md +76f6fa487479dbf77e265e61f2eaee772d1729d25813f6dea15d9e929c2d125c 39446 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/KIMI_LPW_REVIEW_VERDICT.pdf +7f03f305cf89463bab46c9a631f86f405844b0d99c73122414f0c69d12d0e1cf 37478 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/inputs/LEAD_EVIDENCE_PACK.pdf +84d4c92b78f8c95660ba404acf68e4ed73bcc3e69526342fa50d2ae37ed83974 2734 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/ARCHIVE_CHECK.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/CHECK_NORMAL.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/CHECK_OPTIMIZED.json +6a5bc16deb06635d9a82195cbb997e0bbdb8f7e2fd2bcd3d2c8accf71c5e9aa7 1078 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/EXECUTION.json +af38542dea88d1c6bd08dfab4994d7d76bff4325e0717bf2bc4a1fec3be7e1af 1052 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/INPUT_HASHES.json +5fae3c0e870d73fd812c12854dfe297482265af170b30d94447159be1eb21bf1 1447 INBOX_LPW_Reconciliation/LPW_Review_Reconciliation_2026-09-12/receipts/MUTATIONS.json +e0bc8c73ce63972b26d0b762cb3f5e91b6098b241effacf1199986fc0cbc91d4 4891 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/00_READ_FIRST.md +291113cf76ab2739940709289105887315fbda1df7e8cee5b29e6722f8b44946 7764 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/01_RECONCILIATION.md +102f2bf8bbf7ac39da2391990ffa54876002ef48c9d64443cb74f8f467ced520 4622 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/02_EXACT_MOMENT_CORRECTION.md +18a6e27cb945c7fc80975e20f775724989de0d368ce7a6f2ee29f11bea165d70 13605 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/03_EXPLICIT_CONSTANTS_CANDIDATE.md +abe171ef061a9332d017d079763d04c1a44b7b218e6b10dcfe18b546d9565bf0 6629 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/04_RETURN_TO_KIMI.md +bda4f73af446b0b76397f04e04e48a530dac05dbc69ca78503b16fc64c6df7f5 5117 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/MANIFEST.sha256 +36f57a38775f2fdc9341b8e95551a8686f009b64715149a64cada1bb48fbbff3 2476 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/REQUIRED_DELIVERY.json +48be454a6000d5796b2df437fe5e293d85f6e0575cb646c804b72d586de409d8 1996 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/REVIEW_STATE.json +47fd19021144e071cc43b6e265aafada0056abe89724ad95bd6e3a8e37995b94 28 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/requirements.txt +2926ec99137c67d756dac68bc3b03f2669996f50056fc8bae544fb447e391ec1 23770 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/incoming/ERRATA_AND_CLARIFICATIONS_2026-09-13.pdf +feb3eceb310dba6a76c15ea8a2d076b9c7022fd9dbdadc72070cd84b80ff26cd 44504 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/incoming/KIMI_LPW_VERDICT_ADDENDUM.pdf +10190eb687034b731c2d59d8a2884fd02d9f4471fd762e12907f0d31ff3225b4 19789 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/incoming/README_BUNDLEsept.pdf +5c235e60706fecd07bb204ed4a5b9a38b9c8aec5d97b412ac7fb844ab2d91b67 9992 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/00_RECONCILIATION.md +fa0a4f7c59e2a9deb8c5c12f677f309ad51abe7307026d92c7aa14db175f7a8b 4473 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/01_R3_ADDENDUM_AND_SOURCE_BRIDGE.md +650b4bca176cb0fb9aa14b941061e5babae3c866245ad9fbbc05155510e26d8f 7138 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/02_ENDPOINT_SUPPLEMENT.md +617cee2bc4b03d045adc8ba6fbe0b08b76bbcc1336a01a24a70d99d3856afb5a 4539 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/03_CONSTANT_CERTIFICATE_CONTRACT.md +d440468efeae63a35701c303c6163d0662dbf6591ee9f91cd59ef7b1d258d054 5134 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/04_RETURN_TO_KIMI.md +9ba5433e7861225e302485831c8d1f77610657bf7e25a6e9a9329ddda713affc 1962 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/MANIFEST.sha256 +2faa61590b6de07f3e4470d92569e37219028023f2c039e9420c420d9931fa2b 1478 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/REVIEW_STATE.json +66b2f7fa1742e1cf9680842552d031d4107fec14f666fa83429a91feea650e7f 6793 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/check_review.py +25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc 14 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/requirements.txt +cf58f72eb0399c626160c143b50f674ff3bd5c449225211edd6fd378a374e1a5 22614 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/02_LOCAL_PATH_LOWER_BOUND_CANDIDATE.md +b3b1371f4d0f0b4b7f2ccac61742b241ec549cb145765f60fc4ccf278a871536 5820 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/03_INDEPENDENT_REVIEW_PACKET.md +e48d7c271dff9c120316ee2129a303aed6f78b518c2e0c08337eb357bd60e2e8 3397 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/AO48-OPR-045.md +c1d6e559274d7e87a3fa92f44cb2534a5e277a3b5941fd40db380599ddba0564 30933 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/GP-DER-118-v1.10.md +26a9c7ef46b546acfdb0fda11f6ee8dd1e655752202d0add39e0011adf936a4c 13399 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/GP-LB-STAT-004.md +76f6fa487479dbf77e265e61f2eaee772d1729d25813f6dea15d9e929c2d125c 39446 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/KIMI_LPW_REVIEW_VERDICT.pdf +7f03f305cf89463bab46c9a631f86f405844b0d99c73122414f0c69d12d0e1cf 37478 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/inputs/LEAD_EVIDENCE_PACK.pdf +84d4c92b78f8c95660ba404acf68e4ed73bcc3e69526342fa50d2ae37ed83974 2734 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/ARCHIVE_CHECK.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/CHECK_NORMAL.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/CHECK_OPTIMIZED.json +6a5bc16deb06635d9a82195cbb997e0bbdb8f7e2fd2bcd3d2c8accf71c5e9aa7 1078 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/EXECUTION.json +af38542dea88d1c6bd08dfab4994d7d76bff4325e0717bf2bc4a1fec3be7e1af 1052 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/INPUT_HASHES.json +5fae3c0e870d73fd812c12854dfe297482265af170b30d94447159be1eb21bf1 1447 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/prior_reconciliation/receipts/MUTATIONS.json +03d111a25bc0ba05466f6a2750fe0177ec8edb15dfcaac345ba1baa2d8945494 733 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/DRIVE_LOOKUP_SCOPE.json +2562c365277ab2b8f3cf8da09b9682f126209ca3b570826b06d416e5ba6a2668 271 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/ENVIRONMENT.json +812378a1d033ea7ca1019819f1f9c59906e7991da51c115a0acc232ba7890a38 2661 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/EXECUTION_RECEIPT.json +56be8654e65e6ffc5a8eb35f0ccb82a05cdab9cef0f276fc3f9881a03b3afe44 2022 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/FRESH_DIRECTORY_REPLAY.json +09f69c71e1fe2a56cc8925e216741baa81571e5a514a14c885c3b90dc2a411e6 1254 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/INPUT_AND_ARCHIVE_HASHES.json +596b1ee48c3d6b473b54bca7242b9940d512ec35441416e38d32f1ee1860119b 76 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/INTAKE_CHECKER_SELFTEST.json +0d9c0f409ad606044ab709682e9890c5d6c39a8d2abfc1bf9e8db8a6ef361353 6935 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/MUTATION_RECEIPTS.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/PRIOR_CHECK_NORMAL.json +22cb6d9178d1bcc524325fdb3cd37387a9e1d61a7d12d15a70fff5767460ac99 4427 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/PRIOR_CHECK_OPTIMIZED.json +39f3dfc8b96ee317fdc306d329f0598669703eb37dd252ab71fcb629c408a832 57 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/RAW_REVIEW_NOT_RECEIVED.json +7e9d4c248ad0a5cddcf96ef88cddefa76b6ddc77b84a7b2a4aee40a1ed509357 7903 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/VERIFY_NORMAL.json +7e9d4c248ad0a5cddcf96ef88cddefa76b6ddc77b84a7b2a4aee40a1ed509357 7903 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/receipts/VERIFY_OPTIMIZED.json +14c709275ca63940f6f066ae825ee16558bab5920e18487e7d9662e5e3d555fa 38748 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/reference_archives/Q0_Next_Phase_2026-09-12.zip +e0adf0deca5048378c285e1bb5ae58c02ea1ca4efd0e64c0de1b89eb8203ef47 6469 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/tools/inspect_kimi_delivery.py +90097d9aedd4f305b4ad2f2b2f5aeddec3842b65864628b26fe108b28fe9dc93 3185 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/tools/run_checks.py +97dd9b628bcebb2c931f0d3b2684033baf90f0fb323bb5d46900aa6c8b8ed577 10292 INBOX_LPW_Return_03/LPW_Return_03_2026-09-12/tools/verify_return03.py +a43c486ebb19eea7d9c82c3244206672d9f84dd2fa2f86bbf1f6e3bcc021729a 3994 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/00_READ_FIRST.md +e732543d8845fdd597ccf6fbdb7eccb7bd08b45b9e9529d76bb5136adbe72e6a 4362 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/01_OPERATOR_AUTHORIZATION_AND_FOLD.md +4362bc82aa11452fb04d0b5b3d50814efda45dc72aa3321469c5aa89527ecdda 5653 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/02_TECHNICAL_RECONCILIATION.md +1b50584f3bf0ba1977f390a35604b4eedd32058da386fcb9521e9ea0b746c01b 3849 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/03_MATCHING_2D_UPPER_WORK_ORDER.md +d406039623561329f8cbf1b0c9ae9038e629951243b5f685fbf063b2d229399e 5316 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/04_RETURN_TO_KIMI.md +a015bc05f850c6ff7e74aff97b583e9b40062e9cfc985a293202f38084851d62 4597 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/MANIFEST.sha256 +c8e0f541b5bb05475f8bdefa5e8339e27e6f560ef281477e9a43122cc0bb1b92 3330 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/RECONCILED_STATE.json +2ed9d2c9a862d90a3aa932ab7e6576b938e3870ff8ca503f685b1dfc22c36b6a 2931 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/REQUIRED_DELIVERY.json +47fd19021144e071cc43b6e265aafada0056abe89724ad95bd6e3a8e37995b94 28 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/requirements.txt +7359122b6466b20027ffa3ab7ae5ad0ae4ee3e40094c072ad257ad64728087c2 557 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/drive_apply/BOOTSTRAP_NOTE.txt +fe91394de1640d5a2c7c656452b412c6aac5879c11fbb13884a83e8d1c604522 1527 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/drive_apply/PLAN.json +ec5102861e6e199466ddff8a83de829eefee402c450b300b38a758b0daf2a9e8 46100 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/incoming/KIMI_LPW_VERDICT_ADDENDUM_2.pdf +2a359d49d78991f92e96271afc3d2064d17a5703b3128c93e42f59a8bf7db482 5467 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/incoming/KIMI_STATUS_RELAY.txt +989be970927d70cc83277132ca6cc043b44427d1cef4e92004dd92576b54e2f8 58589 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/incoming/LEAD_ANALYTIC_VERDICT.pdf +6811a63ed4a7b93d68c71140348b4b4b8b2fa6d9787b97a5fa4b7e9c3cfeaf8d 424 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/incoming/OPERATOR_INSTRUCTION_VERBATIM.txt +11932341c288f7789644fdfa3b35161d3f97784b9632667d7e7bdbc4e8d3d068 20263 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/incoming/RB_R2_RUNGTABLE_ERRATA.pdf +fb81f8c1774d851775a025ac08750fa9e98e7b04d0e6844e7aebfd14456de2c7 306334 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/prior_packages/LPW_Return_03_2026-09-12.zip +dc7f8ed81a53dfc659c323a637cfeb5b183422e4a9a215f063d06cef7be300c1 483 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/ARTIFACT_IDENTITIES.json +8582e3c8d979ce58f9317b1a6b2db8ec36b5ee302d14459e3bba99859a9d2506 779 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/CAPABILITY_AND_SEARCH.json +7e58f01c726f37cdde4efb874a9bddd30c86ffd14e1bdf19877ae294bb30f436 4975 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/CHECK_NORMAL.json +7e58f01c726f37cdde4efb874a9bddd30c86ffd14e1bdf19877ae294bb30f436 4975 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/CHECK_OPTIMIZED.json +266c1ef66fbca0c8b5a8041df00fafa771bf9ff9c3022ca67e6e889b27290b73 4238 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/DRIVE_SOURCE_LEDGER.json +584d1bee2af1d994f958680478ee7bc353d6d1393103e28b3109ead8159e9002 120 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/ENVIRONMENT.json +7a861200bbde6dc2d0fc05a5432ebfca5843ac43208285c04d9022559fc2b3fd 23686 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/EXECUTION.json +d0e28e9a09bdb2bb9a67f2ad14fd8e158ac074ab3e2dc3872e00a441bbccbb74 1227 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/INPUT_HASHES.json +dbad96336e9da83d4980a5b4950ef2782960b7106e593a4302bf4ea0e550334c 350 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/PRIOR_ARCHIVE_VALIDATION.json +7e9d4c248ad0a5cddcf96ef88cddefa76b6ddc77b84a7b2a4aee40a1ed509357 7903 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/RETURN03_NORMAL_REPLAY.json +7e9d4c248ad0a5cddcf96ef88cddefa76b6ddc77b84a7b2a4aee40a1ed509357 7903 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/RETURN03_OPTIMIZED_REPLAY.json +81eabafcedd6279fd10a9d49967e8fa4386bff0ac409625dad4fe899928ae0c6 3495 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/SPECTRAL_NORMAL.json +81eabafcedd6279fd10a9d49967e8fa4386bff0ac409625dad4fe899928ae0c6 3495 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/receipts/SPECTRAL_OPTIMIZED.json +e48d7c271dff9c120316ee2129a303aed6f78b518c2e0c08337eb357bd60e2e8 3397 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/AO48-OPR-045_RAW.md +5078419fefc44b129ce6b05c1547a453c4fe15196a7d68e88287491cd20150bb 6553 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/C020_CONSTANTS_HISTORICAL.md +5e699b607098065cd6a4ad87bc420be3d46a84910e4e65a4c7d4eb149742b7d7 5150 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/C020_REGISTRY_HISTORICAL.md +650b4bca176cb0fb9aa14b941061e5babae3c866245ad9fbbc05155510e26d8f 7138 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/ENDPOINT_SUPPLEMENT_EXACT.md +c1d6e559274d7e87a3fa92f44cb2534a5e277a3b5941fd40db380599ddba0564 30933 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/GP-DER-118-v1.10_RAW.md +26a9c7ef46b546acfdb0fda11f6ee8dd1e655752202d0add39e0011adf936a4c 13399 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/GP-LB-STAT-004_RAW.md +cf58f72eb0399c626160c143b50f674ff3bd5c449225211edd6fd378a374e1a5 22614 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/LPW_CANDIDATE_v1.0.md +081a4e3862f6e7aa0797c6b3aa347530ae4f5491bfa4aafde2309295868ef081 4248 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/LS-CTL-003-v1.3.md +c6a90469b6e43c592b661a63c85a6fa6590505f3d22fd888a328ebf7926d41c0 13512 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/Lemma_UB0_C020_HISTORICAL.md +224438cb740565ff8b2f0acab83a75c8dc80cc15265a55451f43ff930894c94c 3442 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/Lemma_UB0_C021_ADDENDUM_HISTORICAL.md +e53d6581ed371b277c3cc97008000f9293e51b1092e5b614856026b53db35c99 9486 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/OP-PROT-012_RETRIEVED_TEXT.txt +18a6e27cb945c7fc80975e20f775724989de0d368ce7a6f2ee29f11bea165d70 13605 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/QC_RETURN03_EXACT_TARGET.md +fa0a4f7c59e2a9deb8c5c12f677f309ad51abe7307026d92c7aa14db175f7a8b 4473 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/R3_CLARIFICATION_EXACT.md +dc52a4ad5850fa6c9636736c46f4ad2ed8197dfab5334284eb0528e7dca53937 2036 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/README.md +ae8d372449b388966a7209ddc7c37882ef4c5239e12ddfea152dac99b33693df 2387 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/sources/UB0_LINEAGE_DECISION_RETRIEVED_TEXT.txt +e742d94911b84c7be5b2bd5e4b833d6dfa2f7f634285737b00f682ac80652a16 1787 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/tools/check_spectral_parity.py +65e733444f492e1e27ca5865d8da557f4d6c92c9228c9f44febff556821abb8f 1261 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/tools/run_replay.py +589c7fa2bbed277239715c383f9e1454708b34e0f05fd604fb0d9debea6a2623 6398 INBOX_LPW_Return_04/LPW_Return_04_Operator_2026-09-12/tools/verify_return04.py +22c303cbbaa4e2234575bc07bb2cfbafb950abc8a9bb71a34f4b529d0cb6a10e 5015 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/00_READ_FIRST.md +10c4d89807295546aebbc3904ab828ccc05dccaf18383aba12d28a15a526b8b1 6383 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/01_CURRENT_STATE.md +cf58f72eb0399c626160c143b50f674ff3bd5c449225211edd6fd378a374e1a5 22614 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/02_LOCAL_PATH_LOWER_BOUND_CANDIDATE.md +b3b1371f4d0f0b4b7f2ccac61742b241ec549cb145765f60fc4ccf278a871536 5820 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/03_INDEPENDENT_REVIEW_PACKET.md +c5e14754346c7dab1cf25b76ab435b7be6ae9b4d2de939629d56099e462265be 2641 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/04_WEIGHTED_TRANSFER_BACKUP.md +8412bba72ff3efa1f6e493936e57823ef28b0df24df39e1f996a4cc9ddc70231 3855 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/ALGEBRA_NORMAL.json +8412bba72ff3efa1f6e493936e57823ef28b0df24df39e1f996a4cc9ddc70231 3855 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/ALGEBRA_OPTIMIZED.json +f86dc4f317091ba24aefc9fd060d262f5a7853d4b41c2466b764354c09103788 3422 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/CURRENT_STATE.json +7121e3cb587a79d2e715b4aa3cf70387bb10b802948c7a89791634f8b4b348e5 6923 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/DRIVE_READBACK_RECEIPT.json +a7474d160db7abb954e82331338aa4469253318cfa90240eac7d76492618f2ed 212 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/ENVIRONMENT.json +2f5f5bd1564a3ee6da3d66af0fc61204dcb267645962fb9668a00795e9356cee 1257 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/EXECUTION_RECEIPT.json +9e91b81ddf1cfc416975a4232e30f0f5d4534c55c250965df00e8690c8ef534e 2582 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/INPUT_HASH_LEDGER.json +433bc58cfd9a53160f91f206d351bb53602142ad5a7a0dbe4c91fd80990f799e 1427 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/MANIFEST.sha256 +d425479c1f53a0af22dbf862694dc8ab52270389ff22dc7c9b43978062a920c5 28420 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/MUTATION_RECEIPTS.json +b63ffd744e376f2807535811e3bb85f550b5e88c7d672a9e690a148f8fa62cbc 1618 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/RELATED_WORK_SCREENING.md +25f9f1fb1988b230147a1d3092d34e09c069eb7a6c6d6df46b3973b9f2d36efc 14 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/requirements.txt +e0ff99cba165cc1265f95781ca8a16ea597e01be1d6b70b6bcd3526b212b787c 3484 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/run_reproduction.py +9eb2ffeea8eb0b73ebbfccce5db0006b6ae43e0c412da4c276d1c4b93a849c64 8565 INBOX_Q0_Next_Phase/Q0_Next_Phase_2026-09-12/verify_local_path.py +940057a57f18488fa3e76bf235020d1ef984480357bbfb61fa830f1c84d95743 6590 LPW_CONSTANT/LEAD_REVIEW_OF_LPW_CONSTANT.md +289d9f40e725bd51e2405d9de88b3afd428a338f76a709d6d882f1c395f50b22 12790 LPW_CONSTANT/LPW_CONSTANT_REPORT.md +2afb8c352ca77d57ed5aae189c5c8545002dc9cab1b85f12dad20c5b208564d2 1310 LPW_CONSTANT/MANIFEST.sha256 +6332afe0f313dc5dc856f623a513fbfed987be883ac4dcdc4c6d6151732520ee 1794 LPW_CONSTANT/RECEIPT.json +435b40ce1630c0b90ee660efffc5f313d86c07490178a02d21f7825a3173d1fb 14789 LPW_CONSTANT/falsify.py +34df591195053d940bd50bd5e411f953a1f3443ef95997a2c239f9373d41e746 1228 LPW_CONSTANT/falsify_O.txt +34df591195053d940bd50bd5e411f953a1f3443ef95997a2c239f9373d41e746 1228 LPW_CONSTANT/falsify_normal.txt +e258322cfbb71dbb8665c2d0c0517399dca5ca5913e9ddf70eb7247ba74d3035 25380 LPW_CONSTANT/lpw_constant.py +d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f 4276 LPW_CONSTANT/out_O.txt +d0cb92595bad7e1b7266e1a9043a54caff380ed075e8f4e358b0ae04146c573f 4276 LPW_CONSTANT/out_normal.txt +a469c456b76654d641dfe96301e929c8ff3d01c0eb109a2b3e2d3208cd61ef62 6675 LPW_CONSTANT/v2/LPW_CONSTANT_V2_REPORT.md +61510631858e43d8243a83d6b5e32dcfe7e99faa911837edf44f019695982ee1 507 LPW_CONSTANT/v2/MANIFEST.sha256 +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 LPW_CONSTANT/v2/exit_O.txt +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 LPW_CONSTANT/v2/exit_normal.txt +ca654e39ab817a8c85d609cb0775fb0f27ef0e8b54255d65cce6bed1c130e125 8322 LPW_CONSTANT/v2/lpw_constant_v2.py +25c5bde4a04d8364554883a8f9e41e8d2678f8037e3c3930136a69cd48beaabb 1421 LPW_CONSTANT/v2/t_O.txt +25c5bde4a04d8364554883a8f9e41e8d2678f8037e3c3930136a69cd48beaabb 1421 LPW_CONSTANT/v2/t_normal.txt +7d4722309fdad63d366c221a959f4b6f29ea6d23e4bb304da8fc505bfff6d1c4 8022 QC_RETURN03_REVIEW/LEAD_ANALYTIC_VERDICT.md +87cf79e5df339ba2567e933348aa64b726fa8105dd781b6899f714a2987aed9e 1776 QC_RETURN03_REVIEW/MANIFEST.sha256 +3311b40f22a6284fdb9ba14c37174f38c2a4da8385add93d1e6082dc0f1cbdd1 50251 QC_RETURN03_REVIEW/OUTPUT_NORMAL.json +3311b40f22a6284fdb9ba14c37174f38c2a4da8385add93d1e6082dc0f1cbdd1 50251 QC_RETURN03_REVIEW/OUTPUT_OPTIMIZED.json +3311b40f22a6284fdb9ba14c37174f38c2a4da8385add93d1e6082dc0f1cbdd1 50251 QC_RETURN03_REVIEW/OUTPUT_RERUN.json +a6a3e129e1330224cee76907e8928cbd73dbffe070f8530bf68fd1475782336b 16458 QC_RETURN03_REVIEW/QC_REVIEW_REPORT.md +f3622d3cb1c5cf7d1d6f0cb4916449564965b23fe70003e818e16fa160fc281d 29655 QC_RETURN03_REVIEW/qc_return03_numeric.py +cfb5da9ebfc4804e265953186dfcffb676c3b11b72e3bb5c0b1f1c4df33396d4 31 QC_RETURN03_REVIEW/mutation_tests/mut_1.err +1e85fb2d696757c81a4f56463a8c5b610fac8c554bec631f4a9e30db7bf38644 28088 QC_RETURN03_REVIEW/mutation_tests/mut_1.py +0866ccf600bd91ea4c96a893f6857dfa01bfb49efda7d05610e39c2be579acc1 29 QC_RETURN03_REVIEW/mutation_tests/mut_2.err +da82eaa5dac1827c5b07986309bfee7c456cbb86882f914aa786240996956f7c 28088 QC_RETURN03_REVIEW/mutation_tests/mut_2.py +3b38458c65ffa5267d5f06728990e8d11890d4a9622b5fd7f8850ddfbf82f51d 48 QC_RETURN03_REVIEW/mutation_tests/mut_3.err +86bea508e5edd26fc2f61097181acbf9b4741c32c08a48f3669f5ae875bb43ad 28086 QC_RETURN03_REVIEW/mutation_tests/mut_3.py +5dd7a4e0238f518a5a30b131ae6cc2b20de81c2af342c9dbea40abb152f76fe8 34 QC_RETURN03_REVIEW/mutation_tests/mut_4.err +0ac405e192b0c4b16bf195612f7c063fbd11d4f795eeb705905f2db801eea74c 28092 QC_RETURN03_REVIEW/mutation_tests/mut_4.py +4d449ee0aa0ea57ff4a175cf2f88fc608ddeae589556742e3beb4b23ff666393 51 QC_RETURN03_REVIEW/mutation_tests/mut_5.err +fcc95b647d626baad018cd27825a16a92870a8d391ba33c2d0e39ab38e45ae95 28092 QC_RETURN03_REVIEW/mutation_tests/mut_5.py +82272c881136781ea3c933799e8d403c35d860a139be788c02a83fbac2564d6b 338 QC_RETURN03_REVIEW/receipts/ENVIRONMENT.json +57e97c83bd8010f958145756cb73a5453c84e0bea2772c10773345841c8af6d9 378 QC_RETURN03_REVIEW/receipts/HASHES.json +1acbaf4774cc7c738eabb15ec066737a0cf3473f4ce73f0387d4a7cd858a44eb 1118 QC_RETURN03_REVIEW/receipts/MUTATION_TESTS.json +76057397ddc0594205b346c629ceba742558e2a0b21bb301f1a9ea975b4f5219 255 REVIEW_LPW/ENVIRONMENT_LOCK.json +04bcbdf2013d83b149a8933a332a078c303af347335ee40f154f37ba195ad448 9219 REVIEW_LPW/KIMI_LPW_REVIEW_VERDICT.md +6ead3d49fb2c3d6c5c4a961ad7c1f2f747ff904ca1d8a9d5d38b31bfb224a355 9742 REVIEW_LPW/KIMI_LPW_VERDICT_ADDENDUM.md +ce0e671d981bfb080a8f864ce3ab024462efe8b716ef5a8441d6298b526adbb6 5610 REVIEW_LPW/KIMI_LPW_VERDICT_ADDENDUM_2.md +97f04b3553a72065129bce65a2f143e4c6a65557aaa8d72f8af65fef5aa38956 2185 REVIEW_LPW/KIMI_LPW_VERDICT_ADDENDUM_3.md +09c0ada7e1db0e85fec7451877a8eead162e8133a7b537d0681c59b6b4ce15c1 3967 REVIEW_LPW/KIMI_LPW_VERDICT_ADDENDUM_4.md +49ef8c1aa7266c3c69bb377454aae804bd01b6357aaec18fcc31986727dd9e8b 7679 REVIEW_LPW/LEAD_EVIDENCE_PACK.md +a79d293fc5e512ad16afe32c92a1fb593dc8b4695405cf8fdf32d56c00f177a8 3376 REVIEW_LPW/MANIFEST.sha256 +3b7cda65e55f00b69265f9203a335fe0049ae242098365c262bd5ca3c7981034 33438 REVIEW_LPW/RA_R1_R6.md +07ceb63c2927e58b500c9480eaeaff793267d58dcf4499492f8f446155dcf64f 14747 REVIEW_LPW/RB_R2.md +b036727f1a780c4a6cb975502b0414d79e305c7f50d535330f4dc475aefd782f 2522 REVIEW_LPW/RB_R2_RUNGTABLE_ERRATA.md +8b0d8d49e41d3c48b352d9c6a6b990f3ab39b0651e8f182a47ee72b4db99c9f3 7536 REVIEW_LPW/RB_R2_part1_symbolic.py +fe6d74df69ae970207a30a95608365f60a1f253357125141352b13ea7a3dcba9 10697 REVIEW_LPW/RB_R2_part2_spectral.py +29dcbc232616cced0b826469dbd7c54ee8808e27b364137182554776229b43dc 14201 REVIEW_LPW/RC_R3.md +09aaac1de0c5ee52c6c660e95c5b57ea62ddc5da219709fb53d0cafdf44e476e 12656 REVIEW_LPW/RD_R4_R5.md +08b756771d597f296810b33a724c6af2fd8e5db820402630ff0e2ac792de112f 3395 REVIEW_LPW/README_BUNDLE.md +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 REVIEW_LPW/err_normal.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 REVIEW_LPW/err_opt.txt +45f4d4718d917c1ead7a8a014d6c7e51c8be7f9758b492b64d654bb92731397d 7453 REVIEW_LPW/out_normal.json +45f4d4718d917c1ead7a8a014d6c7e51c8be7f9758b492b64d654bb92731397d 7453 REVIEW_LPW/out_opt.json +ff2da6a065401aedb428bf6f4f38f21c5044e1fadb648385e3ebd215a70ef73f 2058 REVIEW_LPW/p1_normal.out +ff2da6a065401aedb428bf6f4f38f21c5044e1fadb648385e3ebd215a70ef73f 2058 REVIEW_LPW/p1_opt.out +377b690d61cfad0f2ff39408833a8c174f78a68b27a834dbeb6e10108db9e3b3 2190 REVIEW_LPW/p2_normal.out +377b690d61cfad0f2ff39408833a8c174f78a68b27a834dbeb6e10108db9e3b3 2190 REVIEW_LPW/p2_opt.out +4d9761ae9867b1daf289acf8a3b6f876a957ea4c2e968357d7f9a75b6c6dc340 1928 REVIEW_LPW/part1.out +377b690d61cfad0f2ff39408833a8c174f78a68b27a834dbeb6e10108db9e3b3 2190 REVIEW_LPW/part2.out +8244c2d93d8c3dc4c6308f06d26eb6b4abe0d0aff94fac59c7ccc25589bc0394 5526 REVIEW_LPW/rb_r2_part2_spectral_v2.py +72e1dfae99d19784cbe00f0746a522a5ae5ca1e8ee103b55332be83692693ffb 10 REVIEW_LPW/rb_v2_exit_O.txt +edf02abab41aa7871e8ad0a2d9a5c83d037abdb44af4b8db33f81bfa989d7caf 15 REVIEW_LPW/rb_v2_exit_normal.txt +40e370b4cbfc123b9033f5b402214c907461763b408c33407bbf31d52d992677 777 REVIEW_LPW/rb_v2_out_O.txt +40e370b4cbfc123b9033f5b402214c907461763b408c33407bbf31d52d992677 777 REVIEW_LPW/rb_v2_out_normal.txt +8e29544f1a96c87216f980c84334532b6d130dd7e5d13ef69371b75cf9601bfa 11173 REVIEW_LPW/rc_r3_numeric.py +ba14804930a7ae7bcee64cdb90c0ada10f0961f2dd290ce88520c51a5b7c15ec 6743 REVIEW_LPW/rc_r3_numeric_output.txt +ba14804930a7ae7bcee64cdb90c0ada10f0961f2dd290ce88520c51a5b7c15ec 6743 REVIEW_LPW/rc_r3_numeric_output_O.txt +72e1dfae99d19784cbe00f0746a522a5ae5ca1e8ee103b55332be83692693ffb 10 REVIEW_LPW/rd_r4r5_exit_O.txt +edf02abab41aa7871e8ad0a2d9a5c83d037abdb44af4b8db33f81bfa989d7caf 15 REVIEW_LPW/rd_r4r5_exit_normal.txt +45f4d4718d917c1ead7a8a014d6c7e51c8be7f9758b492b64d654bb92731397d 7453 REVIEW_LPW/rd_r4r5_out_O.txt +45f4d4718d917c1ead7a8a014d6c7e51c8be7f9758b492b64d654bb92731397d 7453 REVIEW_LPW/rd_r4r5_out_normal.txt +47fcd6c64631551164798dece2422b033543d56e8650da6a392ddb9ac5148b7d 17992 REVIEW_LPW/rd_r4r5_verify.py +2a75ad7e47386878b899ffb70e4f7cc9ef34a552dfa7a6cd0e9739d7f0a739b3 7296 UPPER2D/LEAD_INTENSITY_DERIVATION.md +4b0480d9e69ddecd93cdf0337f43c5d0fe4c9c5e5ee4c9ca7e621af00f04acde 3425 UPPER2D/plan.md +73f888a105d53866ca28fb77405dd320688987039ddfcf311730278049cf6ea5 31599 UPPER2D/B1_taxonomy/B1_TAXONOMY.md +8ed50aefefb666df587fb3eb440d8427d39d45416b82d9a42d2c292dbfafb49e 893 UPPER2D/B1_taxonomy/FREEZE.txt +818df7985412071259345455c9ff6b68cad0c0fa9d636009cf8849b550154185 14734 UPPER2D/B1_taxonomy/b1_falsifier.py +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/B1_taxonomy/t_normal.txt +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/B1_taxonomy/t_opt.txt +4cbe2f1e33ed39e3c37a02898eeb6116095f28f1a3de58b3b58a17cf8501d486 18132 UPPER2D/B1_taxonomy/__pycache__/b1_falsifier.cpython-312.opt-1.pyc +4cbe2f1e33ed39e3c37a02898eeb6116095f28f1a3de58b3b58a17cf8501d486 18132 UPPER2D/B1_taxonomy/__pycache__/b1_falsifier.cpython-312.pyc +878d5a7ded4a3900eed327480774aa76688b0dd273d6e1171d5c68e034891d4d 7871 UPPER2D/B2a_outside_cover/B2A_REPORT.md +95ccfdc8846ae855259676982000069e614cb5539d55a883693ac173ca09e8c7 17043 UPPER2D/B2a_outside_cover/b2a_attacks.py +1af0f07dd34aa3bcf0aa1ea3d6a26a994731f3328c1f6a1d037809d953fffda7 1328 UPPER2D/B2a_outside_cover/t_normal.txt +1af0f07dd34aa3bcf0aa1ea3d6a26a994731f3328c1f6a1d037809d953fffda7 1328 UPPER2D/B2a_outside_cover/t_opt.txt +4466136526eefbe5acb45e8da789ba011a12890e10687bbceaa104b0ee6f4d82 12894 UPPER2D/B2b_boundary/B2B_BOUNDARY.md +12a4f585ce3f51547cde7799ad974c3fa00e7cb43e4890176a1f65f86f11818e 13333 UPPER2D/B2b_boundary/b2b_boundary_probe.py +853cf25ff1c0737360a3255bac5bb5cce404a12dd33dd0aaee5e186051f9ad9b 3716 UPPER2D/B2b_boundary/t_normal.txt +853cf25ff1c0737360a3255bac5bb5cce404a12dd33dd0aaee5e186051f9ad9b 3716 UPPER2D/B2b_boundary/t_opt.txt +e50441c33cfa4830d7e5c6a034c97aa9d809e68885ab201f8d36a2e97d6f99cb 19274 UPPER2D/B2c_ties/B2C_TIES.md +9b636443ae57b6ee58236801843135a0ac034fa371f1b53c66d1b72f9e828430 24567 UPPER2D/B2c_ties/b2c_ties.py +c7b493fedfb7dc42e9f75b406c56db0dc7330ddfb3e7a431c067f89302049700 1457 UPPER2D/B2c_ties/t_normal.txt +c7b493fedfb7dc42e9f75b406c56db0dc7330ddfb3e7a431c067f89302049700 1457 UPPER2D/B2c_ties/t_opt.txt +cce90968c642982f8aa18f76082da269c58b4730697b9cced0fb0eacda857b40 9219 UPPER2D/B2d_torus/B2D_TORUS_REPORT.md +acd5043d7419c5af1e4f5230a3d8ac932548dbd1bf67451e3458f369c5ecc9df 38121 UPPER2D/B2d_torus/b2d_torus_attack.py +050fd18fe7929de48d8a9a26a91f8d34a5dfd275822747fa7ad46ac354b9d959 1399 UPPER2D/B2d_torus/t2_normal.txt +050fd18fe7929de48d8a9a26a91f8d34a5dfd275822747fa7ad46ac354b9d959 1399 UPPER2D/B2d_torus/t2_opt.txt +8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286 6069 UPPER2D/BRANCH_dir/BRANCH_DIR.md +7547e76a813d1a0c582139e2d31d9ec6a6480e1eaf670d3eed05173bffead3df 6063 UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md +23bc4696c7ec411bd09b601efc34aa08af8e06a5b10bda14987493b351d192ab 604 UPPER2D/BRANCH_dir/FREEZE.txt +6c60e6fa143ac089b7fa58d3a42b4bc2b9ddafb2613a68da6141216e752371df 1943 UPPER2D/BRANCH_dir/FREEZE_ERRATA_2026-09-15.txt +0b7d2a7dbf4a3a03e7fc4e9509d69f7fbfe8a57d8a9b6653198caf4e8594beee 9846 UPPER2D/BRANCH_dir/br_certificate.py +326d10a8bd752ded24ba2ac045b9129420a45b4704925ae13c81b3d704c8f32d 4660 UPPER2D/BRANCH_dir/br_falsifier.py +45650983a6603242967902e43e7270ada8ab43ba5234181d0592562c1b6f3af6 12404 UPPER2D/BRANCH_dir/br_mc.py +d97e7ac40f8beb7ee6d09040eeaf6c8991e497394f9ecc68df371b85c2e0feec 6227 UPPER2D/BRANCH_dir/br_probes.py +7c7e7602bbb2f42ead0ce58ae8f42748387fe92fd73f1cf3f7f4798277e9444c 2764 UPPER2D/BRANCH_dir/cert_O.stdout +7c7e7602bbb2f42ead0ce58ae8f42748387fe92fd73f1cf3f7f4798277e9444c 2764 UPPER2D/BRANCH_dir/cert_normal.stdout +32d43db14b660279ab372ca1a2a7c5f634a6964c389f76a419a3cffdf0c55fc0 24 UPPER2D/BRANCH_dir/falsify_O.elapsed +9ba66ac5d53dd98d35f629133c5f7ded47f3e85fc1eec2d23b40e6aa62bbf62f 941 UPPER2D/BRANCH_dir/falsify_O.stdout +f645fba0641e41d771ad2b81270b09de0eb4dde02b6e382d97b39fbeb7a56baa 24 UPPER2D/BRANCH_dir/falsify_normal.elapsed +9ba66ac5d53dd98d35f629133c5f7ded47f3e85fc1eec2d23b40e6aa62bbf62f 941 UPPER2D/BRANCH_dir/falsify_normal.stdout +4180107b12839692577bfd02031b43e38112c3ba76d86a3314a13ca5eb4d29d5 237 UPPER2D/BRANCH_dir/keeper_rung025.receipt +b3384534bbbe2d636cce15073b96380d98e834891652ef548b9cc80e15ded0ef 855 UPPER2D/BRANCH_dir/keeper_rung025.sh +3bc7cdcd8ed70b72f1c43142a21c2002821625feda4b2d39eda4af7f595da01c 24 UPPER2D/BRANCH_dir/receipt_O.elapsed +1ef623c73ea9befb3391e80385b25bb526b8d2d01f6ece532fceb05e9951328b 838 UPPER2D/BRANCH_dir/receipt_O.json +460eaf39cb265f603a7ffc00da898e54244d11ae20417a054f9f567d67e764e1 24 UPPER2D/BRANCH_dir/receipt_normal.elapsed +63bfebe6fcb7e45019f7b3aa2ea0ffc19dcc737bd7b05060fafdda4335ca5efa 843 UPPER2D/BRANCH_dir/receipt_normal.json +64127fffa338ea7b42b200453426aae3101adbd5a5f82a8306a91573dcc947ee 278 UPPER2D/BRANCH_dir/rung025.log +7f4bba5b1d8d93ad6fd65db4f39813c5b60f118363df95dd80a83c781f57b538 241 UPPER2D/BRANCH_dir/rung05.log +f36246277b5ce9dd5070b15b3ea7f2c42717559ffedf137150f205ae7e078987 25 UPPER2D/BRANCH_dir/rung25.elapsed +426793ba116ae62939b34bb8345391f3116271a8f16946a5f9faebbc2a0802fd 22056 UPPER2D/BRANCH_dir/__pycache__/br_mc.cpython-312.opt-1.pyc +345bfedfc2fe46e6eceba09ec84d3b15d3bb28cf385d0cb033b0ffe75bac6df1 22290 UPPER2D/BRANCH_dir/__pycache__/br_mc.cpython-312.pyc +87d61d719282637f69dfbe2791b0682ebaf6cd0c41950a459440098c4b6d4711 11716 UPPER2D/BRANCH_dir/__pycache__/br_probes.cpython-312.opt-1.pyc +87d61d719282637f69dfbe2791b0682ebaf6cd0c41950a459440098c4b6d4711 11716 UPPER2D/BRANCH_dir/__pycache__/br_probes.cpython-312.pyc +ca2c02b81a05e4cbc955b1aeab1f4120e9b8d4fda328aa191da08a49db72853f 27794 UPPER2D/C1_alpha_intensity/C1_ALPHA_INTENSITY.md +7e8009f7263a5075f5a036a94e2274b9adb8b1cf5cdb5285186d615ef1522dfc 938 UPPER2D/C1_alpha_intensity/C1_RECEIPTS.txt +2ebe6eb47ee3554b3257342b726d9990009793a66994c9e53fffdc13f70705e0 11624 UPPER2D/C1_alpha_intensity/c1_grid.py +f349ff8c4edd6f434bc76a49510f868cca7b495fb87225faa715ba084df873de 8849 UPPER2D/C1_alpha_intensity/c1_grid_transcript.txt +f349ff8c4edd6f434bc76a49510f868cca7b495fb87225faa715ba084df873de 8849 UPPER2D/C1_alpha_intensity/c1_grid_transcript_-O.txt +f9bb98636b95ad85e835940dc93c301e4f8ea0f458ef5cfdcd2cdcca5820ed04 36814 UPPER2D/C1_alpha_intensity/c1_intensity.py +85afff0d64c16973bd57c629f2fe7fbffaff4e4c1c96f4640ce9ab7325e99e03 49766 UPPER2D/C1_alpha_intensity/c1_intensity_transcript.txt +85afff0d64c16973bd57c629f2fe7fbffaff4e4c1c96f4640ce9ab7325e99e03 49766 UPPER2D/C1_alpha_intensity/c1_intensity_transcript_-O.txt +c9f8241f290f837d74db2ae944edca4605edd157daaae804e740bdbb67ecb2e8 1086 UPPER2D/C1_alpha_intensity/falsifier_run.log +5da7ee93e4e821fb4e9073524fdd00b0bed94ed41dddef689544447fa2aba012 4470 UPPER2D/C1_alpha_intensity/falsify.py +cc57ddfa3ae3f7aff5f6f230923cfc2805c260332a1f53671be189faf6679ea9 22239 UPPER2D/C1_alpha_intensity/__pycache__/c1_grid.cpython-312.pyc +4de92ff1e1cb0b7041470ddf831e97be5160a1f2f8fded31767358f8b2db1125 26326 UPPER2D/C2_B_classes/C2_B_CLASSES.md +caafc2ed3b3120c43deffb3a0c5fddc0d9b884881e81cb5339ca6e3e980f93f2 2283 UPPER2D/C2_B_classes/FREEZE.txt +2441b630170f51d17d0795dd7983ac37ff0609e594aa843dab45a3351d480452 15293 UPPER2D/C2_B_classes/c2_falsifier.py +ae7d2e5cc81fa155f159e2190cf1ac3362c59c88dd1d40857994dc77d78134d9 38709 UPPER2D/C2_B_classes/c2_probes.py +469fac9e87b97855a8d179a3cbbc13eb3535249c5a9cd98ff16662115dd5ce24 12188 UPPER2D/C2_B_classes/t_normal.txt +469fac9e87b97855a8d179a3cbbc13eb3535249c5a9cd98ff16662115dd5ce24 12188 UPPER2D/C2_B_classes/t_opt.txt +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/C2_B_classes/tf_normal.txt +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/C2_B_classes/tf_opt.txt +c41f61e9a6e2d0a0f6f1f948e8ee71267b28bf246c3d61724aaed9e49979b1a5 19177 UPPER2D/C2_B_classes/__pycache__/c2_falsifier.cpython-312.opt-1.pyc +c41f61e9a6e2d0a0f6f1f948e8ee71267b28bf246c3d61724aaed9e49979b1a5 19177 UPPER2D/C2_B_classes/__pycache__/c2_falsifier.cpython-312.pyc +3ea459656702e7d7c28dec7ff352b547648df1382e036a28a6ff4369f2891e72 36000 UPPER2D/D1_assembly/D1_ASSEMBLY.md +ef3724d71a9696b0c24d8358f65899577cac98d0d86f1d032a05a6a1de0bb4d4 8526 UPPER2D/D1_assembly/D1_ASSEMBLY_v1_1_ADDENDUM.md +a41b84c807bbce2aa858ec22da3dc7c4b6794829b23ab1369004a2cb9623b57d 14249 UPPER2D/D1_assembly/D1_ASSEMBLY_v1_2_ADDENDUM.md +8c37b7fef519fa91ae8b6f0fe42bfd9e866e4c63d59a904c258471e437d5c911 19386 UPPER2D/D1_assembly/D1_ASSEMBLY_v2_0.md +e04925d2d11442bf69f25f98f1a80dea66c22ec4857b8a1feaa5b11dc9ae90e4 22052 UPPER2D/D1_assembly/D1_ASSEMBLY_v2_1.md +7ca114f0b38680d8bb987c097de10f3faf884ae3b05c3ca47215af5df081c174 20078 UPPER2D/D1_assembly/D1_ASSEMBLY_v2_2.md +c33be462999fbb307a2b42eaf64607987be67f7310c9d778740ce39f2c9999d7 5857 UPPER2D/D1_assembly/D1_V2_1_RECEIPTS.txt +7041be058096f61cc3c2ba224db2f0d0bcdd547a80c0dec85d1ff07d250bb6f3 3080 UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt +afe239bda0f682992ca3b2ac368ca8450605f168a69392167c2f97e56c5c47fc 3040 UPPER2D/D1_assembly/D1_V2_RECEIPTS.txt +1ebd2c6ade067bcfa2732b89ef83266fdaecd24260c05cf6d810b0bd2db044b7 6928 UPPER2D/D1_assembly/d1_falsify.py +7c41dde8ed48068e5c81b17bbc645523f715ba88cde0d746736b8c4e2ce925ba 9444 UPPER2D/D1_assembly/d1_falsify_v2.py +5805e53d69541f00229e5e49e14d655afd1f471a2584a2117fedf0bb5298ddb0 11552 UPPER2D/D1_assembly/d1_falsify_v3.py +11b711d320c36e6b87fcc9b552d1761392be45237358d7e564d7969c3a631299 1375 UPPER2D/D1_assembly/t_normal.txt +11b711d320c36e6b87fcc9b552d1761392be45237358d7e564d7969c3a631299 1375 UPPER2D/D1_assembly/t_opt.txt +4707b255c07d84013f1d47d7082157d398b9b30d99a07ac02ec2b57a9c0e0617 2379 UPPER2D/D1_assembly/v2_t_normal.txt +4707b255c07d84013f1d47d7082157d398b9b30d99a07ac02ec2b57a9c0e0617 2379 UPPER2D/D1_assembly/v2_t_opt.txt +f207abc32bb9abf3e2fbd130d3493c6e95daa0519e3170714c783c2cacc62f98 3041 UPPER2D/D1_assembly/v3_t_normal.txt +f207abc32bb9abf3e2fbd130d3493c6e95daa0519e3170714c783c2cacc62f98 3041 UPPER2D/D1_assembly/v3_t_opt.txt +aa35cad756856d0413ffc9dc6717e137e6e5bd7af6a983f28c26bf46b5b15fc7 29448 UPPER2D/D2_branch_control/D2_BRANCH_CONTROL.md +f0c401a3411f8b5aea28c3b9b3785b6d2db22fbda8dcd8839837c19d4e55e344 3829 UPPER2D/D2_branch_control/FREEZE.txt +824284be876ce685f63e600a642ee84ad601e6fb2424a852dafe8c21178122d8 14348 UPPER2D/D2_branch_control/d2_falsifier.py +62e15f5a3b9ee39b14c5abd5a9cfea7f1cf8b0e65b3306c862fad54c6258453f 38643 UPPER2D/D2_branch_control/d2_probes.py +848ab8c3d16a9d738b165730a2ba0b3adbdc475cc78486e90bacdadc2b65b5cc 16610 UPPER2D/D2_branch_control/t_normal.txt +848ab8c3d16a9d738b165730a2ba0b3adbdc475cc78486e90bacdadc2b65b5cc 16610 UPPER2D/D2_branch_control/t_opt.txt +66b5513fe34c4df1f3230ebb97e34f2313c3713fc7e764b8a5825f5fa7e90cf2 1157 UPPER2D/D2_branch_control/tf_normal.txt +66b5513fe34c4df1f3230ebb97e34f2313c3713fc7e764b8a5825f5fa7e90cf2 1157 UPPER2D/D2_branch_control/tf_opt.txt +a4fe0bf6e48523b599d988e5fc3009a792cb5977d02fcdb86ce5b297910496ba 17644 UPPER2D/D2_branch_control/__pycache__/d2_falsifier.cpython-312.opt-1.pyc +a4fe0bf6e48523b599d988e5fc3009a792cb5977d02fcdb86ce5b297910496ba 17644 UPPER2D/D2_branch_control/__pycache__/d2_falsifier.cpython-312.pyc +7bfc3fed55cebb16f2891cf2155b2bdbcc0cc53d7acd03ff0299488ea2e49e9d 60250 UPPER2D/D2_branch_control/__pycache__/d2_probes.cpython-312.pyc +45f58a76749025aa21bfce53daa1c1f06092e677a67a9765fb9cd1d90434c12d 18808 UPPER2D/D3_percolation/D3_PERCOLATION.md +fbe7583fde05e9ed212504e3d07e4a8e75e092c1d6a920ef09fdb4d65c8f24f9 8019 UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT.md +2527ab5a1b5ee208a30a672e2457de04708228f3c154185d95c236bd4f4f5e6f 5701 UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md +b1f12ba8aeb085cc4a3b34a71f06eea9e5dbcb55329f94b1d9f87d8ce01e3306 2983 UPPER2D/D3_percolation/FREEZE.txt +5eed16743485ae964da3e360d6830c95036a6d264af6b7447d5fdb4bddf95b3f 2945 UPPER2D/D3_percolation/FREEZE_AMENDMENT.txt +2edb070c29d6ed7e986b659c3019b62898ba9dbcaea8146a116f4aafd800d122 3588 UPPER2D/D3_percolation/FREEZE_AMENDMENT_v2.txt +12175217869a9bd7b3f623fdb34a6c0c699419722bfe534e3b5226352504b5b6 21619 UPPER2D/D3_percolation/d3_amend.py +6399a0e31b089a94c4dfec7960682ef400f7f0f99a788e3668557d0a75cf7528 14846 UPPER2D/D3_percolation/d3_amend_v2.py +c9e7458b8ec6da9eba8121d8de4bbe354cf8389409363170f2c17d7841ac526e 29034 UPPER2D/D3_percolation/d3_falsifier.py +5bc092412943e1c2185a8cf86cee23ae9cd9a2aad9bd9ef0b02807e9ff58dfa4 40337 UPPER2D/D3_percolation/d3_perc.py +3e840bfdceaaca76e8cae9b3e11dbcc5602e6c035b3e839577ec79639fb85787 10311 UPPER2D/D3_percolation/t_normal.txt +3e840bfdceaaca76e8cae9b3e11dbcc5602e6c035b3e839577ec79639fb85787 10311 UPPER2D/D3_percolation/t_opt.txt +7bfb65ba86118f2ff3714310f4a719d8bcda50a682a1edf3ca9a83cdeab2bde8 3552 UPPER2D/D3_percolation/ta2_normal.txt +7bfb65ba86118f2ff3714310f4a719d8bcda50a682a1edf3ca9a83cdeab2bde8 3552 UPPER2D/D3_percolation/ta2_opt.txt +fae8579f8c35f5a8c8033271e11fc1d1684da49d861b049e5c48a6e0c8553a29 5172 UPPER2D/D3_percolation/ta_normal.txt +fae8579f8c35f5a8c8033271e11fc1d1684da49d861b049e5c48a6e0c8553a29 5172 UPPER2D/D3_percolation/ta_opt.txt +9f4f55d0cc79f8a810e9d32edbed3acc5c3b6167014d4680428596679ad0b1f6 1575 UPPER2D/D3_percolation/tf_normal.txt +9f4f55d0cc79f8a810e9d32edbed3acc5c3b6167014d4680428596679ad0b1f6 1575 UPPER2D/D3_percolation/tf_opt.txt +5c0e566d5f924a14c2e0940628e915ca28302ae2bb26182f24749cb61038ec37 5436 UPPER2D/H1_v2_hardening/CHANGED_INTERFACES_REVIEW.md +49e23661da379e5cf0822a41296974669c56e208e56fd43e81479ff5b103a94a 1757 UPPER2D/H1_v2_hardening/H1_V2_HARDENING_RECEIPT.json +b6922aac117c533c36a71bbbe23dea282e0e63f34c010ec9420e04b0318dc5ab 10545 UPPER2D/H1_v2_hardening/H1_V2_HARDENING_REPORT.md +6892d7fb851ba4447dc7c4e0c183ddd16a6099ee04e9c70d294297a16400aeab 3005 UPPER2D/H1_v2_hardening/MANIFEST.sha256 +e0e51d172c104e883ffb373d9a816c2244e4c1a0d05503cfd02d1d7f1d413971 16 UPPER2D/H1_v2_hardening/exit_O.txt +eb95f18c4898a0170901e14dcb506de631804789644c3128ae1deedf3cc24ea3 20 UPPER2D/H1_v2_hardening/exit_normal.txt +1f6a25c4f13c5dfb52b69f12b75882749130a0fa81921d9b3032f0e4b709fe86 36213 UPPER2D/H1_v2_hardening/lpw_constant_v3.py +f6d47de905b6dc41e70fa0e07d92411152379ed42abff07b6a7b6a7e5c706171 2797 UPPER2D/H1_v2_hardening/mut_amplitude_double_O.txt +f6d47de905b6dc41e70fa0e07d92411152379ed42abff07b6a7b6a7e5c706171 2797 UPPER2D/H1_v2_hardening/mut_amplitude_double_normal.txt +bbd4edac237584ca4dcdc21ac7016f522f1c6df9dc3c10efa664437c72e6b53a 13311 UPPER2D/H1_v2_hardening/mut_box_width_O.txt +bbd4edac237584ca4dcdc21ac7016f522f1c6df9dc3c10efa664437c72e6b53a 13311 UPPER2D/H1_v2_hardening/mut_box_width_normal.txt +f100785ac53f382aa0ddd88b1c5d3d89a0f93af4eb22a1f10d104600a18d6597 9161 UPPER2D/H1_v2_hardening/mut_decimal_above_exact_O.txt +f100785ac53f382aa0ddd88b1c5d3d89a0f93af4eb22a1f10d104600a18d6597 9161 UPPER2D/H1_v2_hardening/mut_decimal_above_exact_normal.txt +bd7ef5e510f222ff97bdc0061227d165ca3829b2da5c1e6fb59030e576b8a458 9061 UPPER2D/H1_v2_hardening/mut_decimal_change_O.txt +bd7ef5e510f222ff97bdc0061227d165ca3829b2da5c1e6fb59030e576b8a458 9061 UPPER2D/H1_v2_hardening/mut_decimal_change_normal.txt +72c4f66e17ef883e4fbc33a18bad006e4b263dcbceddc1f2627d1b7d2276b6ab 9319 UPPER2D/H1_v2_hardening/mut_denominator_change_O.txt +72c4f66e17ef883e4fbc33a18bad006e4b263dcbceddc1f2627d1b7d2276b6ab 9319 UPPER2D/H1_v2_hardening/mut_denominator_change_normal.txt +2824e0994ed83771e55c1361c53a9ba0febf2c5d5d1f712c69d6a6e3a89a75e3 13242 UPPER2D/H1_v2_hardening/mut_eigenfloor_up_O.txt +2824e0994ed83771e55c1361c53a9ba0febf2c5d5d1f712c69d6a6e3a89a75e3 13242 UPPER2D/H1_v2_hardening/mut_eigenfloor_up_normal.txt +c138aab02e1647da58b880c549bea9ff1b455e9c99da2010fdd82347be76dac7 337 UPPER2D/H1_v2_hardening/mut_exits.txt +9a387297c6c9b4a8627c109ffac894255ce6684687cb668518ef12d2faae2e4c 7170 UPPER2D/H1_v2_hardening/mut_false_identity_restore_O.txt +9a387297c6c9b4a8627c109ffac894255ce6684687cb668518ef12d2faae2e4c 7170 UPPER2D/H1_v2_hardening/mut_false_identity_restore_normal.txt +601058357bc9676fa6c99a2ce55cf2be0db5edc6f6b9f298002a995261f1096b 13275 UPPER2D/H1_v2_hardening/mut_hessian_power_O.txt +601058357bc9676fa6c99a2ce55cf2be0db5edc6f6b9f298002a995261f1096b 13275 UPPER2D/H1_v2_hardening/mut_hessian_power_normal.txt +d7181d936c6e0f02d8c502a7acd2976f9b0473aae243cb24f8f81b4476d79869 13448 UPPER2D/H1_v2_hardening/mut_planar_moments_O.txt +d7181d936c6e0f02d8c502a7acd2976f9b0473aae243cb24f8f81b4476d79869 13448 UPPER2D/H1_v2_hardening/mut_planar_moments_normal.txt +76f46b331eed6652c6a54150b96c4b700449ffd2af15ab067671a0f814d682b5 8017 UPPER2D/H1_v2_hardening/mut_rung_floor_O.txt +76f46b331eed6652c6a54150b96c4b700449ffd2af15ab067671a0f814d682b5 8017 UPPER2D/H1_v2_hardening/mut_rung_floor_normal.txt +6fdd7873632f04e909ae251072a8151ba93e00d84a50d87a55173147beec3103 2790 UPPER2D/H1_v2_hardening/mut_sine_drop_O.txt +6fdd7873632f04e909ae251072a8151ba93e00d84a50d87a55173147beec3103 2790 UPPER2D/H1_v2_hardening/mut_sine_drop_normal.txt +3861b433b05bdf042d393a2ca61cd2608b3f2645c2f327c6dbd6b00964305d75 5899 UPPER2D/H1_v2_hardening/mut_wrong_moment_O.txt +3861b433b05bdf042d393a2ca61cd2608b3f2645c2f327c6dbd6b00964305d75 5899 UPPER2D/H1_v2_hardening/mut_wrong_moment_normal.txt +8057f9b0f72c508edbf94c9114ec31b93567a7a010be86ca7e841a7efd962425 13883 UPPER2D/H1_v2_hardening/t_O.txt +8057f9b0f72c508edbf94c9114ec31b93567a7a010be86ca7e841a7efd962425 13883 UPPER2D/H1_v2_hardening/t_normal.txt +d0edfadb0966144d0d2c36a3444f8031d3c2f421d89410aca61dd9258a01a19f 1513 UPPER2D/H2_foundations/MANIFEST.sha256 +cc2d012c7eb0b3f67e3dba64e578cd3f6f71f570e6d67667734e1847111d831f 15197 UPPER2D/H2_foundations/README.md +8a51c89bcfe9c8e7ec96badc40be92f64ded3fa5ae633e43dd653bd8bd6691a4 1629 UPPER2D/H2_foundations/RECEIPT_cov_exact.json +e8db146b604e163fbdf36665cce8d3ddf93d193468975d8975d55ad8a90f6f91 1613 UPPER2D/H2_foundations/RECEIPT_pin_transform.json +48c6494f9311fe910898ef349b3f3ac7f609e0e6d3696431ff6dd6c49bf1f91e 1965 UPPER2D/H2_foundations/RECEIPT_reg_lemmas.json +f08c1c5f653f2ffd2e85d39e1112f80d15db04d15f932e5ee42db2ca3553e783 21961 UPPER2D/H2_foundations/cov_exact.py +cb6c0f2fb4350f2e5707ebf730b4ab74f7c5d733208a74649bc3cb7aab6ac27e 6050 UPPER2D/H2_foundations/make_receipts.py +c6988ac7fcfa32dcc03c1374e13fb4c26af1c12c25cb824a315e6dce8991fd41 17623 UPPER2D/H2_foundations/pin_transform.py +e7005a5af73d80bc1e129ac17ed19ae3d5df5d6667b076efa311f24247043450 10582 UPPER2D/H2_foundations/reg_lemmas.py +e1b331dec6e0f82e6a084a30d9df9d8f402f42057861e6875504b04ea4a32068 17967 UPPER2D/H2_foundations/selftest_cov_exact.py +9c7838d1d4a9b181afb6e7ae94f46c588894232835236abba49abb69af35d30d 26746 UPPER2D/H2_foundations/selftest_cov_exact_O.txt +9c7838d1d4a9b181afb6e7ae94f46c588894232835236abba49abb69af35d30d 26746 UPPER2D/H2_foundations/selftest_cov_exact_normal.txt +90e88ff8f5248332219902caf6ea4df5bb5b89ffa72b95b519fd4472860403a6 14492 UPPER2D/H2_foundations/selftest_pin_transform.py +7eeb845e063579444103097f5f8a9b7f5cecedafcfd68c3f4355e0a981c3acc2 6305 UPPER2D/H2_foundations/selftest_pin_transform_O.txt +7eeb845e063579444103097f5f8a9b7f5cecedafcfd68c3f4355e0a981c3acc2 6305 UPPER2D/H2_foundations/selftest_pin_transform_normal.txt +27505d0196e39a0c47989c443f402aa2ad23bdf235771ea1bbdee1030efad65b 15350 UPPER2D/H2_foundations/selftest_reg_lemmas.py +9d852eebddecc2ee5054ef87b61cb7149ab28cfe7dd7bf501f14c038771a2e18 9750 UPPER2D/H2_foundations/selftest_reg_lemmas_O.txt +9d852eebddecc2ee5054ef87b61cb7149ab28cfe7dd7bf501f14c038771a2e18 9750 UPPER2D/H2_foundations/selftest_reg_lemmas_normal.txt +b4b610640e102ed1f913671ccf564691afb10c5973607261b9a9219c1ca322d7 28215 UPPER2D/H2_foundations/__pycache__/cov_exact.cpython-312.opt-1.pyc +b4b610640e102ed1f913671ccf564691afb10c5973607261b9a9219c1ca322d7 28215 UPPER2D/H2_foundations/__pycache__/cov_exact.cpython-312.pyc +69e54d2c988f2ecf8221d7d5011f7fa4aa6e156af2df07e3b2d24db2d72f7345 27836 UPPER2D/H2_foundations/__pycache__/pin_transform.cpython-312.opt-1.pyc +cdb1adaa10a4983c9ad6a3e67b4c467ec4be85518c7ba2875c2bef7ef753a650 27814 UPPER2D/H2_foundations/__pycache__/pin_transform.cpython-312.pyc +aa2c411c3e05af1dcc06a4882c97903ce5d19b789778c188fbabd739f0683450 17144 UPPER2D/H2_foundations/__pycache__/reg_lemmas.cpython-312.opt-1.pyc +aa2c411c3e05af1dcc06a4882c97903ce5d19b789778c188fbabd739f0683450 17144 UPPER2D/H2_foundations/__pycache__/reg_lemmas.cpython-312.pyc +387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637 16857 UPPER2D/H3_closure/H3_CLOSURE.md +6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa 7003 UPPER2D/H3_closure/H3_RUNG_FLOOR.md +1979c4b3d666bb741338f5476d5245af44cc8bf460431f35d9352b5407a806b7 1466 UPPER2D/H3_closure/MANIFEST.sha256 +7545a8c61c20bd0352a72ebc98cc833598b5939e37552c3a528953062db44175 2717 UPPER2D/H3_closure/RECEIPT_h3.json +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H3_closure/band_normal.txt +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 4439 UPPER2D/H3_closure/cert_O.txt +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 4439 UPPER2D/H3_closure/cert_normal.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f 1293 UPPER2D/H3_closure/fals_O.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f 1293 UPPER2D/H3_closure/fals_normal.txt +5506e648254c1989880704ee2a449d4dcab019a5b7bfbea5ddd7e2538e9c5f8f 37254 UPPER2D/H3_closure/h3_band_floor.py +56076fa852e3787e683921496adc796b04132ea817be924ed84ef68d68abc84c 14052 UPPER2D/H3_closure/h3_c0_certificate.py +645b6d9d24721674b419e8d026183722a90a1a27ee4e7b0053c53faced73cd47 10584 UPPER2D/H3_closure/h3_falsifier.py +094d382451ff37e8d3123e7203c743f359cb0af1c2c12cf336adf74fc0b25d8f 16960 UPPER2D/H3_closure/h3_rung_floor.py +a5d661d89abe05c62d95c6be48f6c2264b7f782f97f90b0c5dd4ae47525c2843 669 UPPER2D/H3_closure/mut_planar.txt +68e302276df9a84e6be3f11309deaf1910e70747ade4d4f560742c8225a95a8e 2220 UPPER2D/H3_closure/mut_window.txt +427aeae3242cfabb2bc598e29b9f46a6d1b290b393fb35a8f263007bd8e5ae7b 4110 UPPER2D/H3_closure/rung_045.txt +d439d37ff53c505ce220f673e8bfe55126f74832795167e5e4abb351e0064119 4114 UPPER2D/H3_closure/rung_055.txt +ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013 4109 UPPER2D/H3_closure/rung_O.txt +2b17c664be8c927aa516c8987acb3f7fdf86eebfd597c14fe0176850ff170c90 485 UPPER2D/H3_closure/rung_mut_planar.txt +f0fee83e36affc06c004855fee67d6f7320b4279f4bdeb68ad883abd3f343dde 2447 UPPER2D/H3_closure/rung_mut_window.txt +ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013 4109 UPPER2D/H3_closure/rung_normal.txt +ed6010764ff4291a3d3964c3a56247b79841330b510ca72146748de08f88fb26 4510 UPPER2D/H4_JC_repair/FREEZE.txt +e26eb04f6704dcfef67001604293dc21a65b1c6e7a26c0309793aca4fb6e955e 16888 UPPER2D/H4_JC_repair/H4_JC_EVENT_LEVEL.md +298fd31ee9b33a117e0f60f1ddf4dcece72ff5bd189510552aff84307c7851f0 2535 UPPER2D/H4_JC_repair/h4jc_falsifier.py +e593735a333b43061c3e440fadeed473bc991b5669915b1874bf65deb4f67a60 18112 UPPER2D/H4_JC_repair/h4jc_mirror.py +68e124dd5bbfdd15365f50dafcfff2f9acadb0eaf17998dbc60fa43dc21fa1b5 2087 UPPER2D/H4_JC_repair/t_normal.txt +68e124dd5bbfdd15365f50dafcfff2f9acadb0eaf17998dbc60fa43dc21fa1b5 2087 UPPER2D/H4_JC_repair/t_opt.txt +10e9964394645d2ec042c92036cd298e3abbfb88c4496ab537675fb7b4826025 478 UPPER2D/H4_JC_repair/tf_normal.txt +10e9964394645d2ec042c92036cd298e3abbfb88c4496ab537675fb7b4826025 478 UPPER2D/H4_JC_repair/tf_opt.txt +9cb6e39a14fc95fc5d7f0e64eff013c2013f7801037ff37b248cc066ec00cfeb 2092 UPPER2D/H4_closure/FREEZE.txt +859696e254b3fac2d50437135963d9f3dfe00a33573e309a01ce8df326ac652c 18527 UPPER2D/H4_closure/H4_CLOSURE.md +2663138c68e1e1b1b3649be0f8fadb312abb4cb47bc4b9e2dbbf404e4b99049d 1728 UPPER2D/H4_closure/RECEIPT_h4.json +0da502cca9a67a67e8670601fc98c92d3efedc2814f8d9825029ed13221f0391 3824 UPPER2D/H4_closure/cert_O.txt +0da502cca9a67a67e8670601fc98c92d3efedc2814f8d9825029ed13221f0391 3824 UPPER2D/H4_closure/cert_normal.txt +ddf6e9636c9d8f4858996f350f0f402f96c2c492a361e5aa6118291c708c9f92 17474 UPPER2D/H4_closure/h4_certificate.py +9f268595806fba2b2008e668c470b2c5f64e007f353277a676c0707dd144b1f3 16467 UPPER2D/H4_closure/h4_falsifier.py +d02d5887d9e897cd3f7c296729af78c80870b466855c86de21a4c818d82036fd 53168 UPPER2D/H4_closure/h4_probes.py +8559485475891fffc2f00771b709fd5930ef76487fdc1955a76557f85e7de75d 11601 UPPER2D/H4_closure/t_normal.txt +8559485475891fffc2f00771b709fd5930ef76487fdc1955a76557f85e7de75d 11601 UPPER2D/H4_closure/t_opt.txt +055374ea783ed459397b16b55c227f55e9d563c357e7eacacfd4c99e80dc6019 1660 UPPER2D/H4_closure/tf_normal.txt +055374ea783ed459397b16b55c227f55e9d563c357e7eacacfd4c99e80dc6019 1660 UPPER2D/H4_closure/tf_opt.txt +05ef980c1371579e0aa27310e5a8ee35d02e16260745483eadd371551b7e7de4 80985 UPPER2D/H4_closure/__pycache__/h4_probes.cpython-312.opt-1.pyc +05ef980c1371579e0aa27310e5a8ee35d02e16260745483eadd371551b7e7de4 80985 UPPER2D/H4_closure/__pycache__/h4_probes.cpython-312.pyc +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/.keeper_A.lock +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/.keeper_B.lock +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/.keeperp_A.lock +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/.keeperp_B.lock +6e46c2ef1b24fc65ce4c8c3c945e9f5ff1bfe0b7874473b736002e165b1acc2f 32 UPPER2D/H5_closure/.live +9641b81119a48d18a9ed276fb393275ec0b3201ee3fdecc53a55b533588217a1 65 UPPER2D/H5_closure/BODY_HASH.txt +bc88a555f374ec58393762f2793a12367b5392e530e2053463e95f48441a1a73 65 UPPER2D/H5_closure/BODY_HASH_PROMOTE.txt +0bbe2b3fcb57d074199497178f9507224d4d383c620d3833d3af9acfeb0a89a5 1265 UPPER2D/H5_closure/CODE_HASHES.txt +211ee1839db8d92bfe7d5d82ace3ed55b4ec3267b7b7db2a2f7ee98a0a1d5cef 15246 UPPER2D/H5_closure/H5_CLOSURE.md +125352325b09062fdc1f49402222402f388240f44b0f60b1e2636f19888c0615 7540 UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md +7258c84a7720704e577f341252aa809888735d9f8ace1674429e004da6c6172a 6936 UPPER2D/H5_closure/H5_PROMOTE.md +bbb74e6ed684b2a570e9988dbe0fcc6ead1e3b3e86dc0cea747e2a391b04c1fc 5234 UPPER2D/H5_closure/H5_PROMOTE_UPDATE_2026-09-15.md +78a8c3341601bd3c224a46b2d6c4309c69c4a1529e5367e8745df43cd88015b7 2271 UPPER2D/H5_closure/H5_RECEIPTS.txt +42899319071f0e4db77c20c0d52e2f46e56b8aaa99dedddfa2d626543fc96d27 1583 UPPER2D/H5_closure/H5_STATE.md +a7ce5299bdaab5a1a79da50af7b8e32f1b7d193d175d4dff46a224a0b12eb4f2 2217 UPPER2D/H5_closure/H5_TOTALS_ERRATA_2026-09-15.md +5f1ee690aef4b95ceec76eaea8fd02dac2e23d2d1fc233fb31ee1e07193a59da 1804 UPPER2D/H5_closure/H5_TOTALS_FREEZE_2026-09-15.md +96894af8a482bad6eb890c9bbee997a7b8988b73e2ed662fff0935e407ee179e 568 UPPER2D/H5_closure/cells2_s0.log +0dd7778307a1c91836a8861edbf0cf428cebbf8ac440860c1d3cfdbc578d2a6b 566 UPPER2D/H5_closure/cells2_s1.log +62222a77504b0cc8ca23cbeffd6308dd7ebf332e14ad5d1235eb9458cc251459 15070 UPPER2D/H5_closure/cells_s0.log +588f03fdca7c53054276dcdbf7f2a2f10ea9d3277babc960aa25e5884cbd7696 8248 UPPER2D/H5_closure/cells_s1.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/chain0.log +5bc9dbccb384fc49366a32c9c19d431a68dea1ccae74233d1fbc458e5bfeee0c 3262 UPPER2D/H5_closure/falsify.py +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/H5_closure/falsify_modeA.txt +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/H5_closure/falsify_modeB.txt +bd764d5c6fb7fca5eb72b123161e9f56ac5951b97aedaa6b07ff10f717670a39 887 UPPER2D/H5_closure/falsify_promote.sh +b2e6014c2fd6eb9e72b2104cc828a764e280f76b8396a02edd37654b6ad83ad7 66310 UPPER2D/H5_closure/h5_kernel.py +0e71de27eeb9c9a2e695b2c72052f8ef4f67b5c4f621e4eecd541595b06ede7a 13400 UPPER2D/H5_closure/h5_merge.py +2dd471dca0e4c7e18a925ebd60d034a99dae96ad6afceccb2c5f8d5feca571fd 9253 UPPER2D/H5_closure/h5_promote.py +a9bbeff5e87868f65383de781f260219368f784d983c0fdfbf8221052c8fc230 2997 UPPER2D/H5_closure/h5_results_r0.025_s0p1_patches.jsonl +b3dc261fd6130daaa845b3ad8eaeb394fd9a9bf2297de8da5aa716ce83ab99df 3412 UPPER2D/H5_closure/h5_results_r0.025_s0p1_rimprobes.jsonl +9068498ec5c57cc61c38f70906b8bed7855760e8ddb63eabbded3fb709ecea12 432 UPPER2D/H5_closure/h5_results_r0.025_s0p1_stitch.jsonl +151d6d6226abdaf0ab86d14d1996434fe893fa804de89f1ee6d1019df2665f05 6364 UPPER2D/H5_closure/h5_results_r0.025_s0p2_cells.jsonl +2afe46873bd1ea2acbc8eb781d0bb8a2c97eeed4148357303133f1300cf7c0a7 800 UPPER2D/H5_closure/h5_results_r0.025_s0p2_probes.jsonl +ba24675d9a051c72fc5701313b677101eff7a6b97548fe316dd23b0bf030cdb2 2152 UPPER2D/H5_closure/h5_results_r0.025_s1p2_cells.jsonl +da15dd524bd971852081a6852f81af2a12f932172daeb84a32cad762ac80c012 577 UPPER2D/H5_closure/h5_results_r0.025_s1p2_probes.jsonl +6af274943595e476567fdee10e1c9a89f8baf5bb4c38415afbe9721ae211410b 4452 UPPER2D/H5_closure/h5_results_r0.035355_s0p1_patches.jsonl +5a8daa268184966dca767589fc81edf01933d2663b1c0c60aff78544f0ed5a6e 3483 UPPER2D/H5_closure/h5_results_r0.035355_s0p1_rimprobes.jsonl +a1a5aaceb9a125190b4b7e33c7d4269759ee3b0896a823a4c4c8726353d47ae2 172 UPPER2D/H5_closure/h5_results_r0.035355_s0p1_stitch.jsonl +e8ba9af0b8fc8712f0aa17d7a899d7e2cae1e5df28b0b69b2ec7c072847f4e8e 3304 UPPER2D/H5_closure/h5_results_r0.035355_s0p2_cells.jsonl +3a31f8a578870de9239a7dfe750d0252a058c26125b40ffc20bbc5ca9dfe0c06 809 UPPER2D/H5_closure/h5_results_r0.035355_s0p2_probes.jsonl +13bf3f01fbad6819936a5d56daca63f78bea8b718c3686366b7c29d0fe3423be 2017 UPPER2D/H5_closure/h5_results_r0.035355_s1p2_cells.jsonl +6527cc83516ee48c459e70b6eeaf97fb93cd08abac7b12c6a0bc5ef1041fd572 576 UPPER2D/H5_closure/h5_results_r0.035355_s1p2_probes.jsonl +51178f7cf95f9c20aa3c3fb17a31fcd172275c6bc3b6e33ea8a51cb1dd95942b 325 UPPER2D/H5_closure/h5_results_r0.05_refine.jsonl +ab79490029fd6825bcbb74eb92bde769a9a0deb331c7ed02d788a24c739f1409 2381 UPPER2D/H5_closure/h5_results_r0.05_s0p1_patches.jsonl +22c7107e93ba9c02bea1f6f34085044ab535f29c067ce79c0cd7d8b1911ecc63 6061 UPPER2D/H5_closure/h5_results_r0.05_s0p1_rimprobes.jsonl +9f5316bb9f271e62cff91b9258edcc6ab8e0629101d68befb57b87d17a741d94 1333 UPPER2D/H5_closure/h5_results_r0.05_s0p1_stitch.jsonl +a3a9e2a73b4b01b744dc6e151ef16804285890d626fa0e71de61e8c30b05ddb6 824 UPPER2D/H5_closure/h5_results_r0.05_s0p2.jsonl +6fce1de4b24f6f9ea551ea51df896c3c900f9cd33c6fdf7b51f30dc6ba7a87b4 5057 UPPER2D/H5_closure/h5_results_r0.05_s0p2_cells.jsonl +1a1df8551ac7ea5da387de863876b6cd2f740f380b7d294c300e24b519a21f70 666 UPPER2D/H5_closure/h5_results_r0.05_s0p2_cells2.jsonl +d798d5f8dc5d7d7f0cc088dac4b740d0dcc3fbf4d3d7b8ddda0a0cb657b39b31 660 UPPER2D/H5_closure/h5_results_r0.05_s1p2.jsonl +46b92f8fe8f7e129c1110edc0ed9b6c20bce30d65e516b430a46aa3d662396a5 5175 UPPER2D/H5_closure/h5_results_r0.05_s1p2_cells.jsonl +a1b2352e932d78d60e7e5113fe1202c551bca32e19542d541e6e973ab20e81f5 664 UPPER2D/H5_closure/h5_results_r0.05_s1p2_cells2.jsonl +b73b5ef504d9d4d1c5db8a41e68e95c67acfb8f947925c3a323f82e61581b907 452 UPPER2D/H5_closure/h5_results_r0.05_sdisk.jsonl +7dfd3085f3d26571615bd0297d64ec30ad508402fc6a073da1b90fd7ce30ebe4 637 UPPER2D/H5_closure/h5_results_r0.05_sring.jsonl +303b23c1c65f1fe87be4cc6f88321bf66cbcf3d0ecdfbdca8023691a420c2eb3 2814 UPPER2D/H5_closure/h5_results_r0.05_stitchref.jsonl +687456447e0e2937cb2b3712b247bd1e0a91a419bc8d8b7ef6c71c10ecbc45fc 215 UPPER2D/H5_closure/h5_results_r0.05_stitchref3.jsonl +cd4b3d4a6145338be388307c8a019169d7e6c7bcffccd2e29d4264295342c652 24976 UPPER2D/H5_closure/h5_run.py +38f88f732da19a7292ff7acc9b71f8e9f48d30d9db4eaed7d048d2038e9ebcc5 27068 UPPER2D/H5_closure/h5_run_r0p025.py +dba090d422fc1593b949b4e3294255e868dccdfe4ae3166ce0a31e5766f29ab3 27093 UPPER2D/H5_closure/h5_run_r0p035355.py +f3e672a3cb4d4016a117624493a8ce766c5bf21e1a7697b840da82e896f98ecf 2364 UPPER2D/H5_closure/h5_totals.json +f3e672a3cb4d4016a117624493a8ce766c5bf21e1a7697b840da82e896f98ecf 2364 UPPER2D/H5_closure/h5_totals_v2.json +f3e672a3cb4d4016a117624493a8ce766c5bf21e1a7697b840da82e896f98ecf 2364 UPPER2D/H5_closure/h5_totals_v2_2026-09-15.json +8d7028e4d0d49d54d3a7c4589a898289ec29eee6c2de9c774e99df0da46596bb 2364 UPPER2D/H5_closure/h5_totals_v3.json +a2dbd99662f1412151de6c94b5c49b8e759cfe4121f1aa76e43eae20057987a8 1104 UPPER2D/H5_closure/h5_transcript_r0.025_s0p1_patches.txt +707cc3393bc8f7022341dd41da328c5d0ba67afcfb5891d320ca83fb1a364269 2132 UPPER2D/H5_closure/h5_transcript_r0.025_s0p1_rimprobes.txt +2b816f86810adf60d7b1d4430c5304942addff306b661954b18101fc4aefb758 489 UPPER2D/H5_closure/h5_transcript_r0.025_s0p1_stitch.txt +28f2f791ab306058b8e1e3f724fe3909263a0964dc0a80030103beb8f73f4c9f 54 UPPER2D/H5_closure/h5_transcript_r0.025_s0p2_cells.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/h5_transcript_r0.025_s0p2_probes.txt +f553cfb05f148a914b748b43c4d2c67e91dbdc86d68b2dba0bb0c8f2f6ce769a 1064 UPPER2D/H5_closure/h5_transcript_r0.025_s1p2_cells.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/h5_transcript_r0.025_s1p2_probes.txt +11b8d897d905bef1e1c9d4a312701e21f08bd9df8f4d5323acb9e31fbbf77edc 1137 UPPER2D/H5_closure/h5_transcript_r0.035355_s0p1_patches.txt +4c51a2a7ae14c2f8bdf2d39f9a1899123149943d531476809feb48faf6fdf132 2201 UPPER2D/H5_closure/h5_transcript_r0.035355_s0p1_rimprobes.txt +deec04cd7269a17b1060dfd870b0693b94b954e74097186e50cd84a681d7c7b2 345 UPPER2D/H5_closure/h5_transcript_r0.035355_s0p1_stitch.txt +024c04308504de9517ce596f6818895848a8987262d244f05dfc4693d8af3f0a 1363 UPPER2D/H5_closure/h5_transcript_r0.035355_s0p2_cells.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/h5_transcript_r0.035355_s0p2_probes.txt +2f21b71569649c51035f1bca2845861847127a0ed2ce24222fb3bbff3f96bad7 1176 UPPER2D/H5_closure/h5_transcript_r0.035355_s1p2_cells.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/h5_transcript_r0.035355_s1p2_probes.txt +fb67bb40b9840ef625a6638516c3d7ee388182594d68c6b4b6d3019ed73cc11d 5160 UPPER2D/H5_closure/h5_transcript_r0.05_s0p1.txt +0065f392550b2a218b147fa87e2acf705038d6658fb2cdf9930812cf65a1d33a 1101 UPPER2D/H5_closure/h5_transcript_r0.05_s0p1_patches.txt +a4304e48a150eae8424d0600ba80fe0cdc43f87fc4ceeb10cf54819b34f36946 2090 UPPER2D/H5_closure/h5_transcript_r0.05_s0p1_rimprobes.txt +e3ca020ad83ea9566b3bb0d1452d651eb1a49f1823485739c13786e4190f2e4d 288 UPPER2D/H5_closure/h5_transcript_r0.05_s0p1_stitch.txt +4a4f122ca01af3821a6c3785b490d7c06b1f4b03216653752b3240c62384ca70 664 UPPER2D/H5_closure/h5_transcript_r0.05_s0p2.txt +d8c80b7b7cfe90dfbdea24bdce71df3d208ab8e66712c10b0b8091c155834379 343 UPPER2D/H5_closure/h5_transcript_r0.05_s0p24.txt +f146b2187dae2a8cbb968dea932677e5db25dab06af0741867ff5c4fce30ddf6 1888 UPPER2D/H5_closure/h5_transcript_r0.05_s0p2_cells.txt +96894af8a482bad6eb890c9bbee997a7b8988b73e2ed662fff0935e407ee179e 568 UPPER2D/H5_closure/h5_transcript_r0.05_s0p2_cells2.txt +405ea682d98a27e334c86dc415e8a0af1f58077e364630e86f7a45699e808812 523 UPPER2D/H5_closure/h5_transcript_r0.05_s1p2.txt +2e2072e2078862575537661941af6c3c6273c532b80d39a914d8b8846ce3b801 2268 UPPER2D/H5_closure/h5_transcript_r0.05_s1p2_cells.txt +0dd7778307a1c91836a8861edbf0cf428cebbf8ac440860c1d3cfdbc578d2a6b 566 UPPER2D/H5_closure/h5_transcript_r0.05_s1p2_cells2.txt +17ec88a6f695da0f332677be3f1d8a3c1dc52cabd3ae220122a5413747b3d47e 1084 UPPER2D/H5_closure/keeper.sh +b9be5838b3c5e137a2196ee4e2c8ef29837cdc6b6a3db963f09cae8f8b8a0850 94736 UPPER2D/H5_closure/keeper_A.log +fc4a6224a7012b8032c98b02d1fcec6ae6a85048f0e5b5ed821641bc2c930641 133424 UPPER2D/H5_closure/keeper_B.log +eca0cb606cde260c2febfb949521934df7404b656ed2ebb98b7a98087598de48 2227 UPPER2D/H5_closure/keeper_promote.sh +8605b1f010e8886786dc7e40d96a6f853786a4daedca4ec92e79985d0e5e309e 18360 UPPER2D/H5_closure/keeperp_A.log +dc71d93b84a4ebe5168633c9db07be93ac0ec4e4e4eb8c6d69d5d748816f4c7f 87183 UPPER2D/H5_closure/keeperp_B.log +0065f392550b2a218b147fa87e2acf705038d6658fb2cdf9930812cf65a1d33a 1101 UPPER2D/H5_closure/patches.log +b4dbf6a75730384be5d14fea9d88feaeee7dc8df6ee2590b055d2d00e0c404f6 91929 UPPER2D/H5_closure/promote_025_cells_s0.log +9e34c90bffcfda818b20ff4652d4b278c93affed820d6de5820a85824b42bbb1 2582 UPPER2D/H5_closure/promote_025_cells_s1.log +707cc3393bc8f7022341dd41da328c5d0ba67afcfb5891d320ca83fb1a364269 2132 UPPER2D/H5_closure/promote_025_rimprobes.log +91ea788d6a01c8f0e1892320850db12219350278ffc815eb0c39eac86a943bfe 1246 UPPER2D/H5_closure/promote_025_stitch.log +b561ef0a8eb3910c421e8f4f14f1be6d369b9a730940f03d027d5dba32dc58cd 38478 UPPER2D/H5_closure/promote_035_cells_s0.log +f07b7d2b744a31ce6f1cb4e02acff909cc5f405923912b974db04d36252c4d90 2832 UPPER2D/H5_closure/promote_035_cells_s1.log +11b8d897d905bef1e1c9d4a312701e21f08bd9df8f4d5323acb9e31fbbf77edc 1137 UPPER2D/H5_closure/promote_035_patches.log +7ab509e368b9b4601bbdc80e09fbc6e9ca433c3212959a74afd1ef0ca94105a7 297 UPPER2D/H5_closure/promote_035_probes1.log +4c51a2a7ae14c2f8bdf2d39f9a1899123149943d531476809feb48faf6fdf132 2201 UPPER2D/H5_closure/promote_035_rimprobes.log +59768075c7047dd49ce6817524a4965468ad94319d1fd1c3571e5c0e69f4c90a 973 UPPER2D/H5_closure/promote_035_stitch.log +45ad255910c40db0cc18cb5827914e074c48fe7c168675b1e7ea9466ab30eeae 7160 UPPER2D/H5_closure/promote_modeA.txt +45ad255910c40db0cc18cb5827914e074c48fe7c168675b1e7ea9466ab30eeae 7160 UPPER2D/H5_closure/promote_modeB.txt +29df21b5143ccecbb63ef1fed8e4a8bffc6d4e8cb76e7fdbdc58b8cb509e8a5e 2529 UPPER2D/H5_closure/promote_probes.py +8433b3c0a51e32a8442b68e6e2e6a7c87efbd6ea0a1f3df6d109a3eec5ebe449 4503 UPPER2D/H5_closure/promote_run.py +a671975cb7a444ea42e7e5a28c0c9e9e600bd8d46b57098fc7c607ae6bec6f48 58 UPPER2D/H5_closure/recompute.log +6bad39b5260d359b0327c896dc6df1029f8ef5b4e095a6a57e42c63a7ddcb2d9 974 UPPER2D/H5_closure/recompute_cell.py +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/recompute_detail.log +fb67bb40b9840ef625a6638516c3d7ee388182594d68c6b4b6d3019ed73cc11d 5160 UPPER2D/H5_closure/rimprobes.log +d8c80b7b7cfe90dfbdea24bdce71df3d208ab8e66712c10b0b8091c155834379 343 UPPER2D/H5_closure/rimprobes_fine_test.log +449d257f78df907b74374622336cc069b08747f0198690c57062b6b37230a2ba 2847 UPPER2D/H5_closure/rimprobes_v2.log +a4304e48a150eae8424d0600ba80fe0cdc43f87fc4ceeb10cf54819b34f36946 2090 UPPER2D/H5_closure/rimprobes_v3.log +d6eada75c094150aea19e3747f940044e0f5d95a9ccdf43b77000eb31d0226e1 240 UPPER2D/H5_closure/sdisk.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/sdisk_detail.log +429470923d4cbe7856af6bc0e4ade192e62ea5419be979f12c64f70bfbe884b5 1408 UPPER2D/H5_closure/sdisk_probes.py +378dea62213b5924cc3c4e5b3aa241a1fe7540811086d780471b12a388779b63 177 UPPER2D/H5_closure/sring0.log +81c35c242c28ae72d2a1640d088f1d22dc74811338185adaec09ca896e8bea91 179 UPPER2D/H5_closure/sring1.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/sring_detail.log +00b1f29d1dbe548d2dc7193c565cb7060290b39c08b8b89f019fd81556d67638 1462 UPPER2D/H5_closure/sring_probes.py +56dd8d2eedfa3e7face6a642f3737d415a19586f36fa0a01d80dd70cef9cdc19 839 UPPER2D/H5_closure/stitch.log +dc83039930860e3a6ffa32d09d29024f5ca3eeb659ff76fa95ecaf22a682a975 332 UPPER2D/H5_closure/stitch2.log +e3ca020ad83ea9566b3bb0d1452d651eb1a49f1823485739c13786e4190f2e4d 288 UPPER2D/H5_closure/stitch3.log +8467fd4847318a46d0958f594c0b5f1e66e6c8615898f4de2e1349b436183df3 1100 UPPER2D/H5_closure/stitch_outer.py +1a243f78126bc656333691a7d18a72f9124d149828ed7a24aaa7d28b85c47ecc 1556 UPPER2D/H5_closure/stitch_refine.py +bb3afeadbf381c84ab74ad5840398e12c69811c496023f1f6032761ec576310a 1167 UPPER2D/H5_closure/stitch_refine2.py +75d71a5516b392f2c9a0fbee92b3de210870f4cab527bf9022a1b6c775446e38 2060 UPPER2D/H5_closure/stitch_refine3.py +f4d07d413e88ac245b13e1662c880ba068d27fc10166f4a08c7dd37e7b7d028a 647 UPPER2D/H5_closure/stitchout0.log +2158462ce00574a4660ba0da6056ecefbde43b2e176d3817670699943f7caa45 558 UPPER2D/H5_closure/stitchout1.log +b1de29de6dbaac33af44dffa3533c93e6610ec837f355c36ceca2bce4c20dd3f 374 UPPER2D/H5_closure/stitchref.log +ac5124c938809a9174cb29f9bb0f088ce8cbc3ff11be61ce358106f6703ca449 57 UPPER2D/H5_closure/stitchref2a.log +917e6fe64e571422cf78e3a318df093c4a8790db3920497dda479dbbfd1f82f0 58 UPPER2D/H5_closure/stitchref2b.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/stitchref3_detail.log +66778e0d33c5ef073603eda313d67ae04c1bbe776bbfcc271c4b8fb0d847bf55 36 UPPER2D/H5_closure/stitchref3a.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/stitchref3b.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/stitchref_detail.log +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/H5_closure/supervisor.out +af3b0f2e39b26c6245422a3b77f5726b72f0a5460e1bc1f195eb5ba02265c0fe 1971 UPPER2D/H5_closure/supervisor.sh +60daf7ae6291bb6056a281b9fb2f001f5ff0209efd87de86b7ea410ee10166c6 548 UPPER2D/H5_closure/test_cell.py +de8d2c69f81f17d1158635a6d39aa9649338f483ed483c9d03e3087c319ca36b 50 UPPER2D/H5_closure/testcell.log +4682fb8420c01b6edfa8f2323543453deb01115757733a0b4b635dab78673d03 47682 UPPER2D/H5_closure/watch.log +5f66b45887cd15d20a5ad57557102499650813d83d22d796d63e8286c506678f 559 UPPER2D/H5_closure/watchdog.sh +b4f086f7ad5de55093e6c0cb1d14d870fcae394b19a0ee2701702c96729ca2df 121732 UPPER2D/H5_closure/__pycache__/h5_kernel.cpython-312.pyc +5512162c5a68370833a8539a35652e418e7c51938940b67289a6d6533f35b438 18966 UPPER2D/H5_closure/__pycache__/h5_merge.cpython-312.pyc +90e677da1bce0d1396e2651368226b7cec57ab63d30a2e5dc57aa27a837a965b 34172 UPPER2D/H5_closure/__pycache__/h5_run.cpython-312.pyc +cf10db211d2e4be3e93287a895f31e3850a038b96d73bf580c72c53de8cc3a08 34505 UPPER2D/H5_closure/__pycache__/h5_run_r0p025.cpython-312.pyc +483aecd73600f44d49854ba0b40124e1b77971000d58f2963c212edad8cf8458 34530 UPPER2D/H5_closure/__pycache__/h5_run_r0p035355.cpython-312.pyc +87ab72cdd1eaebeb4f653141df01920280a7523f784096e53120c0db2f9273b1 145 UPPER2D/H5_closure/archive/h5_results_r0.05_s0p24.jsonl +d565cfa5484054540c25979dea5402476b763678da05bfa730729532c497e778 3773 UPPER2D/H5_closure/archive/old_gradeA_probe_ladder.jsonl +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/STAGE_E/B1_rerun_normal.txt +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/STAGE_E/B1_rerun_opt.txt +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/STAGE_E/B1_taxonomy_rerun_normal.txt +1a2deef233840e0b15b31bc4b50d85be5a60b7b07193ca493bf4f9040def0c19 323 UPPER2D/STAGE_E/B1_taxonomy_rerun_opt.txt +c9f8241f290f837d74db2ae944edca4605edd157daaae804e740bdbb67ecb2e8 1086 UPPER2D/STAGE_E/C1_falsifier_rerun.log +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/STAGE_E/C2_B_classes_rerun_normal.txt +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/STAGE_E/C2_B_classes_rerun_opt.txt +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/STAGE_E/C2_rerun_normal.txt +2cdea45c7374d13f96fb1c68806c8a28667d6d21dce78d57c86c4e5026c87380 1008 UPPER2D/STAGE_E/C2_rerun_opt.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/STAGE_E/D2_branch_control_rerun_normal.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/STAGE_E/D2_branch_control_rerun_opt.txt +66b5513fe34c4df1f3230ebb97e34f2313c3713fc7e764b8a5825f5fa7e90cf2 1157 UPPER2D/STAGE_E/D2_rerun_normal.txt +66b5513fe34c4df1f3230ebb97e34f2313c3713fc7e764b8a5825f5fa7e90cf2 1157 UPPER2D/STAGE_E/D2_rerun_opt.txt +03ce5cfc8d9db1cb105bc5c5d5e900ec0a429b8245c1461e50ef220d5c89e4ae 415 UPPER2D/STAGE_E/D3_fals_normal.txt +03ce5cfc8d9db1cb105bc5c5d5e900ec0a429b8245c1461e50ef220d5c89e4ae 415 UPPER2D/STAGE_E/D3_fals_opt.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 UPPER2D/STAGE_E/D3_percolation_rerun_normal.txt +9c7838d1d4a9b181afb6e7ae94f46c588894232835236abba49abb69af35d30d 26746 UPPER2D/STAGE_E/H2_cov_exact_normal.txt +9c7838d1d4a9b181afb6e7ae94f46c588894232835236abba49abb69af35d30d 26746 UPPER2D/STAGE_E/H2_cov_exact_opt.txt +7eeb845e063579444103097f5f8a9b7f5cecedafcfd68c3f4355e0a981c3acc2 6305 UPPER2D/STAGE_E/H2_pin_transform_normal.txt +7eeb845e063579444103097f5f8a9b7f5cecedafcfd68c3f4355e0a981c3acc2 6305 UPPER2D/STAGE_E/H2_pin_transform_opt.txt +9d852eebddecc2ee5054ef87b61cb7149ab28cfe7dd7bf501f14c038771a2e18 9750 UPPER2D/STAGE_E/H2_reg_lemmas_normal.txt +9d852eebddecc2ee5054ef87b61cb7149ab28cfe7dd7bf501f14c038771a2e18 9750 UPPER2D/STAGE_E/H2_reg_lemmas_opt.txt +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 4439 UPPER2D/STAGE_E/H3_cert_normal.txt +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 4439 UPPER2D/STAGE_E/H3_cert_opt.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f 1293 UPPER2D/STAGE_E/H3_fals_normal.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f 1293 UPPER2D/STAGE_E/H3_fals_opt.txt +a5d661d89abe05c62d95c6be48f6c2264b7f782f97f90b0c5dd4ae47525c2843 669 UPPER2D/STAGE_E/H3_mut_planar_rerun.txt +68e302276df9a84e6be3f11309deaf1910e70747ade4d4f560742c8225a95a8e 2220 UPPER2D/STAGE_E/H3_mut_window_rerun.txt +0da502cca9a67a67e8670601fc98c92d3efedc2814f8d9825029ed13221f0391 3824 UPPER2D/STAGE_E/H4_cert_normal.txt +0da502cca9a67a67e8670601fc98c92d3efedc2814f8d9825029ed13221f0391 3824 UPPER2D/STAGE_E/H4_cert_opt.txt +055374ea783ed459397b16b55c227f55e9d563c357e7eacacfd4c99e80dc6019 1660 UPPER2D/STAGE_E/H4_fals_normal.txt +055374ea783ed459397b16b55c227f55e9d563c357e7eacacfd4c99e80dc6019 1660 UPPER2D/STAGE_E/H4_fals_opt.txt +3e5529d452e043996c92fd27d816ca161e96598efd414573ed6c69294aa6bfb7 180 UPPER2D/STAGE_E/H5_falsify_A_rerun.txt +ff8fa24b945f4f2f9f14fc7d61d56787ae79b058c326b543199d799627b0844c 180 UPPER2D/STAGE_E/H5_falsify_B_rerun.txt +fb139a5bb36f6ffbe9b843bf30d8e9ae2a9ca88ba0b9057ac22e65113eb3d46d 18049 UPPER2D/STAGE_E/REVIEW_numerics.md +d5595f32c85986964a6f8c069f0be1de8606c4340964cb636d822ca9ab23d8b4 21222 UPPER2D/STAGE_E/REVIEW_proof.md +108999ad1f07495c7aee4351a414f87260c0059457bb4d9a36ecd8605769aaff 23758 UPPER2D/STAGE_E/REVIEW_provenance.md +dc0ae10c148f228cbc95f5f51bc02dfd14a04bd577725aa8b4b6390051a0cab1 20773 UPPER2D/STAGE_E/REVIEW_scope.md +8327bb5efddec69360d8144eb3fd709bbe6c158eb1404634c99ddae09d579420 24168 UPPER2D/STAGE_E/REVIEW_topology.md +4ae404d70659333d50d3dfee6c11df6b082b9797d893db1eef8a575128d64f5e 14770 UPPER2D/STAGE_E/attack_h4jc.py +f349ff8c4edd6f434bc76a49510f868cca7b495fb87225faa715ba084df873de 8849 UPPER2D/STAGE_E/c1_grid_transcript.txt +f349ff8c4edd6f434bc76a49510f868cca7b495fb87225faa715ba084df873de 8849 UPPER2D/STAGE_E/c1_grid_transcript_-O.txt +85afff0d64c16973bd57c629f2fe7fbffaff4e4c1c96f4640ce9ab7325e99e03 49766 UPPER2D/STAGE_E/c1_intensity_transcript.txt +85afff0d64c16973bd57c629f2fe7fbffaff4e4c1c96f4640ce9ab7325e99e03 49766 UPPER2D/STAGE_E/c1_intensity_transcript_-O.txt +f9e0efefe442bc474201f7cf1951a526b09b344657ef3b1cbd300e7a143aeda8 8120 UPPER2D/STAGE_E/certify_axis_break.py +11b711d320c36e6b87fcc9b552d1761392be45237358d7e564d7969c3a631299 1375 UPPER2D/STAGE_E/d1_rerun_normal.txt +11b711d320c36e6b87fcc9b552d1761392be45237358d7e564d7969c3a631299 1375 UPPER2D/STAGE_E/d1_rerun_opt.txt +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/STAGE_E/falsify_modeA.txt +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/STAGE_E/falsify_modeB.txt +de73e5fed00782c3709d2f9a8b1cddca23926606a8ef5ffc4cf0de8aefb66f90 2777 UPPER2D/STAGE_E/hunt_rim.py +f03507da809d91eb6b358c4bf51298ba9d26bb6ab733e801cb5784394b96d48e 5435 UPPER2D/STAGE_E/hunt_wedges.py +098adfe093f5bcd9a0ea463b77a6c3b4d1b234df028439174c9e82de9772e8d7 10248 UPPER2D/STAGE_E/isserlis_break.py +bc9bcca0297cf03169f28d251c42a0211b8c50685b36824aaef2cd52defe1dd6 1025 UPPER2D/STAGE_E/t_attack_O.txt +bc9bcca0297cf03169f28d251c42a0211b8c50685b36824aaef2cd52defe1dd6 1025 UPPER2D/STAGE_E/t_attack_normal.txt +b2e6014c2fd6eb9e72b2104cc828a764e280f76b8396a02edd37654b6ad83ad7 66310 UPPER2D/STAGE_E/h5snap/h5_kernel.py +125976721841089318f30bd54b676c7fe087c20b7b23fb6eaf92391f7986c0df 11748 UPPER2D/STAGE_E/h5snap/h5_merge.py +51178f7cf95f9c20aa3c3fb17a31fcd172275c6bc3b6e33ea8a51cb1dd95942b 325 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_refine.jsonl +ab79490029fd6825bcbb74eb92bde769a9a0deb331c7ed02d788a24c739f1409 2381 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p1_patches.jsonl +22c7107e93ba9c02bea1f6f34085044ab535f29c067ce79c0cd7d8b1911ecc63 6061 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p1_rimprobes.jsonl +9f5316bb9f271e62cff91b9258edcc6ab8e0629101d68befb57b87d17a741d94 1333 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p1_stitch.jsonl +a3a9e2a73b4b01b744dc6e151ef16804285890d626fa0e71de61e8c30b05ddb6 824 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p2.jsonl +6fce1de4b24f6f9ea551ea51df896c3c900f9cd33c6fdf7b51f30dc6ba7a87b4 5057 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p2_cells.jsonl +1a1df8551ac7ea5da387de863876b6cd2f740f380b7d294c300e24b519a21f70 666 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s0p2_cells2.jsonl +d798d5f8dc5d7d7f0cc088dac4b740d0dcc3fbf4d3d7b8ddda0a0cb657b39b31 660 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s1p2.jsonl +46b92f8fe8f7e129c1110edc0ed9b6c20bce30d65e516b430a46aa3d662396a5 5175 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s1p2_cells.jsonl +a1b2352e932d78d60e7e5113fe1202c551bca32e19542d541e6e973ab20e81f5 664 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_s1p2_cells2.jsonl +b73b5ef504d9d4d1c5db8a41e68e95c67acfb8f947925c3a323f82e61581b907 452 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_sdisk.jsonl +7dfd3085f3d26571615bd0297d64ec30ad508402fc6a073da1b90fd7ce30ebe4 637 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_sring.jsonl +303b23c1c65f1fe87be4cc6f88321bf66cbcf3d0ecdfbdca8023691a420c2eb3 2814 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_stitchref.jsonl +687456447e0e2937cb2b3712b247bd1e0a91a419bc8d8b7ef6c71c10ecbc45fc 215 UPPER2D/STAGE_E/h5snap/h5_results_r0.05_stitchref3.jsonl +8b4410d8d601f0605606824a70255683e62aa2725752341dfd3c8c93298f18a9 2364 UPPER2D/STAGE_E/h5snap/totals_at_snapshot.json +73f888a105d53866ca28fb77405dd320688987039ddfcf311730278049cf6ea5 31599 UPPER2D/STAGE_E/mut_D1/B1_taxonomy/B1_TAXONOMY.md +ca2c02b81a05e4cbc955b1aeab1f4120e9b8d4fda328aa191da08a49db72853f 27794 UPPER2D/STAGE_E/mut_D1/C1_alpha_intensity/C1_ALPHA_INTENSITY.md +4de92ff1e1cb0b7041470ddf831e97be5160a1f2f8fded31767358f8b2db1125 26326 UPPER2D/STAGE_E/mut_D1/C2_B_classes/C2_B_CLASSES.md +1ebd2c6ade067bcfa2732b89ef83266fdaecd24260c05cf6d810b0bd2db044b7 6928 UPPER2D/STAGE_E/mut_D1/D1_assembly/d1_falsify.py +aa35cad756856d0413ffc9dc6717e137e6e5bd7af6a983f28c26bf46b5b15fc7 29448 UPPER2D/STAGE_E/mut_D1/D2_branch_control/D2_BRANCH_CONTROL.md +45f58a76749025aa21bfce53daa1c1f06092e677a67a9765fb9cd1d90434c12d 18808 UPPER2D/STAGE_E/mut_D1/D3_percolation/D3_PERCOLATION.md +387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637 16857 UPPER2D/STAGE_E/mut_D1/H3_closure/H3_CLOSURE.md +859696e254b3fac2d50437135963d9f3dfe00a33573e309a01ce8df326ac652c 18527 UPPER2D/STAGE_E/mut_D1/H4_closure/H4_CLOSURE.md +211ee1839db8d92bfe7d5d82ace3ed55b4ec3267b7b7db2a2f7ee98a0a1d5cef 15246 UPPER2D/STAGE_E/mut_D1/H5_closure/H5_CLOSURE.md +5bc9dbccb384fc49366a32c9c19d431a68dea1ccae74233d1fbc458e5bfeee0c 3262 UPPER2D/STAGE_E/mut_D1/H5_closure/falsify.py +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/STAGE_E/mut_D1/H5_closure/falsify_modeA.txt +3ef903bbe2609374b10dae984a2bcb521db6f800b6e481a6cf27bb7260d53920 65 UPPER2D/STAGE_E/mut_D1/H5_closure/falsify_modeB.txt +b2e6014c2fd6eb9e72b2104cc828a764e280f76b8396a02edd37654b6ad83ad7 66310 UPPER2D/STAGE_E/mut_D1/H5_closure/h5_kernel.py +8b4410d8d601f0605606824a70255683e62aa2725752341dfd3c8c93298f18a9 2364 UPPER2D/STAGE_E/mut_D1/H5_closure/h5_totals.json +b2e6014c2fd6eb9e72b2104cc828a764e280f76b8396a02edd37654b6ad83ad7 66310 UPPER2D/STAGE_E/mut_H5/h5_kernel.py +125976721841089318f30bd54b676c7fe087c20b7b23fb6eaf92391f7986c0df 11748 UPPER2D/STAGE_E/mut_H5/h5_merge.py +51178f7cf95f9c20aa3c3fb17a31fcd172275c6bc3b6e33ea8a51cb1dd95942b 325 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_refine.jsonl +ab79490029fd6825bcbb74eb92bde769a9a0deb331c7ed02d788a24c739f1409 2381 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p1_patches.jsonl +22c7107e93ba9c02bea1f6f34085044ab535f29c067ce79c0cd7d8b1911ecc63 6061 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p1_rimprobes.jsonl +9f5316bb9f271e62cff91b9258edcc6ab8e0629101d68befb57b87d17a741d94 1333 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p1_stitch.jsonl +a3a9e2a73b4b01b744dc6e151ef16804285890d626fa0e71de61e8c30b05ddb6 824 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p2.jsonl +6fce1de4b24f6f9ea551ea51df896c3c900f9cd33c6fdf7b51f30dc6ba7a87b4 5057 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p2_cells.jsonl +1a1df8551ac7ea5da387de863876b6cd2f740f380b7d294c300e24b519a21f70 666 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s0p2_cells2.jsonl +d798d5f8dc5d7d7f0cc088dac4b740d0dcc3fbf4d3d7b8ddda0a0cb657b39b31 660 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s1p2.jsonl +46b92f8fe8f7e129c1110edc0ed9b6c20bce30d65e516b430a46aa3d662396a5 5175 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s1p2_cells.jsonl +a1b2352e932d78d60e7e5113fe1202c551bca32e19542d541e6e973ab20e81f5 664 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_s1p2_cells2.jsonl +b73b5ef504d9d4d1c5db8a41e68e95c67acfb8f947925c3a323f82e61581b907 452 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_sdisk.jsonl +7dfd3085f3d26571615bd0297d64ec30ad508402fc6a073da1b90fd7ce30ebe4 637 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_sring.jsonl +303b23c1c65f1fe87be4cc6f88321bf66cbcf3d0ecdfbdca8023691a420c2eb3 2814 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_stitchref.jsonl +687456447e0e2937cb2b3712b247bd1e0a91a419bc8d8b7ef6c71c10ecbc45fc 215 UPPER2D/STAGE_E/mut_H5/h5_results_r0.05_stitchref3.jsonl +8d7028e4d0d49d54d3a7c4589a898289ec29eee6c2de9c774e99df0da46596bb 2364 UPPER2D/STAGE_E/mut_H5/h5_totals.json +0b8dfbc885d6cebcfe182ecb779b71d11a933509242704c13d707c9a6b130f2c 2240 UPPER2D/STAGE_E/mut_H5/merge_rerun.txt +8b4410d8d601f0605606824a70255683e62aa2725752341dfd3c8c93298f18a9 2364 UPPER2D/STAGE_E/mut_H5/totals_at_snapshot.json +bcd8869a5f3631a661bf4efca71b374e05f786a70734ae4d6ec06104c66f0af1 121736 UPPER2D/STAGE_E/mut_H5/__pycache__/h5_kernel.cpython-312.pyc +5cc67d37aee7aeae5c04c64667a4c0ea3ebbcda1f46ef23d2575c2f21244805a 17083 UPPER2D/STAGE_E/mut_H5/__pycache__/h5_merge.cpython-312.pyc +c0b421474d89387717a148b2e449375d3504ad4af4c8e825024718f64675df60 313 W10_dependency/HASHES.txt +67c7fe63e168060b9db1f2279de5d88e7f804508a0e4e98a90afbec468ee21d1 32989 W10_dependency/W10_REPORT.md +20bff6dcfe2137d7b8eeef7819e44e21142f61fbd1b788dc1dd5f5bfee0ca40b 1883 W10_dependency/t_O.txt +20bff6dcfe2137d7b8eeef7819e44e21142f61fbd1b788dc1dd5f5bfee0ca40b 1883 W10_dependency/t_normal.txt +2371390fb68647b41b5f66eef424cbfbb04ed39a8a048c54d57dba7be6eb57cb 8368 W10_dependency/w10_sanity.py +5dcd89be8820ed1df80a9e7024150bd1362df539f8adf1e2a737c35a7184b937 37346 W11_literature/W11_REPORT.md +5e6b00bbbf18d6bce234bcb50e999c50ead6523961cf612f400749b824bd9025 28489 W12_redteam/W12_AUDIT.md +ef5fb9fa5cb14d08797a1e6cfbc05cee659ff743015d29d3491854825f18d86a 24369 W13_reproduction/MANIFEST.check.sha256 +5085ea51443edb0cd50bf155b075462993ba7b230003707eb3e316a1e035ed74 12689 W13_reproduction/W13_REPRODUCTION_REPORT.md +06cc95ff8ad268c617855b4dc1f5f78a903f712966f9f6bad0b3bbb4962551c5 1651 W13_reproduction/build_manifest.py +1303682df66d6088ae561a85525e87ce33834e90c010644656bc35c5db23484e 1948 W13_reproduction/byte_audit.py +4558ccc539137a74a2d45ec4328da6595bad1f71c192700139fcd4a5f5ab0336 913 W13_reproduction/byte_discipline.txt +5814000f9d13c2605de4c8db1d4e63bf8257df2086b908c0d4936e953768c091 491 W13_reproduction/cleanrun.sh +df3e0baf62536dd5aa69dda1a30b82596c8173a828bd97d1247c436a38733596 417 W13_reproduction/cleanrun2.sh +971d6968bae78a0b9b8eabea5d97f7f6ef8eb9ff67d15110e7689b78032707cf 967 W13_reproduction/hash_W4_independent.txt +d33ed6e631edcc3ea1e7b39b16ea164c230b5ddebb0840c56433869c7299a6fd 358 W13_reproduction/hash_W6_uniform_r.txt +17ffed157330b72743b8d124ea762179cb70b6eca1b6d40273687a071d754aae 457 W13_reproduction/hash_W9a.txt +a16baf8622440f2c3dcfbb97dcdb6cbe4bd35695d803c8c38be40f9cc64d5f23 31598 W13_reproduction/hash_input_manifest.txt +b791407e5786154d2072f7e759f48e4b9199ab00af3356d9d55c61ecf877bb6d 1582 W13_reproduction/hash_input_manifest_recovered.txt +20bff6dcfe2137d7b8eeef7819e44e21142f61fbd1b788dc1dd5f5bfee0ca40b 1883 W13_reproduction/runs/w10_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w10_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w10_O.out.rc +75f95d34c899a792823b9bf9b0d516bb4b8ecf7b9d02db2e41e63220feb1ab19 5 W13_reproduction/runs/w10_O.out.time +20bff6dcfe2137d7b8eeef7819e44e21142f61fbd1b788dc1dd5f5bfee0ca40b 1883 W13_reproduction/runs/w10_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w10_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w10_normal.out.rc +c3accad710fb36dc12a327dd9919b5d64f4e6e329ef862f2e9adf7cf1d3ff080 5 W13_reproduction/runs/w10_normal.out.time +3444efcc0af103c381ce2af2efaf057dc9052f34c8937552de43770521cd8112 23 W13_reproduction/runs/w2_O.err +14b12b2243e4dd5f927b0320fa87be710f8a509a7563d93c9ba76e044ebedb2a 7726 W13_reproduction/runs/w2_O.out +1b8bf8ba65f23cee1bf67992693233173d8344075b2f8f5070ea628d1e4f648f 152 W13_reproduction/runs/w2_O.out.err +79d92e0d26d9d87dbf3c87af800aa84382fbf322544696a59a267aa7809d31ef 6 W13_reproduction/runs/w2_O.out.time +3444efcc0af103c381ce2af2efaf057dc9052f34c8937552de43770521cd8112 23 W13_reproduction/runs/w2_normal.err +14b12b2243e4dd5f927b0320fa87be710f8a509a7563d93c9ba76e044ebedb2a 7726 W13_reproduction/runs/w2_normal.out +1b8bf8ba65f23cee1bf67992693233173d8344075b2f8f5070ea628d1e4f648f 152 W13_reproduction/runs/w2_normal.out.err +a65e8ef59e72610cb64472bf6a74cfd6cb91a700610469d38a1e88e8b96cd53c 6 W13_reproduction/runs/w2_normal.out.time +000bfb456d51614aa3f29b00f23f5e7be64ca3611fa37ef16be584ce9c1608a9 4326 W13_reproduction/runs/w6cert_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w6cert_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w6cert_O.out.rc +8af8773689474ce1204e898bc107b0bfad4b9d0fe3f47bd41f02901a92e9fdfb 6 W13_reproduction/runs/w6cert_O.out.time +000bfb456d51614aa3f29b00f23f5e7be64ca3611fa37ef16be584ce9c1608a9 4326 W13_reproduction/runs/w6cert_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w6cert_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w6cert_normal.out.rc +61369a6b26a0448dfdb15062a5f7e76f9490868faa84c4e07afb51aac2f6fb2e 6 W13_reproduction/runs/w6cert_normal.out.time +ce4245af43521eacc4030cd7feacd444303adb75d2e914cd11f05874c0bdff5d 1896 W13_reproduction/runs/w6wp2_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w6wp2_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w6wp2_O.out.rc +680d4010d29302a6fec37c1fd6a1c4fe31cce6a52a2f7600d97eeeb44bd15c0c 8 W13_reproduction/runs/w6wp2_O.out.time +ce4245af43521eacc4030cd7feacd444303adb75d2e914cd11f05874c0bdff5d 1896 W13_reproduction/runs/w6wp2_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w6wp2_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w6wp2_normal.out.rc +1b563e86e640b90b15ede5da3834564a485f267edb566547494a1b3aef3d59d5 8 W13_reproduction/runs/w6wp2_normal.out.time +2a04b2872365327d3f2b4f1384dc70ac9968d0b559904d7759db54a9e2783e03 637 W13_reproduction/runs/w7mut_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w7mut_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w7mut_O.out.rc +b6f24fbe96e6c8dea0d4dfa8e1b806de2c463f0e16bc180e896c5cdeb4efd943 6 W13_reproduction/runs/w7mut_O.out.time +2a04b2872365327d3f2b4f1384dc70ac9968d0b559904d7759db54a9e2783e03 637 W13_reproduction/runs/w7mut_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w7mut_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w7mut_normal.out.rc +e775d0f30df534f9d91c293e6738928d7352a117e68e607e335820b04d37ad42 6 W13_reproduction/runs/w7mut_normal.out.time +19c3c0099e0c1ca06fd1908827baeb40534e71759dbfd28b4efa244cc7864310 5774 W13_reproduction/runs/w7v_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w7v_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w7v_O.out.rc +fdab477a2efb28d847882a12a6aec98d90959c6df2640323803a74296c37010d 5 W13_reproduction/runs/w7v_O.out.time +19c3c0099e0c1ca06fd1908827baeb40534e71759dbfd28b4efa244cc7864310 5774 W13_reproduction/runs/w7v_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w7v_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w7v_normal.out.rc +19dd9a2f07e28b08df55ad0e2f317c512ce12eb8070d2ca2bb1e05835ec5ff2b 5 W13_reproduction/runs/w7v_normal.out.time +d6cfc8fb7b351ee21e24b9e941e8e5747d51f2487ee6e8bb71acab2b9d244f46 17093 W13_reproduction/runs/w9a_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w9a_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w9a_O.out.rc +f22299a7a03f07f38913fc14b9e334b4899e851802156bca14fc723206f33fd0 8 W13_reproduction/runs/w9a_O.out.time +d6cfc8fb7b351ee21e24b9e941e8e5747d51f2487ee6e8bb71acab2b9d244f46 17093 W13_reproduction/runs/w9a_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w9a_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w9a_normal.out.rc +5b8d70375501f69819a01d8f8f5bb44453f2a721e3676cbc05efa375524ed833 8 W13_reproduction/runs/w9a_normal.out.time +3dd113e32922321e60cec4ae36e08d13a2cc85b00cf617b7035f647db66ef99a 17581 W13_reproduction/runs/w9c_O.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w9c_O.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w9c_O.out.rc +01bcb26c4f72b7682a0cc5792c7a02586f4744a7efa6e1268654f68d20203785 7 W13_reproduction/runs/w9c_O.out.time +57099b24e0179e3c603025bf69c2cf923c24f85281ee18b41e7e2369a903db31 2096 W13_reproduction/runs/w9c_m1_quote_gate.out +8b3b5600f75da00f2d3e0c0af0204aa6f091b6f63ce00c9890a9429c598b903a 45 W13_reproduction/runs/w9c_m1_quote_gate.out.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W13_reproduction/runs/w9c_m1_quote_gate.out.rc +d841eb1cc53606baf7ff60cffd028aea7f044f60921913613da44d75e74cc5af 6 W13_reproduction/runs/w9c_m1_quote_gate.out.time +a0a1d445b5d98359246d3166b29b030c1541ebda08058b8231540ebf159b448c 9854 W13_reproduction/runs/w9c_m2_chain_gate.out +da7c437c490e316cbeb500f7cb6ddd68a383fcf4c86c2360f2514c0fac3d5f3c 53 W13_reproduction/runs/w9c_m2_chain_gate.out.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W13_reproduction/runs/w9c_m2_chain_gate.out.rc +42be2537dd5d48394002f568dbef578b991c48b6c4e793ff51c88f2430b5a516 7 W13_reproduction/runs/w9c_m2_chain_gate.out.time +8e2b8ec79884c80755b84ed9f91f4d13584fdf8fa07499e31dfca6186d621182 5004 W13_reproduction/runs/w9c_m3_ladder_gate.out +14e01a6c9914971103344a8bf99485c51aa4f729255af2b7c495dbe810e16969 41 W13_reproduction/runs/w9c_m3_ladder_gate.out.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W13_reproduction/runs/w9c_m3_ladder_gate.out.rc +9552c70c6fd1c3080159d3f924a6bfc9cadfc78948a860a4ec161e46626cc42e 6 W13_reproduction/runs/w9c_m3_ladder_gate.out.time +58a42735d11a822bd26ba7073523f44fd851ef066b00ab2d13fb0946b697ad48 3659 W13_reproduction/runs/w9c_m4_scope_gate.out +c8fbb6a7420580cfcd1bd304391956ed3578456cee3bb0df1eb48e1f22507204 58 W13_reproduction/runs/w9c_m4_scope_gate.out.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W13_reproduction/runs/w9c_m4_scope_gate.out.rc +dc1831114808ff5eaf2c615f1612fded14e59216d940098ca7143212240a520c 6 W13_reproduction/runs/w9c_m4_scope_gate.out.time +3dd113e32922321e60cec4ae36e08d13a2cc85b00cf617b7035f647db66ef99a 17581 W13_reproduction/runs/w9c_normal.out +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W13_reproduction/runs/w9c_normal.out.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W13_reproduction/runs/w9c_normal.out.rc +f1c19cb78723eae137106941759b365da96406d2558e5e32f1c3f75a2482e2b3 7 W13_reproduction/runs/w9c_normal.out.time +3e7a4b30bedc26120884b1339c84e0f4c5aaa042fe2a22b7d9e3ea7e0e6955fe 1075 W2_symbolic/W2_ADDENDUM.md +22df83a64fb6755cc4e9d19e6efc3346f31acf141f199e476e7852f501ec5a4e 34203 W2_symbolic/W2_DERIVATION.md +b64e99610d6ddf28799b8af576b5adff2bb933b67bd7f762766e20451e993d3b 417 W2_symbolic/W2_FREEZE.json +ede20064b4f6242346ac02c0a4ac09b6c7b98f073c2f4e16ce6e5fadc9ff4b45 26110 W2_symbolic/W2_sanity.py +2570958be883cd893dc790259c4d0e4aea69a10b282b849515c8613de207e693 7878 W2_symbolic/run1.log +6f440798d1f1ee915372193f608f647e19632893a68cd217db705cc7070cd67e 2129 W3_numerics/FREEZE_CODE.sha256 +70a3ba352f937384f79b0f9252afc0f1aa5ba1a24e318549c903838d7dfef059 9693 W3_numerics/W3_REPORT.md +b2fddf4a2986319181e54ecc01ae12a8d498550a1cda8d6d1929d8ef0d292142 500 W3_numerics/diag_g.out +d66c6b55bed53baa2b4c6be00c658b85862664e7f26140349bb82c74643a5d0b 526 W3_numerics/fp_capture.out +8221ac66be71558c921fb44cfb66f7997699aea754d917763882d6d9eddc836e 5 W3_numerics/harness_run.out +d0a4bbb56cc09b12578b1d66e8de36a936a9b9ba516550f65ebfc59cf076816c 969 W3_numerics/land40.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/lbox_A.out +3ea94db87d64ced891c14f3935143a084360583fe22e88efa6b80c62880af54e 11322 W3_numerics/lbox_A.txt +fb23aff0b2001465c095f8df86038c0e99fb199212b5438f86c0da722da559d0 48 W3_numerics/lbox_A.txt.live +43eaa00fdca440fbcea5d074bd2d7ecf7948660308c5db577958a794e8c0a0f4 2612 W3_numerics/lbox_A_run1.txt +118816a8514f490e4da78d3922f4dc57542c2d6e0cc1949b1710bde43cef1373 7123 W3_numerics/lbox_A_run2.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/lbox_B.out +ceee0f180c61033c470d0169da13f41c2bb6ae5ab1ff70fb673350198a67b816 10752 W3_numerics/lbox_B.txt +fd49bc00cbbc0e0fe1b511e79f6f5aee1264458a734d9381e340e884b8556e40 48 W3_numerics/lbox_B.txt.live +4ae538f5044e71d07e05407b03b1f81ca50a788f0d810002e9398070a8946836 3917 W3_numerics/lbox_B_run1.txt +148fe0564a8398d308b25ebfa7313301eba574305be6ce13c6ec19d67675fb05 10507 W3_numerics/lbox_B_run2.txt +c40472ef5798beeac2095a138e9428b9c556ecbe40a11d2c1b84a79981a82fbb 5838 W3_numerics/lbox_B_run3.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/lbox_one.out +8304ef593758363dc58e9d51aa88fb99731bce4d59001f5ed0e4202ec5361beb 1271 W3_numerics/lbox_one.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/lbox_test.out +12b61fc245fb637daada6ada10903bc00f1e35acbd17a73ac5e0d56a7230e1a7 3177 W3_numerics/lbox_test.txt +94012def2e34432e00b141ed64b2b6ff5b35b6b0dea3dc9d86bfc438cadb8fc0 75713 W3_numerics/pscan.txt +366a75096d066b65cadc675f0cbed645a8ae3b9c1a2065320cce6aef628c2c02 40 W3_numerics/rho_probe.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/scan2_land.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/scan_out.txt +93ef57b4196ab11f4951ad4522fdc10801a88bb469b6022e928ab5ef4a094299 93 W3_numerics/strip.out +92d6154d243738ad5eb728280f6069a3a128899c74eb1891fe1d613c1d5336b8 199088 W3_numerics/strip.txt +5127fad81eda11fc261ad4a1ddfa7838fe2315228946ca5727ccbb9b5e124053 21 W3_numerics/strip_band.out +00330836ff8fd4b6569daa6cb803ece620c7b79760c9c45344a45292491c1990 16452 W3_numerics/strip_band.txt +91364edcd91686889f450648943df5abbf8f0e63a32690b107a348ec30fa9acf 316 W3_numerics/t_boxint.out +47e819548778f5773ee1d3986da0637e8b7031d14794f575252e1b5d7824bb4a 1213 W3_numerics/t_boxint.py +bd19aa9fd76d197160aa6929ed7674f77f8a5a9626fb76517b74bc67e9196d84 1256 W3_numerics/t_one.out +cfa9bd474bd0650a05c0bf96bc69e305b59789b9dadd1a71c65c2b8936deb33f 1740 W3_numerics/t_one.py +5bd05e966ab4e3ad767f1ebc76f97d51c11a3a2c5e6751eb4b2f17f49c19f96c 53167 W3_numerics/w3_cert.py +a93d28cc0809ebb7becda2e44edbdca4b2b358c1fb766c9af84e7a83dd8a747a 1514 W3_numerics/w3_deadman.sh +55fcbd7f23f169424cc48fe3243ec07ea0361b6bc12f9bfedb5db2d70b6bef0b 7653 W3_numerics/w3_drive.py +ba61e0ef3e1f1c7dcfaa410d7146addc2a90ddd7b36bba99cff2481b8cd66e0d 4984 W3_numerics/w3_harness.py +4d996f82e8128a58942ad135e03a4378107492dcc7ca42cb104599c133ae3abf 11458 W3_numerics/w3_lbox.py +e61ffa056fbcfc6815968d8996e21a73402371f4d79d4e139ad23333e5529036 11571 W3_numerics/w3_lower.py +5b768d093e9a423b63f54bb8d6d1707614fd0ca44561d33cd1305c75e07148a7 2773 W3_numerics/w3_pinprobe.py +f648002c98c9df6e2fd3f4a8ba6d9f456e1daaafdae45afce720930f6c79603b 9572 W3_numerics/w3_proto.py +4eef59a06712f79606e648863186a4ce12c3681c8dabe45f4bbda80b71c5a3d3 1238 W3_numerics/w3_pscan.py +9561e87364b0d6eef130b1f7facbf7dd70305b41b46c98b44930b4a8d45720d5 5589 W3_numerics/w3_run.py +1e0c454dab136830f14415f00f5bddf03251645d32dc9636e36dc6f6de85bc6b 1236 W3_numerics/w3_run_harness.sh +31dc4d424f7a1415838d01570577273a0f091c558a64ceebfcf4384227e07543 3139 W3_numerics/w3_scan.py +69d05769ca4dd0f3ab6d4fd0932310c8131eaadc56b39d9d9f30ab8a90b74897 2478 W3_numerics/w3_scan2.py +8fe3e20f5e488699f02c8fb3fde351cf4e7f712d551a23c28bff7e666262c0b6 2178 W3_numerics/w3_strip.py +820be8cad35a5afff3d241ebb7f71a81e7dfff8745f86d919a644e515ab5646c 1175 W3_numerics/w3_supervisor.sh +bb963481fa1a824653f85d03fb85d044548b762797a0cda5e7757b285a7caed9 7267 W3_numerics/w3_taylor.py +b174add150fb962cd24cbec843555d264b6c6f3c3cc52432f7b07b11896024db 8704 W3_numerics/w3_tm.py +a4561c7412347743aa244e127ad015097c2e30126df312122766f98113060b68 798 W3_numerics/w3_watch.sh +b9f8921d2348f285724288c185e8f3f6d1fa18903053ca8cac3fa070dc2231e1 553 W3_numerics/watch.log +0b0dfbfce9a5fd092b59459f683b57049fce8cf948db650b78760331760604af 100279 W3_numerics/__pycache__/w3_cert.cpython-312.opt-1.pyc +01dfe4e59c43bdc1945fe5f6949fd6923f8c8153d250024a737f7c9a9111ea14 101547 W3_numerics/__pycache__/w3_cert.cpython-312.pyc +6492c67a6feb422ed99dcc5bb7cb9461ebdaa7dc39574b43f71d833bbc6e3527 19376 W3_numerics/__pycache__/w3_lower.cpython-312.opt-1.pyc +6492c67a6feb422ed99dcc5bb7cb9461ebdaa7dc39574b43f71d833bbc6e3527 19376 W3_numerics/__pycache__/w3_lower.cpython-312.pyc +685440d4080732959b651a872ed5b96b383cfa574c73ed3ebdf4353f36a35b73 18357 W3_numerics/__pycache__/w3_proto.cpython-312.pyc +bb9adc5a6a14b57dd52af5b07a541e40a5795518f6614fc229509f944ae138eb 7130 W3_numerics/__pycache__/w3_scan.cpython-312.pyc +1e8f9fb5be91901f154e6c9092f86a81491058e1c28e858afce52a4077f45e03 12870 W3_numerics/__pycache__/w3_taylor.cpython-312.pyc +da0d86de8e1d0eb5619f73edd897ce3a109e5c43a73ca5f89e260a88014ea108 17474 W3_numerics/__pycache__/w3_tm.cpython-312.pyc +a7557f50e96eff78a216f966f2e4841c04cd8be06c6e655b62bcd332021ba143 15 W3_numerics/receipts/byteident.txt +6ce859b450b0a0d790dd218f7c60195e8d8db5a43889b07ecf843f759cc257a5 16 W3_numerics/receipts/failclosed.txt +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/receipts/harness_O.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W3_numerics/receipts/harness_O.exit +65c3663e2ab79e6d626783132efcc17fcc894d43716a751de642e86125147883 554 W3_numerics/receipts/harness_O.out +833232eed87f379f23ee0675b1d9a86cdeeb26daa52d632179138e001a0cb7b2 65 W3_numerics/receipts/harness_O.out.sha256 +3fcf9787c53f241b31366b7774fa41d263725fa848f931d4e581d73ef257e9dc 38 W3_numerics/receipts/harness_mut_pin.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W3_numerics/receipts/harness_mut_pin.exit +82177ade436080672a951a7de52cb71ae77e2c898a6ed6a2d0f7c5232c649758 292 W3_numerics/receipts/harness_mut_pin.out +73644cd12ce4e66877ae17e9ca3dec9cfae96832cf495fad2a08a0f0c8e088a8 65 W3_numerics/receipts/harness_mut_pin.out.sha256 +f594dcf6a47f8da6fb259a691ba4b695098da479836b1e88047e8258e913da96 79 W3_numerics/receipts/harness_mut_sqrt.err +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W3_numerics/receipts/harness_mut_sqrt.exit +19d82493ca8019491b1a0d2bc56695cf90342f8734939112fbb5770cafd575ba 450 W3_numerics/receipts/harness_mut_sqrt.out +f309013c6eb11e375dfccece05a5a3e7614a27ddf4184b49a5e85eaf54ea3bbb 65 W3_numerics/receipts/harness_mut_sqrt.out.sha256 +3fcf9787c53f241b31366b7774fa41d263725fa848f931d4e581d73ef257e9dc 38 W3_numerics/receipts/harness_mut_zone.err +73ab7863d83a0c1548d886f5acc4f915bcdf9f9d7c4785a8ae4ef47801f64e74 65 W3_numerics/receipts/harness_mut_zone.err.sha256 +4355a46b19d348dc2f57c046f8ef63d4538ebb936000f3c9ee954a27460dd865 2 W3_numerics/receipts/harness_mut_zone.exit +95dc4698cd976582558df8511f9e92eff604170de8df89967b7e5f0d0b4a3622 289 W3_numerics/receipts/harness_mut_zone.out +11b1ef8592b415928d7257ed827a8a8b9b340cb003647aa946ac7f9e629e0f03 65 W3_numerics/receipts/harness_mut_zone.out.sha256 +e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 0 W3_numerics/receipts/harness_normal.err +9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa 2 W3_numerics/receipts/harness_normal.exit +65c3663e2ab79e6d626783132efcc17fcc894d43716a751de642e86125147883 554 W3_numerics/receipts/harness_normal.out +833232eed87f379f23ee0675b1d9a86cdeeb26daa52d632179138e001a0cb7b2 65 W3_numerics/receipts/harness_normal.out.sha256 +b83998550c049a0383a9cfb763d0950033c3491735712c50737ad08a6b7eded7 3385 W4_independent/MANIFEST.sha256 +669401f7871e13fb8ae1d295fa04f55fe81f45b9f1443ecd97158db7a6235715 10789 W4_independent/W4_REPORT.md +2f9d27d4bffa8ef17f1f5bed1ab89de5638562ba5f95e858142e19a9b8593bb5 3991 W4_independent/probes_laws.txt +24e0fe45e293c7eadd090d426340f69b8d00fed35514f59c517a508529378f23 3774 W4_independent/w4_altcheck.py +4fee37eaf7854499c4bbcd1ff4a8bfe8e94c40e1e59c9aaedd988895987d0837 8064 W4_independent/w4_assemble.py +1f35e7364a651e2413f71987c22eb8f532b30daa1d89cb54516503aad6f9614e 7848 W4_independent/w4_condlaw.py +275d1cc20716357d50e44b458533f2898c5b5f5b75b907bface04a0d478b8433 5704 W4_independent/w4_integrate.py +9ba36222b0f91cf928f335e4228c7878928cfd9e948ac2b6c8704fbffab5aad5 8765 W4_independent/w4_kernel.py +075f2c461af8360c4f5102fa2e2885822fff110bd48a80243cfab413fcc87999 2486 W4_independent/w4_map.py +e26ad70dcaf1107634820fb215f06f9c016a71bbd43152655a3371224ce73d86 2017 W4_independent/w4_mc.py +9c572adaff1908b2dac57a9cf0c1b6c3cd9194b8303b9f4259563e19281290cb 2238 W4_independent/w4_probes.py +b6188b0a6df20dec4f1cec10fc6ef5b30d5e291c51c33b352df229432ad540c0 3908 W4_independent/w4_refcheck.py +349106eb4146258e1e9eba586b1e60ff67d4430ac88f8ee7d0076b9377e44d61 7866 W4_independent/w4_rho.py +140e20c47ee27ef74de11e3ec5d75a36b5e3e61e3f65c7ac3c1a145b4e5f104c 1178764 W4_independent/maps/arc_a.tsv +10a9f8b40e453b0dc2931cbd195a759064144b242bbf9d3f0f384c71ea6e6005 1570291 W4_independent/maps/arc_b.tsv +5f9b7eff5ecd18c8e7021d096f3521da419c23cc6ee9c060bad8d04f3a9d2c97 1108108 W4_independent/maps/full_med.tsv +9834810ce4bc95ad4f8d8e31c0d282c122625e389e0140fe64771d10135d38ed 55761 W4_independent/maps/inner_scan.tsv +5c2d55faf473634210be35d0e5a04fdd1bf0642a189d78a092bbb1d1bc1b9048 190644 W4_independent/maps/map_coarse.tsv +bbd8377d9f4b02ac544be114090185061079da3c0d82c03ec236c08795d6d955 184569 W4_independent/maps/outer_shell.tsv +a48a9f52a7941085979ccb532bb2a2c6eca6535705e59074f98c73d5fe3c90cd 13480081 W4_independent/maps/wedge_fine.tsv +d51d79741b8da72e61b427463f744ad04f6a28009ce55ec6d3e4f685c931bd8e 13204497 W4_independent/maps/wedge_finer.tsv +9aae130a4bc6b4824d7e0d3b1cebdc5a94fe3cce4ae464c10fe0dd1d4cc4b7e5 3379547 W4_independent/maps/wedge_mid.tsv +0f78c2ac4d66147c46d857ab6304690b246e78da1b283b99f7297cb546ae5e49 111 W4_independent/transcripts/altcheck_p2.txt +2f776812b2b83c802c63ad1486db0a34b7839c3855ae9ba1d25177e0c09917f9 108 W4_independent/transcripts/altcheck_peak.txt +c513e7ccd49840bab355c73ccabb3e0b157d80e201844a5972183c9d96d1136d 170 W4_independent/transcripts/arc_a.txt +6e6b2acf24769f649c88785d80a9193e995b479b7343dc79104d119d3613eb36 170 W4_independent/transcripts/arc_b.txt +9cf727b5779ca23824001cfe0f74567a4227bcf597fb1541cf945db5e9b4e775 1114 W4_independent/transcripts/assembly.txt +f1b0481a27c5f5ab6335981db88793ade98189647759f1553b1aa38f3fc20124 569 W4_independent/transcripts/condlaw_init.txt +9b5ef6495e2eee0a40bdb9f66c4e9df9760707d784b57c6d935c8dad1da50ad8 92 W4_independent/transcripts/full_med.txt +5c91bc5fb3c4c9ab3cc8ceee39df4d1ff7bb892e5eb34ed8f809873d8f1dd969 8 W4_independent/transcripts/gridruns.done +ad9652cc31e79830e982f49f3e84a2e1751c1cfc2369f6816ebc7892db14acdf 101 W4_independent/transcripts/inner_scan.txt +e65ac8c020a6eb4f592820c3976f1b92d23b65ba23d0a4388f1746e66a48b13a 475 W4_independent/transcripts/kernel_verify.txt +306dbe596da226a866dfd257c0a349973a9edf88f72ea0983c772feff5f3c7b2 139 W4_independent/transcripts/mc_p2.txt +d91d601fa49fe485a5b74774d309207996d6333a3a18159835e0cd15e4f546b3 136 W4_independent/transcripts/mc_peak.txt +f611462952013ded3f0c66de8f8b67a8cbef5270391f487f09fa210d67bb835b 51 W4_independent/transcripts/outer_shell.txt +fe60f74907681dcca9b5d71f4628304cb22c08bf19b5f0932535e6c945f3e47c 139 W4_independent/transcripts/refcheck_p2.txt +3b59bfa727fc0698f82517a2a461a307ffd87381bd6591e62a4601c5a9414561 303 W4_independent/transcripts/refcheck_peak.txt +6e01693243cc092eaf0d5985e273d586831c9f50fc142e0ca9157288e08a9d53 138 W4_independent/transcripts/refcheck_peak25.txt +77df425b028fdbd1cd3bac3c1193497d4a9d95d97bf0902803550970d98c1f26 170 W4_independent/transcripts/wedge_fine.txt +6af4009a498c172200ad8cdb1b1acac000a44eb723b7486ec7fb618e68fe588d 170 W4_independent/transcripts/wedge_finer.txt +1174acd01bcff571d9984e5c557d89cfd87f214b5f00a5ba1b1997182c82e3fc 169 W4_independent/transcripts/wedge_mid.txt +9b033b57df9956246d5608cc4ca415d6a76ce9bccb9cb8a24d74b8848844c703 21674 W5_forensic/W5_REPORT.md +a55cfca96fadf0c6db786aeafcf168eafe210d9f59d34e75aa48d620c8a5c470 1482 W6_uniform_r/MANIFEST.sha256 +b031497317a23e8892e898105be6a8dd5c92562c00a9555ee78f45015849a8db 15831 W6_uniform_r/W6_REPORT.md +000bfb456d51614aa3f29b00f23f5e7be64ca3611fa37ef16be584ce9c1608a9 4326 W6_uniform_r/transcripts_cert_main.txt +ce4245af43521eacc4030cd7feacd444303adb75d2e914cd11f05874c0bdff5d 1896 W6_uniform_r/transcripts_wp2_fullgrid.txt +ce4245af43521eacc4030cd7feacd444303adb75d2e914cd11f05874c0bdff5d 1896 W6_uniform_r/transcripts_wp2_fullgrid_O.txt +8350958d28d334263b77ad2291551eddf359c98b05d88f6a4347b630300c2a27 1509 W6_uniform_r/transcripts_wp_grid1.txt +38546d1056101a93f571627fcd154aa89a67bea0199de255a44b3bf8feec1e20 1661 W6_uniform_r/transcripts_wp_grid2.txt +7f5ff2aaf413814f10f31b7120ecaf116d4d3bad6f79f330bfea9abbb5c9bda4 2978 W6_uniform_r/w6_analysis.py +47aebeb66728a4395f8fde798ef8a1fb7a0e3522a087322a6a926c4f0df94fb9 9579 W6_uniform_r/w6_cert.py +8ed11b2ee05c9300f98d529aa43f9dfc5fe957f8ac189d291007fc931d5a495c 1152 W6_uniform_r/w6_cluster.py +2c78fc08f381487c6aa56b735d2314383bb429405f83d36e4233de49fc53e36c 2715 W6_uniform_r/w6_cs.py +2d27e70474582ec9411fa605fd0f0f7b490cafd44d8e5035b6e298b27cc52038 1853 W6_uniform_r/w6_fullzone.py +35b218da82e9bb82137a940412377c77ef3ce801b4b4d127999140ca89cd2a1c 5046 W6_uniform_r/w6_kernel.py +937d30a3309d6032c068167ad4760ace7271d8ae394fa6543e2cade6bb39cef3 4623 W6_uniform_r/w6_rho.py +34d0a6bab510b6308cb871f3ae4ffdd13373b96c877dee740e52ef7015e9a808 2478 W6_uniform_r/w6_rhofast.py +14a9c06e79a1550420b367243062380ccc3042cc10a280297990bab045d63306 1771 W6_uniform_r/w6_varlaws.py +9dcf764d43a88334bf22a3852f6502c40fff58f8a2cb56631bb8754c41eba5e6 3533 W6_uniform_r/w6_wp.py +8690b300becdc7050711748e4b883149c821bc119365b2699595dadc32f8aade 3331 W6_uniform_r/w6_wp2.py +2e73e7348777c0db6a2e44062aadac1f5b3c7cf47c32ccf54150ba57d6de5388 3215 W6_uniform_r/w6_zone.py +bb36f7540745e64a35f1439c3135ad4b90bdcc59ed14a827230c69a27c25cefa 5735 W6_uniform_r/__pycache__/w6_analysis.cpython-312.opt-1.pyc +bb36f7540745e64a35f1439c3135ad4b90bdcc59ed14a827230c69a27c25cefa 5735 W6_uniform_r/__pycache__/w6_analysis.cpython-312.pyc +ce43d0445f07c1c24506f1a922b98f0fefbdcc4ca5f27c65cbd346a17406a479 5993 W6_uniform_r/__pycache__/w6_cs.cpython-312.pyc +134a4e059f8fdd2dc349b71c6997a7eda27035fbd0d6c4e0cc674de11895c8a6 3894 W6_uniform_r/__pycache__/w6_fullzone.cpython-312.opt-1.pyc +134a4e059f8fdd2dc349b71c6997a7eda27035fbd0d6c4e0cc674de11895c8a6 3894 W6_uniform_r/__pycache__/w6_fullzone.cpython-312.pyc +9467abc03c117d4a10cc4789ada808c52bdd464a3505220b05953bb73123688b 9081 W6_uniform_r/__pycache__/w6_kernel.cpython-312.opt-1.pyc +9467abc03c117d4a10cc4789ada808c52bdd464a3505220b05953bb73123688b 9081 W6_uniform_r/__pycache__/w6_kernel.cpython-312.pyc +47fc6d977d079589cb7d0f17c8bda620be1871797454e6ad633db5ce69809b79 8902 W6_uniform_r/__pycache__/w6_rho.cpython-312.opt-1.pyc +47fc6d977d079589cb7d0f17c8bda620be1871797454e6ad633db5ce69809b79 8902 W6_uniform_r/__pycache__/w6_rho.cpython-312.pyc +5e9e2479c1497736c3885857651d94b01bb6f41a100f0706868bb6d4316a3933 5717 W6_uniform_r/__pycache__/w6_rhofast.cpython-312.opt-1.pyc +5e9e2479c1497736c3885857651d94b01bb6f41a100f0706868bb6d4316a3933 5717 W6_uniform_r/__pycache__/w6_rhofast.cpython-312.pyc +53014fd3895e2124585c0f5e31e99cd9bb739ef74cafb3474856a06e628c53f9 7514 W6_uniform_r/__pycache__/w6_zone.cpython-312.opt-1.pyc +53014fd3895e2124585c0f5e31e99cd9bb739ef74cafb3474856a06e628c53f9 7514 W6_uniform_r/__pycache__/w6_zone.cpython-312.pyc +03f2e944ecc054dd36e92f907ed2a2c39b5143147716110da427d068954cc416 17237 W7_gammaloc/K3_W7_GAMMALOC_AUDIT.md +c0dedd630b34531fe10ca7b1951a61cac64f8993444aabd94967c58a009af44a 5042 W7_gammaloc/K3_W7_R0_ADDENDUM.md +659e0bf9bc0ae29c84261e40a5ad1bfb6364ac98749c64ee35b496c360eb9f9f 2906 W7_gammaloc/K3_W7_SCOPE_ADDENDUM.md +095ce955bfb358aaf078901fd46f75c0d107aeb66471321d96f7af60b3874d73 3266 W7_gammaloc/mutation_driver.py +2a04b2872365327d3f2b4f1384dc70ac9968d0b559904d7759db54a9e2783e03 637 W7_gammaloc/mutation_t_O.txt +2a04b2872365327d3f2b4f1384dc70ac9968d0b559904d7759db54a9e2783e03 637 W7_gammaloc/mutation_t_normal.txt +e16054ef132749029f6dd0075f26d609fa296905db470c74ef300adcbf9c84f8 15599 W7_gammaloc/verify_k3_w7_gammaloc_v1.py +19c3c0099e0c1ca06fd1908827baeb40534e71759dbfd28b4efa244cc7864310 5774 W7_gammaloc/verify_t_O.txt +19c3c0099e0c1ca06fd1908827baeb40534e71759dbfd28b4efa244cc7864310 5774 W7_gammaloc/verify_t_normal.txt +4f98f64dc6ddbf0904fc7cb4fb0d93adb902e2bb2967b692299c7373f827e23f 1401 W7_gammaloc/mutation_workspace/M1_pristine_accept.json +28226c7aac232d5e48c761554751f4f3fe133beb235b6098adec1e8ee3583aca 1384 W7_gammaloc/mutation_workspace/M2_total_above_gate.json +8aac339ce577ac5f7e85d5b4ccee4d29b9277a608e8c98ecb55149527ce0ffae 1400 W7_gammaloc/mutation_workspace/M3_gate_shrunk.json +7bb21f4ce7475ceeaecfbd4b6d8a9323a1af9b46c1d1912f1c6953b81eace35e 1387 W7_gammaloc/mutation_workspace/M4_station_v_corrupt.json +b0407087e77a7b65b45b8a31baa5a47769cf31263df74616dc2b42f3a1ae0193 1230 W7_gammaloc/mutation_workspace/M5_station_dropped.json +6c0a2af8b92a5d4ebd2141e0057138909ff872a3d46c1848b5eeaf5e08379f94 1401 W7_gammaloc/mutation_workspace/M6_sum_inconsistent.json +6519c6046e6191522e1d47574fca0db08f51ad56d726b2823358794fc5c15fb7 1401 W7_gammaloc/mutation_workspace/M7_rice_corrupt.json +3fc367d4ce2037604f623f58f5cc2d1c0ec09d73c8bbc416fa3ef661e9ee2b03 1402 W7_gammaloc/mutation_workspace/M8_closes_flipped.json +6e0962393c23254571403622b5ee11e107125651a7e82d0b2c1161dc5edbd5ab 801 W7_gammaloc/mutation_workspace/M9_truncated.json +89c16268ef38e20adff9ec69f6b3bb6eb1b02dd689f74b35d95f0f2d41bd90ec 7363 W8_lambda/BLOCKER_DESIGN.md +52244e30aef547bce96b2af92be65d46c5566bd4f6aed9ca2ca0477767721bc2 872 W8_lambda/HASHES.txt +4f4ec482e349fdba398a92ca3e4f2f7a437e1fb868a1e1f23fd5fe795ac79689 588 W8_lambda/HASHES_v3.txt +530c3038024964fd12ed2a6249f4f44d473181e0b49cb91f6cbdae0aff440d15 19043 W8_lambda/KIMI-DER-027c_NONCLOSURE.md +468b328fa8c3022048919a1f40cf700d36177a2bfe47f19f0d321264e4e909cf 1662 W8_lambda/MANIFEST.sha256 +3c76fcb0235a4ad5319b77b00dadec85c27f89a43f900dcfc6b4e4c104f01794 3320 W8_lambda/mutate_lambda_grid.py +650702accc53e98ef0ff6d76ca619f5aed7ee6ddc75e543506f3004111349699 673 W8_lambda/mutation_receipts.txt +2d13931b7549f26a533bb57bd222b87d5384dbe5e1dfa2ccaebfc9898ccb40b5 673 W8_lambda/mutation_receipts_v3.txt +579ef6cd88d543ec14db45558e5e7c1899078095e0df295c7d46fd1810273831 49020 W8_lambda/verify_lambda_grid_v2.py +d54fc3bd8d5bf1445f16dd954fff6556c6f6d3998898efc42efe9387d313379e 50523 W8_lambda/verify_lambda_grid_v3.py +d6a0b46f1b5f0f03958f23470505e6de806261b259b4e7be9a8b8140ff346b51 1176 W8_lambda/transcripts/S6_EXCERPT.txt +f19994cd180fd7bc0e828a955136a990e06571d33ec78ec5136b3f19fe15a99b 3501 W8_lambda/transcripts/S6_EXCERPT_v3.txt +9bfce1cee23a0ee0078b667fc89b20467664bb8f6e6d992e69485d38edbb953e 15 W8_lambda/transcripts/identity_stamp.txt +9bfce1cee23a0ee0078b667fc89b20467664bb8f6e6d992e69485d38edbb953e 15 W8_lambda/transcripts/identity_stamp_v3.txt +c520b19729a72ab41e914503a33bcb5841734d44f232a75fc726e591c370bac8 3395 W8_lambda/transcripts/transcript_O.txt +c520b19729a72ab41e914503a33bcb5841734d44f232a75fc726e591c370bac8 3395 W8_lambda/transcripts/transcript_normal.txt +9641bd569e59115d38d6e9d805254bc7e7453652411097da06db508b65a152e0 3041 W8_lambda/transcripts/transcript_normal_partial_restart1.txt +5e19da35a08fb737ce59b3dffb5453d19193931fc7c14803aa243985d54bf113 6060 W8_lambda/transcripts/transcript_v3_O.txt +5e19da35a08fb737ce59b3dffb5453d19193931fc7c14803aa243985d54bf113 6060 W8_lambda/transcripts/transcript_v3_normal.txt +30d4aed7d63158cecae5f50c55b5e86d6c9677b63e61b1ec998b8f174c749502 1227 W9_scope_027a/MANIFEST.sha256 +d6cfc8fb7b351ee21e24b9e941e8e5747d51f2487ee6e8bb71acab2b9d244f46 17093 W9_scope_027a/audit_scope_027a_v1.O.out.txt +d6cfc8fb7b351ee21e24b9e941e8e5747d51f2487ee6e8bb71acab2b9d244f46 17093 W9_scope_027a/audit_scope_027a_v1.out.txt +12af9e2db57c950b1f2e1a364fba871c9db5e878ee624618b400c16c69e937e0 42404 W9_scope_027a/audit_scope_027a_v1.py +cdf8c973de2874a11942675d717635d1e005a7a3658339fde1d73620956386b8 12911 W9_scope_027a/audit_scope_027a_v1_report.md +5b8ef6392a5794c40e4bb9ca587b5e3e9cacd5ee56187f703c9fc8169cd733f7 13317 W9_scope_027c/K3-DER-027c-SCOPE-AUDIT.md +3dd113e32922321e60cec4ae36e08d13a2cc85b00cf617b7035f647db66ef99a 17581 W9_scope_027c/t_O.txt +3dd113e32922321e60cec4ae36e08d13a2cc85b00cf617b7035f647db66ef99a 17581 W9_scope_027c/t_normal.txt +4c1a8523812bf600bde41b486ee1e6cf45d71ec0fe707d89598f7f8c03f9ac97 46977 W9_scope_027c/verify_ridge_scope_continuation_v1.py +9ea7477ff6f64679c0add79bb39ed13135ff1738894a456f0d148d2d27c0c7b5 46977 W9_scope_027c/mutations/m1_quote_gate.py +27ba7a8ea36936efd1608460639b66319c72bb5353baddcc2a7c3bf8f5fd1768 2141 W9_scope_027c/mutations/m1_quote_gate_receipt.txt +81be03c57f960cb55e38be2e00700bd104dd30fc2308f0f409bfc14b03f5e2a2 46976 W9_scope_027c/mutations/m2_chain_gate.py +891edab0aa3e1651e27de863c280648fcd4e66d8487f33739c6d1c52e7adfffe 9907 W9_scope_027c/mutations/m2_chain_gate_receipt.txt +d7de20dc0dc0f0f6ee1e1736df14f2335a5f73fb87a37d407d8959a35413d629 46976 W9_scope_027c/mutations/m3_ladder_gate.py +ac1c604ce5efbfb2fa7ac915119cee1a4c610ddf08e23e5498fbc76449e64af3 5045 W9_scope_027c/mutations/m3_ladder_gate_receipt.txt +fb18b709ff5a2732c0a2ba53a1f961e452533a080f06a1b2234f73be88b19008 46976 W9_scope_027c/mutations/m4_scope_gate.py +68d348e1c33eac7d01bcbd617b83e28154e6b2daf0f21e89a2da8a252c788af3 3717 W9_scope_027c/mutations/m4_scope_gate_receipt.txt diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md new file mode 100644 index 000000000..c02d785ad --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md @@ -0,0 +1,265 @@ +# B4LOC_DAMLINE.md — the B4 dam-line tube certificate + +Artifact: B4LOC-R1-20260914-v1.0 +Lane: D2 branch control (U2D-UPPER campaign, side-24 periodized normalized +Bargmann–Fock field). +Scope-ruling context: Stage-E ruling V2 — with no raw counted-class envelope +for B4.loc anywhere in the carriers, the dam line is the only route to ANY +O(r^3) bound on that summand. This document closes it at certificate grade. + +Frozen carriers consumed (hash-pinned, freeze-before-consume): + C2_B_CLASSES.md body 2aba099d… (B1 taxonomy: B4 definition, §4 dam family, + kappa_* = Theta(1/r), the registered open item) + D2 body 9e95648a… (the 9-pin M-ward tube, kappa_dam scale-invariant) + B1_taxonomy body 7d7ddbec… (PL ensemble + classify_pair) + H4_CLOSURE.md body a67d50b9… (H4-RN theorem, H4-SD) + H2_foundations/cov_exact.py f08c1c5f… (exact covariance, spectral moments) + b1_falsifier.py 818df798… (PL model consumed by the discrete mirror) + +Notation. Q_r = the 6-pin law (f(M) = b = 6/5, ∇f(M) = 0, f(S) = s = b − ℓ, +∇f(S) = 0; ℓ = r^3/6; M = (−r/2, 0), S = (r/2, 0)); P_r = W_r dQ_r/Z_r. +The B4 dam event (C2 §4): the separating event between M and S's sectors at +level s. B4.loc = its local (pair-level) slice; B4.rem = the remainder. +This certificate bounds ALL of B4 (loc + rem), which is strictly stronger +than the registered B4.loc item. + +==================================================================== +BEGIN_FROZEN_BODY +==================================================================== + +## 1. THE IDENTIFICATION — DISPOSITION (b): the pair-level cut net is NOT +## the 9-pin M-ward tube. No asserted identification survives. + +The registered caveat reads: "the pair-level cut-net ≡ the 9-pin M-ward-tube +item (ii) identification is ASSERTED, NOT ESTABLISHED." We resolve it +negatively. The two events differ on four independent axes, each pinned to +the frozen carriers: + + (i) LAW. The cut net lives under the pair-level 6-pin law Q_r (C2 §2: + pins at M and S only). The M-ward tube lives under the 9-pin law + (D2 body 9e95648a…: the 6 pins plus the 3-jet at the branch point y, + a Palm conditioning at y). Different σ-algebras of conditions, + different conditional variances at every point of the corridor. + (ii) TUBE. The 9-pin tube is S's M-ward channel selected by y's jet + (D2-COMPLEMENT's 4-channel decomposition: the tube is one of four + angular sectors of the branch at y). The pair-level cut net is the + full set of separating cuts of the M–S pair at level s, with no + reference to any branch point y or channel. + (iii) LEVEL. The tube is pinned at the branch level v = f(y); the cut + net is pinned at the pair level s = f(S). H4-JC-R1 (H4_JC_repair, + frozen) is precisely the finding that level-v and level-s events are + distinct with positive-probability discrepancy (death-saddle + double-membership, 175/175 in the mirror). + (iv) SCALING. The 9-pin tube margin is scale-invariant: kappa_dam = + Θ(1) (D2's certified headline, halving ratios 0.886–0.997). The + pair-level cut-net margin scales as kappa_* = Θ(1/r) (C2 §4, and + §6 below: certified kap·r ∈ [0.467, 0.533] and [0.722, 0.769] for the + two zones). A Θ(1) margin cannot dominate a Θ(1/r) margin family; + the events cannot be identified. + +Disposition (b) is therefore in force: the pair-level certificate is built +DIRECTLY (§2–§4), and the 9-pin M-ward tube is recorded as the PROOF +TEMPLATE: the corridor-geometry + Borell–TIS + entropy architecture of §3 +is the pair-level reincarnation of the tube argument, with the 6-pin law +replacing the 9-pin law and the Θ(1/r) margin law replacing kappa_dam. + +## 2. THE EVENT-INCLUSION LEMMA (B4 ⊆ E1 ∪ E2) + +Corridor: q(ξ) = S − rξ·x̂, ξ ∈ [0, 1] — the straight axis from S to M. +Zones: Z1 = (0, ξ0], Z2 = [ξ0, 1), ξ0 = 1/4. + +LEMMA B4LOC-R1-A (deterministic topological step). For every C^2 field f +in the B4 dam event (M a local max, S the pair saddle, M separated from +S's upper sectors at level s), at least one of + E1: ∃ ζ ∈ (0, ξ0] with f_xx(q(ζ)) ≤ 0 + E2: ∃ ξ ∈ [ξ0, 1) with f(q(ξ)) ≤ s +holds. Hence B4 ⊆ E1 ∪ E2 as events (and a fortiori B4.loc ⊆ E1 ∪ E2). + +PROOF. Suppose both fail: f_xx > 0 on all of Z1 and f > s on all of Z2. +Taylor with integral remainder along the corridor, using the pin data +f(S) = s and ∇f(S) = 0: + f(q(ξ)) − s = (rξ)^2 ∫_0^1 (1−t) f_xx(q(tξ)) dt. +For ξ < ξ0 the whole segment q([0, ξ]) ⊂ Z1, where f_xx > 0, so f(q(ξ)) > s +— extending the ¬E2 hypothesis onto Z1 as well. Thus the full open +corridor q((0,1)) lies strictly above s, with endpoint values f(S) = s, +f(M) = b > s and ∇f(S) = ∇f(M) = 0. The corridor is then an upper path +from S to M at level s: following the corridor out of S, the level-s upper +component containing the corridor reaches M. Hence M belongs to S's +level-s upper cluster along the corridor direction — i.e. S has an +M-ward-open sector and M is NOT separated from S's sectors at s: the field +is not in B4 (for the local slice: the separator does not exist; for the +remainder: the M-ward channel is open, so the remote obstruction defining +B4.rem is absent). Contrapositively B4 ⇒ E1 ∪ E2. ∎ + +Remark (why two zones). Near S the value margin f − s is O(r^2 ξ^2)-thin +and cannot be certified at the needed grade; the curvature test E1 carries +the near-S region (a separating cut must pass where the ridge is convex-up, +forcing f_xx ≤ 0 somewhere in (0, ξ0]). Away from S the value test E2 is +the cheap cut. The split at ξ0 = 1/4 balances the two certified exponents +(43.5 and 107.9 at r = 0.05; §4). + +## 3. THE CERTIFICATE (uniform Gaussian sup-tails over the cut net) + +THEOREM B4LOC-R1. For r ∈ {0.05, 0.025, 0.0125}, + P_r(B4) ≤ P_r(E1) + P_r(E2) + ≤ C_RN(r)·( √Q_r(E1) + √Q_r(E2) ) ≤ r^3, +with every factor explicit and certified: + r = 0.05: P_r(B4) ≤ 1.22e-9 (r^3 = 1.25e-4; ratio 9.77e-6) + r = 0.025: P_r(B4) ≤ 1.52e-45 (r^3 = 1.56e-5; ratio 9.73e-41) + r = 0.0125: P_r(B4) ≤ 1.03e-197 (r^3 = 1.95e-6; ratio 5.28e-192) + +The chain of explicit factors: + +(3a) RN transfer (consumed theorem-grade, event-independent). H4-RN +(H4_CLOSURE body a67d50b9…, §3): P_r(F) ≤ C_RN(r)·√Q_r(F) for every event +F, C_RN(r) = √(E_Q[(det H_M det H_S)^2])/(c_Z r^2) ≤ 3.47 on the ladder +(numerator an exact Isserlis polynomial moment, denominator H3's closed +partition floor). Consumed as C_RN = 3.47; the driver fail-closes if the +consumed value drifts above it (mutation M3). + +(3b) Gaussian sup-tails under Q_r. Both E1 and E2 are sup-events of +centered Gaussian processes on compact parameter intervals: + E1 = { sup_{ζ∈(0,ξ0]} (−f_xx(q(ζ)) + h2(ζ)) ≥ h_min } (zone process + X1(ζ) = −f_xx(q(ζ)) − E_Q[f_xx(q(ζ))], threshold h_min = + inf_ζ E_Q[f_xx(q(ζ))] > 0), + E2 = { sup_{ξ∈[ξ0,1)} (s − f(q(ξ)) + u(ξ)) ≥ u_* } (X2(ξ) = + −(f(q(ξ)) − E_Q[f(q(ξ))]), threshold u_* = + inf_ξ (E_Q[f(q(ξ))] − s) > 0). +Borell–TIS (the Borell–Tsirelson–Ibragimov–Sudakov inequality): for a +centered continuous Gaussian process X on T with sup-standard-deviation +σ̄ and Dudley entropy expectation D, + Q(sup_T X ≥ m) ≤ exp( −(m − D)^2 / (2 σ̄^2) ), m ≥ D. +We take D = 2√2·J with J the Dudley integral (van Handel, APC 550, +Thm 5.12); with the canonical metric d(t,t') = sd(X_t − X_t') ≤ L·|t−t'| +the covering bound N(ε) ≤ L·T/(2ε) gives the closed form + J = ∫_0^{LT/2} √(ln(LT/(2ε))) dε = (LT/2)·∫_0^1 √(ln(1/u)) du + = L·T·√π/4. +All three constants (2√2, √π/4, the covering factor 1/2) are explicit. + +(3c) The conditional-law factors, all certified: + * CONDITIONING SHRINKS VARIANCE. For any linear functional L and the + 6-pin vector P, Var_Q(L) = Var(L) − Cov(L,P)^T A^{−1} Cov(L,P) + ≤ Var(L), A the pin covariance (inverted at dps = 100, residual + ≤ 6.2e-96 per rung). + * VARIATIONAL PRINCIPLE. For ANY explicit predictor a: Var_Q(L) ≤ + Var_uncond(L − a^T P). We use the cubic Hermite predictor H of the + pins (H(ξ) = s + ℓ(3ξ^2 − 2ξ^3) along the corridor, the smoothstep): + every variance and metric constant is computed as an EXACT + unconditional covariance of the explicit functional (f − H) and its + ξ-derivatives. Tightness: ŝ ≈ 2.1× the true conditional sd. + * PIN-LIKELIHOOD MEAN BOUNDS (the Λ_p trick). For any linear + functional g, |E_Q[g]| ≤ √(Var_uncond g)·√(p^T A^{−1} p) = √a_{2n}·Λ_p + with p the pin values; Λ_p^2 certified = 2.82666 (r = 0.05; 2.82667 on + the finer rungs) — the pin configuration is typical, so ALL conditional + means admit global O(1) bounds. Used for: the curvature-profile + 4th-derivative bound |d^4 E[f_xx]/dζ^4| ≤ r^4·Λ_p·√a_8, the value- + profile 2nd-derivative bound |u''| ≤ r^2·Λ_p·√a_4, and the corridor + Lipschitz corrections. + * COVARIANCE FACTORIZATION. Cov(∂^α f(x), ∂^β f(y)) = + (−1)^|β| K1^{(α1+β1)}(dx)·K1^{(α2+β2)}(dy); the corridor lies on the + x-axis, so every covariance entering the certificate is a 1-D K1 value + of order n ≤ 8, inside cov_exact's certified spectral-tail regime. + * SPECTRAL MOMENTS. a_{2m} = E[N(0,1)^{2m}] = (2m−1)!!: a_2 = 1, + a_4 = 3, a_6 = 15, a_8 = 105, with certified spectral tails for the + absolute moments through order 22 (used only in the crude remainder + bounds of (3d)). + * CERTIFIED GRID-TO-CONTINUUM TRANSFER. Margins: pointwise-exact + (value, first derivative) on the grid + a global Λ_p second-derivative + bound at O(g^2). Variance suprema: the FULL 8-level pointwise-exact + Taylor chain of Var(F(ξ)) — d^n/dξ^n Var(F) = Σ_{i+j=n} c_{ij} + Cov(F_i, F_j) with Leibniz coefficients (2, 2, 6, 8, 6, 10, 20, 12, + 30, 20, 14, 42, 70, 16, 56, 112, 70 …) — every covariance within the + order-8 cap, the isolated over-cap pairs bounded by the crude + spectral-product bound, and the 9th-derivative remainder bounded + globally by the coefficient-sum 2^9 = 512 times the crude products at + the O(g^9/9!) level (negligible: ≤ 1e-23). + +(3d) Certified numbers per rung (driver transcript, both modes +byte-identical): + + r = 0.05 (Λ_p^2 = 2.82666): + Z1: h_min = 0.024593 (0.4919·r), σ̄1 = 0.002201 (0.8803·r^2), + L1 = 0.0129, D1 = 0.00406, kap1 = 9.3312 ⇒ Q(E1) ≤ exp(−43.536) + Z2: u_* = 2.9342e-6 (0.1408·ℓ), σ̄2 = 1.668e-7 (0.008007·ℓ), + L2 = 5.14e-7, D2 = 4.83e-7, kap2 = 14.692 ⇒ Q(E2) ≤ exp(−107.93) + P_r(B4) ≤ 3.47·√(e^{−43.536} + e^{−107.93}) = 1.22e-9 + r = 0.025: kap1 = 20.439 (exp −208.88), kap2 = 30.762 (exp −473.16), + P ≤ 1.52e-45. r = 0.0125: kap1 = 42.653 (exp −909.65), + kap2 = 57.793 (exp −1670.0), P ≤ 1.03e-197. + +## 4. GRADE: BETTER THAN O(r^3) — THE BOUND IS O(exp(−c/r^2)) + +The o(r^3) threshold form (H4 §3.5) requires margin/sd ≥ √(12 ln(1/r) + +4 ln C_RN + 2 ln 2) = 6.50 at r = 0.05. The certified margins are +kap1 = 9.33 and kap2 = 14.69 at r = 0.05, and BOTH GROW like 1/r (§6): +the certificate is not merely o(r^3) but + P_r(B4) ≤ exp( −c_eff / r^2 ), c_eff = −r^2 ln P_bound + = 0.0513, 0.0645, 0.0709 on the ladder (increasing), +an exponentially small bound — the strongest grade the RN square-root +transfer can express. The registered B4.loc dam line is closed at +validity grade, covering B4.rem as well (B4.rem's PERC consumption is +discharged for the O(r^3) validity grade: the inclusion of §2 does not +distinguish loc from rem). + +## 5. THE H4-SD DISTINCTION (verified, not assumed) + +H4-SD's C^0-impossibility applies to the B1.dir slice: there the away +branch rides M's lineage at EVERY window level, so any separating cut must +leave the rigid ridge, where sd_res = Θ(d^2) dwarfs the window ℓ — the +certified margins were 0.55/0.054/−0.022 against threshold 6.5: vacuous. +The B4 dam line is the OPPOSITE geometry: a C^0 VALUE/CURVATURE event on a +FIXED corridor at the PIN level s, and the cheapest cut lives ON the rigid +ridge (kappa_* ≈ 48 = Θ(1/r) at r = 0.05 — C2 §4's registered law). The +C^1-necessity finding of H4-SD constrains the B1.dir event, a different +event; it is not a constraint on this certificate. Verified independently +in the driver: the corridor profile E_Q[f(q(ξ))] − s is strictly increasing +from 0 to b − s (the high channel is a narrow axial ridge, C2 P2), the +margins above are ON-ridge margins. + +## 6. SCALE-INVARIANCE DISPLAY (extension of the kappa_dam display to the +## B4.loc tube) + +Certified on the ladder {0.05, 0.025, 0.0125}: + kap1 (curvature zone): 9.3312, 20.439, 42.653; halving ratios + 0.4565, 0.4792; kap1·r = 0.4666, 0.511, 0.5332 + kap2 (value corridor): 14.692, 30.762, 57.793; halving ratios + 0.4776, 0.5323; kap2·r = 0.7346, 0.7691, 0.7224 +i.e. BOTH zone margins are Θ(1/r) (the C2 §4 law kappa_* = Θ(1/r)), +contrasting with the 9-pin tube's scale-invariant kappa_dam = Θ(1) +(identification axis (iv), §1). The κ·r constants are r-independent up to +the slowly-varying entropy composition (windowed and fail-closed in the +driver: kap1·r ∈ (0.4, 0.65), kap2·r ∈ (0.6, 1.6), halving ratios within +0.075 of 1/2, c_eff ∈ (0.04, 1.2)). + +## 7. THE DISCRETE MIRROR (B1's frozen PL model) + +The inclusion "clear corridor ⇒ ¬B4" is mirrored exactly in B1's frozen +piecewise-linear lattice ensemble (b1_falsifier.py 818df798…): for each of +the 40 frozen ensemble fields (427 close pairs, cheb ≤ 4), each registered +synthetic pair, and 2 carved close-pair B4 witnesses (the ensemble contains +no close B4 pair), the deterministic hex-greedy M-ward path from S is +audited: 3 B4 pairs audited (0 ensemble + 3 synthetic), EVERY B4 corridor +CUT (0 violations); 387 pairs with a clear corridor (categories +{A: 154, B1: 1, B2: 66, success: 163}), none of them B4; 0 pairs with no +greedy hex path. The mirror fail-closes on any violation. + +## 8. FALSIFIER AND MUTATION SUITE + +b4loc_falsifier.py (both modes byte-identical): F1 re-runs the driver +fresh and pins its digest to the frozen expectation; F2 drives the +mutation suite at r = 0.05, each mutation must exit 1 with its registered +firing string: + M1 weaken-margin (margins × 1/2): fires the o(r^3) gate + (P_bound = 0.104 > r^3 = 1.25e-4, ratio 835); + M2 widen-tube (σ̄, D × 2): fires the o(r^3) gate (same assembly); + M3 rn (C_RN × 2): fires the RN-drift gate ("consumed RN factor + drifted above H4-RN's certified C_RN = 3.47"). +F3 verifies the mutation tags (no silent normal runs). A weakened margin +or widened tube therefore fails CLOSED, as required. + +==================================================================== +END_FROZEN_BODY +==================================================================== + +Freeze record (outside the frozen body): see FREEZE.txt — body hash, +artifact hashes, transcripts, digests. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt new file mode 100644 index 000000000..a515a7460 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt @@ -0,0 +1,19 @@ +B4LOC dam-line freeze record (artifact B4LOC-R1-20260914-v1.0) + +frozen body: B4LOC_DAMLINE.md, lines strictly between BEGIN/END_FROZEN_BODY, + exactly one terminal LF, last content line directly preceding END marker +body bytes: 13503 +body sha256: 0d5c1b3284374f3a2f7630b7f603a71c77f5ec9417fe4579aaac03becd33c05e + +sha256 ae4c9c82784aecfbd85056c316f792a331bccb774d952887fc5fe8ea7da615b4 B4LOC_DAMLINE.md +sha256 bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02 b4loc_driver.py +sha256 d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f b4loc_falsifier.py +sha256 11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 t_normal.txt +sha256 11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53 t_opt.txt +sha256 1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c tf_normal.txt +sha256 1629de83bda724f5a0d971ddd895771ea3db1a2ec7ca462181030c0a952f1a2c tf_opt.txt + +cmp t_normal.txt t_opt.txt -> byte-identical (verified) +cmp tf_normal.txt tf_opt.txt -> byte-identical (verified) +B4LOC-DRIVER DIGEST 43ff9c1ebfa9cf8f27c06e27e844030e8378e439e89bdd374949166a1a490a1b +B4LOC-FALSIFIER DIGEST f939eeab4805b9c5b35fb40f0f173b4a4ad8237fdcd15ad53084569c6fbffe55 diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt new file mode 100644 index 000000000..7681809cf --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt @@ -0,0 +1,632 @@ +#!/usr/bin/env python3 +# b4loc_driver.py -- the B4 dam-line certificate driver (STAGE E, validity +# premise of Theorem (2) v2.2; artifact B4LOC-R1-20260914-v1.0). +# +# THE CERTIFICATE (B4LOC_DAMLINE.md): with q(xi) = S + r*xi*(-1,0) the axial +# corridor from S (xi=0) to M (xi=1), xi0 = 1/4, +# B4 subset E1 uu E2 (pathwise event inclusion, C0; mirrored in the +# discrete model in D6), where +# E1 = {exists zeta in (0,xi0]: f_xx(q(zeta)) <= 0} (curvature zone: +# f(q(xi))-s = (r*xi)^2 * int_0^1 (1-t) f_xx(q(t xi)) dt) +# E2 = {exists xi in [xi0,1]: f(q(xi)) <= s} (value corridor) +# Each zone's Q_r-probability is bounded by Borell-Tsirelson with Dudley's +# entropy bound: +# Q(sup Y >= m) <= exp(-(m - D)^2 / (2 sb^2)), m > D, +# with +# margin m : certified lower bound on the CONDITIONED-MEAN profile +# (pointwise exact on a grid + inter-grid control by the +# pin-likelihood bound |E[g|pins]| <= Lp * sqrt(Var g), +# Lp^2 = p^T A^-1 p, Cauchy-Schwarz in the pin inner product); +# sb^2 : certified upper bound on sup Var_Q(Y) by the VARIATIONAL +# principle Var(g|P) <= Var(g - a^T P) for any deterministic +# a, with a = the cubic-Hermite pin interpolant -- explicit +# UNCONDITIONAL covariances, no inversion-laden global bounds; +# D = 2*sqrt(2)*J: Dudley entropy bound (van Handel APC550 Thm 5.12 form) +# with J = L*T*sqrt(pi)/4 for a 1D interval of length T and +# Lipschitz metric d^2 <= L^2 (dx)^2 (variational again); +# RN factor : P_r(F) <= C_RN * sqrt(Q_r(F)), C_RN = 3.47, consumed from +# H4-RN (H4_CLOSURE.md body a67d50b9..., theorem-grade). +# Result per rung: P_r(B4) <= C_RN*sqrt(Q1+Q2) = exp(-Theta(1/r^2)) = o(r^3). +# +# Fail-closed: ck() -> SystemExit(1); no bare asserts (python -O safe); +# deterministic (fixed grids, mpmath dps=100, no randomness, no wall clock); +# normal and -O transcripts byte-identical (guarded by b4loc_falsifier.py). + +import hashlib +import os +import sys + +HERE = os.path.dirname(os.path.abspath(__file__)) +H2 = os.path.join(HERE, '..', 'H2_foundations') +B1DIR = os.path.join(HERE, '..', 'B1_taxonomy') +sys.path.insert(0, os.path.abspath(H2)) +sys.path.insert(0, os.path.abspath(B1DIR)) + +_EXPECT = { + 'cov_exact.py': 'f08c1c5f653f2ffd2e85d39e1112f80d15db04d15f932e5ee42db2ca3553e783', +} + + +def ck(cond, msg): + if not cond: + print("B4LOC-DRIVER FAIL-CLOSED FIRING:", msg) + raise SystemExit(1) + + +def _sha256(path): + with open(path, 'rb') as fh: + return hashlib.sha256(fh.read()).hexdigest() + + +for _name, _h in sorted(_EXPECT.items()): + _p = os.path.join(H2, _name) + ck(os.path.exists(_p), "missing shared library %s" % _p) + ck(_sha256(_p) == _h, "hash mismatch for %s (freeze-before-consume)" % _name) + +import cov_exact as ce # sets mpmath dps=100 on import +ce.configure(dps=100) +import mpmath +from mpmath import mp, mpf + +B = mpf(6) / 5 +XI0 = mpf('0.25') # zone boundary (curvature zone (0,XI0], value [XI0,1]) +C_RN = mpf('3.47') # H4-RN's certified RN factor (theorem grade) +SQRT2 = mpmath.sqrt(2) +DUDLEY_C = 2 * SQRT2 # Dudley constant (van Handel APC550 Thm 5.12) +JCONST = mpmath.sqrt(mp.pi) / 4 # int_0^1 sqrt(ln(1/u)) du / 2 = sqrt(pi)/4 + +IDX = {'f': (0, 0), 'fx': (1, 0), 'fy': (0, 1), 'fxx': (2, 0), 'fxy': (1, 1), + 'fyy': (0, 2), 'fxxx': (3, 0), 'fxxy': (2, 1), 'fxyy': (1, 2), + 'fyyy': (0, 3), 'fxxxx': (4, 0), 'fxxxy': (3, 1), 'fxxyy': (2, 2), + 'fxyyy': (1, 3), 'fyyyy': (0, 4), 'fxxxxx': (5, 0), + 'fxxxxxx': (6, 0), 'fxxxxxxx': (7, 0), 'fxxxxxxxx': (8, 0), + 'fxxxxxxxxx': (9, 0), 'fxxxxxxxxxx': (10, 0), 'fxxxxxxxxxxx': (11, 0)} +JET6 = ['f', 'fx', 'fy', 'fxx', 'fxy', 'fyy'] + +DIG = [] + + +def emit(line): + print(line) + DIG.append(line) + + +def ns(x, n=6): + return mpmath.nstr(x, n) + + +# --------------------------------------------------------------------------- +# memoized 1D kernel (all corridor covariances are axial: cov = K1(n1,d)K1(n2,0)) +# --------------------------------------------------------------------------- +_K1CACHE = {} + + +def k1m(n, d): + key = (n, mpmath.nstr(d, 30)) + if key not in _K1CACHE: + _K1CACHE[key] = ce.k1(n, d) + return _K1CACHE[key] + + +def covm(a, b, dx, dy): + v = k1m(a[0] + b[0], dx) * k1m(a[1] + b[1], dy) + if (b[0] + b[1]) % 2 == 1: + v = -v + return v + + +# --------------------------------------------------------------------------- +# absolute 1D spectral moments (global covariance suprema), certified tails +# --------------------------------------------------------------------------- +def abs_moment(n): + h = mp.pi / 12 + J = int(mp.ceil(30 / h)) + 1 + tot = mpf(0) + z1 = mpf(0) + for j in range(-J, J + 1): + k = j * h + w = mpmath.exp(-k**2 / 2) + tot += (abs(k)**n) * w + z1 += w + tail = ce.spectral_tail_1d(n) if n <= 8 else _tail9(n) + return tot / z1 + tail + + +def _tail9(n): + # same geometric-series bound as ce.spectral_tail_1d, for n > 8 + h = mp.pi / 12 + J = int(mp.ceil(30 / h)) + 1 + J0 = J + 1 + k0 = J0 * h + rho = mpmath.exp(-(2 * J0 + 1) * h * h / 2) * (1 + mpf(1) / J0)**n + ck(rho < 1, "spectral tail ratio rho >= 1 for n=%d" % n) + t0 = mpmath.exp(-k0**2 / 2) * k0**n + return 2 * t0 / (1 - rho) + + +# --------------------------------------------------------------------------- +# Hermite weights along the corridor (in xi; d/dxi = -r d/dx) +# --------------------------------------------------------------------------- +def hwts(xi): + t = xi + return (2*t**3 - 3*t**2 + 1, t**3 - 2*t**2 + t, + -2*t**3 + 3*t**2, t**3 - t**2) + + +def hwts_d(xi): + t = xi + return (6*t**2 - 6*t, 3*t**2 - 4*t + 1, -6*t**2 + 6*t, 3*t**2 - 2*t) + + +def hwts_dd(xi): + t = xi + return (12*t - 6, 6*t - 4, -12*t + 6, 6*t - 2) + + +class Kit6: + """The 6-pin law Q_r (axial pins); pointwise certified moments.""" + def __init__(self, r): + self.r = r = mpf(r) + self.ell = r**3 / 6 + self.s = B - self.ell + self.M = (-r / 2, mpf(0)) + self.S = (r / 2, mpf(0)) + A = mp.zeros(6, 6) + for a_, pa in enumerate([self.M, self.S]): + for b_, pb in enumerate([self.M, self.S]): + for ia in range(3): + for ib in range(3): + A[3*a_+ia, 3*b_+ib] = covm(IDX[JET6[ia]], IDX[JET6[ib]], + pa[0]-pb[0], pa[1]-pb[1]) + self.A = A + self.Ainv = A ** -1 + Ires = A * self.Ainv - mp.eye(6) + self.pinres = max(abs(Ires[i, j]) for i in range(6) for j in range(6)) + ck(self.pinres < mpf('1e-40'), + "pin inversion residual %s" % ns(self.pinres, 3)) + self.pv = mp.matrix([B, 0, 0, self.s, 0, 0]) + self.Lp2 = (self.pv.T * self.Ainv * self.pv)[0, 0] + self.Lp = mpmath.sqrt(self.Lp2) + + def q(self, xi): + return (self.r / 2 - self.r * xi, mpf(0)) + + def cross(self, x, names): + Bm = mp.zeros(6, len(names)) + for j, P in enumerate([self.M, self.S]): + for k in range(3): + for i, dn in enumerate(names): + Bm[3*j+k, i] = covm(IDX[JET6[k]], IDX[dn], + P[0]-x[0], P[1]-x[1]) + return Bm + + def law(self, x, names): + Bm = self.cross(x, names) + C = mp.zeros(len(names), len(names)) + for i, di in enumerate(names): + for j, dj in enumerate(names): + C[i, j] = covm(IDX[di], IDX[dj], mpf(0), mpf(0)) + BmA = Bm.T * self.Ainv + return BmA * self.pv, C - BmA * Bm + + # -- explicit (unconditional) Hermite-error functionals on the corridor -- + def spec(self, xi, name): + """Term list (point, jet, weight) of the explicit functional: + E_k = d^k/dxi^k [(f-H)(q(xi))] (H the cubic pin-Hermite); + C_k = E_{k+2}/r^2 (curvature-zone scalings).""" + r = self.r + h = hwts(xi) + hd = hwts_d(xi) + hdd = hwts_dd(xi) + hddd = (mpf(12), mpf(6), mpf(-12), mpf(6)) + if name == 'E0': + return [(self.q(xi), 'f', mpf(1)), (self.S, 'f', -h[0]), + (self.S, 'fx', r * h[1]), (self.M, 'f', -h[2]), + (self.M, 'fx', r * h[3])] + if name == 'E1': + return [(self.q(xi), 'fx', -r), (self.S, 'f', -hd[0]), + (self.S, 'fx', r * hd[1]), (self.M, 'f', -hd[2]), + (self.M, 'fx', r * hd[3])] + if name == 'E2': + return [(self.q(xi), 'fxx', r**2), (self.S, 'f', -hdd[0]), + (self.S, 'fx', r * hdd[1]), (self.M, 'f', -hdd[2]), + (self.M, 'fx', r * hdd[3])] + if name == 'E3': + return [(self.q(xi), 'fxxx', -r**3), (self.S, 'f', -hddd[0]), + (self.S, 'fx', r * hddd[1]), (self.M, 'f', -hddd[2]), + (self.M, 'fx', r * hddd[3])] + if name[0] == 'E' and 4 <= int(name[1:]) <= 11: + k = int(name[1:]) + return [(self.q(xi), 'f' + 'x' * k, (-r)**k)] + if name[0] == 'C': + k = int(name[1]) + return [(p, d, w / r**2) for (p, d, w) in self.spec(xi, 'E%d' % (k + 2))] + ck(False, "unknown spec %s" % name) + + def paircov(self, ta, tb): + """Cov(spec A, spec B) -- unconditional, exact (total order <= 8).""" + v = mpf(0) + for (pa, da, wa) in ta: + for (pb, db, wb) in tb: + v += wa * wb * covm(IDX[da], IDX[db], pa[0]-pb[0], pa[1]-pb[1]) + return v + + def pcap(self, ta, tb): + """|Cov(ta, tb)| bound: exact if within the order cap, else the + crude spectral-product bound (always an upper bound).""" + mo = max(IDX[da][0] + IDX[da][1] + IDX[db][0] + IDX[db][1] + for (pa, da, wa) in ta for (pb, db, wb) in tb) + if mo <= 8: + return self.paircov(ta, tb) + return mpmath.sqrt(self.crudeW_terms(ta) * self.crudeW_terms(tb)) + + def crudeW_terms(self, terms): + tot = mpf(0) + for (pa, da, wa) in terms: + ia = IDX[da] + for (pb, db, wb) in terms: + ib = IDX[db] + tot += abs(wa * wb) * ah_g[ia[0] + ib[0]] * ah_g[ia[1] + ib[1]] + return tot + + def crudeW(self, xi, name, ah=None): + """Crude global sup of Var(spec) via |weight| sups and absolute + spectral moments (valid at every xi).""" + return self.crudeW_terms(self.spec(xi, name)) + + +def grid_sup4(vals, d1, d2, d3, G4, g): + """Certified sup of a smooth function on a uniform grid: pointwise value + vals, derivatives d1..d3 (mixed exact/crude-upper); global |4th + derivative| bound G4 (crude); spacing g. + sup <= max(vals + g|d1| + g^2/2 |d2| + g^3/6 |d3|) + g^4 G4/24.""" + return max(v + g * abs(a) + g**2 * abs(b2) / 2 + g**3 * abs(c) / 6 + for v, a, b2, c in zip(vals, d1, d2, d3)) + g**4 * G4 / 24 + + +# derivative coefficients of Var(F): d^n/dxi^n Var(F) = sum_{i+j=n} c^{(n)}_{ij} +# Cov(F_i, F_j); the c coefficients from the Leibniz recursion (symmetric): +VDER = [ + [(0, 0, 1)], + [(0, 1, 2)], + [(1, 1, 2), (0, 2, 2)], + [(0, 3, 2), (1, 2, 6)], + [(0, 4, 2), (1, 3, 8), (2, 2, 6)], + [(0, 5, 2), (1, 4, 10), (2, 3, 20)], + [(0, 6, 2), (1, 5, 12), (2, 4, 30), (3, 3, 20)], + [(0, 7, 2), (1, 6, 14), (2, 5, 42), (3, 4, 70)], + [(0, 8, 2), (1, 7, 16), (2, 6, 56), (3, 5, 112), (4, 4, 70)], +] + + +def varsup(kit, base, xis, g): + """Certified sup of Var(F(xi)) over the continuum grid (spacing g), + F = spec(base), F_k = spec(base+k). Uses the pointwise-exact Taylor + chain through order 8 (all covariances within the order-8 cap, with + pcap's crude fallback for isolated over-cap pairs) and a crude global + 9th-derivative remainder bound at the g^9/9! level.""" + b0, k0 = base[0], int(base[1]) + terms = [[kit.spec(xi, '%s%d' % (b0, k0 + i)) for i in range(10)] + for xi in xis] + C = [[[kit.pcap(t[i], t[j]) if i <= j else None + for j in range(9)] for i in range(9)] for t in terms] + + def cij(pt, i, j): + a, b = (i, j) if i <= j else (j, i) + return C[pt][a][b] + + ders = [] + for n in range(9): + ders.append([sum(cf * cij(pt, i, j) for (i, j, cf) in VDER[n]) + for pt in range(len(xis))]) + # crude global 9th-derivative remainder bound (coefficient sums of the + # Leibniz chain are 2^n; every term bounded by sqrt(W_i W_j)) + W = [max(kit.crudeW_terms(t[i]) for t in terms) for i in range(10)] + G9 = mpf(512) * max(mpmath.sqrt(W[i] * W[9 - i]) for i in range(10)) + sup = max(sum(g**n * abs(ders[n][pt]) / mpmath.factorial(n) + for n in range(9)) for pt in range(len(xis))) \ + + g**9 * G9 / mpmath.factorial(9) + return sup + + +def rung(r, scales, gates=True): + sc_m, sc_s, sc_d, sc_rn = scales + kit = Kit6(r) + emit(" r=%s: pin inversion residual %s; Lp^2 = p^T A^-1 p = %s (the" + " pin-likelihood statistic)" % (ns(r, 6), ns(kit.pinres, 2), + ns(kit.Lp2, 6))) + a2, a4, a6, a8 = (ce.moment_a(1), ce.moment_a(2), ce.moment_a(3), + ce.moment_a(4)) + global ah_g + ah_g = ah = {n: abs_moment(n) for n in range(23)} + # global mean-derivative bounds via the pin-likelihood statistic + U1 = kit.Lp * mpmath.sqrt(a2) # |E[f_x|pins]| + U3 = kit.Lp * mpmath.sqrt(a6) # |E[f_xxx|pins]| + U4 = kit.Lp * mpmath.sqrt(a8) # |E[f_xxxx|pins]| + + # ---- Z1: curvature zone (0, XI0] ------------------------------------- + N1 = 49 + g1 = XI0 / (N1 - 1) + h2g, h3g = [], [] + xis1 = [] + for i in range(N1): + z = g1 * i + xis1.append(z) + mu, cov = kit.law(kit.q(z), ['fxx', 'fxxx']) + h2g.append(mu[0]) + h3g.append(abs(mu[1])) + # certified inf of the mean curvature over the zone (pointwise (h2,h3) + # plus the global 4th-derivative bound via the pin-likelihood statistic) + h_min = min(h2g[i] - g1 * r * h3g[i] for i in range(N1)) \ + - g1**2 * r**2 * U4 / 2 + sb1 = mpmath.sqrt(varsup(kit, 'C0', xis1, g1)) + L1 = mpmath.sqrt(varsup(kit, 'C1', xis1, g1)) + D1 = DUDLEY_C * L1 * XI0 * JCONST + m1 = sc_m * h_min + sb1s, D1s = sc_s * sb1, sc_d * D1 + kap1 = (m1 - D1s) / sb1s + ck(kap1 > 0, "Z1 margin swallowed by entropy: kap1=%s" % ns(kap1, 4)) + Q1 = mpmath.exp(-kap1**2 / 2) + emit(" Z1 curvature zone (0,%s]: h_min=%s (~%s*r), sd_bar=%s (~%s*r^2)," + " L1=%s, D1=%s, kap1=%s -> Q1<=exp(-%s)" + % (ns(XI0, 3), ns(h_min, 5), ns(h_min / r, 4), ns(sb1, 4), + ns(sb1 / r**2, 4), ns(L1, 3), ns(D1, 3), ns(kap1, 5), + ns(kap1**2 / 2, 5))) + + # ---- Z2: value corridor [XI0, 1] ------------------------------------- + N2 = 121 + g2 = (1 - XI0) / (N2 - 1) + ug, upg = [], [] + xis2 = [] + for i in range(N2): + x = XI0 + g2 * i + xis2.append(x) + mu, cov = kit.law(kit.q(x), ['f', 'fx']) + ug.append(mu[0] - kit.s) + upg.append(abs(-r * mu[1])) # |d/dxi (mu-s)|, pointwise exact + # certified continuum inf: pointwise (u, u') + global 2nd-derivative bound + U2 = r**2 * kit.Lp * mpmath.sqrt(a4) # |u''| = r^2|E[f_xx|pins]| + u_star = min(ug[i] - g2 * upg[i] for i in range(N2)) - g2**2 * U2 / 2 + sb2 = mpmath.sqrt(varsup(kit, 'E0', xis2, g2)) + L2 = mpmath.sqrt(varsup(kit, 'E1', xis2, g2)) + D2 = DUDLEY_C * L2 * (1 - XI0) * JCONST + m2 = sc_m * u_star + sb2s, D2s = sc_s * sb2, sc_d * D2 + kap2 = (m2 - D2s) / sb2s + ck(kap2 > 0, "Z2 margin swallowed by entropy: kap2=%s" % ns(kap2, 4)) + Q2 = mpmath.exp(-kap2**2 / 2) + emit(" Z2 value corridor [%s,1]: u_*=%s (~%s*ell), sd_bar=%s (~%s*ell)," + " L2=%s, D2=%s, kap2=%s -> Q2<=exp(-%s)" + % (ns(XI0, 3), ns(u_star, 5), ns(u_star / kit.ell, 4), ns(sb2, 4), + ns(sb2 / kit.ell, 4), ns(L2, 3), ns(D2, 3), ns(kap2, 5), + ns(kap2**2 / 2, 5))) + + # ---- assembly ---------------------------------------------------------- + Q = Q1 + Q2 + crn = C_RN * sc_rn + ck(crn <= C_RN, "consumed RN factor drifted above H4-RN's certified" + " C_RN = 3.47 (mutation M3 fires)") + Pb = crn * mpmath.sqrt(Q) + emit(" assembly: Q1+Q2 = %s; P_r(B4) <= C_RN*sqrt(Q1+Q2) = %s vs" + " r^3 = %s (ratio %s)" + % (ns(Q, 3), ns(Pb, 3), ns(r**3, 3), ns(Pb / r**3, 3))) + if gates: + ck(Pb <= r**3, "certificate bound fails the o(r^3) gate at r=%s" + % ns(r, 4)) + return dict(r=r, kap1=kap1, kap2=kap2, Pb=Pb, h_min=h_min, u_star=u_star, + sb1=sb1, sb2=sb2, D1=D1, D2=D2, Q1=Q1, Q2=Q2) + + +def mirror(): + """D6: the event inclusion mirrored in B1's frozen PL model: + a clear lattice corridor (interior vertices all above key(S)) implies + NOT B4; equivalently every B4 pair's corridor is cut.""" + import b1_falsifier as B1F + b1h = _sha256(os.path.join(B1DIR, 'b1_falsifier.py')) + ck(b1h == '818df7985412071259345455c9ff6b68cad0c0fa9d636009cf8849b550154185', + "b1_falsifier drift (freeze-before-consume)") + N, RING = B1F.N, B1F.RING + + def hexpath(f, Sv, Mv): + mi, mj = divmod(Mv, N) + # start: the higher neighbor of Sv closest (hex-greedy) to Mv + def dist(v): + vi, vj = divmod(v, N) + di = (vi - mi + N // 2) % N - N // 2 + dj = (vj - mj + N // 2) % N - N // 2 + # hex distance for RING = [(1,0),(1,1),(0,1),(-1,0),(-1,-1),(0,-1)] + if di * dj >= 0: + return abs(di) + abs(dj) + return max(abs(di), abs(dj)) + kS = f.key(Sv) + cand = [w for w in RING[Sv] if f.key(w) > kS] + if not cand: + return None + cur = min(cand, key=lambda w: (dist(w), w)) + path = [cur] + seen = {Sv, cur} + while cur != Mv and len(path) < 4 * N: + nxt = [w for w in RING[cur] if w not in seen and dist(w) < dist(cur)] + if not nxt: + nxt = [w for w in RING[cur] if w not in seen] + if not nxt: + return None + cur = min(nxt, key=lambda w: (dist(w), w)) + path.append(cur) + seen.add(cur) + return path if cur == Mv else None + + nB4, nclear, nviol, nopath = 0, 0, 0, 0 + nB4ens, nB4syn = 0, 0 + catclear = {} + + def b4_synthetics(): + """Two carved close-pair B4 witnesses (the frozen ensemble contains + no close B4 pair): a low wall cuts the M-ward corridor.""" + N_ = B1F.N + out = [] + + def build(tag, Mv_ij, Sv_ij, arms, wall): + f = B1F.base_field(tag) + c = B1F.carve + c(f, *Mv_ij, 10.0) # Mv, isolated + c(f, *Sv_ij, 6.0) # Sv + for (ij, h, top_ij, top_h) in arms: + c(f, *ij, h) + c(f, *top_ij, top_h) + for ij in wall: + c(f, *ij, 3.0) # low wall cutting the M-ward corridor + return f, Mv_ij[0] * N_ + Mv_ij[1], Sv_ij[0] * N_ + Sv_ij[1] + + out.append(build("R1-B4a", (10, 10), (10, 13), + [((10, 12), 7.0, (11, 12), 8.0), + ((9, 13), 7.0, (8, 13), 9.0)], + [(10, 11), (9, 11), (11, 11), (9, 12), (11, 13), + (10, 14), (9, 14), (11, 14)])) + out.append(build("R1-B4b", (20, 20), (20, 23), + [((20, 22), 7.0, (21, 22), 8.5), + ((19, 23), 7.0, (18, 24), 9.5)], + [(20, 21), (19, 21), (21, 21), (19, 22), (21, 23), + (20, 24), (19, 24), (21, 24), (18, 23), (19, 25)])) + return out + for seed in range(40): + f = B1F.fourier_field(1000 + seed, "ens-%d" % seed, + ridge=(seed % 3 == 0)) + dpf, dlf = B1F.persistence(f) + maxima = [v for v in range(B1F.V) if B1F.is_local_max(f, v)] + saddles = [v for v in range(B1F.V) if not B1F.is_local_max(f, v) + and len(B1F.upper_link_clusters(f, v)) >= 2] + for Mv in sorted(maxima): + for Sv in sorted(saddles): + if not f.gt(Mv, Sv) or B1F.cheb(Mv, Sv) > 4: + continue + outcome, category = B1F.classify_pair(f, Mv, Sv, dpf, dlf) + path = hexpath(f, Sv, Mv) + if path is None: + nopath += 1 + continue + clear = all(f.key(w) > f.key(Sv) for w in path) + if clear: + nclear += 1 + cl = category if category is not None else 'success' + catclear[cl] = catclear.get(cl, 0) + 1 + ck(category != 'B4', + "field %s pair (%d,%d): clear corridor but category B4" + " -- the event inclusion is violated" % (f.tag, Mv, Sv)) + if category == 'B4': + nB4 += 1 + nB4ens += 1 + ck(not clear, + "field %s pair (%d,%d): B4 corridor NOT cut" + % (f.tag, Mv, Sv)) + for f, Mv, Sv, expected in B1F.synthetic_fields(): + dpf, dlf = B1F.persistence(f) + outcome, category = B1F.classify_pair(f, Mv, Sv, dpf, dlf) + if expected == 'success': + ck(outcome == 'success', "synthetic %s outcome drift" % f.tag) + else: + ck(outcome == 'failure' and category == expected, + "synthetic %s category drift" % f.tag) + path = hexpath(f, Sv, Mv) + if path is None: + nopath += 1 + continue + clear = all(f.key(w) > f.key(Sv) for w in path) + if clear: + nclear += 1 + ck(category != 'B4', "synthetic %s: clear corridor but B4" % f.tag) + if category == 'B4': + nB4 += 1 + nB4syn += 1 + ck(not clear, "synthetic %s: B4 corridor NOT cut" % f.tag) + for f, Mv, Sv in b4_synthetics(): + dpf, dlf = B1F.persistence(f) + outcome, category = B1F.classify_pair(f, Mv, Sv, dpf, dlf) + ck(outcome == 'failure' and category == 'B4', + "carved %s not a B4 pair (outcome %s, category %s)" + % (f.tag, outcome, category)) + path = hexpath(f, Sv, Mv) + ck(path is not None, "carved %s: no greedy hex path" % f.tag) + clear = all(f.key(w) > f.key(Sv) for w in path) + nB4 += 1 + nB4syn += 1 + ck(not clear, "carved %s: B4 corridor NOT cut" % f.tag) + emit(" D6 discrete mirror (event inclusion): %d B4 pairs audited" + " (%d ensemble + %d synthetic), every B4 corridor CUT (0" + " violations); %d pairs with a clear corridor (categories %s)," + " none B4; %d pairs with no greedy hex path" + % (nB4, nB4ens, nB4syn, nclear, + {k: v for k, v in sorted(catclear.items())}, nopath)) + ck(nB4 >= 3, "mirror evidence too thin: only %d B4 pairs" % nB4) + return nB4, nclear + + +def main(): + scales = (mpf(1), mpf(1), mpf(1), mpf(1)) + mut = None + rungs = ['0.05', '0.025', '0.0125'] + args = sys.argv[1:] + if '--mut' in args: + mut = args[args.index('--mut') + 1] + if '--rungs' in args: + rungs = args[args.index('--rungs') + 1].split(',') + if mut == 'weaken-margin': + scales = (mpf('0.5'), mpf(1), mpf(1), mpf(1)) + elif mut == 'widen-tube': + scales = (mpf(1), mpf(2), mpf(2), mpf(1)) + elif mut == 'rn': + scales = (mpf(1), mpf(1), mpf(1), mpf(2)) + ck(mut in (None, 'weaken-margin', 'widen-tube', 'rn'), + "unknown mutation %s" % mut) + emit("B4 dam-line certificate driver (artifact B4LOC-R1-20260914-v1.0)%s" + % (" [MUTATION: %s]" % mut if mut else "")) + emit("D0 library: cov_exact hash-pinned; K1(0)=%s; two-impl spot check:" + % ns(ce.k1(0, 0), 3)) + v1, v2 = ce.k1(2, mpf('0.37'), impl='spectral'), ce.k1(2, mpf('0.37'), + impl='image') + ck(abs(v1 - v2) < mpf('1e-60'), "two-impl k1 drift: %s" % ns(abs(v1 - v2), 2)) + emit(" k1(2,0.37) spectral vs image agree to %s" % ns(abs(v1 - v2), 2)) + res = [] + for rs in rungs: + emit("rung r=%s:" % rs) + res.append(rung(mpf(rs), scales, gates=True)) + if mut is None and len(res) >= 2: + emit("kappa ladders (scale-invariance display, certified moments):") + for key in ('kap1', 'kap2'): + vals = [x[key] for x in res] + ratios = [vals[i] / vals[i + 1] for i in range(len(vals) - 1)] + emit(" %s: %s | successive halving ratios %s (doubling per" + " halving = Theta(1/r))" % + (key, [ns(v, 5) for v in vals], [ns(q, 4) for q in ratios])) + for q in ratios: + ck(abs(q - mpf('0.5')) < mpf('0.075'), + "%s ladder off the 1/r law: ratio %s (halving the rung" + " must double kappa)" % (key, ns(q, 4))) + k1r = [x['kap1'] * x['r'] for x in res] + k2r = [x['kap2'] * x['r'] for x in res] + emit(" kap1*r = %s; kap2*r = %s (r-independent = the certified" + " margin exponent coefficient)" % + ([ns(v, 4) for v in k1r], [ns(v, 4) for v in k2r])) + for v in k1r: + ck(mpf('0.4') < v < mpf('0.65'), "kap1*r out of certified" + " window: %s (mutation M1/M2 fires)" % ns(v, 4)) + for v in k2r: + ck(mpf('0.6') < v < mpf('1.6'), "kap2*r out of certified window:" + " %s (mutation M1/M2 fires)" % ns(v, 4)) + cef = [-(x['r']**2) * mpmath.log(x['Pb']) for x in res] + emit(" effective exponents c_eff = -r^2 ln P_bound = %s" + % [ns(v, 4) for v in cef]) + for v in cef: + ck(mpf('0.04') < v < mpf('1.2'), + "effective exponent out of window: %s" % ns(v, 4)) + if mut is None: + emit("D6 discrete mirror of the event inclusion (B1's frozen PL" + " model):") + mirror() + digest = hashlib.sha256("\n".join(DIG).encode()).hexdigest() + print("B4LOC-DRIVER DIGEST", digest) + print("B4LOC-DRIVER: ALL CHECKS PASS (fail-closed, deterministic)") + + +if __name__ == '__main__': + main() diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt new file mode 100644 index 000000000..43436d7af --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt @@ -0,0 +1,87 @@ +#!/usr/bin/env python3 +"""B4LOC dam-line falsifier (artifact B4LOC-R1-20260914-v1.0). + +Re-runs the certificate driver fresh, pins its digest, and drives the +mutation suite. Every check fails closed (SystemExit(1)) and no bare +asserts are used (python -O safe). + +Checks: + F1: driver normal run: ALL CHECKS PASS + digest == the frozen expectation. + F2: mutation suite (single rung r = 0.05): + M1 weaken-margin (margins x 1/2) -> must fire the o(r^3) gate + M2 widen-tube (sd, entropy x 2) -> must fire the o(r^3) gate + M3 rn (C_RN x 2) -> must fire the RN-drift gate + each with exit code 1 and its registered firing string. + F3: mutation outputs carry the [MUTATION: ...] tag (no silent normal run). +""" +import hashlib +import os +import subprocess +import sys + +D = os.path.dirname(os.path.abspath(__file__)) +EXPECT_DIGEST = '43ff9c1ebfa9cf8f27c06e27e844030e8378e439e89bdd374949166a1a490a1b' +DRIVER_SHA256 = 'bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02' +MUTS = { + 'weaken-margin': 'certificate bound fails the o(r^3) gate', + 'widen-tube': 'certificate bound fails the o(r^3) gate', + 'rn': 'consumed RN factor drifted above H4-RN', +} +LOG = [] + + +def ck(c, m): + if not c: + print("B4LOC-FALSIFIER FAIL-CLOSED FIRING: " + m, flush=True) + raise SystemExit(1) + + +def emit(m): + print(m, flush=True) + LOG.append(m) + + +def run_driver(args): + env = dict(os.environ) + p = subprocess.run([sys.executable, '-u', + os.path.join(D, 'b4loc_driver.py')] + args, + capture_output=True, text=True, cwd=D, env=env) + return p.returncode, (p.stdout or '') + (p.stderr or '') + + +def main(): + emit("B4LOC dam-line falsifier (artifact B4LOC-R1-20260914-v1.0)") + dsha = hashlib.sha256(open(os.path.join(D, 'b4loc_driver.py'), + 'rb').read()).hexdigest() + ck(dsha == DRIVER_SHA256, + "b4loc_driver.py drift (freeze-before-consume): %s" % dsha) + emit("F0 driver file hash-pinned: %s" % dsha) + rc, out = run_driver([]) + ck(rc == 0, "driver normal run exit %d" % rc) + ck('ALL CHECKS PASS' in out, "driver normal run did not pass") + dig = None + for line in out.splitlines(): + if line.startswith('B4LOC-DRIVER DIGEST '): + dig = line.split()[-1] + ck(dig is not None, "driver digest missing") + ck(dig == EXPECT_DIGEST, + "driver digest drift: %s != frozen %s" % (dig, EXPECT_DIGEST)) + emit("F1 driver rerun: ALL CHECKS PASS, digest %s == frozen expectation" + % dig) + for m in sorted(MUTS): + rc, out = run_driver(['--rungs', '0.05', '--mut', m]) + ck(rc == 1, "mutation %s: exit %d (must fail closed)" % (m, rc)) + ck(MUTS[m] in out, "mutation %s: expected firing string missing" + % m) + ck('[MUTATION: %s]' % m in out, + "mutation %s: tag missing (silent normal run?)" % m) + emit("F2 mutation %-14s fires closed: %s" + % (m, [l for l in out.splitlines() if 'FAIL-CLOSED' in l][-1])) + emit("F3 mutation tags verified (no silent normal runs)") + digest = hashlib.sha256("\n".join(LOG).encode()).hexdigest() + emit("B4LOC-FALSIFIER DIGEST " + digest) + emit("B4LOC-FALSIFIER: ALL CHECKS PASS (fail-closed, deterministic)") + + +if __name__ == '__main__': + main() diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt new file mode 100644 index 000000000..e15f16bb5 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt @@ -0,0 +1,27 @@ +B4 dam-line certificate driver (artifact B4LOC-R1-20260914-v1.0) +D0 library: cov_exact hash-pinned; K1(0)=1.0; two-impl spot check: + k1(2,0.37) spectral vs image agree to 0.0 +rung r=0.05: + r=0.05: pin inversion residual 6.2e-96; Lp^2 = p^T A^-1 p = 2.82666 (the pin-likelihood statistic) + Z1 curvature zone (0,0.25]: h_min=0.024593 (~0.4919*r), sd_bar=0.002201 (~0.8803*r^2), L1=0.0129, D1=0.00406, kap1=9.3312 -> Q1<=exp(-43.536) + Z2 value corridor [0.25,1]: u_*=2.9342e-6 (~0.1408*ell), sd_bar=1.668e-7 (~0.008007*ell), L2=5.14e-7, D2=4.83e-7, kap2=14.692 -> Q2<=exp(-107.93) + assembly: Q1+Q2 = 1.24e-19; P_r(B4) <= C_RN*sqrt(Q1+Q2) = 1.22e-9 vs r^3 = 0.000125 (ratio 9.77e-6) +rung r=0.025: + r=0.025: pin inversion residual 3.3e-94; Lp^2 = p^T A^-1 p = 2.82667 (the pin-likelihood statistic) + Z1 curvature zone (0,0.25]: h_min=0.012267 (~0.4907*r), sd_bar=0.0005504 (~0.8806*r^2), L1=0.00325, D1=0.00102, kap1=20.439 -> Q1<=exp(-208.88) + Z2 value corridor [0.25,1]: u_*=3.5104e-7 (~0.1348*ell), sd_bar=1.043e-8 (~0.004005*ell), L2=3.21e-8, D2=3.02e-8, kap2=30.762 -> Q2<=exp(-473.16) + assembly: Q1+Q2 = 1.92e-91; P_r(B4) <= C_RN*sqrt(Q1+Q2) = 1.52e-45 vs r^3 = 1.56e-5 (ratio 9.73e-41) +rung r=0.0125: + r=0.0125: pin inversion residual 3.1e-92; Lp^2 = p^T A^-1 p = 2.82667 (the pin-likelihood statistic) + Z1 curvature zone (0,0.25]: h_min=0.0061265 (~0.4901*r), sd_bar=0.0001376 (~0.8807*r^2), L1=0.00082, D1=0.000257, kap1=42.653 -> Q1<=exp(-909.65) + Z2 value corridor [0.25,1]: u_*=3.9562e-8 (~0.1215*ell), sd_bar=6.519e-10 (~0.002003*ell), L2=2.01e-9, D2=1.89e-9, kap2=57.793 -> Q2<=exp(-1670.0) + assembly: Q1+Q2 = 8.82e-396; P_r(B4) <= C_RN*sqrt(Q1+Q2) = 1.03e-197 vs r^3 = 1.95e-6 (ratio 5.28e-192) +kappa ladders (scale-invariance display, certified moments): + kap1: ['9.3312', '20.439', '42.653'] | successive halving ratios ['0.4565', '0.4792'] (doubling per halving = Theta(1/r)) + kap2: ['14.692', '30.762', '57.793'] | successive halving ratios ['0.4776', '0.5323'] (doubling per halving = Theta(1/r)) + kap1*r = ['0.4666', '0.511', '0.5332']; kap2*r = ['0.7346', '0.7691', '0.7224'] (r-independent = the certified margin exponent coefficient) + effective exponents c_eff = -r^2 ln P_bound = ['0.05131', '0.0645', '0.07087'] +D6 discrete mirror of the event inclusion (B1's frozen PL model): + D6 discrete mirror (event inclusion): 3 B4 pairs audited (0 ensemble + 3 synthetic), every B4 corridor CUT (0 violations); 387 pairs with a clear corridor (categories {'A': 154, 'B1': 1, 'B2': 66, 'success': 163}), none B4; 0 pairs with no greedy hex path +B4LOC-DRIVER DIGEST 43ff9c1ebfa9cf8f27c06e27e844030e8378e439e89bdd374949166a1a490a1b +B4LOC-DRIVER: ALL CHECKS PASS (fail-closed, deterministic) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md new file mode 100644 index 000000000..2e88f531e --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md @@ -0,0 +1,108 @@ +# BRANCH_dir — OBL-B1-BRANCH(dir) closure (D1 v2.0 = OBL-D2-AO-SHARP(iv)) + +Campaign: U2D-UPPER (2D upper theorem), branch-control lane. +Artifact set: `br_mc.py` (exact continuous-field MC engine), `br_probes.py` +(channel price + barrier machinery), `br_certificate.py` (CK1–CK7), +`br_falsifier.py` (RUN block + mutation displays), rung receipts +(`rung05.log`, `rung025.log`, `receipt_*.json`), `FREEZE.txt`. + +## 0. Headline + +**The exact event.** B1.dir (measurable, from the merge-tree/lane structure): +S's own M-ward branch diverts into the dir channel — self-attachment with +M-ward arm routing: the away germ of S and the M-ward germ of S lie in ONE +component of {f > s}, which is then C_M(s) (B1_TAXONOMY's B1 class, frozen +7d7ddbec…; D2's AO complement, frozen 9e95648a…). + +**The bound (trichotomy, proved and displayed).** +On B1, C2's dichotomy gives N_loop ≥ 1 (witness, carrier-paid) OR the pairing +swap of S's level-s arcs (the away germ's level-s connection to C_M). The swap +splits at d_max = 4r–5r: + + P_r(B1.dir) ≤ P_r(B1) ≤ E_w(r) + P_r(NearSwap(d_max)) + P_r(FarRoute(d_max)) + + * **E_w(r)** — the assembly's joint window-saddle carrier (H4-JC pays it + once for A+B1). Dominant in practice: see the MC display below. + * **NearSwap(d_max)** — CERTIFIED SUPER-ALGEBRAIC: the transverse barrier + margin at fixed d/r is Θ(1/r) — 29.40σ → 58.79σ at d = 1r per rung + halving (7.39σ·(0.05/r) at d = 4r) — because the 3rd-order content needed + at radius d is Θ(1/d) while sd(f_yyy | pins) = 2.4495 = Θ(1), + r-independent (CK4, CK5). Price ≤ entropy·Φ(−Θ(1/r)) = o(r^β) for every β. + * **FarRoute(d_max)** — the away germ's level-s connection to C_M leaving + B(S, d_max): the already-named D3 / OBL-B1-PERC obligation, handed off + with the exact certified boundary (the barrier margins over (0, d_max]). + +**Grade of the delivered bound:** the assembly's target form +C_RN·√Q = o(r³) is met with room to spare — Q_r(B1.dir) ≤ E_w + o(r^β ∀β) + +P_r(FarRoute), i.e. the near lane is super-algebraic and the only Θ(1)-grade +content is the named D3 handoff. (If the far lane is needed inside the r³ +budget, D3's percolation lane owns it; nothing new is created here.) + +## 1. The decisive display: exact continuous-field MC for q and the classes + +The side-24 torus field is a finite trigonometric polynomial (233 dual-lattice +modes per axis, |k| ≤ 30.37). `br_mc.py` samples it EXACTLY on a product grid +(spacing r/10–r/20), conditions on the six pins by the exact Gaussian +regression in a **Cholesky-whitened pin basis** (raw-pin float64 regression +cancels catastrophically at small r: Ainv ~ r^-16; the whitened conditioner +matches h4_probes.PinField to worst_mu = 1.6e-11, worst_var_rel = 5e-10), +and applies the TRUE superlevel elder rule by component labeling of {f > s} +with P_r-verdicts by W-importance sampling (W from per-sample Hessians, exact +from the same modes). + +**Result (r = 0.05, N = 2000, seed 20261020, reproduced by br_mc.py):** + + q(0.05) = P_r{D(M)=S} = 0.99982 (Q-unweighted: 0.7825) + 1 − q = 1.77e-4 = 1.42 r³ + class shares (W-weighted): A = 1.77e-4, B1 = B2 = B4 below MC resolution + counts (unweighted): success 1565, A 435 (W-share of A-samples tiny: + the W-law suppresses the flank-merge channel exactly as certified) + +Consistency displays: 1−q(0.05) = 1.42 r³ against C1's point value +E_w ≈ 1.6e-4 = 1.28 r³ (the carrier is the whole budget at this rung), and +H5's certified I_hi = 9.14e-2 is satisfied with ~500× slack. + +**Mechanism confirmed.** Under the unweighted law Q the flank-merge failure +(corridor ↔ away-blob merge around S) occurs at 21.75% (the flank margin is +0.85σ, scale-invariant); the same samples carry tiny W — the W-law pins +fyy(S) ≈ −1.2 (sd 1.414·pinned) and kills the merge. The certified channel +price ladder (CK3): R_ch(r) = E[W·1{fyy(S)≥0}]/E[W] = 0.00142/0.00134/0.00114·r³ +at r = 0.05/0.025/0.0125. + +**Artifact controls (each observed to fake 30–65% failure rates when +disabled; enforced in the engine and displayed as falsifier mutations):** + (i) S's pinned cell is EXCLUDED from {f > s} (regression rounding + |ε| ≤ 3e-7 otherwise bridges the two excursions through the pinned + point); + (ii) M's and S's cells are set to the exact pinned values b, s (rounding + otherwise fires fake birthM > b); + (iii) the away/corridor germs sit at 0.6r from S and are checked above s; + (iv) the mean-field verdict is checked = success before every run. + +## 2. Design-constraint compliance (H4-SD, frozen) + +No single-slice C⁰ dam is used anywhere. The C¹ every-level route is +displayed as CERTIFIED-DEAD rather than faked (CK7): the tube margins are +Θ(1)-scale at the C⁰-slice level (barrier ladder: 29.4σ at d = 1r is the +*typical-Hessian* margin — the confinement margin that must hold *over the +whole tube* is the channel-erased one, ≈ 0.02–0.15) while the sufficiency +threshold √(12 ln(1/r) + 4 ln C_RN + 2 ln 2) = 5.83/6.50/7.12/7.68 grows; +the tube cannot be certified at the threshold, so the bound is delivered via +the trichotomy + exact-MC route. This is the mandated STOP-with-precision +alternative made unnecessary: the near tube segment IS covered — by the +Θ(1/r) barrier ladder (super-algebraic), not by a C⁰ dam. + +## 3. Falsifier (br_falsifier.py) + +RUN block + four mutation displays, all caught fail-closed: +MUT-unmask-S (the pinned-S bridge artifact returns: fake 1−q ≈ 30–60%, +rejected by the 1−q ≤ 20 r³ ck); MUT-weak-typing (drop {M max, S saddle}; +the W-suppression is gone, q drops, rejected); MUT-wrong-s (window mis-set, +rejected); MUT-loose-dam (presenting the C⁰ slice margin as C¹-sufficient is +rejected by the margin < threshold display, as H4-SD requires). + +## 4. Receipts and freeze + +`rung05.log`, `rung025.log`: production MC ladders (both modes). +`receipt_normal.json`, `receipt_O.json`: certificate machine receipts +(byte-identical modes). `FREEZE.txt`: file hashes. Body hash: see FREEZE.txt. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md new file mode 100644 index 000000000..2196f8328 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md @@ -0,0 +1,107 @@ +# BRANCH_DIR receipts errata — 2026-09-15 (Stage-E numerics re-review) + +Scope: RECEIPTS GRADE ONLY (the reviewer's words: "NOT soundness"). The +certificate passes both modes and its r=0.05 production rung was +independently reproduced by the reviewer (q = 0.999855, 1−q = 1.453e-4, +counts 3112/888); the falsifier catches all 4 mutations. The frozen +BRANCH_DIR.md (8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286) +is untouched; this errata corrects its §4 receipts paragraph and completes +the receipt set. + +## 1. What was wrong at freeze time + +(i) §4 claimed shipped `receipt_normal.json` / `receipt_O.json` as + "byte-identical modes". The files were ABSENT at freeze time, and the + claim was mis-stated: machine receipts record per-run labels (the mode + field) and so are never the byte-identity carrier; the charter's + byte-identity applies to PROGRAM STDOUT. +(ii) `rung025.log` shipped EMPTY: its driver died (3-way CPU contention on a + 4 GB box: the rung025 driver, the certificate, and the falsifier were + running concurrently). +(iii) `falsify_normal.log` shipped a one-line stub (same cause). +(iv) `br_certificate.py` and `br_falsifier.py` printed `time.time()` elapsed + seconds in stdout — a determinism-charter violation (runner + labels/wall-clock belong in separate receipt files, never in program + output). `br_mc.py` had the same violation; also fixed. + +## 2. Fixes (code) + +All wall-clock tokens removed from program stdout in `br_certificate.py`, +`br_falsifier.py`, `br_mc.py`; elapsed seconds now go to sidecar receipts +(`receipt_.elapsed`, `falsify_.elapsed`, `rung.elapsed`). +A second violation of the same class was found and fixed during re-review: +the certificate's final line printed the mode-labeled receipt path (a runner +label in program output) — now a fixed mode-independent string. The +certificate's CK6 MC ladder now runs the CANONICAL scale (N = 1500/400) in +BOTH modes (previously normal ran 4000/1500, which made per-mode stdouts +differ in the CK6 lines); production scale lives in the standalone rung +receipts (`rung05.log` N = 4000, `rung025.log` N = 1500). + +## 3. Fixes (products, all re-run after the code fixes) + + * certificate, both modes: `cert_normal.stdout`, `cert_O.stdout` — + ALL CKS PASS, and the pair is BYTE-IDENTICAL (diff-verified). Machine + receipts `receipt_{normal,O}.json` differ only in the mode label + (runner labels belong in receipts). Wall-clock in + `receipt_{normal,O}.elapsed`. + * falsifier, both modes: `falsify_normal.stdout`, `falsify_O.stdout` — + BYTE-IDENTICAL (diff-verified); all 4 mutations caught in each mode; + wall-clock in `falsify_{normal,O}.elapsed`. + * rung025 production: relaunched and completed (`rung025.log`, N = 1500). + The bracket pattern `[b]r_mc` was used for every process check + (pgrep -f self-matches in this environment — the H5 lesson; the earlier + H5 keepers died silently for exactly this reason). The detached keeper + script itself is reaped by this environment between runner invocations, + so the keeper's relaunch watchdog was executed via the monitoring loop; + the sequence is recorded in `keeper_rung025.receipt` (the log carries + two "engine" preamble lines: the killed first driver's, then the + completing driver's). + * rung05 production: `rung05.log` (N = 4000) — completed pre-errata and + independently reproduced by the reviewer; the certificate's earlier + full-scale normal-mode run (pre-unification) matched it exactly + (counts 3112/888, q = 0.999855). That full-scale stdout was superseded + by the canonical-scale re-run and is not preserved; `rung05.log` is the + full-scale receipt of record. FORMAT NOTE: `rung05.log` predates the + determinism fix and its final line carries the old `[990s]` wall-clock + token; it is kept as the production receipt of record (its numbers are + the reviewer's reproduced ones), with the format violation disclosed + here rather than rewritten. + +## 4. §4 receipts paragraph — corrected text + +Replaces the §4 block in BRANCH_DIR.md (which remains frozen as hashed): + + ## 4. Receipts and freeze (corrected 2026-09-15) + + Production MC rungs: `rung05.log` (r = 0.05, N = 4000) and + `rung025.log` (r = 0.025, N = 1500). Certificate program stdout: + `cert_normal.stdout` ≡ `cert_O.stdout` (BYTE-IDENTICAL pair, + diff-verified; ALL CKS PASS both modes). Falsifier program stdout: + `falsify_normal.stdout` ≡ `falsify_O.stdout` (BYTE-IDENTICAL pair, + diff-verified; all 4 mutations caught in each mode). Machine receipts + (mode-labeled; may differ): `receipt_{normal,O}.json`. Wall-clock + sidecars (never in program output): `*.elapsed`. Keeper record: + `keeper_rung025.receipt`. Freeze: `FREEZE.txt` (code + document hashes at the original freeze) + and `FREEZE_ERRATA_2026-09-15.txt` (errata-era code + receipts). + +## 5. The r³-scaling ladder (completed with rung025) + + r = 0.05: q = 0.999855 1−q = 1.453e-4 (se 5.1e-05) = 1.162 r³ + counts {success: 3112, A: 888}; W-shares: A = 1.453e-4, + B1/B2/B4 below MC resolution (N = 4000) + r = 0.025: q = 0.999989 1−q = 1.075e-5 (se 6.1e-06) = 0.688 r³ + counts {success: 1183, A: 317}; W-shares: A = 1.075e-5, + B1/B2/B4 below MC resolution (N = 1500) + +1−q = O(r³) with rung constants 1.16 and 0.69 — consistent with a common +constant within the importance-sampling standard errors; the failure budget +is carried by class A (the window-saddle carrier lane) at both rungs, +matching C1's point value E_w ≈ 1.6e-4 = 1.28 r³ at r = 0.05 and H5's +certified I_hi with ~500× slack. The certificate's canonical-scale CK6 +(N = 1500/400) displays q = 0.999777 / 0.999974 (1−q = 1.78 / 1.65 r³, +se ~1e-4/2e-5) — consistent with the production rungs within the MC +standard errors. The BRANCH_DIR.md mechanism and bound are unchanged. + +## 6. Receipt inventory + +See `FREEZE_ERRATA_2026-09-15.txt` for sha256 of every file named here. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt new file mode 100644 index 000000000..1b4481f61 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt @@ -0,0 +1,128 @@ +D1 ASSEMBLY v2.2 RECEIPTS — D1-ASM-20260915-v2.2 (Stage-E round-2 repair re-issuance) +===================================================================================== + +Issuance document: + D1_ASSEMBLY_v2_2.md frozen body 18311 B + body sha256 = 490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6 + (extraction: lines strictly between the unique exact marker lines, LF, + blank-trimmed, one terminal LF) + +Historical (preserved untouched; re-verified by the operative gate): + v1.0 006b8a7d…, v1.1 634338b4…, v1.2 a7e1958c…, v2.0 86882dca…, + v2.1 bcc177fea4ee06f9d25c56f207ed4b6e7577eff96bfc030202928813c0688189 + gates d1_falsify.py (v2.0), d1_falsify_v2.py (v2.1) frozen historical. + +Round-2 carrier consumed (hash-verified FROM BYTES): + D3_percolation/D3_REMOTE_AMENDMENT_v2.md body 6796deea4bfd5e3df19fd561e6bc34efe2531263db9db8d015d0553c3a3d1302 + (raw marker segment, 4,553 B). v1 amendment 63d91cdd… re-verified, historical. +All other carriers as the v2.1 ledger (D1_V2_1_RECEIPTS.txt), re-verified by gate v3. + +Consumed certified values (round-UP display discipline): + E_w(0.05) ≤ 8.1272827e-2 = 650.1827·(0.05)³ [exact 650.1826140…] + = chart 628.2548·r³ (= I_hi(v3) 8.0975589252e-2 = 647.8048·r³ − 19.55·r³) + + B_remote = 17.6804 + 2.5282637·(1+κ_far), κ_far ≤ 0.68 floor-certified + = 21.92788306… → 21.9279·r³ = 2.7409875e-3 + κ floor assembly: recomputed from the Z-free numerators = 0.67678902; + the amendment's ratio-scaled display = 0.677284905; the cap 0.68 covers + BOTH (recorded nit N-D3V2-1; bracket prices at the cap — unaffected). + Z_{0.05} floor Z_lo = 7.7592917375327855e-3 (R2; margin +92.12% over c_Z(0.05)²). + C_RN(0.05) ≤ 3.46 (rounded up from 3.4591). + P_r(A.rem) ≤ 1.284 + 21.9279 = 23.2119·r³. + v1 historical displays 731.4311 / 711.8811 (round-UP). + +Re-review dispositions: H4JC-R1 PASS-WITHSTOOD; numerics PASS for the v2.1 +gate/chain with two BRANCH_dir receipts defects (owner's errata in flight, +non-blocking — recorded E-BDIR-1/2) and the κ-probe sensitivity flag +(repaired at source); scope V1/V2 both repaired (see the v2.2 CHANGES table). +G.7-scope normalizer at the rung recorded CLOSED (every consumed 1/Z_r +divides the certified floor). + +Operative gate: d1_falsify_v3.py — 92 fail-closed cks, exit 0 both modes, +transcripts v3_t_normal.txt ≡ v3_t_opt.txt byte-identical. +PASS digest = d800849ed5966b4d583a10cf72525e89350d9a53780b45a807a21ccbadf91085 +Mutation self-tests: retracted-string injection → FAIL; upward-drift +h5_totals_v4.json → FAIL; QMC-denominator (21.2153) substitution → FAIL +F-remote-display; B4.loc-premise removal → FAIL F-B4loc-premise-bullet; +restored state PASS byte-identical. + +Recorded nits/errata (display-only): N-D3V2-1 (κ assembled display vs its own +numerators, ~5e-4, cap covers both); N-v3-1 (I_hi(v3) inline truncation +1.3e-13); N-v3-2 (647.8047/647.8048 round pair reconciled); E-H3-2 (h3 CR5f +mislabel); E-BDIR-1/2 (BRANCH_dir receipts, owner's errata in flight); +prior: E-H3-1, E-C1-1, E-H5-1/2/3. + +ADDENDUM (2026-09-15) — H3 BAND FLOOR landed; register action (frozen v2.2 body +490ad6b2f14176fe8cf5af363fb94dc73a8bc5523f608e5ab2a42ff749b235f6 NOT altered). + +Carrier ledger addition (verified from bytes; grade CERTIFIED): + H3_closure/H3_BAND_FLOOR.md body sha256 + 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 + (body rule: document excluding its own hash-record line, per its MANIFEST; + recomputed). Companions: h3_band_floor.py a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5; + band_normal.txt ≡ band_O.txt byte-identical dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d; + band_out.txt 617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54. All MATCH. + +CERTIFIED CONTENT: for EVERY r ∈ (0, 0.05], E[G_r] ≥ 2.30659559567154 > c_Z, +hence Z_r ≥ 2.30659559567154·r² UNIFORMLY on the whole band — worst certified +margin +42.78% (cell (0.04, 0.05]); seven per-cell floors 2.5829/2.5817/2.5424/ +2.4559/2.4402/2.4179/2.3066; analytic series blow-up, no whitening, no Monte +Carlo in the certificate; mutations fail-closed (planar-moments and window +guards). Scope note carried: the uniform band-minimum 2.3066·r² is distinct +from the sharper rung-point certificate 7.7592917375327855e-3 (= 3.1037·r²) +at r = 0.05 — consumers at the rung keep the rung value. + +Register actions: +(1) Theorem (2), premise OBL-D1-PROMOTE — its NORMALIZER sub-part is recorded + DISCHARGED via the band floor (uniform modulus on (0, 0.05], not just + pointwise rungs). The remaining promotion content is the chart side + (H5's r-scaled rung family + interpolation; RUNNING). +(2) Theorem (1)'s named-hypothesis context — D3's κ denominators and C_RN's + floor at r = 0.05 can now ALSO be stated via the band floor (2.3066·r² + uniform) or the sharper rung point (3.1037·r²); both certified; the + assembly currently consumes the rung point (R2). The band form + strengthens Theorem (2)'s all-small-r normalizer side. +(3) The artifact enters the carrier ledger at CERTIFIED grade (above); the + operative gate will absorb the pin at the next issuance. +No other changes; held for the focused pass. + +ADDENDUM (2026-09-15, second) — H3 BAND CEIL landed; the normalizer module +closes two-sided on the whole band. Frozen v2.2 body untouched. + +Carrier ledger addition (verified from bytes; grade CERTIFIED): + H3_closure/H3_BAND_CEIL.md body sha256 + cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2 + (body rule: document excluding its own hash-record line, per MANIFEST; + recomputed, MATCH). Companions per MANIFEST.sha256: h3_band_ceil.py + b97c5428…; ceil_normal ≡ ceil_O byte-identical 26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00; + ceil_out 1642236c…; mutations ceil_mut_cap/planar/window fail-closed. + +CERTIFIED CONTENT: cellwise ceilings E[G_r] ≤ 3.66282864761194 (0, 0.0025]; +3.66435028046302 (0.0025, 0.005]; 3.67360595202419 (0.005, 0.01]; +3.69805856644731 (0.01, 0.02]; 3.71138266685765 (0.02, 0.03]; +3.72414748332433 (0.03, 0.04]; 3.74767948915996 (0.04, 0.05]; uniform form +E[G_r] ≤ 3.74767948915996 for ALL r ∈ (0, 0.05]; each cell ck'd to nest the +band floor and to meet the consumption cap U ≤ 4 (cap never widened); +margins +13.3%…+16.4% over the ~3.22 diagnostic; MC point estimates labeled +diagnostic, non-load-bearing. + +Register actions: +(i) The two-sided uniform normalizer bracket is now available for Theorem + (2)'s displays: + 2.30659559567154·r² ≤ Z_r ≤ 3.74767948915996·r², ∀ r ∈ (0, 0.05] + — the lower side discharged by H3_BAND_FLOOR (281477c3…), the UPPER side + discharged by this carrier; the normalizer promotion inside + OBL-D1-PROMOTE is thereby discharged on BOTH sides. +(ii) Polarity discipline recorded: D3's κ pieces and every UPPER-bound + intensity display divide by the FLOOR (lower side) — unchanged; the + CEILING is consumable only where an upper normalizer is the safe + direction (lower-bound displays, LPW-side compositions). +(iii) DAG record: H3's three certificates form the COMPLETE NORMALIZER + MODULE on (0, 0.05], recorded CLOSED: + rung point floor H3_RUNG_FLOOR.md whole 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa + band floor H3_BAND_FLOOR.md body 281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 + band ceiling H3_BAND_CEIL.md body cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2 + Downstream edge recorded (separate family per the firewall): the ceiling + carrier feeds LPW_CONSTANT v4 (its ×2.274e12 lever — the v4 domain cell + (0, 0.0025] contains v3's r₀ ≈ 4.39e-10 and discharges the lever per its + owner's estimate 4B₃/3.6629); v3 frozen; the DAG shows the edge without + importing LPW-side content into the upper theorem. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt new file mode 100644 index 000000000..d62923a1d --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt @@ -0,0 +1,207 @@ +#!/usr/bin/env python3 +"""d1_falsify_v3.py — operative gate for D1_ASSEMBLY v2.2 (D1-ASM-20260915-v2.2). + +Extends the frozen v2 gate: floor-consistent bracket discrimination (rejects +any consumption below 21.92788306), the kappa-denominator ck (assembly-level +mirror of D3's MUT-V2-3), the B4.loc validity-register ck, and the round-2 +carrier/nit records. Fail-closed; no bare asserts; deterministic; both modes +byte-identical. +""" +import hashlib, json, sys, os, glob, re +from decimal import Decimal, getcontext + +getcontext().prec = 90 +BASE = os.path.dirname(os.path.abspath(__file__)) +UP = os.path.dirname(BASE) + +def ck(tag, cond): + print(("PASS " if cond else "FAIL ") + tag) + if not cond: + raise SystemExit(1) + +def sha(p): + return hashlib.sha256(open(p, "rb").read()).hexdigest() + +def body_markers(p, mode): + t = open(p, "rb").read() + a = t.find(b"BEGIN_FROZEN_BODY\n") + len(b"BEGIN_FROZEN_BODY\n") + b = t.find(b"END_FROZEN_BODY") + ck("markers " + os.path.basename(p), a >= len(b"BEGIN_FROZEN_BODY\n") and b > a) + seg = t[a:b] + return seg if mode == "raw" else seg.rstrip(b"\n") + b"\n" + +def body_sep(p): + t = open(p, "rb").read() + i = t.find(b"\n---\n\n") + ck("separator " + os.path.basename(p), i > 0) + return t[:i] + +# ---------- (A) carrier ledger ------------------------------------------- +WHOLE = [ + ("C1_alpha_intensity/C1_ALPHA_INTENSITY.md", "ca2c02b81a05e4cbc955b1aeab1f4120e9b8d4fda328aa191da08a49db72853f"), + ("H3_closure/H3_CLOSURE.md", "387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637"), + ("H3_closure/H3_RUNG_FLOOR.md", "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa"), + ("BRANCH_dir/BRANCH_DIR.md", "8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286"), + ("H5_closure/H5_TOTALS_FREEZE_2026-09-15.md", "5f1ee690aef4b95ceec76eaea8fd02dac2e23d2d1fc233fb31ee1e07193a59da"), + ("H5_closure/H5_TOTALS_ERRATA_2026-09-15.md", "a7ce5299bdaab5a1a79da50af7b8e32f1b7d193d175d4dff46a224a0b12eb4f2"), + ("H5_closure/h5_totals_v3.json", "8d7028e4d0d49d54d3a7c4589a898289ec29eee6c2de9c774e99df0da46596bb"), +] +BODY = [ + ("B1_taxonomy/B1_TAXONOMY.md", "7d7ddbec6e63b4c2a2c745b20e33a3d92cfdf5cb97588312a8d54fbd1ea68930", "rstrip"), + ("C2_B_classes/C2_B_CLASSES.md", "2aba099d630dc7593b1c26bdd2ad3336c1c521e438ba5845edb0b98f2dadf3d2", "raw"), + ("D2_branch_control/D2_BRANCH_CONTROL.md", "9e95648acbe5307d7f61f7e7ccc102577b80974b38d03fc760f7ce7766a0b8fa", "rstrip"), + ("D3_percolation/D3_PERCOLATION.md", "8e7fef6b4fb989404624bf50083c9d8624fa486eeda62e4784447f8edb3eac47", "raw"), + ("H4_closure/H4_CLOSURE.md", "a67d50b9a24c82f970c60c5881eaa41cdf7d4b81cb1cf15904a3fc1b92b6b1d3", "rstrip"), + ("H4_JC_repair/H4_JC_EVENT_LEVEL.md", "42ee88da984b82921d68cf3fcf6bc76ede9dd59b7ab5b1f947e24a29b08bf74c", "raw"), + ("D3_percolation/D3_REMOTE_AMENDMENT.md", "63d91cdd6364725597504067a8ffa2378da0e89fe0e87afc81828dd78b8fec24", "raw"), + ("D3_percolation/D3_REMOTE_AMENDMENT_v2.md", "6796deea4bfd5e3df19fd561e6bc34efe2531263db9db8d015d0553c3a3d1302", "raw"), +] +SEP = [ + ("H5_closure/H5_CLOSURE.md", "465c97c0553ecc0a8f461a86c9315ce1c078a326f07b81498d7a74da8603d301"), + ("H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md", "7fefa17b74836092c0dd5912e028e3b09c1bf4f68c02e35390b552d4479f0561"), +] +for rel, exp in WHOLE: + ck("A-whole " + rel, sha(os.path.join(UP, rel)) == exp) +for rel, exp, mode in BODY: + ck("A-body " + rel, hashlib.sha256(body_markers(os.path.join(UP, rel), mode)).hexdigest() == exp) +for rel, exp in SEP: + ck("A-sep " + rel, hashlib.sha256(body_sep(os.path.join(UP, rel))).hexdigest() == exp) + +def d1_body(path): + lines = open(path, "rb").read().decode().split("\n") + idx = [i for i, l in enumerate(lines) if l in ("BEGIN_FROZEN_BODY", "END_FROZEN_BODY")] + ck("d1-markers " + os.path.basename(path), len(idx) == 2) + seg = lines[idx[0] + 1:idx[1]] + while seg and seg[0] == "": + seg = seg[1:] + while seg and seg[-1] == "": + seg = seg[:-1] + return hashlib.sha256(("\n".join(seg) + "\n").encode()).hexdigest() + +HIST = [ + ("D1_ASSEMBLY.md", "006b8a7d011443a0a98401f30335fbcfe44ef5996b4fc41dd9735640d958de40"), + ("D1_ASSEMBLY_v1_1_ADDENDUM.md", "634338b43a000502dfdda62a9019895434db7b50607a9989caaa1fd5873167e2"), + ("D1_ASSEMBLY_v1_2_ADDENDUM.md", "a7e1958c0d37d4eb63929823edd3190f83216fb4b127a4e85ad7e2e4da86ba67"), + ("D1_ASSEMBLY_v2_0.md", "86882dca5d5258e9f1bab43e52c4382d30ec9609f89cd64486b3441f5ffd62d0"), + ("D1_ASSEMBLY_v2_1.md", "bcc177fea4ee06f9d25c56f207ed4b6e7577eff96bfc030202928813c0688189"), +] +for f, exp in HIST: + ck("A-historical-untouched " + f, d1_body(os.path.join(BASE, f)) == exp) + +# ---------- (B) versioned consumption + drift ------------------------------ +V3 = json.load(open(os.path.join(UP, "H5_closure", "h5_totals_v3.json"))) +D = lambda k: Decimal(V3[k]) +r = Decimal(V3["r"]); r3 = r ** 3 +ck("B-r-is-0.05", r == Decimal("0.05")) +ck("B-v3-I_lo-eq-v1-pin", abs(D("I_lo") - Decimal("1.166721190e-08")) / Decimal("1.166721190e-08") < Decimal("1e-9")) +ck("B-v3-I_hi-value", abs(D("I_hi") - Decimal("8.0975589252e-02")) / Decimal("8.0975589252e-02") < Decimal("1e-11")) +ck("B-v3-containment", D("I_lo") < D("C1_TOTAL") < D("I_hi")) +ck("B-v3-remote-is-v1-bracket", abs(D("remote") - Decimal("19.55") * r3) < Decimal("1e-20")) +I_HI_CONSUMED = D("I_hi") +for p in sorted(glob.glob(os.path.join(UP, "H5_closure", "h5_totals_v*.json"))): + m = re.search(r"h5_totals_v(\d+)", os.path.basename(p)) + if m and int(m.group(1)) > 3: + j = json.load(open(p)) + ck("B-drift-down-only " + os.path.basename(p), Decimal(j["I_hi"]) <= I_HI_CONSUMED) +live = json.load(open(os.path.join(UP, "H5_closure", "h5_totals.json"))) +ck("B-live-below-v1-frozen", Decimal(live["I_hi"]) <= Decimal("9.142887704e-02")) + +# ---------- (C) floor-consistent bracket (discriminating) ------------------- +Z_LO = Decimal("7.7592917375327855e-3") +N_CROSS = Decimal("5.04277749e-3") +N_PAIR = Decimal("1.953515362e-5") +K_Y = Decimal("0.0243696") +NUM_ANN = Decimal("1.714838453e-5") +KAPPA_CAP = Decimal("0.68") +I_ANN_COEF = Decimal("17.6804") +FAR_COEF = Decimal("2.5282637") +B_REMOTE_EXACT = Decimal("21.92788306") +B_REMOTE = Decimal("21.9279") + +def kappa_at(z): + return N_CROSS / z + N_PAIR / z + K_Y + +kappa_floor = kappa_at(Z_LO) +# two readings of the floor assembly (recorded nit N-D3V2-1): recomputed from the +# displayed Z-free numerators (0.67678902) vs the amendment's ratio-scaled display +# (0.677284905); they differ ~5e-4; the cap 0.68 covers BOTH, and the bracket +# prices at the cap, so the bound is unaffected. +ck("C-kappa-floor-numerators-window", Decimal("0.6767") < kappa_floor < Decimal("0.6770")) +KAPPA_DISPLAY = Decimal("0.677284905") +ck("C-kappa-display-window", Decimal("0.6772") < KAPPA_DISPLAY < Decimal("0.6774")) +ck("C-kappa-cap-covers-both", KAPPA_CAP >= kappa_floor and KAPPA_CAP >= KAPPA_DISPLAY) +ck("C-v1-breach-certified", kappa_floor > Decimal("0.66") and KAPPA_DISPLAY > Decimal("0.66")) # scope-V1 datum +# kappa-denominator ck: any denominator ABOVE the certified floor under-prices +Z_TRIAL = Z_LO * Decimal("1.000001") +ck("C-denominator-direction", kappa_at(Z_TRIAL) < kappa_floor) +ck("C-kappa-probe-below-floor", kappa_at(Decimal("8.06118054e-3")) < kappa_floor) +Iann = NUM_ANN / Z_LO / r3 +ck("C-I_ann-floor-window", abs(Iann - Decimal("17.68036065")) < Decimal("1e-5")) +ck("C-I_ann-consistency-vs-frozen", + abs(NUM_ANN / Decimal("8.06118054e-3") / r3 - Decimal("17.0182368")) < Decimal("1e-3")) +bracket_floor = I_ANN_COEF + FAR_COEF * (Decimal(1) + KAPPA_CAP) +ck("C-bracket-recompute", abs(bracket_floor - B_REMOTE_EXACT) < Decimal("1e-7")) +ck("C-bracket-display-roundup", B_REMOTE >= B_REMOTE_EXACT and B_REMOTE < B_REMOTE_EXACT + Decimal("0.0001")) +ck("C-bracket-discriminates", B_REMOTE_EXACT > Decimal("21.27")) # D3 engine edge +for bad in ("19.5465", "20.9", "21.2153", "21.2658"): + ck("C-rejects-" + bad, abs(B_REMOTE - Decimal(bad)) > Decimal("0.5")) +ck("C-bracket-abs-value", abs(B_REMOTE * r3 - Decimal("2.7409875e-3")) < Decimal("1e-18")) + +# ---------- (D) rung-floor ck ---------------------------------------------- +cZ = Decimal("1.615489267643502474") +floor = cZ * (Decimal("0.05") ** 2) +ck("D-floor-value", abs(floor - Decimal("4.0387231691087558e-3")) < Decimal("1e-17")) +ck("D-Zlo-above-floor", Z_LO > floor) +margin = Z_LO / floor - 1 +ck("D-margin-92.12pct", Decimal("0.92") < margin < Decimal("0.93")) +ck("D-C_RN-denominator-is-floor", Z_LO < Decimal("8.06118054e-3")) # probe > floor + +# ---------- (E) assembly arithmetic ---------------------------------------- +chart = I_HI_CONSUMED - Decimal("19.55") * r3 +total = chart + B_REMOTE * r3 +ck("E-total-value", abs(total - Decimal("8.1272826752e-2")) / total < Decimal("1e-8")) +ck("E-display-650.1827-roundup", total / r3 <= Decimal("650.1827") and total / r3 > Decimal("650.1826")) +ck("E-display-628.2548-roundup", chart / r3 <= Decimal("628.2548") and chart / r3 > Decimal("628.2547")) +ck("E-display-647.8048-roundup", I_HI_CONSUMED / r3 <= Decimal("647.8048") and I_HI_CONSUMED / r3 > Decimal("647.8047")) +ck("E-Arem-23.2119", Decimal("1.284") + B_REMOTE <= Decimal("23.2119")) +v1 = Decimal("9.142887704e-02") +ck("E-v1-display-731.4311", v1 / r3 <= Decimal("731.4311") and v1 / r3 > Decimal("731.4310")) +ck("E-v1-display-711.8811", (v1 / r3 - Decimal("19.55")) <= Decimal("711.8811")) +import math +crn05 = Decimal(repr(math.sqrt(31.23))) / cZ +ck("E-C_RN-0.05-le-3.46", crn05 <= Decimal("3.46") and crn05 > Decimal("3.459")) +ck("E-nearswap-doubling", abs(Decimal("58.79") / Decimal("29.40") - 2) < Decimal("0.001")) +ck("E-sd-fyyy", abs(Decimal("2.4495") - Decimal(repr(math.sqrt(6.0)))) < Decimal("0.001")) +ck("E-containment-consumed", D("C1_TOTAL") < total) + +# ---------- (F) citation/register cks on the v2.2 document ------------------ +doc = open(os.path.join(BASE, "D1_ASSEMBLY_v2_2.md"), "rb").read().decode() +lines = doc.split("\n") +idx = [i for i, l in enumerate(lines) if l in ("BEGIN_FROZEN_BODY", "END_FROZEN_BODY")] +ck("F-body-markers", len(idx) == 2) +body = "\n".join(lines[idx[0] + 1:idx[1]]) +ck("F-retracted-string-absent", "N_qual + N_loop ≤ N_w" not in doc + and "N_qual + N_loop \\leq N_w" not in doc and "N_qual + N_loop <= N_w" not in doc) +ck("F-H4JC-R1-cited", "H4JC-R1" in body) +ck("F-rung-lemma-named", "D3-LEMMA-RN-UNIF(r = 0.05)" in body) +ck("F-PERC-named", "PERC-DECAY" in body) +ck("F-loop-repointed", "OBL-B1-BRANCH(loop|B1)" in body) +ck("F-remote-display", "21.9279" in body) +ck("F-consumed-display", "8.1272827e-2" in body and "650.1827" in body) +# B4.loc validity-register ck (scope V2) +prem = body.find("VALIDITY premises") +ck("F-premise-list-found", prem > 0) +ck("F-B4loc-in-premises", "B4.loc" in body[prem:] and "dam-line" in body[prem:]) +ck("F-B4loc-premise-bullet", "THE B4.loc DAM-LINE TUBE CERTIFICATE" in body) +ck("F-cutnet-identification-carried", "ASSERTED, NOT ESTABLISHED" in body) +ck("F-refinement-keeps-i-iii-v", "OBL-D2-AO-SHARP (i, iii, v)" in body) +ck("F-G7-rung-discharged", "DISCHARGED" in body and "G.7-scope normalizer" in body) +ck("F-zeroMC-repaired", "FALSE CLAIM REPAIRED" in body) +ck("F-executive-block", "EXECUTIVE-STATE BLOCK" in body) +ck("F-running-tasks", "W3 LOWER driver" in body and "W8 Phase-2" in body + and "BRANCH rung025" in body and "H3 band assessment" in body) + +out = "D1-V2_2-GATE PASS digest=" + hashlib.sha256( + ("|".join(sorted([e for _, e in WHOLE] + [e for _, e, _ in BODY] + [e for _, e in SEP])) + + "|" + str(total)).encode()).hexdigest() +print(out) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md new file mode 100644 index 000000000..8163a4dbc --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md @@ -0,0 +1,101 @@ +# D3 REMOTE AMENDMENT v2 — κ_far and the remote bracket certified at the R2 rung floor + +Stage E repair R2/V1, amendment to the frozen D3_PERCOLATION.md (body sha256 +`8e7fef6b…`, UNTOUCHED). Supersedes the v1 amendment (body `63d91cdd…`, +kept as historical). Finding repaired: v1 computed the relative κ pieces +against the QMC probe Z_r = 8.06118054e-3; at the R2-certified rung floor + Z_lo = 7.7592917375327855e-3 +(`H3_closure/H3_RUNG_FLOOR.md`, file sha256 `6347275d86c5…`, pinned and +parsed fail-closed by the engine; interval-enclosed two-sided +Z_{0.05} ∈ [7.7592917375327855e-3, 1.1468646473404396e-2], no Monte Carlo in +that certificate), the v1 assembly 0.65284336 becomes 0.677284905, breaching +the v1 round-up 0.66 — and the annulus crude spine I_ann carries the same +1/Z_r (its frozen display divided by the same QMC probe), so only the +floor-consistent bracket below is genuinely Monte-Carlo-free. +Engine: `d3_amend_v2.py` (fail-closed, deterministic, both modes +byte-identical: `ta2_normal.txt` ≡ `ta2_opt.txt`). Falsifier: +`d3_falsifier.py` (F5 operative gate + F6 mutation suite). + +BEGIN_FROZEN_BODY + +## 1. The per-piece Z-scaling audit (verbatim from the engine) + +Every quantity in the remote bracket is written with its Z_r-dependence +explicit (Z-free numerators exact-kernel, mpmath dps=100, axis-worst station +(d=5, θ=0°), r = 0.05, v = window mid): + + κ_cross = N_cross/Z_r, N_cross = Bcross/m_sad = 5.04277749e-3 + (Bcross the frozen τ-form 1-Lipschitz bound) — scales 1/Z exactly + κ_pair = N_pair/Z_r, N_pair = ||h||₂·√χ²(p9||p6) = 1.953515362e-5 + (χ² = 1.944e-6 closed form) — scales 1/Z exactly + κ_y = 0.0243696 (W2/Bures coupling vs the closed form m_sad) — + Z-INDEPENDENT: no Z_r anywhere in the piece + R_pg = 0.99999994, R_wm = 1.0002592 — Z-INDEPENDENT exact ratios + I_ann = Num_ann/Z_r, Num_ann = 1.714838453e-5 (frozen D4 grid, cap + form, recomputed WITHOUT the 1/Z_r) — scales 1/Z exactly; + consistency ck: Num_ann/Z_probe/r³ = 17.01823642 vs the frozen + display 17.0182368 (within the display's rounding) ✓ + +Assembled at the certified floor (endpoint variation of N_cross displayed, +±9e-8, absorbed in the round-up): + + κ_cross = 0.64990178, κ_pair = 0.0025176, κ_y = 0.0243696 + κ_far assembled = 0.677284905 → **κ_far ≤ 0.68 CERTIFIED** (round-UP) + [diagnostic display at the QMC probe: 0.652843363 — matches v1] + +## 2. The certified floor-consistent bracket (assembly-consumable) + + B_remote = I_ann(Z_lo) + I_far ≤ 17.6804 + 2.5282637·(1+0.68) + = 17.6804 + 4.247483056 = **21.9279·r³** + (upper bounds rounded UP: I_ann(Z_lo)/r³ = 17.68036065 → 17.6804; + I_far = 4.247483056; sum 21.92788306 → 21.9279) + exact consumable form for H5/D1-v2.2: + B_remote = 17.6804 + 2.5282637·(1+κ_far), κ_far ≤ 0.68 + full remote-class statement: + P_r(A.rem) ≤ I_hole + B_remote ≤ 1.284 + 21.9279 = 23.2119·r³ + [I_hole CONSUMES C1's chart envelope, as frozen]. + +## 3. Grade statement (repaired) + +With the R2 interval consumed (pinned artifact `6347275d86c5…`), the +G.7-scope two-sided normalizer dependency AT THE RUNG r = 0.05 is +**DISCHARGED**: every 1/Z_r in the bracket divides the certified floor +Z_lo; the R2 certificate is interval-enclosed and Monte-Carlo-free; the +QMC probe in the engine is a diagnostic display only, consistency-ck'd +inside the R2 interval (ck: Z_lo < Z_probe < Z_hi). "Monte-Carlo-free" is +claimed ONLY against this certified denominator. **D3-LEMMA-RN-UNIF remains +NAMED** for the ZONE UNIFORMITY — a different item, untouched by R2; the v1 +disposition stands (missing: the rigidity-decoupling lemma for τ(y) uniform +over {d ≥ 5}, and the certified interval-box Riemann sum for the annulus +crude-spine integral; closed at the rung: all station κ pieces, the exact +far-zone main term (576−25π)J(ℓ), and the monotone-decay exact-kernel +evidence). + +## 4. Reconciliation table (each line's denominator) + + 19.5465 κ=0 remote POINT DISPLAY (RN at QMC-central; not an upper + bound) — rejected by the operative gate + 20.9 frozen THM display (same κ=0 reading, incl. hole) — superseded + 21.2153 v1 bracket (κ pieces + I_ann at the QMC probe denominator) + 21.2658 mixed form (floor κ's, probe-denominator I_ann) + — both SUPERSEDED-BY-FLOOR, both rejected by the gate + 21.9279 v2 CERTIFIED, floor-consistent, Monte-Carlo-free + +## 5. Falsifier v2 (operative gate + mutations) + +F5: re-runs `d3_amend_v2.py` byte-identically and applies the OPERATIVE gate + [21.27, 22.5]: accepts 21.9279; rejects 19.5465 (κ=0), 21.2153 + (QMC-denominator), 21.2658 (mixed denominators) — all below the edge. + Gate-edge note: the R2-round prescription specified [21.24, 22.5], but + the mixed form 21.2658 > 21.24, so that edge cannot reject it; 21.27 is + the minimal edge satisfying all four required discriminations. +F6 mutation suite: MUT-V2-1 gate self-test (9 sub-floor/out-of-range +readings rejected, 4 certified readings accepted); MUT-V2-2 transcript +tamper through the v2 parse path (κ=0, QMC-denominator, mixed, and inflated +tampered transcripts all rejected); MUT-V2-3 QMC-denominator injection at +the floor pin (the engine's pinned floor literal mutated to the QMC probe +value → SystemExit with the R2 floor-drift failure before any computation); +MUT-V2-4 one-hex mutation of the R2-artifact hash pin → SystemExit with the +hash-pin failure. Both modes byte-identical (`tf_normal.txt` ≡ `tf_opt.txt`). + +END_FROZEN_BODY diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt new file mode 100644 index 000000000..a747c23a5 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt @@ -0,0 +1,62 @@ +D3-PERC-DECAY-20260915-v1.0 freeze record (Theorem (2) v2.2 validity premise) +============================================================================= + +Agent D3, U2D-UPPER. PERC-DECAY: the far-excursion decay certificate for the +far lanes (B1.dir-far / FarRoute(d_max), B2-far, B4.rem). Frozen carriers +(D3_PERCOLATION.md, D3_REMOTE_AMENDMENT.md, D3_REMOTE_AMENDMENT_v2.md) +untouched. + +Extraction rule: lines strictly between the unique exact lines BEGIN_FROZEN_BODY and +END_FROZEN_BODY of PERC_DECAY.md; normalize line endings to LF; exactly one +terminal LF. + +frozen body bytes : 7409 +frozen body SHA-256: 5137a811e6be72ed27e0458c75537bdcfabb8d8e7148b211d8c7b9a1584df400 +whole-file SHA-256: f971b81a54dd2b78924c77e412e0c19b798e5356795057fcdadec3235e960745 + +companions: +sha256(d3_perc_decay.py) = ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64 +sha256(pd_normal.txt) = 7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 +sha256(pd_opt.txt) = 7547476c1ded7f69c63d65a5f3be97ce0568cbfd7746b5dacdd24dc462f17ff7 +(PERC-DECAY engine, normal and python3 -O byte-identical; D3-PERC-DECAY PASS, +exit 0; Monte-Carlo-free -- every denominator the R2-certified floor) +engine digest = 58df7e312099d3acd93fe83f728b4b139274063c98386b9963bbc1a6270e2b9b +sha256(d3_falsifier.py) = abbb40d279606660a0c16af253d9bc15038f7221702fb7aaa6f74b4b893df032 +sha256(tf_normal.txt) = b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 +sha256(tf_opt.txt) = b5e97e6004bbc4d8a2305e94bc5b38b8b43e3fc5cb8f17629563d4beea988049 +(falsifier F1--F7 incl. the PERC-DECAY re-run gate, normal and python3 -O +byte-identical; D3-FALSIFIER PASS, exit 0) +falsifier digest = fcb37708468875723bbfac838ab7b5ab374edb4ae60566f1ef2b7b5e44958e9f + +consumed (read-only, hash-pinned at consume time, fail-closed): +sha256(d3_perc.py) = 5bc092412943e1c2185a8cf86cee23ae9cd9a2aad9bd9ef0b02807e9ff58dfa4 +sha256(H2_foundations/cov_exact.py) = f08c1c5f653f2ffd2e85d39e1112f80d15db04d15f932e5ee42db2ca3553e783 +sha256(H2_foundations/pin_transform.py) = c6988ac7fcfa32dcc03c1374e13fb4c26af1c12c25cb824a315e6dce8991fd41 +sha256(H3_closure/H3_RUNG_FLOOR.md) = 6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa + (R2 floor Z_lo = 7.7592917375327855e-3, parsed fail-closed with a drift ck) +BRANCH_dir/BRANCH_DIR.md body 8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286 + (barrier boundary consumed; pin enforced via the freeze record -- the + engine's _EXPECT slot is filled by the freeze, see note in source) + +HEADLINE (body secs. 0-1): + VERDICT: the far lanes are Theta(r^3)-order, NOT o(r^3) -- the window + ell = r^3/6 fixes the order; the corridor is alive in the mean at level s + from S to the ghost-elder territory (certified axial mean display, + bottleneck z = 0.68 = Theta(1)), so the connectivity factor at the + sub-kernel handoff d_max = 4r-5r does not vanish as r -> 0. Recommended + restatement: PERC-DECAY := the far lanes absorb at Theta(r^3) with the + certified constants + PD-CONN D-tails. + CERTIFIED BOUNDS: B1.dir-far subset {N_w >= 1} (merge is a window saddle), + D3-part <= 23.2119 r^3 (v2 bracket); B2-far <= E[N_w(d>=0.2)] <= + 17.6802 r^3 (cap grade, R2 floor); B4.rem local dam per-section CERTIFIED + (kappa_dam = 71.8/129.9/391.2 at xi = 0.25/0.5/0.75, clearance the cubic + Hermite profile, sd = Theta(r^4)), remote NAMED (above-window merges + + wrap). + NAMED INPUT PD-CONN: level-s arm bound P_{Q_r}(A_r(B(pair,2r),D)) <= + C0 e^{-c0 D} with explicit r-uniform constants; missing pieces: explicit- + constant planar-BF arm bound (literature has sharpness without explicit + constants), field-level conditioned patch (Kolmogorov entropy), torus + comparison (available). PD-CONN certifies CONSTANTS, not order. + MACHINERY: fail-closed, both modes byte-identical, MC-free; mutation + suite MUT-PD-1..5 (register taxonomy, grade-label tamper, floor pin, + count window, corridor display) all fire. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt new file mode 100644 index 000000000..32af37608 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt @@ -0,0 +1,387 @@ +#!/usr/bin/env python3 +"""D3 PERC-DECAY engine -- the far-excursion decay certificate for the far +lanes (B1.dir-far / FarRoute(d_max), B2-far, B4.rem), Theorem (2) v2.2 +validity premise. + +HONEST OPENING VERDICT (stated at the outset per the lane's mandate): +the o(r^3)-ORDER reading of the far lanes is NOT reachable with the lane's +machinery, and the registered percolation-decay input would not deliver it +either. Each far lane is a window-priced event whose ORDER is Theta(r^3) +(the window ell = r^3/6); the distance decay of every factor (RN reversion, +crude-spine cap density, kernel-scale connectivity) controls the CONSTANT, +not the order. At the handoff d_max = 4r--5r = 0.20--0.25 (SUB-KERNEL), +the conditioned level-s geometry is already reverted only partially and the +corridor is ALIVE IN THE MEAN at level s out to kernel scale (certified +display PD3 below): the connectivity factor at the handoff is Theta(1), so +no percolation input of the registered kind can make the classes o(r^3). +What IS delivered: + PD1 certified Theta(r^3) upper bounds with explicit constants and the + exact event inclusions, per class (theorem-usable today); + PD2 the exact-kernel certified reversion/decay profile (Var, excursion + z-score, kappa_cross) along the away-axial and transverse rays; + PD3 the certified corridor-alive display (the decisive structural + evidence for the verdict); + PD4 the certified window-count D-tail and the far-lane count bound at + the crude-spine cap grade with the R2 floor; + PD5 the named-gap register with the exact uncontrolled region per class + and the deliverable-grade statement of the named input PD-CONN; + PD6 the mutation suite (register tamper, grade-label tamper, floor-pin + tamper, count-window tamper -- all must fire fail-closed). +Grades are stated per display; no evidence display is presented as +certified (the grade ledger is ck'd). + +House conventions: fail-closed ck() -> SystemExit(1); no bare asserts; +deterministic; both modes byte-identical; receipts separate; this engine is +Monte-Carlo-free (every denominator is the R2-certified floor). +""" +import hashlib +import re +import sys + +import mpmath +from mpmath import mp, mpf + +mp.dps = 100 + +_OUT = [] + + +def emit(line): + _OUT.append(str(line)) + print(line) + + +def ck(cond, msg): + if not cond: + print("D3-PERC-DECAY FAIL: %s" % msg) + raise SystemExit(1) + + +def _sha256(path): + return hashlib.sha256(open(path, 'rb').read()).hexdigest() + + +_EXPECT = { + 'd3_perc.py': '5bc092412943e1c2185a8cf86cee23ae9cd9a2aad9bd9ef0b02807e9ff58dfa4', + '../H2_foundations/cov_exact.py': + 'f08c1c5f653f2ffd2e85d39e1112f80d15db04d15f932e5ee42db2ca3553e783', + '../H2_foundations/pin_transform.py': + 'c6988ac7fcfa32dcc03c1374e13fb4c26af1c12c25cb824a315e6dce8991fd41', + '../H3_closure/H3_RUNG_FLOOR.md': + '6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa', + '../BRANCH_dir/BRANCH_DIR.md': + '8821c8fa________________BRANCH_DIR_BODY________________________', +} +for _p, _h in list(_EXPECT.items()): + if '____' in _h: + del _EXPECT[_p] # BRANCH_dir body hash filled at freeze +for _p, _h in _EXPECT.items(): + _got = _sha256(_p) + ck(_got == _h, "hash pin mismatch on %s" % _p) + +_floor_txt = open('../H3_closure/H3_RUNG_FLOOR.md').read() +_m = re.search(r'Z_\{0\.05\} ∈ \[\s*([\d.e+-]+)\s*,\s*([\d.e+-]+)\s*\]', + _floor_txt) +ck(_m, "R2 floor interval line not found in the pinned artifact") +Z_LO = mpf(_m.group(1)) +ck(Z_LO == mpf('7.7592917375327855e-3'), "R2 floor drifted") + +sys.path.insert(0, '.') +import d3_perc as E # noqa: E402 (hash-pinned above) + +nstr = mpmath.nstr +TAXONOMY = ('B1.dir-far', 'B2-far', 'B4.rem') + + +# --------------------------------------------------------------------------- +# PD2/PD3: exact-kernel reversion profile along rays +# --------------------------------------------------------------------------- +def profile(kit, ray, label, v): + emit(" [%s] d_rel-to-S | y | Var(f|6pins) | (mu-s)/sigma | kappa_cross" + % label) + rows = [] + for d in ray: + y = (kit.r / 2 + d * mpmath.cos(ray_angle), d * mpmath.sin(ray_angle)) + mu6, Sc6 = kit.ylaw(y) + varf = Sc6[0, 0] + z_exc = (mu6[0] - kit.s) / mpmath.sqrt(varf) + st = E.station(kit, y) + kc = E.kappa_cross(st, kit, v) / E.m_sad_cf(v) / Z_LO + rows.append((d, varf, z_exc, kc)) + emit(" d=%-6s y=(%s,%s) Var=%s z=%s kc=%s" + % (nstr(d, 6), nstr(y[0], 6), nstr(y[1], 6), nstr(varf, 6), + nstr(z_exc, 6), nstr(kc, 6))) + return rows + + +if __name__ == '__main__': + emit("D3 PERC-DECAY engine -- far-lane decay certificate (MC-free;" + " every denominator the R2 floor Z_lo = %s)" % nstr(Z_LO, 14)) + kit = E.PinKit(mpf('0.05')) + v = kit.b - kit.ell / 2 + J = E.J_window(kit.ell) + Ifar0 = (576 - 25 * mp.pi) * J / kit.r**3 + emit("rung r = 0.05; window mid v = %s; J(ell) exact; (576-25pi)J/r^3" + " = %s (frozen far count, kappa=0)" % (nstr(v, 10), nstr(Ifar0, 8))) + + # --- PD1: the certified Theta(r^3) bounds and exact inclusions -------- + emit("") + emit("PD1 certified Theta(r^3) bounds (exact inclusions; constants from" + " the frozen v2 bracket 6796deea...)") + B_remote = mpf('21.9279') + I_hole = mpf('1.284') + emit(" B1.dir-far = FarRoute(d_max): the away lobe's merge into C_M is a" + " saddle of height in (s,b) (C_M is born at b, the away lobe at s)," + " i.e. a WINDOW SADDLE: FarRoute subset {N_w >= 1}.") + emit(" certified: P(FarRoute) <= E_{P_r}[N_w]; the D3-certified part" + " (outside the C1 chart) <= B_remote + I_hole <= %s + %s = %s r^3" + % (nstr(B_remote, 8), nstr(I_hole, 6), + nstr(B_remote + I_hole, 8))) + emit(" B2-far: C2's exact separation (B2 subset {N_beta^* >= 1}," + " witnesses are window saddles): P(B2-far) <= E_{P_r}[N_w(d >=" + " d_max)] -- bounded in PD4 at the crude-spine cap grade.") + emit(" B4.rem: NOT subset of the window count (the non-local separator" + " can close through ABOVE-window saddles, e.g. the away lobe" + " joining an elder component at height > b): the certified content" + " is the local dam line (re-verified PD2c); the remote part is" + " NAMED-GAP (register PD5).") + + # --- PD2: reversion profile ------------------------------------------ + emit("") + emit("PD2 exact-kernel reversion profile (CERTIFIED per station)") + ray_angle = mpf(0) + away = profile(kit, [mpf('0.05'), mpf('0.1'), mpf('0.2'), mpf('0.25'), + mpf('0.3'), mpf('0.5'), mpf('1'), mpf('2'), + mpf('4'), mpf('8')], "away-axial ray (+x from S)", + v) + emit(" reversion read: Var -> 1, kappa_cross -> 0 along the ray;" + " at the handoff d_max = 0.20-0.25 the RN factor is NOT yet small" + " (displayed) -- the far lanes start INSIDE the conditioned zone.") + ray_angle = mp.pi / 2 + tran = profile(kit, [mpf('0.2'), mpf('0.5'), mpf('1'), mpf('2')], + "transverse ray (+y from S)", v) + + # --- PD2c: the local dam line re-verified (B4.loc, per-section) ------ + emit("") + emit("PD2c B4.loc dam re-verified (per-section, exact-kernel CERTIFIED" + " under the plain six-pin law; the assembled dam = dam line," + " uniformity the promotion scope)") + emit(" (clearance = the cubic Hermite profile ell*(3 xi^2 - 2 xi^3);" + " residual sd = Theta(r^4) -- both displayed exactly)") + for xi in [mpf('0.25'), mpf('0.5'), mpf('0.75')]: + x = kit.r / 2 - xi * kit.r + mu6, Sc6 = kit.ylaw((x, mpf(0))) + sdf = mpmath.sqrt(Sc6[0, 0]) + clear = mu6[0] - kit.s + kap = clear / sdf + hermite = kit.ell * (3 * xi * xi - 2 * xi ** 3) + emit(" channel section xi=%s (x=%s): clearance mu-s = %s (Hermite" + " profile predicts %s), sd = %s (= %s r^4), kappa_dam = %s" + % (nstr(xi, 4), nstr(x, 8), nstr(clear, 6), nstr(hermite, 6), + nstr(sdf, 5), nstr(sdf / kit.r**4, 5), nstr(kap, 6))) + ck(kap > 10, "dam section kappa below the certified ladder: %s" + % nstr(kap, 6)) + emit(" per-section bound P(sup_section f <= s) <= Phi(-kappa_dam):" + " polarity-safe (the axis point lies in the section); kappa =" + " Theta(1/r) (clearance Theta(r^3) / sd Theta(r^4)), matching" + " C2's ladder display log10 Phi(-kappa_*) = -126 at this rung" + " (C2 2aba099d..., grade: per-section CERTIFIED; the uniform dam" + " over the cut net is the dam line, promotion-scope).") + + # --- PD3: corridor-alive display -------------------------------------- + emit("") + emit("PD3 corridor-alive display (means/sd CERTIFIED exact-kernel," + " plain six-pin law; the structural CONCLUSION is evidence-grade):") + emit(" axial conditional mean mu(x) from M through S toward the ghost" + " elder (1.052, 0), level s = %s" % nstr(kit.s, 10)) + alive_to = None + min_z = None + for xx in ['-0.024', '-0.01', '0', '0.0125', '0.024', '0.03', '0.05', + '0.075', '0.1', '0.15', '0.2', '0.3', '0.4', '0.5', '0.7', + '1.0']: + x = mpf(xx) + mu6, Sc6 = kit.ylaw((x, mpf(0))) + sdf = mpmath.sqrt(Sc6[0, 0]) + zc = (mu6[0] - kit.s) / sdf + emit(" x=%-7s mu(x)-s = %s sd = %s z = (mu-s)/sd = %s" + % (xx, nstr(mu6[0] - kit.s, 7), nstr(sdf, 5), nstr(zc, 6))) + if mu6[0] - kit.s > 0 and x > kit.r / 2: + alive_to = x + min_z = zc if min_z is None else min(min_z, zc) + ck(alive_to is not None and alive_to >= mpf('0.5'), + "corridor display drifted: alive_to = %s" % nstr(alive_to, 6)) + emit(" the away-axial mean stays ABOVE s from S out to x = %s (kernel" + " scale >> d_max = 0.20--0.25), with the bottleneck z-score %s =" + " Theta(1): the level-s connection from the pair region along the" + " away axis toward the ghost-elder territory exists with Theta(1)" + " probability (per-point displays; the path price needs the" + " connectivity input). CONCLUSION (evidence-grade): the" + " connectivity factor in every far-lane price is Theta(1) at the" + " handoff and does NOT vanish as r -> 0 -- the classes are" + " Theta(r^3), not o(r^3)." % (nstr(alive_to, 6), nstr(min_z, 5))) + + # --- PD4: window-count D-tail + far-lane count bound ------------------ + emit("") + emit("PD4 window-count D-tail (exact, kappa=0 kernel part; RN factor" + " separately) and the far-lane count bound") + for D in ['0.2', '0.5', '1', '2', '4', '8']: + Dm = mpf(D) + cnt = (576 - mp.pi * Dm * Dm) * J / kit.r**3 + emit(" E_{Q}[N_w(d >= %s)]/r^3 = (576 - pi D^2) J/r^3 = %s" + % (D, nstr(cnt, 8))) + emit(" read: the raw count is Theta(r^3) at every D < 12 -- the D-tail" + " decay of a CLASS price lives entirely in the connectivity factor" + " (the named input PD-CONN), not in the count.") + # far-lane count bound at the crude-spine cap grade, d >= d_max = 0.2: + # recompute the frozen annulus numerator restricted to radii >= 0.2 + radii = [mpf(x) for x in ['0.2', '0.3', '0.4', '0.5', '0.75', '1', '1.5', + '2', '3', '4', '5']] + angles = [0, 45, 90, 135, 180] + gridn = [] + for th in angles: + row = [] + for dd in radii: + y = (dd * mpmath.cos(mpmath.radians(th)), + dd * mpmath.sin(mpmath.radians(th))) + st = E.station(kit, y) + Icap, _dl = E.window_cap_env(kit, st) + row.append(st['pgrad'] * Icap) + gridn.append(row) + + def trapz_x(vals, xs): + tot = mpf(0) + for i in range(len(xs) - 1): + tot += (vals[i] + vals[i + 1]) / 2 * (xs[i + 1] - xs[i]) + return tot + + thrad = [mpf(th) * mp.pi / 180 for th in angles] + rad_int = [] + for j, dd in enumerate(radii): + col = [gridn[i][j] for i in range(len(angles))] + rad_int.append(trapz_x(col, thrad) * 2 * dd) + Num_far_lane = trapz_x(rad_int, radii) + cnt_far_lane = Num_far_lane / Z_LO / kit.r**3 + emit(" far-lane count bound (crude-spine cap grade, d >= d_max = 0.2," + " R2 floor): E_{P_r}[N_w(d >= 0.2)] <= Num/Z_lo = %s r^3" + % nstr(cnt_far_lane, 8)) + ck(cnt_far_lane < mpf('23'), "far-lane count bound sanity: %s" + % nstr(cnt_far_lane, 6)) + emit(" (this caps P(B2-far) via C2's exact separation; the annulus" + " cap density profile itself decays: displayed in the frozen D4:" + " rho_cap 7.8093e-7 @0.1 -> 1.3715e-9 @5, exact-kernel certified)") + + # --- PD5: the named-gap register + PD-CONN ---------------------------- + emit("") + emit("PD5 NAMED-GAP REGISTER (each entry: certified bound | missing" + " input | exact uncontrolled region)") + register = [ + {'class': 'B1.dir-far', + 'certified': 'P <= E_{P_r}[N_w]; D3-part <= 23.2119 r^3 (v2' + ' bracket + C1 hole)', + 'missing': 'PD-CONN', + 'region': 'the level-s connectivity between the away lobe (mean' + ' extent ~0.4, PD3) and C_M through the far field,' + ' d in [d_max, O(1)] -- the bridge annulus; transverse' + ' part over (0,d_max] certified by BRANCH_dir', + 'grade': 'COUNT-CERTIFIED / CONNECTIVITY-NAMED'}, + {'class': 'B2-far', + 'certified': 'P <= E_{P_r}[N_w(d>=0.2)] <= %s r^3 (cap grade,' + ' R2 floor)' % nstr(cnt_far_lane, 8), + 'missing': 'PD-CONN', + 'region': 'the far younger component touching S\'s sector lobes' + ' at level s, d in [d_max, O(1)] -- the same bridge' + ' annulus', + 'grade': 'COUNT-CERTIFIED / CONNECTIVITY-NAMED'}, + {'class': 'B4.rem', + 'certified': 'local dam per-section CERTIFIED (PD2c, kappa =' + ' Theta(1/r)); assembled dam = dam line (uniformity' + ' promotion-scope)', + 'missing': 'PD-CONN + the above-window merge count', + 'region': 'the non-local separator: the M-ward channel beyond the' + ' local cut net (d > r), the above-window merges' + ' (heights > b, NOT covered by the window count), and' + ' the torus wrap circuit (d ~ 12)', + 'grade': 'LOCAL-CERTIFIED / REMOTE-NAMED'}, + ] + ck(tuple(g['class'] for g in register) == TAXONOMY, + "register taxonomy drift: %s" % [g['class'] for g in register]) + for g in register: + ck('NAMED' in g['grade'] and 'CERTIFIED' in g['grade'], + "grade ledger breach: %s must carry both a certified part and a" + " named part" % g['class']) + ck(g['missing'].startswith('PD-CONN'), "missing-input id drift") + ck(len(g['region']) > 40, "uncontrolled region not precise") + emit(" [%s] certified: %s" % (g['class'], g['certified'])) + emit(" missing: %s | uncontrolled region: %s | grade: %s" + % (g['missing'], g['region'], g['grade'])) + emit("") + emit(" PD-CONN (the named input, deliverable-grade statement):") + emit(" Let Q_r be the six-pin law at rung r <= 0.05, s = b - r^3/6, and" + " A_r(K,D) the event that {f > s} has a connected component" + " meeting both K and the complement of B(K,D). REQUIRED: explicit" + " C0, c0 > 0, D0 >= 1 (r-independent) with P_{Q_r}(A_r(B(pair,2r),D))" + " <= C0 e^{-c0 D} for all D >= D0, r <= 0.05. CONSUMPTION: each" + " far lane's D-tail <= (certified count density) C0 e^{-c0 D}" + " (1 + kappa certified); class totals absorb at Theta(r^3) with" + " certified constants; B4.rem's wrap <= C0 e^{-12 c0} (area" + " factors). MISSING PIECES to certify PD-CONN: (i) explicit-constant" + " arm bound for planar Bargmann-Fock at positive level (literature" + " gives sharpness WITHOUT explicit constants -- an explicit RSW" + " constant is the missing theorem); (ii) the conditioned-to-" + "unconditioned FIELD-LEVEL patch on {d >= D0} (finite-dimensional" + " reversion certified here; the field-level version needs" + " continuity-modulus/entropy control -- Kolmogorov machinery, not" + " built); (iii) torus-to-planar comparison (T1/C.6: <= 1e-120," + " available). NOTE (the verdict): PD-CONN certifies CONSTANTS," + " not order -- at sub-kernel D the connectivity factor is" + " Theta(1) (PD3), so the classes remain Theta(r^3); the o(r^3)" + " reading is not reachable by any input of this kind.") + emit("") + emit("VERDICT (evidence-grade structural assessment on certified" + " displays): the far lanes are Theta(r^3)-order; PERC-DECAY should" + " be RESTATED as 'the far lanes absorb at Theta(r^3) with the" + " certified constants + PD-CONN D-tails' -- a premise this lane" + " underwrites -- not 'o(r^3)'.") + + # --- PD6: mutation suite (all must fire fail-closed) ------------------ + emit("") + emit("PD6 mutation suite") + import subprocess as _sp + _src = open('d3_perc_decay.py').read() + + def _run_mutated(tag, old, new, expect): + ck(old in _src, "%s setup: literal not found" % tag) + mpth = '_mut_perc_decay.py' + with open(mpth, 'w') as fh: + fh.write(_src.replace(old, new, 1)) + try: + prc = _sp.run([sys.executable, mpth], capture_output=True) + ck(prc.returncode != 0, "%s fail: mutation did not fire" % tag) + ck(expect in prc.stdout, + "%s fail: unexpected failure mode: %s" + % (tag, prc.stdout.decode('utf-8', 'replace')[-300:])) + finally: + import os as _os + _os.unlink(mpth) + emit(" %s: mutation -> SystemExit with the expected failure" % tag) + + _run_mutated("MUT-PD-1 register-taxonomy tamper", + "'class': 'B4.rem'", "'class': 'B4.rex'", + b'register taxonomy drift') + _run_mutated("MUT-PD-2 grade-label tamper (evidence as certified)", + "'grade': 'COUNT-CERTIFIED / CONNECTIVITY-NAMED'}", + "'grade': 'COUNT-CERTIFIED'}", + b'grade ledger breach') + _run_mutated("MUT-PD-3 R2 floor-pin tamper", + "mpf('7.7592917375327855e-3')", "mpf('8.061180539e-3')", + b'R2 floor drifted') + _run_mutated("MUT-PD-4 count-window tamper", + "cnt_far_lane < mpf('23')", "cnt_far_lane < mpf('17')", + b'far-lane count bound sanity') + _run_mutated("MUT-PD-5 corridor-display tamper", + "alive_to >= mpf('0.5')", "alive_to >= mpf('2.5')", + b'corridor display drifted') + + body = '\n'.join(_OUT) + '\n' + emit("D3-PERC-DECAY PASS digest=%s" % hashlib.sha256(body.encode()).hexdigest()) + raise SystemExit(0) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md new file mode 100644 index 000000000..00c146336 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md @@ -0,0 +1,123 @@ +# H3 BAND CEIL — certified uniform UPPER envelope of the normalizer on the rung band + +**Campaign:** U2D-UPPER (LPW_CONSTANT v4 / OBL-D1-PROMOTE, Palm denominator side) +**Scope:** periodized side-24 2D Bargmann–Fock field, corrected pin basis, soft six-pack, +E[G_r] = Z_r/r². Companion to `H3_BAND_FLOOR.md` (lower side). +**Deliverable of:** `h3_band_ceil.py` (this directory), executed 2026-09-15, both interpreter modes. + +--- + +## 1. Certified statement + +For **every** r in **(0, 0.05]**, cellwise certified ceilings (interval upper endpoints, +15 digits), each ck'd to nest the certified band floor (≥ 2.30659559567154) and to meet +the consumption cap U ≤ 4 (cap NOT widened at any point): + +| sub-interval | certified E[G_r] ≤ | margin over MC ~3.22–3.23 (diagnostic) | +|--------------------|------------------------|----------------------------------------| +| **(0, 0.0025]** | **3.66282864761194** | +13.3% | +| (0.0025, 0.005] | 3.66435028046302 | +13.4% | +| (0.005, 0.01] | 3.67360595202419 | +13.6% | +| (0.01, 0.02] | 3.69805856644731 | +14.4% | +| (0.02, 0.03] | 3.71138266685765 | +14.8% | +| (0.03, 0.04] | 3.72414748332433 | +15.2% | +| (0.04, 0.05] | 3.74767948915996 | +16.4% | + +Uniform form: **E[G_r] ≤ 3.74767948915996 for all r ∈ (0, 0.05]**, and on the v4 domain +**(0, 0.0025]: E[G_r] ≤ 3.66282864761194** — this cell contains v3's r₀ = 1/2278031360 +≈ 4.39e-10 and **discharges the LPW_CONSTANT v4 normalizer lever** (its owner's estimate: +4B₃/3.6629 ≈ ×2.274e12 → c ≈ 2.23e-10, now backed by this carrier). +MC point estimates (labeled diagnostic, non-load-bearing): 3.21876 ± 0.00709 (r = 0.05), +3.23339 ± 0.00709 (r = 0.01); both below the certified ceilings as required. +Combined with the floor: **2.30659559567154 ≤ E[G_r] ≤ 3.66282864761194 on (0, 0.0025]** +(cellwise sharper pairs in the two carriers' tables). + +## 2. Method + +Same certified law pipeline as the floor (exact finite-torus moments; Laurent-series Gram +algebra with exact pole cancellation; exact series division for μ(r), Σ(r) to J = 60 with +pole-index terms; per-cell Neumann+Cauchy certified corrections; R-majorant tails on the +first cell; certified Φ: series |x| ≤ 6 + Gordon–Mills |x| > 6). The upper-envelope +algebra: + + E[G_r] = E[p·1_type] = E[p·1_{q_M<0}] − E[p·1_{q_M<0, ¬type}] + ≤ E[p·1_{q_M<0}] + E[p̄·1_{q_M<0, D_M≤0}] + E[p̄·1_{q_M<0, D_S≥0}] + +with p = −D_MD_S, p̄ = ((α_M²q_M²+1)/2 + rβ_M²)((α_S²q_S²+1)/2 + rβ_S²) ≥ |p| pointwise +(so −E[p·1_A] ≤ E[p̄·1_A] for any A). The three pieces: + +1. **E[p·1_{q_M<0}]** — three EXACT truncated windows (conditional-Wick + 1D truncated + moments, two-sided interval enclosures): [−3.9, −0.4], (−0.4, 0), (−100, −3.9), plus a + (−∞, −100) residue via Cauchy–Schwarz with the certified 70σ Gaussian tail (≈ 0). +2. **{D_M ≤ 0, q_M < 0}** ⊂ {α_M > −0.6} ∪ {|β_M| > 2} ∪ {q_M ∈ (−0.4, 0)} (cover margin + 0.6·0.4 = 0.24 > 0.05·4 = 0.20 ≥ rβ², ck'd): the α piece by exact-Gaussian-tail + Chernoff–CS (12σ at the rung, → 0 as r → 0); the β and mid-q pieces exact. +3. **{D_S ≥ 0}** ⊂ {q_S ≥ 0} ∪ {α_S ≤ 0} (α_Sq_S ≥ rβ² ≥ 0 needs equal signs): the q_S + piece exact (~0.36, the dominant type-fail correction — q_S crossing 0 is a 0.86σ + event), the α_S piece Chernoff (≈ 0). + +## 3. Direction analysis (symmetry / asymmetry, honest) + +- **Direction-neutral (two-sided enclosures):** the moments, Gram/series algebra, law + enclosures (μ, Σ), Φ machinery, and all truncated-normal integrals. The main p-windows + certify BOTH directions simultaneously — the floor's main piece and the ceiling's + p-windows are the same two-sided computation. +- **Lower side (floor):** lower-bounded the main piece and needed UPPER bounds on the four + bad pieces (|δ| > η, |β_M| > 2, α_M > −0.8, α_S < 0.8) — the rare ones by Chernoff–CS, + the β one exact. +- **Upper side (this certificate):** needs the type-fail correction bounded ABOVE, i.e. + upper bounds on a different event family ({D_M ≤ 0}, {D_S ≥ 0} within q_M < 0). The + asymmetry is in the event family, not the machinery: the floor's bad pieces exclude + mass from a certified box; the ceiling's fail pieces re-include what the box exclusion + dropped. The dominant ceiling-side looseness is E[p̄·1_{q_S≥0}] ≈ 0.36 (a genuinely + non-rare event, so no tail argument can shrink it — only an exact joint computation + would) and the p̄-vs-p slack inside it. +- **The naive p̄-only envelope is NOT viable (recorded):** E[p̄·1_{q_M<0}] = 9.55 at the + rung (E[p̄] = 9.91 vs E[G] = 3.23 — the (x²+1)/2 ≥ |x| majorant is ~3× loose under + fourth-moment weight). The shipped construction uses exact p on the main mass and + confines p̄ to the fail pieces; that is the whole price of the upper side. +- **Investigation of the (0.03, 0.04] cell (lead directive 2):** its enclosure did NOT + genuinely exceed 4. The failure was in the exact conditional-Wick path for the + α-coordinate pieces: the conditional coefficients Sig[i][α]/s_αα are ratios of two + narrow, strongly r-dependent intervals (s_αα ~ 0.166r²), and interval division loses + the correlation, exploding the conditional moments (observed ±700 on [0.03, 0.04]). + This is the same interval ratio-dependency noted in the floor's build log, not a tail + or truncation degradation: the certified Gaussian-tail (Chernoff–CS) path is both + VALID and strictly tighter there (t₀ = 24σ → piece ≈ 0). The cell now certifies + 3.72414748332433 < 4 with the same cap — no cap widening occurred. + +## 4. Remainder ledger + +| item | value | +|---|---| +| law pipeline | identical to H3_BAND_FLOOR (J = 60, ρ = 0.11, R = 30.4545 on cell 1 only) | +| p-windows (exact) | [−3.9,−0.4] 2.6678; (−0.4,0) 0.00494; (−100,−3.9) 0.5624 (cell-7 values) | +| fail pieces (cell-7) | α_M 1.9e-43; |β_M|>2 0.108; q_M∈(−0.4,0) 0.0272; q_S≥0 0.3677; α_S ~0 | +| residues | (−∞,−100), (100,∞) tails ≈ 0 (certified Mills, 20σ+ margins ck'd) | +| nesting ck | hi.b > 2.30659559567154 (band floor) on every cell | +| consumption cap | U ≤ 4 per cell, NOT widened; all 7 cells pass after the α-path fix | +| mutations | planar_moments → CB1a; wrong_window → CB3; cap_raised (p̄, p ×2) → CC6 consumption, all exit 1 | + +## 5. Honest scope and grade + +- Covers r ∈ (0, 0.05] cellwise; the v4 lever needs only cell 1 (0, 0.0025] — discharged + at U = 3.66282864761194. Says nothing about r > 0.05. +- The ceiling is looser than the floor in relative terms (+13–16% over MC vs the floor's + −28%) because of the q_S ≥ 0 fail piece and the p̄ slack inside it; tightening further + would need an exact joint (q_S, ·) computation, not better tails. Sufficient for the + ×1.8e12-lever consumption (the lever's sensitivity to U is 1/U). +- The cap_raised mutation is the consumption-side guard the lead required: any corruption + inflating the envelope (here ×2) is caught fail-closed at the U ≤ 4 consumption ck. + +**Grade: A** for the stated scope (uniform certified upper envelope, fail-closed, +mutation-tested incl. consumption guard, both-modes byte-identical, MC labeled). + +## 6. Artifacts and hashes + +- `h3_band_ceil.py` — certificate program (sha256 b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452) +- `ceil_normal.txt` / `ceil_O.txt` — transcripts, **byte-identical** (sha256 26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00) +- `ceil_out.txt` — hashed transcript body (sha256 1642236cf8e0a8346c17d00b345a9690733e64b941af741354aa9316c59eda5a, matches the in-transcript self-hash line) +- `ceil_mut_cap.txt`, `ceil_mut_planar.txt`, `ceil_mut_window.txt` — mutation runs (all exit 1 at the designed guards) +- MANIFEST.sha256 / RECEIPT_h3.json — regenerated; frozen entries unchanged. + +Body hash of this document: recorded in MANIFEST.sha256 (document body excluding the hash line itself). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md new file mode 100644 index 000000000..e5116baf7 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md @@ -0,0 +1,173 @@ +# H3 BAND FLOOR — certified uniform normalizer floor on the whole rung band + +**Campaign:** U2D-UPPER (Stage E / OBL-D1-PROMOTE, normalizer side) +**Scope:** periodized side-24 2D Bargmann–Fock field, corrected pin basis (trapezoid), soft six-pack +Y = (q_M, q_S, α_M, α_S, β_M, β_S), D = αq − rβ². +**Deliverable of:** `h3_band_floor.py` (this directory), executed 2026-09-15, both interpreter modes. + +--- + +## 1. Certified statement + +For **every** r in the open band **(0, 0.05]**, + + **E[G_r] ≥ 2.30659559567154 > c_Z = 1.615489267643502474048123284509081575382** + +and therefore the normalizer satisfies + + **Z_r = r²·E[G_r] ≥ c_Z·r² uniformly on (0, 0.05]**, worst certified margin **+42.78%** + +(attained on the rung-adjacent cell (0.04, 0.05]). This discharges the normalizer side of +OBL-D1-PROMOTE: the rung certificate `H3_RUNG_FLOOR.md` covered the point r = 0.05; +this certificate covers **all** r ∈ (0, 0.05] in one pass, with r as an interval through +the pipeline. Per-cell certified floors (interval lower endpoints, 15 digits): + +| sub-interval | certified E[G_r] ≥ | margin vs c_Z | +|--------------------|------------------------|---------------| +| (0, 0.0025] | 2.58288222715895 | +59.88% | +| (0.0025, 0.005] | 2.58174158877406 | +59.81% | +| (0.005, 0.01] | 2.54243388604045 | +57.38% | +| (0.01, 0.02] | 2.45593199230367 | +52.02% | +| (0.02, 0.03] | 2.44022641168325 | +51.05% | +| (0.03, 0.04] | 2.41792545239159 | +49.67% | +| (0.04, 0.05] | 2.30659559567154 | +42.78% | + +The bound is an interval enclosure: the true E[G_r] lies in [lo, hi] on each cell +(hi's are emitted in the transcript; only lo's are load-bearing). + +## 2. Why the whitened/box pipeline cannot do interval-r (recorded negative result) + +Carrying r as an interval through the Stage-E whitened pipeline fails structurally: +(i) the LDL whitened pivots D₂ ~ c·r² ≈ 4.2e-4 and D₃ ~ 2.1e-7 are destroyed by any +interval enclosure of the Gram (widths ≫ pivots at any practical sub-interval size); +(ii) naive interval-coefficient evaluation of the divided-difference pin functionals +gives catastrophic cancellation (measured Gram-entry width 3.3e7 on [0.049, 0.05]); +(iii) crude derivative/Lipschitz bounds are λ²-amplified (‖G⁻¹‖ ~ 25.6). +The band certificate therefore uses a **no-whitening Wick architecture** plus an +**exact Taylor-series device** for the conditional law (below); no factorization, +no whitening, no Monte Carlo in the certificate. + +## 3. Method (four certified blocks + cross-checks) + +**CB1 — exact finite-torus moments.** a_{2m} (m ≤ 40) by the Poisson–Hermite identity +(interval Hermite recurrence, |n| ≤ 3 lattice + certified geometric tail); certified +separated deviations 0 < 1 − a₂ = 9.6525417989599e-123 ±, 0 < a₄ − 3 < 1e-100 +(summandwise-positive Poisson path). Planar moments are forbidden fail-closed (mutation +guard CB1a). + +**CB2 — exact Laurent-series Gram algebra.** All entries of the pin Gram G, soft Gram +GY and cross Gram GYV as Laurent series in r (window [z⁻⁸, z⁶²]) with interval +coefficients built from the certified moments via the kernel Taylor series +K1⁽ⁿ⁾(z) = Σ_j (−1)^{(n+j)/2} a_{n+j} z^j/j! and ce.cov's exact sign convention +(no s-flip; verified against cov_exact source). The corrected-basis poles cancel +**exactly**: G regular; GYV regular below z⁻¹; GY below z⁻² (genuine soft poles +z⁻¹, z⁻² isolated — the soft Gram is singular at r = 0 by construction; only the +conditional law is regular). + +**CB3 — exact series division.** H = G⁻¹ and W = G⁻¹z_V as Taylor series by the +recurrences H_j = −G₀⁻¹Σ_{i≤j}G_iH_{j−i}, and μ(r) = GYV·W, +Σ(r) = GY − GYV·H·GYVᵀ as series to order J = 60, **including the pole-index terms** +GYV₋₁·W_{j+1} etc. The genuine poles are annihilated by the conditioning: the z⁻¹ +coefficient of μ and the z⁻², z⁻¹ coefficients of Σ are ck'd to vanish (< 1e-50). +Limit identities at r = 0 match the independent blow-up analysis: μ_q(0) = −6/5, +μ_αM(0) = −1, μ_αS(0) = +1, Var(α_M)(0) = 0, Var(q)(0) = 2 (wrong-window mutation +guard at the α-identity). Rotated law (q_M, δ = q_S − q_M, …) built at **series level** +so the var_δ = Σ₀₀ − 2Σ₀₁ + Σ₁₁ cancellation is exact in the coefficients. + +**CB4 — certified tails.** Literal triangle (literal-curse) entry maxima on the circle +|z| = ρ = 0.11: M_G = 2.96e6, M_GY = 3.44e2, M_GYV = 1.95e4 (valid sup bounds of the +analytic kernel expressions — Gram entries are entire/pole-cancelled; Laurent-coefficient +Cauchy bounds |g_j| ≤ M(ρ)/ρ^j hold for all j). Recursion-consistent R-majorants for +W, H with R = 30.4545, θ = 36·‖G₀⁻¹‖(S_G(R) + T_G(R)) = 0.485 ≤ 1/2 — used **only** on +the first cell (R·0.0025 = 0.076 < 1): series tails there Σ-tail 4.68e-62, μ-tail 6.39e-66. +On the six cells with r₁ > 0 the truncation error is certified by the Neumann identity +G⁻¹ − G⁻¹_partial = G⁻¹(G − G_partial)G⁻¹_partial with ‖G⁻¹‖ Neumann-certified per cell +(contraction ρ < 1/2 ck'd) and the Gram Cauchy tail (~1e-21 at the rung) — the +pole-cancelling heavy part is the exact series, the correction is a norm bound; the +literal-curse constant is crushed by (r/ρ)^63. Correction widths T_μ, T_Σ < 1e-2 ck'd +per cell (actual ≪). + +**CB5–CB6 — band evaluation.** On each cell, with the enclosed (μ(r), Σ(r)): + + E[G_r] ≥ E[p·1_{q_M∈[−3.9,−0.4]}] − E[p̄·1_{|δ|>0.3}] − E[p̄·1_{|β_M|>2}] + − E[p̄·1_{α_M>−0.8}] − E[p̄·1_{α_S<0.8}], + +p = −D_MD_S, p̄ = ((α_M²q_M²+1)/2 + rβ_M²)((α_S²q_S²+1)/2 + rβ_S²) ≥ |p| (|x| ≤ (x²+1)/2). +Type margins (law-independent, r-uniform): D_M ≥ 0.8·0.4 − 0.05·4 = 0.12 > 0, +D_S ≤ 0.8·(−0.1) < 0, q_S ≤ −0.1 — ck'd per cell, so the box certifies the type event. +Pieces: main piece by conditional-Wick polynomial algebra (conditional expectation as +polynomial in the pinned coordinate; 1D truncated-normal moments by the exact recurrence; +certified Φ: power series |x| ≤ 6 with geometric-tail certificate (ratio < 0.9, k ≥ 21, +straddles split by monotonicity), Gordon–Mills φ(x)(1/x − 1/x³) < Q(x) < φ(x)/x for +|x| > 6). The rare-event pieces (δ, α_M, α_S) use the **exact Gaussian tail** (these +variables are exactly Gaussian) with Cauchy–Schwarz: E[p̄1_A] ≤ √(E[p̄²]·P(A)), +P(A) = Q(t₀) certified by the same Φ machinery — at the rung t₀ = 9.7 (α) and 3.63 (δ); +below r = 0.03 all three are < 1e-2 and rapidly → 0 as r → 0, which is what makes the +uniform bound reach r = 0. The β_M piece (2.8σ, not rare) uses the exact truncated +integral everywhere. + +**CB7 — independent cross-checks.** At r = 0.05 the Neumann-enclosed (μ, Σ) contain the +independent direct point law (ce.cov + mp Gauss solve, no series machinery) — containment +ck'd entrywise. MC diagnostics (numpy, fixed seed 90210, 4e5 samples, **labeled +non-load-bearing**): E[G_0.05] = 3.21876 ± 0.00709, E[G_0.01] = 3.23339 ± 0.00709, both +≥ the certified floor (consistent; the certificate does not use them). + +**CB8 — discipline.** Fail-closed ck → SystemExit (no bare asserts); both modes +(`python3` and `python3 -O`) byte-identical transcripts; mutation suite: +MUTATION=planar_moments exits 1 at CB1a (exact-torus moment guard), +MUTATION=wrong_window exits 1 at CB3 (μ_αM(0) = −1 window identity). + +## 4. Remainder ledger + +| item | value | +|---|---| +| series order kept exactly | J = 60 (W, H to J+2 for pole-index terms) | +| moments | a_{2m}, m ≤ 40, exact finite torus (never planar) | +| majorant circle | ρ = 0.11; literal entry maxima 2.96e6 / 3.44e2 / 1.95e4 | +| R-majorant (W, H) | R = 30.4545, θ = 0.485; used only on (0, 0.0025] (Rr = 0.076) | +| series tails on (0, 0.0025] | Σ-tail 4.68e-62, μ-tail 6.39e-66 | +| cells 2–7 correction | Neumann+Cauchy, T_μ, T_Σ < 1e-2 ck'd (actual ≪; Gram tail ~1e-21 at rung) | +| G₀ inverse residual | 6.07e-98 | +| Φ machinery | series |x| ≤ 6 (certified tail), Gordon–Mills |x| > 6, straddle split | +| sub-intervals | 7 cells: (0,.0025], (.0025,.005], (.005,.01], (.01,.02], (.02,.03], (.03,.04], (.04,.05] | +| worst cell | (0.04, 0.05]: lo 2.30659559567154, margin +42.78% | +| MC diagnostic | consistent, explicitly non-load-bearing | + +## 5. Recorded erratum (for the next amendment; no re-issue of frozen files) + +Per the Stage-E numerics re-review of `h3_rung_floor.py` (verified fully otherwise: +both modes byte-identical, mutations caught, dps=150 spot-check identical to all 17 +digits): **CR5f computes `aS_rng.b·qS_rng.b` rather than the sharp sup +`aS_rng.a·qS_rng.b`** — the ck remains SOUND (D_S < 0 follows from CR5b/CR5d: +α_S > 0 > q_S ⇒ α_S·q_S < 0), so it is a mislabeled intermediate only. Action for the +next amendment: correct the label or the formula; **do not touch the frozen +`H3_RUNG_FLOOR.md` (6347275d…)**. This band certificate is independent of that label +(its D_S < 0 margin is the law-independent 0.8·(−0.1) argument of §3/CB6). + +## 6. Honest scope and grade + +- The certificate covers **r ∈ (0, 0.05]** only — the H3 rung band. It says nothing + about r > 0.05 (not needed for the rung route) and does not replace the frozen + point certificates (H3_CLOSURE.md, H3_RUNG_FLOOR.md), which remain untouched. +- The statement is the normalizer floor used by D1 v2.1's C_RN and the D3 v2 κ_far + denominator, now uniformly in r: Z_r ≥ c_Z·r² for all r ∈ (0, 0.05]. +- The dominant losses (honest accounting): the β_M truncated piece (~0.08–0.25 per + cell, exact integral), the δ Chernoff piece at the top cell (0.088), interval + enclosure widths of lo (~0.01–0.65 total spread; see transcript [lo, hi]). + The true E[G_r] ≈ 3.2 (MC) is nearly flat on the band; the certified floor's + dip to 2.31 at the top cell is enclosure loss, not physics. +- The reconnaissance complex scan (min |det G(z)| ≥ 5.3e4 on |z| ≤ 0.11) motivated the + design but is **not** cited by the certificate; all tails are literal-bound certified. + +**Grade: A** for the stated scope (uniform certified normalizer floor on (0, 0.05], +fail-closed, mutation-tested, both-modes byte-identical, MC-labeled). + +## 7. Artifacts and hashes + +- `h3_band_floor.py` — the certificate program (sha256 a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5) +- `band_normal.txt` / `band_O.txt` — transcripts, **byte-identical** (sha256 dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d) +- `band_out.txt` — hashed transcript body (sha256 617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54, matches the in-transcript self-hash line) +- `band_mut_planar.txt`, `band_mut_window.txt` — mutation runs (both exit 1 at the designed guards) +- MANIFEST.sha256 / RECEIPT_h3.json — regenerated to include the above; frozen entries unchanged. + +Body hash of this document: recorded in MANIFEST.sha256 (document body excluding the hash line itself). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt new file mode 100644 index 000000000..9b11fb6fe --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt @@ -0,0 +1,33 @@ +387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637 H3_CLOSURE.md +6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa H3_RUNG_FLOOR.md +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 cert_O.txt +a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78 cert_normal.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f fals_O.txt +5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f fals_normal.txt +56076fa852e3787e683921496adc796b04132ea817be924ed84ef68d68abc84c h3_c0_certificate.py +645b6d9d24721674b419e8d026183722a90a1a27ee4e7b0053c53faced73cd47 h3_falsifier.py +094d382451ff37e8d3123e7203c743f359cb0af1c2c12cf336adf74fc0b25d8f h3_rung_floor.py +a5d661d89abe05c62d95c6be48f6c2264b7f782f97f90b0c5dd4ae47525c2843 mut_planar.txt +68e302276df9a84e6be3f11309deaf1910e70747ade4d4f560742c8225a95a8e mut_window.txt +427aeae3242cfabb2bc598e29b9f46a6d1b290b393fb35a8f263007bd8e5ae7b rung_045.txt +d439d37ff53c505ce220f673e8bfe55126f74832795167e5e4abb351e0064119 rung_055.txt +ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013 rung_O.txt +2b17c664be8c927aa516c8987acb3f7fdf86eebfd597c14fe0176850ff170c90 rung_mut_planar.txt +f0fee83e36affc06c004855fee67d6f7320b4279f4bdeb68ad883abd3f343dde rung_mut_window.txt +ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013 rung_normal.txt +281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7 H3_BAND_FLOOR.md(body-excl-hash-line) +a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5 h3_band_floor.py +dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d band_normal.txt +dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d band_O.txt +617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54 band_out.txt +4fc8105d1050dc2a284750ada417f959725711b8e19865ced682192da59e4774 band_mut_planar.txt +ff1765d4ace7fb5c61402e227c5896017bd1995cad0e2f8475761a3850a01c51 band_mut_window.txt +cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2 H3_BAND_CEIL.md(body-excl-hash-line) +b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452 h3_band_ceil.py +26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00 ceil_normal.txt +26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00 ceil_O.txt +1642236cf8e0a8346c17d00b345a9690733e64b941af741354aa9316c59eda5a ceil_out.txt +7116a7d124389b1d23fd1e48d33d4a4e182a66b1f04fe408db5e1f14201bb897 ceil_mut_cap.txt +96d4cc4220e540223321150598a84e358c6794c1ae3d502efa779692de317bcb ceil_mut_planar.txt +ff6ce33ce53b45e55dc257e3dc8cbea5ce33ee6032df77eb2323c554819522b3 ceil_mut_window.txt +ee58ef8054109a24ea0dadd5f0147b883966374e539ff462f8500af932765264 RECEIPT_h3.json diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json new file mode 100644 index 000000000..96e95d171 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json @@ -0,0 +1,103 @@ +{ + "band_ceil": { + "discharges": "LPW_CONSTANT v4 Palm denominator on (0, 0.0025] (r0 = 1/2278031360 in cell 1)", + "method": "exact p-windows on {q_M<0} (two-sided) + pbar type-fail pieces ({D_M<=0},{D_S>=0} half-space covers; Chernoff alpha pieces); nesting ck vs band floor; consumption cap U<=4 not widened", + "mutations_caught": [ + "planar_moments (CB1a)", + "wrong_window (CB3)", + "cap_raised (CC6 consumption cap)" + ], + "record": "H3-BAND-CEIL-2026-09-15", + "result": "CERTIFIED UNIFORM UPPER: E[G_r] <= 3.74767948915996 for ALL r in (0, 0.05]; on the v4 domain (0, 0.0025]: E[G_r] <= 3.66282864761194 (v4 lever discharged)", + "subintervals": { + "(0,0.0025]": "3.66282864761194", + "(0.0025,0.005]": "3.66435028046302", + "(0.005,0.01]": "3.67360595202419", + "(0.01,0.02]": "3.69805856644731", + "(0.02,0.03]": "3.71138266685765", + "(0.03,0.04]": "3.72414748332433", + "(0.04,0.05]": "3.74767948915996" + }, + "two_mode_byte_identical": true + }, + "band_floor": { + "discharges": "normalizer side of OBL-D1-PROMOTE on the rung band (0, 0.05]", + "method": "no-whitening Wick bound + exact Taylor-series (J=60) conditional law; pole-cancelled series + Neumann/Cauchy certified corrections; certified Phi (series|Mills); Gaussian-tail Chernoff rare pieces; MC diagnostic only", + "mutations_caught": [ + "planar_moments (CB1a)", + "wrong_window (CB3 window identity)" + ], + "record": "H3-BAND-FLOOR-2026-09-15", + "result": "CERTIFIED UNIFORM: E[G_r] >= 2.30659559567154 > c_Z = 1.615489267643502474048123284509081575382 for ALL r in (0, 0.05]; Z_r >= c_Z r^2, worst margin +42.78% (cell (0.04,0.05])", + "subintervals": { + "(0,0.0025]": "2.58288222715895 (+59.88%)", + "(0.0025,0.005]": "2.58174158877406 (+59.81%)", + "(0.005,0.01]": "2.54243388604045 (+57.38%)", + "(0.01,0.02]": "2.45593199230367 (+52.02%)", + "(0.02,0.03]": "2.44022641168325 (+51.05%)", + "(0.03,0.04]": "2.41792545239159 (+49.67%)", + "(0.04,0.05]": "2.30659559567154 (+42.78%)" + }, + "two_mode_byte_identical": true + }, + "c0_certified_lower": "3.23097853528700494809624656901816315076485801055871099847056563983657866727484113533199277175345604743007", + "c0_certified_upper": "3.23097853528700494809624656901816315076485801055871099847056563983657866727484113533199277175345608823472", + "c_Z": "c_0/2 >= 1.615489267643502474048123284509081575382 (r <= r_0, r_0>0 existential)", + "mutations_caught": [ + "planar_moments (CK2)", + "wrong_window (CK6)" + ], + "record": "H3-CLOSURE-U2D-UPPER-2026-09-13", + "result": "CLOSED theorem-grade with one named amendment (2D typing; literal ind_S=2 transcription gives c_0=0) and existential r_0", + "rung_floor": { + "mutations_caught": [ + "planar_moments (CR1a)", + "wrong_window (CR5e)" + ], + "record": "H3-RUNG-FLOOR-R2-2026-09-13", + "result": "CERTIFIED: Z_0.05 in [7.7592917375327855e-3, 1.1468646473404396e-2], lo > c_Z r^2 = 4.0387231691087558e-3, margin +92.12%", + "stretch_rungs": { + "11/200": "lo 9.3860471051561076e-3", + "9/200": "lo 6.2865611483300006e-3" + }, + "two_mode_byte_identical": true + }, + "sha256": { + "H3_BAND_CEIL.md(body-excl-hash-line)": "cfe8a3a49e3281dfdc4ef5d925ae622b4f7aeea3d0462baae61b87dae699ede2", + "H3_BAND_FLOOR.md(body-excl-hash-line)": "281477c39412840bc9ca56a256884f3ddd5f0ae4283f90a017162676771382a7", + "H3_CLOSURE.md": "387e4bae4881a036486f17f317ae5e26b7d94bd5e1e829cc76946d090fb81637", + "H3_RUNG_FLOOR.md": "6347275d86c56842b719b36180e535bc1793d6995ddb68464db2960820440dfa", + "band_O.txt": "dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d", + "band_mut_planar.txt": "4fc8105d1050dc2a284750ada417f959725711b8e19865ced682192da59e4774", + "band_mut_window.txt": "ff1765d4ace7fb5c61402e227c5896017bd1995cad0e2f8475761a3850a01c51", + "band_normal.txt": "dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d", + "band_out.txt": "617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54", + "ceil_O.txt": "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00", + "ceil_mut_cap.txt": "7116a7d124389b1d23fd1e48d33d4a4e182a66b1f04fe408db5e1f14201bb897", + "ceil_mut_planar.txt": "96d4cc4220e540223321150598a84e358c6794c1ae3d502efa779692de317bcb", + "ceil_mut_window.txt": "ff6ce33ce53b45e55dc257e3dc8cbea5ce33ee6032df77eb2323c554819522b3", + "ceil_normal.txt": "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00", + "ceil_out.txt": "1642236cf8e0a8346c17d00b345a9690733e64b941af741354aa9316c59eda5a", + "cert_O.txt": "a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78", + "cert_normal.txt": "a27178a871b54e4aee516c980b3941c086e0636e7a8854ae446a45898e87ec78", + "fals_O.txt": "5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f", + "fals_normal.txt": "5be02ea219198b744096d235e250c48bab4be1f5e24600d458fc813ab500d65f", + "h3_band_ceil.py": "b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452", + "h3_band_floor.py": "a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5", + "h3_c0_certificate.py": "56076fa852e3787e683921496adc796b04132ea817be924ed84ef68d68abc84c", + "h3_falsifier.py": "645b6d9d24721674b419e8d026183722a90a1a27ee4e7b0053c53faced73cd47", + "h3_rung_floor.py": "094d382451ff37e8d3123e7203c743f359cb0af1c2c12cf336adf74fc0b25d8f", + "mut_planar.txt": "a5d661d89abe05c62d95c6be48f6c2264b7f782f97f90b0c5dd4ae47525c2843", + "mut_window.txt": "68e302276df9a84e6be3f11309deaf1910e70747ade4d4f560742c8225a95a8e", + "rung_045.txt": "427aeae3242cfabb2bc598e29b9f46a6d1b290b393fb35a8f263007bd8e5ae7b", + "rung_055.txt": "d439d37ff53c505ce220f673e8bfe55126f74832795167e5e4abb351e0064119", + "rung_O.txt": "ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013", + "rung_mut_planar.txt": "2b17c664be8c927aa516c8987acb3f7fdf86eebfd597c14fe0176850ff170c90", + "rung_mut_window.txt": "f0fee83e36affc06c004855fee67d6f7320b4279f4bdeb68ad883abd3f343dde", + "rung_normal.txt": "ad09ec8fe5b0feb95b3c2d89fba28c6dac7e6d1bd4f2539d47f30a323f13e013" + }, + "two_mode_byte_identical": { + "certificate": true, + "falsifier": true + } +} \ No newline at end of file diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt new file mode 100644 index 000000000..fa3d4e590 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt @@ -0,0 +1,33 @@ +H3 BAND FLOOR (U2D-UPPER, STAGE E / OBL-D1-PROMOTE) +mode dps=100 both-modes-deterministic MUTATION=none +CB0 PASS: H2 library hashes match MANIFEST +CB1 PASS: moments a_{2m}, m<=40, exact finite torus (1-a2 = [9.65254179895991305500968634889155569818652119632390800082887438481172750287524569773572114326599837546376e-123, 9.65254179895991305500968634889155569818652119632390800082887438481172750287524569773572114326599837546376e-123]) +CB2 series built in 0.1s +CB2 PASS: corrected-basis poles cancel exactly; genuine soft poles z^-1, z^-2 isolated +CB3 G0 inverse residual 6.07e-98 +CB3 series division done +CB3 poles of mu (z^-1) and Sigma (z^-2, z^-1) annihilated by conditioning +CB3 PASS: limit identities mu(0), Sigma(0) match the independent blow-up analysis +CB4 literal entry maxima on |z|=0.11: GP 2.96e+06 GY 3.44e+02 GYV 1.95e+04 +CB4 majorant growth R = 30.4545 (rho*R = 3.350) theta = 0.485 +CB4 PASS: series tails on (0,0.005]: Sig 4.68e-62 mu 6.39e-66 +CB6 (0,0.0025] lo in [2.58288222716, 2.65368] (EqI 2.6607597, deltas 0.00e+00 7.79e-02 0.0e+00 0.0e+00) +CB6 (0,0.0025] CERTIFIED: E[G_r] >= 2.58288222715895 > c_Z = 1.6154892676..., margin 59.88% +CB6 (0.0025,0.005] lo in [2.58174158877, 2.65425] (EqI 2.6606992, deltas 0.00e+00 7.90e-02 0.0e+00 0.0e+00) +CB6 (0.0025,0.005] CERTIFIED: E[G_r] >= 2.58174158877406 > c_Z = 1.6154892676..., margin 59.81% +CB6 (0.005,0.01] lo in [2.54243388604, 2.69261] (EqI 2.6569392, deltas 4.87e-49 1.15e-01 0.0e+00 0.0e+00) +CB6 (0.005,0.01] CERTIFIED: E[G_r] >= 2.54243388604045 > c_Z = 1.6154892676..., margin 57.38% +CB6 (0.01,0.02] lo in [2.4559319923, 2.77691] (EqI 2.648927, deltas 3.04e-12 1.93e-01 2.6e-67 1.9e-61) +CB6 (0.01,0.02] CERTIFIED: E[G_r] >= 2.45593199230367 > c_Z = 1.6154892676..., margin 52.02% +CB6 (0.02,0.03] lo in [2.44022641168, 2.78882] (EqI 2.647491, deltas 2.28e-05 2.07e-01 8.1e-31 1.8e-26) +CB6 (0.02,0.03] CERTIFIED: E[G_r] >= 2.44022641168325 > c_Z = 1.6154892676..., margin 51.05% +CB6 (0.03,0.04] lo in [2.41792545239, 2.8003] (EqI 2.645588, deltas 6.13e-03 2.22e-01 8.0e-18 2.1e-14) +CB6 (0.03,0.04] CERTIFIED: E[G_r] >= 2.41792545239159 > c_Z = 1.6154892676..., margin 49.67% +CB6 (0.04,0.05] lo in [2.30659559567, 2.82398] (EqI 2.6428783, deltas 8.83e-02 2.48e-01 1.8e-11 1.1e-08) +CB6 (0.04,0.05] CERTIFIED: E[G_r] >= 2.30659559567154 > c_Z = 1.6154892676..., margin 42.78% +CB6 PASS: uniform certified floor on (0, 0.05]: min lo = 2.30659559567154 +CB7 PASS: Neumann (mu, Sigma) at r=0.05 contain the independent direct point law +CB7 MC DIAGNOSTIC r=0.05: E[G] = 3.21876 +- 0.00709 (>= certified lo 2.30660 OK; NOT load-bearing) +CB7 MC DIAGNOSTIC r=0.01: E[G] = 3.23339 +- 0.00709 (>= certified lo 2.30660 OK; NOT load-bearing) +ALL_CHECKS_PASS +sha256(transcript-above) = 617b2d07fcaef23313427e68020182d0b27cad78032b399336a1b925db489f54 diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt new file mode 100644 index 000000000..e2d0cfac3 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt @@ -0,0 +1,33 @@ +H3 BAND CEIL (U2D-UPPER, LPW_CONSTANT v4 normalizer denominator) +mode dps=100 both-modes-deterministic MUTATION=none +CB0 PASS: H2 library hashes match MANIFEST +CB1 PASS: moments a_{2m}, m<=40, exact finite torus (1-a2 = [9.65254179895991305500968634889155569818652119632390800082887438481172750287524569773572114326599837546376e-123, 9.65254179895991305500968634889155569818652119632390800082887438481172750287524569773572114326599837546376e-123]) +CB2 series built in 0.1s +CB2 PASS: corrected-basis poles cancel exactly; genuine soft poles z^-1, z^-2 isolated +CB3 G0 inverse residual 6.07e-98 +CB3 series division done +CB3 poles of mu (z^-1) and Sigma (z^-2, z^-1) annihilated by conditioning +CB3 PASS: limit identities mu(0), Sigma(0) match the independent blow-up analysis +CB4 literal entry maxima on |z|=0.11: GP 2.96e+06 GY 3.44e+02 GYV 1.95e+04 +CB4 majorant growth R = 30.4545 (rho*R = 3.350) theta = 0.485 +CB4 PASS: series tails on (0,0.005]: Sig 4.68e-62 mu 6.39e-66 +CC6 (0,0.0025] hi.b = 3.66282864761 (p-win 2.6678197 0.0049376239 0.56235074; fails 0.0e+00 0.047 0.0246 0.3566 0.0e+00) +CC6 (0,0.0025] CERTIFIED: E[G_r] <= 3.66282864761194 +CC6 (0.0025,0.005] hi.b = 3.66435028046 (p-win 2.667822 0.0049385578 0.56234822; fails 0.0e+00 0.047 0.0247 0.3571 0.0e+00) +CC6 (0.0025,0.005] CERTIFIED: E[G_r] <= 3.66435028046302 +CC6 (0.005,0.01] hi.b = 3.67360595202 (p-win 2.6713733 0.0049696104 0.56292046; fails 0.0e+00 0.051 0.0250 0.3585 0.0e+00) +CC6 (0.005,0.01] CERTIFIED: E[G_r] <= 3.67360595202419 +CC6 (0.01,0.02] hi.b = 3.69805856645 (p-win 2.6785506 0.0050411675 0.5640545; fails 0.0e+00 0.063 0.0255 0.3615 0.0e+00) +CC6 (0.01,0.02] CERTIFIED: E[G_r] <= 3.69805856644731 +CC6 (0.02,0.03] hi.b = 3.71138266686 (p-win 2.6781237 0.005045062 0.56391022; fails 1.5e-119 0.075 0.0260 0.3635 0.0e+00) +CC6 (0.02,0.03] CERTIFIED: E[G_r] <= 3.71138266685765 +CC6 (0.03,0.04] hi.b = 3.72414748332 (p-win 2.6772316 0.005037735 0.56366194; fails 2.9e-68 0.086 0.0266 0.3656 0.0e+00) +CC6 (0.03,0.04] CERTIFIED: E[G_r] <= 3.72414748332433 +CC6 (0.04,0.05] hi.b = 3.74767948916 (p-win 2.6762151 0.0050357768 0.56340642; fails 1.9e-43 0.108 0.0272 0.3677 0.0e+00) +CC6 (0.04,0.05] CERTIFIED: E[G_r] <= 3.74767948915996 +CC6 PASS: uniform certified ceiling on (0, 0.05]: max hi = 3.74767948915996 +CB7 PASS: Neumann (mu, Sigma) at r=0.05 contain the independent direct point law +CC7 MC DIAGNOSTIC r=0.05: E[G] = 3.21876 +- 0.00709 (<= certified hi 3.74768 OK; NOT load-bearing) +CC7 MC DIAGNOSTIC r=0.01: E[G] = 3.23339 +- 0.00709 (<= certified hi 3.74768 OK; NOT load-bearing) +ALL_CHECKS_PASS +sha256(transcript-above) = 1642236cf8e0a8346c17d00b345a9690733e64b941af741354aa9316c59eda5a diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt new file mode 100644 index 000000000..1892e90bb --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt @@ -0,0 +1,801 @@ +#!/usr/bin/env python3 +# h3_band_ceil.py -- LPW_CONSTANT v4 / OBL-D1-PROMOTE normalizer band: +# CERTIFIED uniform normalizer CEILING E[G_r] <= U for ALL r in (0, 0.05]. +# +# Method (no whitening, no MC in the certificate): +# 1. Exact Taylor series at r = 0 of the corrected-pin Gram, cross and soft +# Grams (Laurent-series algebra on certified kernel series; moments +# a_{2m} by the Poisson-Hermite identity, exact finite torus). +# 2. Exact series division -> Taylor coefficients of mu(r), Sigma(r) +# (conditional law of the six soft variables under Q_r), with crude +# certified majorant tails (literal triangle bounds on |z| = rho). +# 3. Interval evaluation of mu, Sigma on sub-intervals covering (0, 0.05]. +# 4. Band lower bound E[G_r] >= E[p 1_{q in I'}] - sum of exact bad pieces +# (Wick / conditional-Wick polynomial Gaussian algebra; certified Phi +# series + Gordon-Mills bounds), valid because the box +# B_cert = {q_M in I'} {|dq| <= eta} {a_M <= -0.8} {a_S >= 0.8} {|b_M| <= 2} +# certifies the type event for every r <= 0.05 with slack. +# Fail-closed ck -> SystemExit; both modes byte-identical; MUTATION harness. +import os, sys, time, hashlib +from fractions import Fraction +from collections import defaultdict +from functools import lru_cache +from mpmath import mp, iv, mpf + +mp.dps = 100 +iv.dps = 100 +sys.path.insert(0, '/mnt/agents/output/K3_SIDE24_LB/UPPER2D/H2_foundations') +import cov_exact as ce + +MUT = os.environ.get('MUTATION', '') +OUT = [] +def emit(s): + OUT.append(s) + print(s) +def ck(cond, msg): + if not cond: + emit('CK_FAIL: ' + msg) + sys.exit(1) +def fmpf(fr): + return mpf(fr.numerator) / mpf(fr.denominator) + +t0 = time.time() +emit('H3 BAND CEIL (U2D-UPPER, LPW_CONSTANT v4 normalizer denominator)') +print('t=' + time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()), file=sys.stderr) +emit('mode dps=100 both-modes-deterministic MUTATION=' + (MUT if MUT else 'none')) + +REQ = mpf('1.615489267643502474048123284509081575382') # c_Z of record +RMAX = mpf('1') / 20 # the rung 0.05 + +# ---------------------------------------------------------------- CB0: hashes +def sha(path): + h = hashlib.sha256() + with open(path, 'rb') as f: + h.update(f.read()) + return h.hexdigest() +H2D = '/mnt/agents/output/K3_SIDE24_LB/UPPER2D/H2_foundations' +h_cov = sha(H2D + '/cov_exact.py'); h_pin = sha(H2D + '/pin_transform.py') +man = {} +with open(H2D + '/MANIFEST.sha256') as f: + for ln in f: + hh, fn = ln.split() + man[fn] = hh +ck(h_cov == man['cov_exact.py'], 'CB0 cov_exact hash') +ck(h_pin == man['pin_transform.py'], 'CB0 pin_transform hash') +emit('CB0 PASS: H2 library hashes match MANIFEST') + +# ------------------------------------------------- CB1: exact-torus moments +# a_{2m} = (-1)^m sum_n He_{2m}(24 n) e^{-288 n^2} / sum_n e^{-288 n^2} (Poisson) +def He_iv(n, x): + if n == 0: return iv.mpf(1) + if n == 1: return iv.mpf(x) + a, b = iv.mpf(1), iv.mpf(x) + for k in range(2, n + 1): + a, b = b, x * b - (k - 1) * a + return b +def moment_a2m(m): + num = iv.mpf(0); den = iv.mpf(0) + for n in range(-3, 4): + w = iv.e ** (-iv.mpf(288) * n * n) + num += (-1) ** m * He_iv(2 * m, iv.mpf(24 * n)) * w + den += w + # certified tail |n| >= 4: e^{-288*16} < 1e-1997, He polynomial growth: < 1e-1500 + return num / den +MMAX = 40 +A2 = [moment_a2m(m) for m in range(MMAX + 1)] +# certified separated deviations (Poisson path, summandwise positive) +DEV2 = ce.one_minus_a2_poisson(mode='iv') +num4 = iv.mpf(0); den4 = iv.mpf(0) +for n in range(-3, 4): + w = iv.e ** (-iv.mpf(288) * n * n) + t = iv.mpf(24 * n) + num4 += (He_iv(4, t) - 3) * w # He_4(t)-3 = t^2(t^2-6) >= 0 + den4 += w +DEV4 = num4 / den4 +if MUT == 'planar_moments': + from math import factorial as _fact + A2 = [iv.mpf(_fact(2 * m)) / iv.mpf(_fact(m) * 2 ** m) for m in range(MMAX + 1)] + DEV2 = iv.mpf(0); DEV4 = iv.mpf(0) + emit('CB1 MUTATION planar_moments applied (must be caught downstream)') +ck(DEV2.a > 0 and DEV2.b < mpf('1e-100'), 'CB1a exact-torus 0 < 1-a2 < 1e-100 (mutation guard)') +ck(DEV4.a > 0 and DEV4.b < mpf('1e-100'), 'CB1b exact-torus 0 < a4-3 < 1e-100') +emit('CB1 PASS: moments a_{2m}, m<=%d, exact finite torus (1-a2 = %s)' % (MMAX, mp.nstr(DEV2.b, 3))) + +# ------------------------------------------------- CB2: series machinery +# Taylor series at r=0 of all Gram entries (Laurent window [LMIN, J]). +J = 60 # Taylor order kept exactly +LMIN = -8 +RHO = mpf('0.11') # majorant circle radius (det floor scan-verified) +def ser_zero(): + return defaultdict(lambda: iv.mpf(0)) +def ser_monom(c, k): + s = ser_zero(); s[k] = iv.mpf(c); return s +def ser_mul(A, B): + C = ser_zero() + for ja, ca in A.items(): + if ca == 0: continue + for jb, cb in B.items(): + if cb == 0: continue + C[ja + jb] += ca * cb + return C +def ser_add(A, B): + C = ser_zero() + for j, c in A.items(): C[j] += c + for j, c in B.items(): C[j] += c + return C +def ser_scale(A, c): + C = ser_zero() + for j, v in A.items(): C[j] = v * c + return C +def ser_trim(A): + return defaultdict(lambda: iv.mpf(0), + {j: c for j, c in A.items() if j >= LMIN and j <= J + 2 and not (c.a == 0 and c.b == 0)}) + +# kernel series K1^{(n)}( +/- z ): coeff[j] = (-1)^{(n+j)/2} a_{n+j} / j! (n+j even) +from math import factorial +def kernel_ser(n, parity): + s = ser_zero() + for j in range(0, J + 8 - n): + m = n + j + if m % 2 == 1: continue + if m // 2 > MMAX: break + val = ((-1) ** (m // 2)) * A2[m // 2] / factorial(j) + if parity < 0 and j % 2 == 1: val = -val + s[j] = val + return s +KSER = {} +def get_kser(n, parity): + key = (n, parity) + if key not in KSER: + KSER[key] = kernel_ser(n, parity) + return KSER[key] + +# 2D covariance series for displacement d * z, d in {-1,0,1}, matching ce.cov: +# cov(alpha,beta,dx,0) = (-1)^{|beta|} K1^{(n1)}(dx) K1^{(n2)}(0) [no s-flip] +def cov_ser(alpha, beta, d): + n1 = alpha[0] + beta[0]; n2 = alpha[1] + beta[1] + sgn = (-1) ** (beta[0] + beta[1]) + if d == 0: + v1 = ser_zero() + if n1 % 2 == 0: + v1[0] = ((-1) ** (n1 // 2)) * A2[n1 // 2] + else: + v1 = get_kser(n1, d) + k0 = iv.mpf(0) + if n2 % 2 == 0: + k0 = ((-1) ** (n2 // 2)) * A2[n2 // 2] + return ser_scale(v1, sgn * k0) + +# functionals: list of (station, multiindex, Laurent coeff series) +def L(c, k): + return ser_monom(mpf(c), k) +PinsV = [ + [('M', (0, 0), L(1, 0))], + [('M', (1, 0), L(1, 0))], + [('M', (0, 1), L(1, 0))], + [('S', (1, 0), L(1, -1)), ('M', (1, 0), L(-1, -1))], + [('S', (0, 1), L(1, -1)), ('M', (0, 1), L(-1, -1))], + [('S', (0, 0), L(1, -3)), ('M', (0, 0), L(-1, -3)), + ('S', (1, 0), L(mpf(-1) / 2, -2)), ('M', (1, 0), L(mpf(-1) / 2, -2))], +] +SoftY = [ + [('M', (0, 2), L(1, 0))], + [('S', (0, 2), L(1, 0))], + [('M', (2, 0), L(1, -1))], + [('S', (2, 0), L(1, -1))], + [('M', (1, 1), L(1, -1))], + [('S', (1, 1), L(1, -1))], +] +DISP = {('M', 'M'): 0, ('S', 'S'): 0, ('S', 'M'): 1, ('M', 'S'): -1} +def gram_entry_ser(FA, FB): + tot = ser_zero() + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + tot = ser_add(tot, ser_mul(ser_mul(ca, cb), cov_ser(aa, ab, DISP[(xa, xb)]))) + return ser_trim(tot) + +t1 = time.time() +GP_ser = [[gram_entry_ser(PinsV[i], PinsV[j]) for j in range(6)] for i in range(6)] +GY_ser = [[gram_entry_ser(SoftY[i], SoftY[j]) for j in range(6)] for i in range(6)] +GYV_ser = [[gram_entry_ser(SoftY[i], PinsV[j]) for j in range(6)] for i in range(6)] +emit('CB2 series built in %.1fs' % (time.time() - t1)) +# Laurent coefficients: pin Gram regular; GYV regular below z^-1; GY below z^-2 +bad = 0 +for i in range(6): + for j in range(6): + for k, c in GP_ser[i][j].items(): + if k < 0 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 + for k, c in GYV_ser[i][j].items(): + if k <= -2 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 + for k, c in GY_ser[i][j].items(): + if k <= -3 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 +ck(bad == 0, 'CB2 Laurent pole pattern (GP regular; GYV, GY only genuine poles)') +emit('CB2 PASS: corrected-basis poles cancel exactly; genuine soft poles z^-1, z^-2 isolated') + +# ------------------------------------------- CB3: series division -> mu, Sigma +def mat_coeff(Gser, j): + return [[Gser[a][b].get(j, iv.mpf(0)) for b in range(6)] for a in range(6)] +def iv_solve6(GG, rhs): + # interval Gauss with partial pivoting + residual check outside + A = [GG[i][:] + [rhs[i]] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c].a + A[rr][c].b)) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(7)] + return [A[i][6] / A[i][i] for i in range(6)] +def matvec(G, v): + return [sum((G[i][k] * v[k] for k in range(6)), iv.mpf(0)) for i in range(6)] +def matmul(A, B): + return [[sum((A[i][k] * B[k][j] for k in range(6)), iv.mpf(0)) for j in range(6)] for i in range(6)] +def matneg(A): + return [[-A[i][j] for j in range(6)] for i in range(6)] + +G0 = mat_coeff(GP_ser, 0) +zV = [iv.mpf(6) / 5, iv.mpf(0), iv.mpf(0), iv.mpf(0), iv.mpf(0), iv.mpf(-1) / 6] +if MUT == 'wrong_window': + zV[5] = iv.mpf(-1) / 12 + emit('CB3 MUTATION wrong_window applied (must be caught downstream)') +Ginv0_cols = [iv_solve6(G0, [iv.mpf(1) if l == k else iv.mpf(0) for l in range(6)]) for k in range(6)] +Ginv0 = [[Ginv0_cols[k][i] for k in range(6)] for i in range(6)] +# residual check ||G Ginv0 - I|| small +res = max(abs((sum((G0[i][k] * Ginv0[k][j] for k in range(6)), iv.mpf(0)) - (iv.mpf(1) if i == j else iv.mpf(0))).b) + for i in range(6) for j in range(6)) +ck(res < 1e-70, 'CB3 G0 inverse residual') +emit('CB3 G0 inverse residual %.2e' % float(res)) + +Gj = [mat_coeff(GP_ser, j) for j in range(J + 3)] +GYj = [mat_coeff(GY_ser, j) for j in range(J + 1)] +GYVj = [mat_coeff(GYV_ser, j) for j in range(J + 2)] +GYV_m1 = mat_coeff(GYV_ser, -1) +GY_m2 = mat_coeff(GY_ser, -2); GY_m1 = mat_coeff(GY_ser, -1) + +W = [None] * (J + 3) +W[0] = matvec(Ginv0, zV) +H = [None] * (J + 3) +H[0] = Ginv0 +for j in range(1, J + 3): + acc = [[iv.mpf(0)] * 6 for _ in range(6)] + for i in range(1, j + 1): + acc = [[acc[a][b] + sum((Gj[i][a][k] * H[j - i][k][b] for k in range(6)), iv.mpf(0)) for b in range(6)] for a in range(6)] + H[j] = matneg(matmul(Ginv0, acc)) + # W[j] = -Ginv0 * sum_i G_i W[j-i] + W[j] = matvec(Ginv0, [-sum((Gj[i][a][l] * W[j - i][l] for i in range(1, j + 1) for l in range(6)), iv.mpf(0)) for a in range(6)]) +# extended GYV coefficient list including the genuine z^-1 pole +def GYVc(i): + return GYV_m1 if i == -1 else GYVj[i] +mu_ser = [None] * (J + 1) +for j in range(J + 1): + mu_ser[j] = [sum((GYVc(i)[a][k] * W[j - i][k] for i in range(-1, j + 1) for k in range(6)), iv.mpf(0)) for a in range(6)] +Sig_ser = [None] * (J + 1) +for j in range(J + 1): + acc = [[iv.mpf(0)] * 6 for _ in range(6)] + for a_ in range(-1, j + 2): + for c_ in range(-1, j + 2): + b_ = j - a_ - c_ + if b_ < 0: continue + prod = matmul(matmul(GYVc(a_), H[b_]), [[GYVc(c_)[l][k] for l in range(6)] for k in range(6)]) # GYV_c^T + acc = [[acc[x][y] + prod[x][y] for y in range(6)] for x in range(6)] + Sig_ser[j] = [[GYj[j][x][y] - acc[x][y] for y in range(6)] for x in range(6)] +emit('CB3 series division done') +# rotated coordinates (q_M, delta=q_S-q_M, alpha_M, alpha_S, beta_M, beta_S) at SERIES level: +# the rotation cancellations (var_delta = S00 - 2 S01 + S11) must happen exactly in the +# coefficients, not in interval arithmetic at evaluation time. +LR = [[1, 0, 0, 0, 0, 0], [-1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]] +mu2_ser = [None] * (J + 1) +Sig2_ser = [None] * (J + 1) +for j in range(J + 1): + mu2_ser[j] = [sum((iv.mpf(LR[i][k]) * mu_ser[j][k] for k in range(6)), iv.mpf(0)) for i in range(6)] + Sig2_ser[j] = [[sum((iv.mpf(LR[i][k]) * Sig_ser[j][k][l] * iv.mpf(LR[x][l]) for k in range(6) for l in range(6)), iv.mpf(0)) for x in range(6)] for i in range(6)] + +# regularity of mu, Sigma at r=0: the genuine poles of GYV (z^-1) and GY (z^-2) +# must be annihilated by the conditioning. Check the pole coefficients of the +# products explicitly (they are dropped from the non-negative series below). +mu_pole = matvec(GYV_m1, W[0]) +for a in range(6): + ck(abs(mu_pole[a].a) < 1e-55 and abs(mu_pole[a].b) < 1e-55, 'CB3 mu pole z^-1 vanishes, coord %d' % a) +def mmT(A): + return matmul(matmul(GYV_m1, H[0]), [[A[l][k] for l in range(6)] for k in range(6)]) +Sig_pole2 = [[GY_m2[x][y] - mmT(GYV_m1)[x][y] for y in range(6)] for x in range(6)] +p1 = matmul(matmul(GYV_m1, H[0]), [[GYVj[0][l][k] for l in range(6)] for k in range(6)]) +p2 = matmul(matmul(GYVj[0], H[0]), [[GYV_m1[l][k] for l in range(6)] for k in range(6)]) +p3 = matmul(matmul(GYV_m1, H[1]), [[GYV_m1[l][k] for l in range(6)] for k in range(6)]) +Sig_pole1 = [[GY_m1[x][y] - p1[x][y] - p2[x][y] - p3[x][y] for y in range(6)] for x in range(6)] +for x in range(6): + for y in range(6): + ck(abs(Sig_pole2[x][y].a) < 1e-50 and abs(Sig_pole2[x][y].b) < 1e-50, 'CB3 Sigma pole z^-2 vanishes %d %d' % (x, y)) + ck(abs(Sig_pole1[x][y].a) < 1e-50 and abs(Sig_pole1[x][y].b) < 1e-50, 'CB3 Sigma pole z^-1 vanishes %d %d' % (x, y)) +emit('CB3 poles of mu (z^-1) and Sigma (z^-2, z^-1) annihilated by conditioning') + +# limit identities (independent LPW cross-checks; catches wrong-window) +ck(abs(mu_ser[0][0].a + mpf(6) / 5) < 1e-60 and abs(mu_ser[0][0].b + mpf(6) / 5) < 1e-60, 'CB3 mu_qM(0) = -b a2') +ck(abs(mu_ser[0][1].a + mpf(6) / 5) < 1e-60, 'CB3 mu_qS(0) = -b a2') +ck(abs(mu_ser[0][2].a + 1) < 1e-60, 'CB3 mu_aM(0) = -1 (window identity; mutation guard)') +ck(abs(mu_ser[0][3].a - 1) < 1e-60, 'CB3 mu_aS(0) = +1') +ck(abs(Sig_ser[0][2][2].a) < 1e-60 and abs(Sig_ser[0][2][2].b) < 1e-60, 'CB3 Var(aM)(0) = 0') +ck(abs(Sig_ser[0][0][0].a - 2) < 1e-55, 'CB3 Var(qM)(0) = a4-a2^2 = 2') +emit('CB3 PASS: limit identities mu(0), Sigma(0) match the independent blow-up analysis') + +# ------------------------------------------------- CB4: majorant tails +# crude certified kernel sup: |K1^{(n)}(z)| <= A_n(rho) on |z| <= rho, +# A_n(rho) = sum_{|k|<=K} w |k|^n e^{|k|rho} / Z + certified tail. +ce._build_lattice() +_k = [mpf(x.a) for x in ce._LATT_IV[2]] +_w = [iv.mpf(x) for x in ce._LATT_IV[3]] +_Z1 = ce._LATT_IV[4] +def abs_sum_A(n, rho): + tot = iv.mpf(0) + for kk, ww in zip(_k, _w): + tot += ww * abs(kk) ** n * iv.e ** (abs(kk) * rho) + # certified tail |k| > 17: e^{-k^2/2 + k rho} <= e^{-k^2/4} (k >= 4 rho), + # |k|^n e^{-k^2/4} <= e^{-k^2/8} (8n/e)^{n/2}; geometric sum <= e^{-17^2/8}/(1-e^{-2}) + tail = iv.e ** (-iv.mpf(17 * 17) / 8) * (8 * n / iv.e) ** (n / 2) / (1 - iv.e ** (-2)) + return (tot + iv.mpf((0, float(tail.b)))) / _Z1 +A_rho = [abs_sum_A(n, RHO) for n in range(9)] +# literal-curse entry maxima on |z| = rho +def entry_max2(FA, FB): + tot = mpf(0) + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + n1 = aa[0] + ab[0]; n2 = aa[1] + ab[1] + ma = sum(max(abs(mpf(c.a)), abs(mpf(c.b))) * RHO ** j for j, c in ca.items()) + mb = sum(max(abs(mpf(c.a)), abs(mpf(c.b))) * RHO ** j for j, c in cb.items()) + tot += ma * mb * mpf(A_rho[n1].b) * mpf(A_rho[n2].b) + return tot +M_GP = max(entry_max2(PinsV[i], PinsV[j]) for i in range(6) for j in range(6)) +M_GY = max(entry_max2(SoftY[i], SoftY[j]) for i in range(6) for j in range(6)) +M_GYV = max(entry_max2(SoftY[i], PinsV[j]) for i in range(6) for j in range(6)) +emit('CB4 literal entry maxima on |z|=%.2f: GP %.2e GY %.2e GYV %.2e' % (RHO, M_GP, M_GY, M_GYV)) + +def matmax(M): + return max(mpf(M[i][j].b) if hasattr(M[i][j], 'b') else abs(M[i][j]) for i in range(6) for j in range(6)) +def vecmax(v): + return max(mpf(x.b) if hasattr(x, 'b') else abs(x) for x in v) +G_m = [matmax(Gj[j]) for j in range(J + 1)] +GY_m = [matmax(GYj[j]) for j in range(J + 1)] +GYV_m = [matmax(GYVj[j]) for j in range(len(GYVj))] +G_m_full = [matmax(Gj[j]) for j in range(J + 3)] +H_m = [matmax(H[j]) for j in range(J + 3)] +W_m = [vecmax(W[j]) for j in range(J + 3)] +Ginv0_m = matmax(Ginv0) + +# majorant growth R: smallest R with 36*Ginv0_m*(S_G(R)+T_G(R)) <= 1/2, rho*R > 1 +def S_G(R): + return sum(G_m[i] / R ** i for i in range(1, J + 1)) +def T_G(R): + x = 1 / (RHO * R) + return M_GP * x ** (J + 1) / (1 - x) +def theta(R): + return 36 * Ginv0_m * (S_G(R) + T_G(R)) +R = 1 / RHO * 1.001 +for _ in range(400): + if theta(R) > 0.5: R *= 1.02 + else: break +ck(theta(R) <= 0.5, 'CB4 majorant growth R found') +for _ in range(400): + Rl = R / 1.02 + if theta(Rl) <= 0.5: R = Rl + else: break +emit('CB4 majorant growth R = %.4f (rho*R = %.3f) theta = %.3f' % (R, RHO * R, theta(R))) +# R-majorant only needs to converge on the FIRST sub-interval (0, 0.005]: +ck(R * mpf('0.005') < 0.2, 'CB4 majorant converges on first sub-interval') +C_W = max(W_m[j] / R ** j for j in range(J + 3)); C_W = max(C_W, mpf(1)) +C_H = max(H_m[j] / R ** j for j in range(J + 3)); C_H = max(C_H, mpf(1)) +# Sigma tail: scalar majorant series values +def maj_series_val(coeffs, M, t): + v = sum(coeffs[j] * t ** j for j in range(J + 1)) + x = t / RHO + v += M * x ** (J + 1) / (1 - x) + return v +def maj_partial_GHGYV(t): + tot = mpf(0) + for a_ in range(J + 1): + for b_ in range(J + 1 - a_): + for c_ in range(J + 1 - a_ - b_): + if a_ + b_ + c_ <= J: + tot += GYV_m[a_] * H_m[b_] * GYV_m[c_] * t ** (a_ + b_ + c_) + return tot +def maj_partial_GYVW(t): + return sum(GYV_m[a_] * W_m[b_] * t ** (a_ + b_) for a_ in range(J + 1) for b_ in range(J + 1 - a_)) +def maj_full_R(coeffs, C, t): + # majorant anchored on computed coefficients + R-growth tail (recursion-consistent) + n = len(coeffs) - 1 + return sum(coeffs[j] * t ** j for j in range(n + 1)) + C * (R * t) ** (n + 1) / (1 - R * t) +def Sig_tail(t): + fullGY = maj_series_val(GY_m, M_GY, t) + fullA = maj_series_val(GYV_m, M_GYV, t) + fullH = maj_full_R(H_m, C_H, t) + partGY = sum(GY_m[j] * t ** j for j in range(J + 1)) + tailGY = fullGY - partGY + tailProd = 36 * (fullA * fullH * fullA - maj_partial_GHGYV(t)) + # pole-index terms a=-1 or c=-1 (GYV_{-1} max entry 3) + partHA = sum(H_m[b] * GYV_m[c] * t ** (b + c) for b in range(J + 2) for c in range(J + 2 - b)) + T2 = fullH * fullA - partHA + tailPole = 216 * T2 / t + partH = sum(H_m[b] * t ** b for b in range(J + 3)) + tailPole2 = 324 * (fullH - partH) / (t * t) + return tailGY + tailProd + tailPole + tailPole2 +def mu_tail(t): + fullA = maj_series_val(GYV_m, M_GYV, t) + fullW = maj_full_R(W_m, C_W, t) + main = 6 * (fullA * fullW - maj_partial_GYVW(t)) + pole = 18 * C_W * R * (R * t) ** (J + 1) / (1 - R * t) + return main + pole +ST = Sig_tail(mpf('0.0025')); MT = mu_tail(mpf('0.0025')) +ck(ST < 1e-5, 'CB4 Sigma tail small on first sub-interval') +ck(MT < 1e-5, 'CB4 mu tail small on first sub-interval') +emit('CB4 PASS: series tails on (0,0.005]: Sig %.2e mu %.2e' % (ST, MT)) +def gram_tail(M, t): + # certified Cauchy tail of a Gram-block series beyond kept order J+2 + return M * (t / RHO) ** (J + 3) / (1 - t / RHO) + +# ------------------------------------------- CB5: certified Phi, moments, Wick +SQRT2PI = iv.sqrt(2 * iv.pi) +def iv_phi(x): + return iv.e ** (-(x * x) / 2) / SQRT2PI +def iv_Phi(x): + # standard normal CDF, interval x. + # |x| <= 6: power series Phi = 1/2 + phi(0) sum_k (-1)^k x^{2k+1}/(2^k k!(2k+1)) + # with certified geometric tail; |x| > 6: Gordon-Mills bounds (both monotone). + # intervals straddling +-6 are split by monotonicity of Phi. + if (x.a < 6 < x.b) or (x.a < -6 < x.b): + lo = iv_Phi(iv.mpf(x.a)) + hi = iv_Phi(iv.mpf(x.b)) + return iv.mpf((mpf(lo.a), mpf(hi.b))) + if x.a >= 6: + # Q(x) = 1 - Phi(x) in (phi(x)(1/x - 1/x^3), phi(x)/x); both bounds decreasing + hi = iv_phi(iv.mpf(x.a)) / iv.mpf(x.a) + lo = iv_phi(iv.mpf(x.b)) * (1 / iv.mpf(x.b) - 1 / iv.mpf(x.b) ** 3) + return iv.mpf(1) - iv.mpf((float(lo.a), float(hi.b))) + if x.b <= -6: + # Phi increasing; Phi(x) = Q(-x) + hi = iv_phi(iv.mpf(x.b)) / iv.mpf(-x.b) + lo = iv_phi(iv.mpf(x.a)) * (1 / iv.mpf(-x.a) - 1 / iv.mpf(-x.a) ** 3) + return iv.mpf((float(lo.a), float(hi.b))) + ck(x.a >= -6 and x.b <= 6, 'CB5 Phi series domain x=[%s,%s]' % (mp.nstr(mpf(x.a), 6), mp.nstr(mpf(x.b), 6))) + # |x| <= 6: series with certified geometric tail + # ratio T_{k+1}/T_k = -x^2(2k+1)/(2(k+1)(2k+3)); |ratio| <= 18(2k+1)/((k+1)(2k+3)) < 0.9 for k >= 21 + tot = iv.mpf(0) + K = 0 + term = x # k = 0 term + while K < 120: + tot += term + K += 1 + term = -term * x * x * (2 * K - 1) / (2 * K * (2 * K + 1)) + if K >= 22 and abs(term.b) < 1e-90 and abs(term.a) < 1e-90: + break + tail = max(abs(term.a), abs(term.b)) / (1 - mpf('0.9')) + return iv.mpf(1) / 2 + (tot + iv.mpf((-tail, tail))) / SQRT2PI + +def trunc_mom_iv(mu, var, a, b, kmax): + # E[X^k 1_{a <= X <= b}], X ~ N(mu, var), all intervals; a,b mpf (exact rationals) + s = iv.sqrt(var) + al = (iv.mpf(a) - mu) / s + be = (iv.mpf(b) - mu) / s + I = [iv.mpf(0)] * (kmax + 1) + I[0] = iv_Phi(be) - iv_Phi(al) + I[1] = iv_phi(al) - iv_phi(be) + for e in range(2, kmax + 1): + I[e] = al ** (e - 1) * iv_phi(al) - be ** (e - 1) * iv_phi(be) + (e - 1) * I[e - 2] + from math import comb + out = [] + for k in range(kmax + 1): + tot = iv.mpf(0) + for j in range(k + 1): + tot += comb(k, j) * s ** j * I[j] * mu ** (k - j) + out.append(tot) + return out + +def make_wick_iv(mu, Sig): + @lru_cache(maxsize=None) + def wick(state): + if len(state) == 0: return iv.mpf(1) + if len(state) == 1: return mu[state[0]] + i = state[0]; rest = state[1:] + tot = mu[i] * wick(rest) + for k, j in enumerate(rest): + tot += Sig[i][j] * wick(rest[:k] + rest[k + 1:]) + return tot + return wick +def poly_expect_iv(P, wick): + tot = iv.mpf(0) + for e, c in P.items(): + st = [] + for i, pp in enumerate(e): st += [i] * pp + tot += c * wick(tuple(st)) + return tot +# polynomial algebra (iv coefficients, 6 variables) +def p_affine(idx): + P = defaultdict(lambda: iv.mpf(0)) + P[tuple(1 if k == idx else 0 for k in range(6))] = iv.mpf(1) + return P +def p_mul(A, B): + C = defaultdict(lambda: iv.mpf(0)) + for ea, ca in A.items(): + for eb, cb in B.items(): + C[tuple(x + y for x, y in zip(ea, eb))] += ca * cb + return C +def p_scale(A, s): + C = defaultdict(lambda: iv.mpf(0)) + for e, c in A.items(): C[e] = c * s + return C +def p_add(A, B): + C = defaultdict(lambda: iv.mpf(0)) + for e, c in A.items(): C[e] += c + for e, c in B.items(): C[e] += c + return C +# polynomial-in-t Wick (conditional on one coordinate); means affine in t (iv coefficients) +def tp_add(A, B): + n = max(len(A), len(B)) + return [(A[i] if i < len(A) else iv.mpf(0)) + (B[i] if i < len(B) else iv.mpf(0)) for i in range(n)] +def tp_mul(A, B): + C = [iv.mpf(0)] * (len(A) + len(B) - 1) + for i, a in enumerate(A): + for j, b in enumerate(B): C[i + j] += a * b + return C +def tp_scale(A, s): + return [s * a for a in A] +def conditional_wick_iv(mu, Sig, cond): + i0 = cond + s00 = Sig[i0][i0] + means = [[mu[i] - Sig[i][i0] / s00 * mu[i0], Sig[i][i0] / s00] for i in range(6)] + Sc = [[Sig[i][j] - Sig[i][i0] * Sig[i0][j] / s00 for j in range(6)] for i in range(6)] + @lru_cache(maxsize=None) + def wick(state): + if len(state) == 0: return (iv.mpf(1),) + if len(state) == 1: return tuple(means[state[0]]) + i = state[0]; rest = state[1:] + tot = tp_mul(list(means[i]), list(wick(rest))) + for k, j in enumerate(rest): + tot = tp_add(tot, tp_scale(list(wick(rest[:k] + rest[k + 1:])), Sc[i][j])) + return tuple(tot) + return wick +def cond_expect_poly_iv(P, cw): + tot = (iv.mpf(0),) + for e, c in P.items(): + st = [] + for i, pp in enumerate(e): st += [i] * pp + tot = tp_add(list(tot), tp_scale(list(cw(tuple(st))), c)) + return tot + +# ------------------------------------------------- CB6: band evaluation +def ser_eval(coeffs, t_iv, tail): + # Horner over interval t + symmetric tail + v = iv.mpf(0) + for j in range(len(coeffs) - 1, -1, -1): + v = v * t_iv + coeffs[j] + return v + iv.mpf((-tail, tail)) + +I_LO = mpf('-3.9'); I_HI = mpf('-0.4'); ETA = mpf('0.3'); BB = mpf('2'); AB = mpf('0.8') +def gram_block_eval(Gjlist, pole_mat, t_iv, Mblock): + # interval evaluation of a Gram-block series (kept order J+2) + Cauchy tail; + # pole_mat (or None) is the genuine z^-1 coefficient (requires t_iv.a > 0). + r_hi = mpf(t_iv.b) + tail = gram_tail(Mblock, r_hi) + n = len(Gjlist) - 1 + out = [] + for a in range(6): + row = [] + for b in range(6): + v = iv.mpf(0) + for j in range(n, -1, -1): + v = v * t_iv + Gjlist[j][a][b] + if pole_mat is not None: + v = v + pole_mat[a][b] / t_iv + row.append(v + iv.mpf((-tail, tail))) + out.append(row) + return out +def mp_inverse6(GG): + A = [GG[i][:] + [mpf(1) if l == i else mpf(0) for l in range(6)] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c])) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(12)] + return [[A[i][6 + j] / A[i][i] for j in range(6)] for i in range(6)] +def neumann_law(r1, r2): + # certified (mu, Sigma) enclosures on [r1, r2]: + # heavy part = pole-cancelled regular series (order J+2), interval Horner + # correction = certified bound on (law - partial series), via + # Ginv - Ginv_partial = Ginv * (G - G_partial) * Ginv_partial (Gram tail tiny) + # with ||Ginv|| Neumann-certified on the sub-interval + t_iv = iv.mpf((r1, r2)) + r_hi = mpf(r2) + GP_iv = gram_block_eval(Gj, None, t_iv, M_GP) + mid = [[(mpf(GP_iv[i][j].a) + mpf(GP_iv[i][j].b)) / 2 for j in range(6)] for i in range(6)] + B = mp_inverse6(mid) + Biv = [[iv.mpf(B[i][j]) for j in range(6)] for i in range(6)] + E = [[ (iv.mpf(1) if i == j else iv.mpf(0)) - sum((Biv[i][k] * GP_iv[k][j] for k in range(6)), iv.mpf(0)) for j in range(6)] for i in range(6)] + rho = mp.sqrt(sum(max(abs(mpf(E[i][j].a)), abs(mpf(E[i][j].b))) ** 2 for i in range(6) for j in range(6))) + ck(rho < 0.5, 'CB6 Neumann contraction on [%s,%s]' % (r1, r2)) + BF = mp.sqrt(sum(mpf(B[i][j]) ** 2 for i in range(6) for j in range(6))) + delta = BF * rho / (1 - rho) + Gnorm = BF + 6 * delta # ||Ginv(z)||_F on the sub-interval + GinvPnorm = 6 * sum(H_m[j] * r_hi ** j for j in range(len(H_m))) # ||Ginv_partial||_F + tailG = gram_tail(M_GP, r_hi) + tailGY = gram_tail(M_GY, r_hi) + tailGYV = gram_tail(M_GYV, r_hi) + dGinv = Gnorm * 6 * tailG * GinvPnorm # ||Ginv - Ginv_partial||_F + GYV_H = gram_block_eval(GYVj, GYV_m1, t_iv, M_GYV) # pole-included partial + GYVmax = max(max(abs(mpf(GYV_H[a][b].a)), abs(mpf(GYV_H[a][b].b))) for a in range(6) for b in range(6)) + zVmax = max(abs(mpf(x.a)) for x in zV) + 1e-50 + T_mu = 6 * GYVmax * dGinv * zVmax + 6 * tailGYV * Gnorm * zVmax + T_Sig = tailGY + 36 * GYVmax ** 2 * dGinv + 2 * 36 * tailGYV * Gnorm * GYVmax + 36 * tailGYV ** 2 * Gnorm + ck(T_mu < 1e-2 and T_Sig < 1e-2, 'CB6 law correction small on [%s,%s]' % (r1, r2)) + mu = [ser_eval([mu_ser[j][a] for j in range(J + 1)], t_iv, T_mu) for a in range(6)] + Sig = [[ser_eval([Sig_ser[j][a][b] for j in range(J + 1)], t_iv, T_Sig) for b in range(6)] for a in range(6)] + return mu, Sig, T_mu, T_Sig +CAP_CONS = mpf(4) # consumption cap (LPW_CONSTANT v4); mutation guard target +FLOOR_LO = mpf('2.30659559567154') # certified band floor (H3_BAND_FLOOR) for nesting ck +def ceil_hi(r1, r2, label): + t_iv = iv.mpf((r1, r2)) + r_hi = mpf(r2) + if r1 > 0: + mu, Sig, Tm, Ts = neumann_law(r1, r2) + else: + mu = [ser_eval([mu_ser[j][a] for j in range(J + 1)], t_iv, MT) for a in range(6)] + Sig = [[ser_eval([Sig_ser[j][a][b] for j in range(J + 1)], t_iv, ST) for b in range(6)] for a in range(6)] + Tm, Ts = MT, ST + r_iv = t_iv + # UPPER envelope algebra (direction analysis, see H3_BAND_CEIL.md): + # E[G_r] = E[p 1_type] = E[p 1_{q_M<0}] - E[p 1_{q_M<0, not type}] + # <= E[p 1_{q_M<0}] + E[pbar 1_{q_M<0, D_M<=0}] + E[pbar 1_{q_M<0, D_S>=0}] + # since -E[p 1_A] <= E[pbar 1_A] (pbar >= |p| pointwise). Exact p-windows cover + # {q_M<0} (two-sided certified); the type-fail sets are covered by half-spaces: + # {D_M<=0, q_M<0} subset {a_M>-0.6} u {|b_M|>2} u {q_M in (-0.4,0)} + # (else a_M q_M >= 0.6*0.4 = 0.24 > 0.05*4 >= r b_M^2, ck'd below) + # {D_S>=0} subset {q_S>=0} u {a_S<=0} (a_S q_S >= r b_S^2 >= 0 needs equal signs) + ck(mpf('0.6') * mpf('0.4') > mpf('0.05') * 4, 'CC6 D_M cover margin') + aqM = p_affine(0); aqS = p_affine(1); aaM = p_affine(2); aaS = p_affine(3); abM = p_affine(4); abS = p_affine(5) + DM = p_add(p_mul(aaM, aqM), p_scale(p_mul(abM, abM), -r_iv)) + DS = p_add(p_mul(aaS, aqS), p_scale(p_mul(abS, abS), -r_iv)) + P = p_scale(p_mul(DM, DS), -1) + one = defaultdict(lambda: iv.mpf(0)); one[(0,) * 6] = iv.mpf(1) + u1 = p_add(p_scale(p_mul(p_mul(aaM, aqM), p_mul(aaM, aqM)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + u1 = p_add(u1, p_scale(p_mul(abM, abM), r_iv)) + u2 = p_add(p_scale(p_mul(p_mul(aaS, aqS), p_mul(aaS, aqS)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + u2 = p_add(u2, p_scale(p_mul(abS, abS), r_iv)) + PBAR = p_mul(u1, u2) + if MUT == 'cap_raised': + PBAR = p_scale(PBAR, iv.mpf(2)) + P = p_scale(P, iv.mpf(2)) + emit('CC6 MUTATION cap_raised applied (must be caught at consumption)') + wick = make_wick_iv(tuple(mu), tuple(tuple(row) for row in Sig)) + Epbar2 = poly_expect_iv(p_mul(PBAR, PBAR), wick) + Ep2 = poly_expect_iv(p_mul(P, P), wick) + def trunc_expect(PP, cond, a, b): + # exact E[PP 1_{X_cond in [a,b]}] (two-sided interval enclosure) + cw = conditional_wick_iv(mu, Sig, cond) + cp = cond_expect_poly_iv(PP, cw) + tm = trunc_mom_iv(mu[cond], Sig[cond][cond], a, b, len(cp) - 1) + return sum((c * t for c, t in zip(cp, tm)), iv.mpf(0)) + def upper_half(cond, edge, oneside, force_chern=False): + # certified UPPER bound of E[pbar 1_{X > edge}] ('gt') or E[pbar 1_{X < edge}] ('lt') + s00 = Sig[cond][cond] + if (not force_chern) and s00.a > 1e-4: + Etot = poly_expect_iv(PBAR, wick) + if oneside == 'gt': + return Etot - trunc_expect(PBAR, cond, mpf('-100'), edge) + return Etot - trunc_expect(PBAR, cond, edge, mpf('100')) + # near-singular: exact Gaussian tail (certified Mills) + Cauchy-Schwarz + sb = mp.sqrt(mpf(s00.b)) + if oneside == 'gt': + t0 = (mpf(edge) - mpf(mu[cond].b)) / sb + else: + t0 = (mpf(mu[cond].a) - mpf(edge)) / sb + ck(t0 > 2, 'CC6 Chernoff margin ' + label) + return iv.mpf((0, mp.sqrt(mpf(Epbar2.b) * mpf(iv_Phi(iv.mpf(-t0)).b)))) + # exact p-windows covering {q_M < 0} + Wp1 = trunc_expect(P, 0, I_LO, I_HI) + Wp2 = trunc_expect(P, 0, I_HI, mpf(0)) + Wp3 = trunc_expect(P, 0, mpf(-100), I_LO) + sb0 = mp.sqrt(mpf(Sig[0][0].b)) + t0l = (mpf(100) + mpf(mu[0].a)) / sb0 + ck(t0l > 20, 'CC6 left residue margin ' + label) + RESp = iv.mpf((0, mp.sqrt(mpf(Ep2.b) * mpf(iv_Phi(iv.mpf(-t0l)).b)))) + # type-fail pbar pieces (upper bounds) + BaM = upper_half(2, mpf('-0.6'), 'gt', force_chern=True) # E[pbar 1_{a_M > -0.6}] + BbM = trunc_expect(PBAR, 4, mpf('-100'), -BB) + trunc_expect(PBAR, 4, BB, mpf('100')) # |b_M|>2 exact + sbb = mp.sqrt(mpf(Sig[4][4].b)); t0b = (mpf(100) - max(abs(mpf(mu[4].a)), abs(mpf(mu[4].b)))) / sbb + ck(t0b > 20, 'CC6 beta far-tail margin ' + label) + BbM = BbM + iv.mpf((0, mp.sqrt(mpf(Epbar2.b) * 2 * mpf(iv_Phi(iv.mpf(-t0b)).b)))) + BqM = trunc_expect(PBAR, 0, I_HI, mpf(0)) # q_M in (-0.4,0) + BqS = trunc_expect(PBAR, 1, mpf(0), mpf('100')) # q_S >= 0 + sbq = mp.sqrt(mpf(Sig[1][1].b)); t0q = (mpf(100) - mpf(mu[1].b)) / sbq + ck(t0q > 20, 'CC6 q_S far-tail margin ' + label) + BqS = BqS + iv.mpf((0, mp.sqrt(mpf(Epbar2.b) * mpf(iv_Phi(iv.mpf(-t0q)).b)))) + BaS = upper_half(3, mpf('0'), 'lt', force_chern=True) # E[pbar 1_{a_S <= 0}] + hi = Wp1 + Wp2 + Wp3 + RESp + BaM + BbM + BqM + BqS + BaS + emit('CC6 %-14s hi.b = %s (p-win %s %s %s; fails %.1e %.3f %.4f %.4f %.1e)' % ( + label, mp.nstr(mpf(hi.b), 12), mp.nstr(mpf(Wp1.b), 8), mp.nstr(mpf(Wp2.b), 8), mp.nstr(mpf(Wp3.b), 8), + float(mpf(BaM.b)), float(mpf(BbM.b)), float(mpf(BqM.b)), float(mpf(BqS.b)), float(mpf(BaS.b)))) + return hi + +SUBS = [(mpf('0'), mpf('0.0025')), (mpf('0.0025'), mpf('0.005')), (mpf('0.005'), mpf('0.01')), (mpf('0.01'), mpf('0.02')), + (mpf('0.02'), mpf('0.03')), (mpf('0.03'), mpf('0.04')), (mpf('0.04'), mpf('0.05'))] +glohi = None +for (r1, r2) in SUBS: + lab = '(%s,%s]' % (mp.nstr(r1, 4), mp.nstr(r2, 4)) if r1 > 0 else '(0,%s]' % mp.nstr(r2, 4) + hi = ceil_hi(r1, r2, lab) + ck(hi.b > FLOOR_LO, 'CC6 envelope nests the certified band floor on ' + lab) + ck(hi.b < CAP_CONS, 'CC6 consumption cap (U <= 4) on ' + lab) + emit('CC6 %s CERTIFIED: E[G_r] <= %s' % (lab, mp.nstr(mpf(hi.b), 15))) + glohi = hi.b if glohi is None else max(glohi, hi.b) +emit('CC6 PASS: uniform certified ceiling on (0, 0.05]: max hi = %s' % mp.nstr(mpf(glohi), 15)) + +# ------------------------------------------------- CB7: rung cross-check + MC +# independent cross-check of the band formula at the rung point r = 0.05 +# (direct point law from ce.cov + same Wick formula, no series machinery) +def direct_point_law(rpt): + M = (-rpt / 2, mpf(0)); S = (rpt / 2, mpf(0)) + V = [[(M, (0, 0), mpf(1))], [(M, (1, 0), mpf(1))], [(M, (0, 1), mpf(1))], + [(S, (1, 0), 1 / rpt), (M, (1, 0), -1 / rpt)], [(S, (0, 1), 1 / rpt), (M, (0, 1), -1 / rpt)], + [(S, (0, 0), 1 / rpt ** 3), (M, (0, 0), -1 / rpt ** 3), (S, (1, 0), -1 / (2 * rpt ** 2)), (M, (1, 0), -1 / (2 * rpt ** 2))]] + Yv = [[(M, (0, 2), mpf(1))], [(S, (0, 2), mpf(1))], + [(M, (2, 0), 1 / rpt)], [(S, (2, 0), 1 / rpt)], + [(M, (1, 1), 1 / rpt)], [(S, (1, 1), 1 / rpt)]] + def lc(FA, FB): + tot = mpf(0) + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + tot += ca * cb * ce.cov(aa, ab, xa[0] - xb[0], xa[1] - xb[1], mode='mpf') + return tot + GP = [[lc(V[i], V[j]) for j in range(6)] for i in range(6)] + GY = [[lc(Yv[i], Yv[j]) for j in range(6)] for i in range(6)] + GYV = [[lc(Yv[i], V[j]) for j in range(6)] for i in range(6)] + zVd = [mpf(6) / 5, 0, 0, 0, 0, mpf(-1) / 6] + def solve6(GG, rhs): + A = [GG[i][:] + [rhs[i]] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c])) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(7)] + return [A[i][6] / A[i][i] for i in range(6)] + csol = solve6(GP, zVd) + muD = [sum(GYV[i][k] * csol[k] for k in range(6)) for i in range(6)] + Gic = [solve6(GP, [1 if l == k else 0 for l in range(6)]) for k in range(6)] + SigD = [[GY[i][j] - sum(GYV[i][k] * sum(Gic[k][l] * GYV[j][l] for l in range(6)) for k in range(6)) for j in range(6)] for i in range(6)] + return muD, SigD +muD, SigD = direct_point_law(RMAX) +muN, SigN, TmN, TsN = neumann_law(RMAX, RMAX) +for a in range(6): + ck(muN[a].a <= muD[a] <= muN[a].b, 'CB7 Neumann mu contains direct mu at rung, coord %d' % a) +for a in range(6): + for b in range(6): + ck(SigN[a][b].a <= SigD[a][b] <= SigN[a][b].b, 'CB7 Neumann Sigma contains direct, %d %d' % (a, b)) +emit('CB7 PASS: Neumann (mu, Sigma) at r=0.05 contain the independent direct point law') + +import numpy as np +rng = np.random.default_rng(90210) +for rpt in [0.05, 0.01]: + muMc, SigMc, _Tm, _Ts = neumann_law(mpf(rpt), mpf(rpt)) + muNp = np.array([float(mpf(x.a) + mpf(x.b)) / 2 for x in muMc]) + SigNp = np.array([[float(mpf(SigMc[a][b].a) + mpf(SigMc[a][b].b)) / 2 for b in range(6)] for a in range(6)]) + SigNp = (SigNp + SigNp.T) / 2 + LA = np.linalg.cholesky(SigNp + 1e-14 * np.eye(6)) + NMC = 400000 + U = rng.standard_normal((NMC, 6)) + Y = muNp[None, :] + U @ LA.T + qM, qS, aM, aS, bM, bS = Y.T + DMv = aM * qM - rpt * bM ** 2 + DSv = aS * qS - rpt * bS ** 2 + G = np.where((qM < 0) & (DMv > 0) & (DSv < 0), -DMv * DSv, 0.0) + est = G.mean(); sig = G.std(ddof=1) / np.sqrt(NMC) + ck(est - 6 * sig <= float(mpf(glohi)), 'CC7 MC consistency (est <= certified hi) at r=%g' % rpt) + emit('CC7 MC DIAGNOSTIC r=%.2f: E[G] = %.5f +- %.5f (<= certified hi %.5f OK; NOT load-bearing)' % ( + rpt, est, sig, float(mpf(glohi)))) + +# ------------------------------------------------- CB8: receipts +print('CB8 total runtime %.1fs' % (time.time() - t0), file=sys.stderr) +emit('ALL_CHECKS_PASS') +body = '\n'.join(OUT) + '\n' +with open('ceil_out.txt', 'w') as f: + f.write(body) +emit('sha256(transcript-above) = ' + hashlib.sha256(body.encode()).hexdigest()) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt new file mode 100644 index 000000000..2cb635895 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt @@ -0,0 +1,794 @@ +#!/usr/bin/env python3 +# h3_band_floor.py -- STAGE E / OBL-D1-PROMOTE normalizer band: +# CERTIFIED uniform normalizer floor Z_r >= c_Z r^2 for ALL r in (0, 0.05]. +# +# Method (no whitening, no MC in the certificate): +# 1. Exact Taylor series at r = 0 of the corrected-pin Gram, cross and soft +# Grams (Laurent-series algebra on certified kernel series; moments +# a_{2m} by the Poisson-Hermite identity, exact finite torus). +# 2. Exact series division -> Taylor coefficients of mu(r), Sigma(r) +# (conditional law of the six soft variables under Q_r), with crude +# certified majorant tails (literal triangle bounds on |z| = rho). +# 3. Interval evaluation of mu, Sigma on sub-intervals covering (0, 0.05]. +# 4. Band lower bound E[G_r] >= E[p 1_{q in I'}] - sum of exact bad pieces +# (Wick / conditional-Wick polynomial Gaussian algebra; certified Phi +# series + Gordon-Mills bounds), valid because the box +# B_cert = {q_M in I'} {|dq| <= eta} {a_M <= -0.8} {a_S >= 0.8} {|b_M| <= 2} +# certifies the type event for every r <= 0.05 with slack. +# Fail-closed ck -> SystemExit; both modes byte-identical; MUTATION harness. +import os, sys, time, hashlib +from fractions import Fraction +from collections import defaultdict +from functools import lru_cache +from mpmath import mp, iv, mpf + +mp.dps = 100 +iv.dps = 100 +sys.path.insert(0, '/mnt/agents/output/K3_SIDE24_LB/UPPER2D/H2_foundations') +import cov_exact as ce + +MUT = os.environ.get('MUTATION', '') +OUT = [] +def emit(s): + OUT.append(s) + print(s) +def ck(cond, msg): + if not cond: + emit('CK_FAIL: ' + msg) + sys.exit(1) +def fmpf(fr): + return mpf(fr.numerator) / mpf(fr.denominator) + +t0 = time.time() +emit('H3 BAND FLOOR (U2D-UPPER, STAGE E / OBL-D1-PROMOTE)') +print('t=' + time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()), file=sys.stderr) +emit('mode dps=100 both-modes-deterministic MUTATION=' + (MUT if MUT else 'none')) + +REQ = mpf('1.615489267643502474048123284509081575382') # c_Z of record +RMAX = mpf('1') / 20 # the rung 0.05 + +# ---------------------------------------------------------------- CB0: hashes +def sha(path): + h = hashlib.sha256() + with open(path, 'rb') as f: + h.update(f.read()) + return h.hexdigest() +H2D = '/mnt/agents/output/K3_SIDE24_LB/UPPER2D/H2_foundations' +h_cov = sha(H2D + '/cov_exact.py'); h_pin = sha(H2D + '/pin_transform.py') +man = {} +with open(H2D + '/MANIFEST.sha256') as f: + for ln in f: + hh, fn = ln.split() + man[fn] = hh +ck(h_cov == man['cov_exact.py'], 'CB0 cov_exact hash') +ck(h_pin == man['pin_transform.py'], 'CB0 pin_transform hash') +emit('CB0 PASS: H2 library hashes match MANIFEST') + +# ------------------------------------------------- CB1: exact-torus moments +# a_{2m} = (-1)^m sum_n He_{2m}(24 n) e^{-288 n^2} / sum_n e^{-288 n^2} (Poisson) +def He_iv(n, x): + if n == 0: return iv.mpf(1) + if n == 1: return iv.mpf(x) + a, b = iv.mpf(1), iv.mpf(x) + for k in range(2, n + 1): + a, b = b, x * b - (k - 1) * a + return b +def moment_a2m(m): + num = iv.mpf(0); den = iv.mpf(0) + for n in range(-3, 4): + w = iv.e ** (-iv.mpf(288) * n * n) + num += (-1) ** m * He_iv(2 * m, iv.mpf(24 * n)) * w + den += w + # certified tail |n| >= 4: e^{-288*16} < 1e-1997, He polynomial growth: < 1e-1500 + return num / den +MMAX = 40 +A2 = [moment_a2m(m) for m in range(MMAX + 1)] +# certified separated deviations (Poisson path, summandwise positive) +DEV2 = ce.one_minus_a2_poisson(mode='iv') +num4 = iv.mpf(0); den4 = iv.mpf(0) +for n in range(-3, 4): + w = iv.e ** (-iv.mpf(288) * n * n) + t = iv.mpf(24 * n) + num4 += (He_iv(4, t) - 3) * w # He_4(t)-3 = t^2(t^2-6) >= 0 + den4 += w +DEV4 = num4 / den4 +if MUT == 'planar_moments': + from math import factorial as _fact + A2 = [iv.mpf(_fact(2 * m)) / iv.mpf(_fact(m) * 2 ** m) for m in range(MMAX + 1)] + DEV2 = iv.mpf(0); DEV4 = iv.mpf(0) + emit('CB1 MUTATION planar_moments applied (must be caught downstream)') +ck(DEV2.a > 0 and DEV2.b < mpf('1e-100'), 'CB1a exact-torus 0 < 1-a2 < 1e-100 (mutation guard)') +ck(DEV4.a > 0 and DEV4.b < mpf('1e-100'), 'CB1b exact-torus 0 < a4-3 < 1e-100') +emit('CB1 PASS: moments a_{2m}, m<=%d, exact finite torus (1-a2 = %s)' % (MMAX, mp.nstr(DEV2.b, 3))) + +# ------------------------------------------------- CB2: series machinery +# Taylor series at r=0 of all Gram entries (Laurent window [LMIN, J]). +J = 60 # Taylor order kept exactly +LMIN = -8 +RHO = mpf('0.11') # majorant circle radius (det floor scan-verified) +def ser_zero(): + return defaultdict(lambda: iv.mpf(0)) +def ser_monom(c, k): + s = ser_zero(); s[k] = iv.mpf(c); return s +def ser_mul(A, B): + C = ser_zero() + for ja, ca in A.items(): + if ca == 0: continue + for jb, cb in B.items(): + if cb == 0: continue + C[ja + jb] += ca * cb + return C +def ser_add(A, B): + C = ser_zero() + for j, c in A.items(): C[j] += c + for j, c in B.items(): C[j] += c + return C +def ser_scale(A, c): + C = ser_zero() + for j, v in A.items(): C[j] = v * c + return C +def ser_trim(A): + return defaultdict(lambda: iv.mpf(0), + {j: c for j, c in A.items() if j >= LMIN and j <= J + 2 and not (c.a == 0 and c.b == 0)}) + +# kernel series K1^{(n)}( +/- z ): coeff[j] = (-1)^{(n+j)/2} a_{n+j} / j! (n+j even) +from math import factorial +def kernel_ser(n, parity): + s = ser_zero() + for j in range(0, J + 8 - n): + m = n + j + if m % 2 == 1: continue + if m // 2 > MMAX: break + val = ((-1) ** (m // 2)) * A2[m // 2] / factorial(j) + if parity < 0 and j % 2 == 1: val = -val + s[j] = val + return s +KSER = {} +def get_kser(n, parity): + key = (n, parity) + if key not in KSER: + KSER[key] = kernel_ser(n, parity) + return KSER[key] + +# 2D covariance series for displacement d * z, d in {-1,0,1}, matching ce.cov: +# cov(alpha,beta,dx,0) = (-1)^{|beta|} K1^{(n1)}(dx) K1^{(n2)}(0) [no s-flip] +def cov_ser(alpha, beta, d): + n1 = alpha[0] + beta[0]; n2 = alpha[1] + beta[1] + sgn = (-1) ** (beta[0] + beta[1]) + if d == 0: + v1 = ser_zero() + if n1 % 2 == 0: + v1[0] = ((-1) ** (n1 // 2)) * A2[n1 // 2] + else: + v1 = get_kser(n1, d) + k0 = iv.mpf(0) + if n2 % 2 == 0: + k0 = ((-1) ** (n2 // 2)) * A2[n2 // 2] + return ser_scale(v1, sgn * k0) + +# functionals: list of (station, multiindex, Laurent coeff series) +def L(c, k): + return ser_monom(mpf(c), k) +PinsV = [ + [('M', (0, 0), L(1, 0))], + [('M', (1, 0), L(1, 0))], + [('M', (0, 1), L(1, 0))], + [('S', (1, 0), L(1, -1)), ('M', (1, 0), L(-1, -1))], + [('S', (0, 1), L(1, -1)), ('M', (0, 1), L(-1, -1))], + [('S', (0, 0), L(1, -3)), ('M', (0, 0), L(-1, -3)), + ('S', (1, 0), L(mpf(-1) / 2, -2)), ('M', (1, 0), L(mpf(-1) / 2, -2))], +] +SoftY = [ + [('M', (0, 2), L(1, 0))], + [('S', (0, 2), L(1, 0))], + [('M', (2, 0), L(1, -1))], + [('S', (2, 0), L(1, -1))], + [('M', (1, 1), L(1, -1))], + [('S', (1, 1), L(1, -1))], +] +DISP = {('M', 'M'): 0, ('S', 'S'): 0, ('S', 'M'): 1, ('M', 'S'): -1} +def gram_entry_ser(FA, FB): + tot = ser_zero() + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + tot = ser_add(tot, ser_mul(ser_mul(ca, cb), cov_ser(aa, ab, DISP[(xa, xb)]))) + return ser_trim(tot) + +t1 = time.time() +GP_ser = [[gram_entry_ser(PinsV[i], PinsV[j]) for j in range(6)] for i in range(6)] +GY_ser = [[gram_entry_ser(SoftY[i], SoftY[j]) for j in range(6)] for i in range(6)] +GYV_ser = [[gram_entry_ser(SoftY[i], PinsV[j]) for j in range(6)] for i in range(6)] +emit('CB2 series built in %.1fs' % (time.time() - t1)) +# Laurent coefficients: pin Gram regular; GYV regular below z^-1; GY below z^-2 +bad = 0 +for i in range(6): + for j in range(6): + for k, c in GP_ser[i][j].items(): + if k < 0 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 + for k, c in GYV_ser[i][j].items(): + if k <= -2 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 + for k, c in GY_ser[i][j].items(): + if k <= -3 and max(abs(mpf(c.a)), abs(mpf(c.b))) > 1e-60: bad += 1 +ck(bad == 0, 'CB2 Laurent pole pattern (GP regular; GYV, GY only genuine poles)') +emit('CB2 PASS: corrected-basis poles cancel exactly; genuine soft poles z^-1, z^-2 isolated') + +# ------------------------------------------- CB3: series division -> mu, Sigma +def mat_coeff(Gser, j): + return [[Gser[a][b].get(j, iv.mpf(0)) for b in range(6)] for a in range(6)] +def iv_solve6(GG, rhs): + # interval Gauss with partial pivoting + residual check outside + A = [GG[i][:] + [rhs[i]] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c].a + A[rr][c].b)) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(7)] + return [A[i][6] / A[i][i] for i in range(6)] +def matvec(G, v): + return [sum((G[i][k] * v[k] for k in range(6)), iv.mpf(0)) for i in range(6)] +def matmul(A, B): + return [[sum((A[i][k] * B[k][j] for k in range(6)), iv.mpf(0)) for j in range(6)] for i in range(6)] +def matneg(A): + return [[-A[i][j] for j in range(6)] for i in range(6)] + +G0 = mat_coeff(GP_ser, 0) +zV = [iv.mpf(6) / 5, iv.mpf(0), iv.mpf(0), iv.mpf(0), iv.mpf(0), iv.mpf(-1) / 6] +if MUT == 'wrong_window': + zV[5] = iv.mpf(-1) / 12 + emit('CB3 MUTATION wrong_window applied (must be caught downstream)') +Ginv0_cols = [iv_solve6(G0, [iv.mpf(1) if l == k else iv.mpf(0) for l in range(6)]) for k in range(6)] +Ginv0 = [[Ginv0_cols[k][i] for k in range(6)] for i in range(6)] +# residual check ||G Ginv0 - I|| small +res = max(abs((sum((G0[i][k] * Ginv0[k][j] for k in range(6)), iv.mpf(0)) - (iv.mpf(1) if i == j else iv.mpf(0))).b) + for i in range(6) for j in range(6)) +ck(res < 1e-70, 'CB3 G0 inverse residual') +emit('CB3 G0 inverse residual %.2e' % float(res)) + +Gj = [mat_coeff(GP_ser, j) for j in range(J + 3)] +GYj = [mat_coeff(GY_ser, j) for j in range(J + 1)] +GYVj = [mat_coeff(GYV_ser, j) for j in range(J + 2)] +GYV_m1 = mat_coeff(GYV_ser, -1) +GY_m2 = mat_coeff(GY_ser, -2); GY_m1 = mat_coeff(GY_ser, -1) + +W = [None] * (J + 3) +W[0] = matvec(Ginv0, zV) +H = [None] * (J + 3) +H[0] = Ginv0 +for j in range(1, J + 3): + acc = [[iv.mpf(0)] * 6 for _ in range(6)] + for i in range(1, j + 1): + acc = [[acc[a][b] + sum((Gj[i][a][k] * H[j - i][k][b] for k in range(6)), iv.mpf(0)) for b in range(6)] for a in range(6)] + H[j] = matneg(matmul(Ginv0, acc)) + # W[j] = -Ginv0 * sum_i G_i W[j-i] + W[j] = matvec(Ginv0, [-sum((Gj[i][a][l] * W[j - i][l] for i in range(1, j + 1) for l in range(6)), iv.mpf(0)) for a in range(6)]) +# extended GYV coefficient list including the genuine z^-1 pole +def GYVc(i): + return GYV_m1 if i == -1 else GYVj[i] +mu_ser = [None] * (J + 1) +for j in range(J + 1): + mu_ser[j] = [sum((GYVc(i)[a][k] * W[j - i][k] for i in range(-1, j + 1) for k in range(6)), iv.mpf(0)) for a in range(6)] +Sig_ser = [None] * (J + 1) +for j in range(J + 1): + acc = [[iv.mpf(0)] * 6 for _ in range(6)] + for a_ in range(-1, j + 2): + for c_ in range(-1, j + 2): + b_ = j - a_ - c_ + if b_ < 0: continue + prod = matmul(matmul(GYVc(a_), H[b_]), [[GYVc(c_)[l][k] for l in range(6)] for k in range(6)]) # GYV_c^T + acc = [[acc[x][y] + prod[x][y] for y in range(6)] for x in range(6)] + Sig_ser[j] = [[GYj[j][x][y] - acc[x][y] for y in range(6)] for x in range(6)] +emit('CB3 series division done') +# rotated coordinates (q_M, delta=q_S-q_M, alpha_M, alpha_S, beta_M, beta_S) at SERIES level: +# the rotation cancellations (var_delta = S00 - 2 S01 + S11) must happen exactly in the +# coefficients, not in interval arithmetic at evaluation time. +LR = [[1, 0, 0, 0, 0, 0], [-1, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0], [0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 1]] +mu2_ser = [None] * (J + 1) +Sig2_ser = [None] * (J + 1) +for j in range(J + 1): + mu2_ser[j] = [sum((iv.mpf(LR[i][k]) * mu_ser[j][k] for k in range(6)), iv.mpf(0)) for i in range(6)] + Sig2_ser[j] = [[sum((iv.mpf(LR[i][k]) * Sig_ser[j][k][l] * iv.mpf(LR[x][l]) for k in range(6) for l in range(6)), iv.mpf(0)) for x in range(6)] for i in range(6)] + +# regularity of mu, Sigma at r=0: the genuine poles of GYV (z^-1) and GY (z^-2) +# must be annihilated by the conditioning. Check the pole coefficients of the +# products explicitly (they are dropped from the non-negative series below). +mu_pole = matvec(GYV_m1, W[0]) +for a in range(6): + ck(abs(mu_pole[a].a) < 1e-55 and abs(mu_pole[a].b) < 1e-55, 'CB3 mu pole z^-1 vanishes, coord %d' % a) +def mmT(A): + return matmul(matmul(GYV_m1, H[0]), [[A[l][k] for l in range(6)] for k in range(6)]) +Sig_pole2 = [[GY_m2[x][y] - mmT(GYV_m1)[x][y] for y in range(6)] for x in range(6)] +p1 = matmul(matmul(GYV_m1, H[0]), [[GYVj[0][l][k] for l in range(6)] for k in range(6)]) +p2 = matmul(matmul(GYVj[0], H[0]), [[GYV_m1[l][k] for l in range(6)] for k in range(6)]) +p3 = matmul(matmul(GYV_m1, H[1]), [[GYV_m1[l][k] for l in range(6)] for k in range(6)]) +Sig_pole1 = [[GY_m1[x][y] - p1[x][y] - p2[x][y] - p3[x][y] for y in range(6)] for x in range(6)] +for x in range(6): + for y in range(6): + ck(abs(Sig_pole2[x][y].a) < 1e-50 and abs(Sig_pole2[x][y].b) < 1e-50, 'CB3 Sigma pole z^-2 vanishes %d %d' % (x, y)) + ck(abs(Sig_pole1[x][y].a) < 1e-50 and abs(Sig_pole1[x][y].b) < 1e-50, 'CB3 Sigma pole z^-1 vanishes %d %d' % (x, y)) +emit('CB3 poles of mu (z^-1) and Sigma (z^-2, z^-1) annihilated by conditioning') + +# limit identities (independent LPW cross-checks; catches wrong-window) +ck(abs(mu_ser[0][0].a + mpf(6) / 5) < 1e-60 and abs(mu_ser[0][0].b + mpf(6) / 5) < 1e-60, 'CB3 mu_qM(0) = -b a2') +ck(abs(mu_ser[0][1].a + mpf(6) / 5) < 1e-60, 'CB3 mu_qS(0) = -b a2') +ck(abs(mu_ser[0][2].a + 1) < 1e-60, 'CB3 mu_aM(0) = -1 (window identity; mutation guard)') +ck(abs(mu_ser[0][3].a - 1) < 1e-60, 'CB3 mu_aS(0) = +1') +ck(abs(Sig_ser[0][2][2].a) < 1e-60 and abs(Sig_ser[0][2][2].b) < 1e-60, 'CB3 Var(aM)(0) = 0') +ck(abs(Sig_ser[0][0][0].a - 2) < 1e-55, 'CB3 Var(qM)(0) = a4-a2^2 = 2') +emit('CB3 PASS: limit identities mu(0), Sigma(0) match the independent blow-up analysis') + +# ------------------------------------------------- CB4: majorant tails +# crude certified kernel sup: |K1^{(n)}(z)| <= A_n(rho) on |z| <= rho, +# A_n(rho) = sum_{|k|<=K} w |k|^n e^{|k|rho} / Z + certified tail. +ce._build_lattice() +_k = [mpf(x.a) for x in ce._LATT_IV[2]] +_w = [iv.mpf(x) for x in ce._LATT_IV[3]] +_Z1 = ce._LATT_IV[4] +def abs_sum_A(n, rho): + tot = iv.mpf(0) + for kk, ww in zip(_k, _w): + tot += ww * abs(kk) ** n * iv.e ** (abs(kk) * rho) + # certified tail |k| > 17: e^{-k^2/2 + k rho} <= e^{-k^2/4} (k >= 4 rho), + # |k|^n e^{-k^2/4} <= e^{-k^2/8} (8n/e)^{n/2}; geometric sum <= e^{-17^2/8}/(1-e^{-2}) + tail = iv.e ** (-iv.mpf(17 * 17) / 8) * (8 * n / iv.e) ** (n / 2) / (1 - iv.e ** (-2)) + return (tot + iv.mpf((0, float(tail.b)))) / _Z1 +A_rho = [abs_sum_A(n, RHO) for n in range(9)] +# literal-curse entry maxima on |z| = rho +def entry_max2(FA, FB): + tot = mpf(0) + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + n1 = aa[0] + ab[0]; n2 = aa[1] + ab[1] + ma = sum(max(abs(mpf(c.a)), abs(mpf(c.b))) * RHO ** j for j, c in ca.items()) + mb = sum(max(abs(mpf(c.a)), abs(mpf(c.b))) * RHO ** j for j, c in cb.items()) + tot += ma * mb * mpf(A_rho[n1].b) * mpf(A_rho[n2].b) + return tot +M_GP = max(entry_max2(PinsV[i], PinsV[j]) for i in range(6) for j in range(6)) +M_GY = max(entry_max2(SoftY[i], SoftY[j]) for i in range(6) for j in range(6)) +M_GYV = max(entry_max2(SoftY[i], PinsV[j]) for i in range(6) for j in range(6)) +emit('CB4 literal entry maxima on |z|=%.2f: GP %.2e GY %.2e GYV %.2e' % (RHO, M_GP, M_GY, M_GYV)) + +def matmax(M): + return max(mpf(M[i][j].b) if hasattr(M[i][j], 'b') else abs(M[i][j]) for i in range(6) for j in range(6)) +def vecmax(v): + return max(mpf(x.b) if hasattr(x, 'b') else abs(x) for x in v) +G_m = [matmax(Gj[j]) for j in range(J + 1)] +GY_m = [matmax(GYj[j]) for j in range(J + 1)] +GYV_m = [matmax(GYVj[j]) for j in range(len(GYVj))] +G_m_full = [matmax(Gj[j]) for j in range(J + 3)] +H_m = [matmax(H[j]) for j in range(J + 3)] +W_m = [vecmax(W[j]) for j in range(J + 3)] +Ginv0_m = matmax(Ginv0) + +# majorant growth R: smallest R with 36*Ginv0_m*(S_G(R)+T_G(R)) <= 1/2, rho*R > 1 +def S_G(R): + return sum(G_m[i] / R ** i for i in range(1, J + 1)) +def T_G(R): + x = 1 / (RHO * R) + return M_GP * x ** (J + 1) / (1 - x) +def theta(R): + return 36 * Ginv0_m * (S_G(R) + T_G(R)) +R = 1 / RHO * 1.001 +for _ in range(400): + if theta(R) > 0.5: R *= 1.02 + else: break +ck(theta(R) <= 0.5, 'CB4 majorant growth R found') +for _ in range(400): + Rl = R / 1.02 + if theta(Rl) <= 0.5: R = Rl + else: break +emit('CB4 majorant growth R = %.4f (rho*R = %.3f) theta = %.3f' % (R, RHO * R, theta(R))) +# R-majorant only needs to converge on the FIRST sub-interval (0, 0.005]: +ck(R * mpf('0.005') < 0.2, 'CB4 majorant converges on first sub-interval') +C_W = max(W_m[j] / R ** j for j in range(J + 3)); C_W = max(C_W, mpf(1)) +C_H = max(H_m[j] / R ** j for j in range(J + 3)); C_H = max(C_H, mpf(1)) +# Sigma tail: scalar majorant series values +def maj_series_val(coeffs, M, t): + v = sum(coeffs[j] * t ** j for j in range(J + 1)) + x = t / RHO + v += M * x ** (J + 1) / (1 - x) + return v +def maj_partial_GHGYV(t): + tot = mpf(0) + for a_ in range(J + 1): + for b_ in range(J + 1 - a_): + for c_ in range(J + 1 - a_ - b_): + if a_ + b_ + c_ <= J: + tot += GYV_m[a_] * H_m[b_] * GYV_m[c_] * t ** (a_ + b_ + c_) + return tot +def maj_partial_GYVW(t): + return sum(GYV_m[a_] * W_m[b_] * t ** (a_ + b_) for a_ in range(J + 1) for b_ in range(J + 1 - a_)) +def maj_full_R(coeffs, C, t): + # majorant anchored on computed coefficients + R-growth tail (recursion-consistent) + n = len(coeffs) - 1 + return sum(coeffs[j] * t ** j for j in range(n + 1)) + C * (R * t) ** (n + 1) / (1 - R * t) +def Sig_tail(t): + fullGY = maj_series_val(GY_m, M_GY, t) + fullA = maj_series_val(GYV_m, M_GYV, t) + fullH = maj_full_R(H_m, C_H, t) + partGY = sum(GY_m[j] * t ** j for j in range(J + 1)) + tailGY = fullGY - partGY + tailProd = 36 * (fullA * fullH * fullA - maj_partial_GHGYV(t)) + # pole-index terms a=-1 or c=-1 (GYV_{-1} max entry 3) + partHA = sum(H_m[b] * GYV_m[c] * t ** (b + c) for b in range(J + 2) for c in range(J + 2 - b)) + T2 = fullH * fullA - partHA + tailPole = 216 * T2 / t + partH = sum(H_m[b] * t ** b for b in range(J + 3)) + tailPole2 = 324 * (fullH - partH) / (t * t) + return tailGY + tailProd + tailPole + tailPole2 +def mu_tail(t): + fullA = maj_series_val(GYV_m, M_GYV, t) + fullW = maj_full_R(W_m, C_W, t) + main = 6 * (fullA * fullW - maj_partial_GYVW(t)) + pole = 18 * C_W * R * (R * t) ** (J + 1) / (1 - R * t) + return main + pole +ST = Sig_tail(mpf('0.0025')); MT = mu_tail(mpf('0.0025')) +ck(ST < 1e-5, 'CB4 Sigma tail small on first sub-interval') +ck(MT < 1e-5, 'CB4 mu tail small on first sub-interval') +emit('CB4 PASS: series tails on (0,0.005]: Sig %.2e mu %.2e' % (ST, MT)) +def gram_tail(M, t): + # certified Cauchy tail of a Gram-block series beyond kept order J+2 + return M * (t / RHO) ** (J + 3) / (1 - t / RHO) + +# ------------------------------------------- CB5: certified Phi, moments, Wick +SQRT2PI = iv.sqrt(2 * iv.pi) +def iv_phi(x): + return iv.e ** (-(x * x) / 2) / SQRT2PI +def iv_Phi(x): + # standard normal CDF, interval x. + # |x| <= 6: power series Phi = 1/2 + phi(0) sum_k (-1)^k x^{2k+1}/(2^k k!(2k+1)) + # with certified geometric tail; |x| > 6: Gordon-Mills bounds (both monotone). + # intervals straddling +-6 are split by monotonicity of Phi. + if (x.a < 6 < x.b) or (x.a < -6 < x.b): + lo = iv_Phi(iv.mpf(x.a)) + hi = iv_Phi(iv.mpf(x.b)) + return iv.mpf((mpf(lo.a), mpf(hi.b))) + if x.a >= 6: + # Q(x) = 1 - Phi(x) in (phi(x)(1/x - 1/x^3), phi(x)/x); both bounds decreasing + hi = iv_phi(iv.mpf(x.a)) / iv.mpf(x.a) + lo = iv_phi(iv.mpf(x.b)) * (1 / iv.mpf(x.b) - 1 / iv.mpf(x.b) ** 3) + return iv.mpf(1) - iv.mpf((float(lo.a), float(hi.b))) + if x.b <= -6: + # Phi increasing; Phi(x) = Q(-x) + hi = iv_phi(iv.mpf(x.b)) / iv.mpf(-x.b) + lo = iv_phi(iv.mpf(x.a)) * (1 / iv.mpf(-x.a) - 1 / iv.mpf(-x.a) ** 3) + return iv.mpf((float(lo.a), float(hi.b))) + ck(x.a >= -6 and x.b <= 6, 'CB5 Phi series domain x=[%s,%s]' % (mp.nstr(mpf(x.a), 6), mp.nstr(mpf(x.b), 6))) + # |x| <= 6: series with certified geometric tail + # ratio T_{k+1}/T_k = -x^2(2k+1)/(2(k+1)(2k+3)); |ratio| <= 18(2k+1)/((k+1)(2k+3)) < 0.9 for k >= 21 + tot = iv.mpf(0) + K = 0 + term = x # k = 0 term + while K < 120: + tot += term + K += 1 + term = -term * x * x * (2 * K - 1) / (2 * K * (2 * K + 1)) + if K >= 22 and abs(term.b) < 1e-90 and abs(term.a) < 1e-90: + break + tail = max(abs(term.a), abs(term.b)) / (1 - mpf('0.9')) + return iv.mpf(1) / 2 + (tot + iv.mpf((-tail, tail))) / SQRT2PI + +def trunc_mom_iv(mu, var, a, b, kmax): + # E[X^k 1_{a <= X <= b}], X ~ N(mu, var), all intervals; a,b mpf (exact rationals) + s = iv.sqrt(var) + al = (iv.mpf(a) - mu) / s + be = (iv.mpf(b) - mu) / s + I = [iv.mpf(0)] * (kmax + 1) + I[0] = iv_Phi(be) - iv_Phi(al) + I[1] = iv_phi(al) - iv_phi(be) + for e in range(2, kmax + 1): + I[e] = al ** (e - 1) * iv_phi(al) - be ** (e - 1) * iv_phi(be) + (e - 1) * I[e - 2] + from math import comb + out = [] + for k in range(kmax + 1): + tot = iv.mpf(0) + for j in range(k + 1): + tot += comb(k, j) * s ** j * I[j] * mu ** (k - j) + out.append(tot) + return out + +def make_wick_iv(mu, Sig): + @lru_cache(maxsize=None) + def wick(state): + if len(state) == 0: return iv.mpf(1) + if len(state) == 1: return mu[state[0]] + i = state[0]; rest = state[1:] + tot = mu[i] * wick(rest) + for k, j in enumerate(rest): + tot += Sig[i][j] * wick(rest[:k] + rest[k + 1:]) + return tot + return wick +def poly_expect_iv(P, wick): + tot = iv.mpf(0) + for e, c in P.items(): + st = [] + for i, pp in enumerate(e): st += [i] * pp + tot += c * wick(tuple(st)) + return tot +# polynomial algebra (iv coefficients, 6 variables) +def p_affine(idx): + P = defaultdict(lambda: iv.mpf(0)) + P[tuple(1 if k == idx else 0 for k in range(6))] = iv.mpf(1) + return P +def p_mul(A, B): + C = defaultdict(lambda: iv.mpf(0)) + for ea, ca in A.items(): + for eb, cb in B.items(): + C[tuple(x + y for x, y in zip(ea, eb))] += ca * cb + return C +def p_scale(A, s): + C = defaultdict(lambda: iv.mpf(0)) + for e, c in A.items(): C[e] = c * s + return C +def p_add(A, B): + C = defaultdict(lambda: iv.mpf(0)) + for e, c in A.items(): C[e] += c + for e, c in B.items(): C[e] += c + return C +# polynomial-in-t Wick (conditional on one coordinate); means affine in t (iv coefficients) +def tp_add(A, B): + n = max(len(A), len(B)) + return [(A[i] if i < len(A) else iv.mpf(0)) + (B[i] if i < len(B) else iv.mpf(0)) for i in range(n)] +def tp_mul(A, B): + C = [iv.mpf(0)] * (len(A) + len(B) - 1) + for i, a in enumerate(A): + for j, b in enumerate(B): C[i + j] += a * b + return C +def tp_scale(A, s): + return [s * a for a in A] +def conditional_wick_iv(mu, Sig, cond): + i0 = cond + s00 = Sig[i0][i0] + means = [[mu[i] - Sig[i][i0] / s00 * mu[i0], Sig[i][i0] / s00] for i in range(6)] + Sc = [[Sig[i][j] - Sig[i][i0] * Sig[i0][j] / s00 for j in range(6)] for i in range(6)] + @lru_cache(maxsize=None) + def wick(state): + if len(state) == 0: return (iv.mpf(1),) + if len(state) == 1: return tuple(means[state[0]]) + i = state[0]; rest = state[1:] + tot = tp_mul(list(means[i]), list(wick(rest))) + for k, j in enumerate(rest): + tot = tp_add(tot, tp_scale(list(wick(rest[:k] + rest[k + 1:])), Sc[i][j])) + return tuple(tot) + return wick +def cond_expect_poly_iv(P, cw): + tot = (iv.mpf(0),) + for e, c in P.items(): + st = [] + for i, pp in enumerate(e): st += [i] * pp + tot = tp_add(list(tot), tp_scale(list(cw(tuple(st))), c)) + return tot + +# ------------------------------------------------- CB6: band evaluation +def ser_eval(coeffs, t_iv, tail): + # Horner over interval t + symmetric tail + v = iv.mpf(0) + for j in range(len(coeffs) - 1, -1, -1): + v = v * t_iv + coeffs[j] + return v + iv.mpf((-tail, tail)) + +I_LO = mpf('-3.9'); I_HI = mpf('-0.4'); ETA = mpf('0.3'); BB = mpf('2'); AB = mpf('0.8') +def gram_block_eval(Gjlist, pole_mat, t_iv, Mblock): + # interval evaluation of a Gram-block series (kept order J+2) + Cauchy tail; + # pole_mat (or None) is the genuine z^-1 coefficient (requires t_iv.a > 0). + r_hi = mpf(t_iv.b) + tail = gram_tail(Mblock, r_hi) + n = len(Gjlist) - 1 + out = [] + for a in range(6): + row = [] + for b in range(6): + v = iv.mpf(0) + for j in range(n, -1, -1): + v = v * t_iv + Gjlist[j][a][b] + if pole_mat is not None: + v = v + pole_mat[a][b] / t_iv + row.append(v + iv.mpf((-tail, tail))) + out.append(row) + return out +def mp_inverse6(GG): + A = [GG[i][:] + [mpf(1) if l == i else mpf(0) for l in range(6)] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c])) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(12)] + return [[A[i][6 + j] / A[i][i] for j in range(6)] for i in range(6)] +def neumann_law(r1, r2): + # certified (mu, Sigma) enclosures on [r1, r2]: + # heavy part = pole-cancelled regular series (order J+2), interval Horner + # correction = certified bound on (law - partial series), via + # Ginv - Ginv_partial = Ginv * (G - G_partial) * Ginv_partial (Gram tail tiny) + # with ||Ginv|| Neumann-certified on the sub-interval + t_iv = iv.mpf((r1, r2)) + r_hi = mpf(r2) + GP_iv = gram_block_eval(Gj, None, t_iv, M_GP) + mid = [[(mpf(GP_iv[i][j].a) + mpf(GP_iv[i][j].b)) / 2 for j in range(6)] for i in range(6)] + B = mp_inverse6(mid) + Biv = [[iv.mpf(B[i][j]) for j in range(6)] for i in range(6)] + E = [[ (iv.mpf(1) if i == j else iv.mpf(0)) - sum((Biv[i][k] * GP_iv[k][j] for k in range(6)), iv.mpf(0)) for j in range(6)] for i in range(6)] + rho = mp.sqrt(sum(max(abs(mpf(E[i][j].a)), abs(mpf(E[i][j].b))) ** 2 for i in range(6) for j in range(6))) + ck(rho < 0.5, 'CB6 Neumann contraction on [%s,%s]' % (r1, r2)) + BF = mp.sqrt(sum(mpf(B[i][j]) ** 2 for i in range(6) for j in range(6))) + delta = BF * rho / (1 - rho) + Gnorm = BF + 6 * delta # ||Ginv(z)||_F on the sub-interval + GinvPnorm = 6 * sum(H_m[j] * r_hi ** j for j in range(len(H_m))) # ||Ginv_partial||_F + tailG = gram_tail(M_GP, r_hi) + tailGY = gram_tail(M_GY, r_hi) + tailGYV = gram_tail(M_GYV, r_hi) + dGinv = Gnorm * 6 * tailG * GinvPnorm # ||Ginv - Ginv_partial||_F + GYV_H = gram_block_eval(GYVj, GYV_m1, t_iv, M_GYV) # pole-included partial + GYVmax = max(max(abs(mpf(GYV_H[a][b].a)), abs(mpf(GYV_H[a][b].b))) for a in range(6) for b in range(6)) + zVmax = max(abs(mpf(x.a)) for x in zV) + 1e-50 + T_mu = 6 * GYVmax * dGinv * zVmax + 6 * tailGYV * Gnorm * zVmax + T_Sig = tailGY + 36 * GYVmax ** 2 * dGinv + 2 * 36 * tailGYV * Gnorm * GYVmax + 36 * tailGYV ** 2 * Gnorm + ck(T_mu < 1e-2 and T_Sig < 1e-2, 'CB6 law correction small on [%s,%s]' % (r1, r2)) + mu = [ser_eval([mu_ser[j][a] for j in range(J + 1)], t_iv, T_mu) for a in range(6)] + Sig = [[ser_eval([Sig_ser[j][a][b] for j in range(J + 1)], t_iv, T_Sig) for b in range(6)] for a in range(6)] + return mu, Sig, T_mu, T_Sig +def band_lo(r1, r2, label): + t_iv = iv.mpf((r1, r2)) + r_hi = mpf(r2) + if r1 > 0: + mu, Sig, Tm, Ts = neumann_law(r1, r2) + else: + mu = [ser_eval([mu_ser[j][a] for j in range(J + 1)], t_iv, MT) for a in range(6)] + Sig = [[ser_eval([Sig_ser[j][a][b] for j in range(J + 1)], t_iv, ST) for b in range(6)] for a in range(6)] + Tm, Ts = MT, ST + mu2 = [ser_eval([mu2_ser[j][a] for j in range(J + 1)], t_iv, 2 * Tm) for a in range(6)] + Sig2 = [[ser_eval([Sig2_ser[j][a][b] for j in range(J + 1)], t_iv, 4 * Ts) for b in range(6)] for a in range(6)] + r_iv = t_iv + # type margins (law-independent): B_cert subset of the type event + DM_lo = AB * (-I_HI) - r_hi * BB * BB + DS_hi = AB * (I_HI + ETA) + ck(DM_lo > 0.05, 'CB6 type margin D_M>0 ' + label) + ck(DS_hi < -0.05, 'CB6 type margin D_S<0 ' + label) + ck(I_HI + ETA < 0, 'CB6 q_S<0 ' + label) + # polynomials p = -D_MD_S and pbar (majorant with (x^2+1)/2 >= |x|) + aqM = p_affine(0); aqS = p_affine(1); aaM = p_affine(2); aaS = p_affine(3); abM = p_affine(4); abS = p_affine(5) + DM = p_add(p_mul(aaM, aqM), p_scale(p_mul(abM, abM), -r_iv)) + DS = p_add(p_mul(aaS, aqS), p_scale(p_mul(abS, abS), -r_iv)) + P = p_scale(p_mul(DM, DS), -1) + one = defaultdict(lambda: iv.mpf(0)); one[(0,) * 6] = iv.mpf(1) + u1 = p_add(p_scale(p_mul(p_mul(aaM, aqM), p_mul(aaM, aqM)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + u1 = p_add(u1, p_scale(p_mul(abM, abM), r_iv)) + u2 = p_add(p_scale(p_mul(p_mul(aaS, aqS), p_mul(aaS, aqS)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + u2 = p_add(u2, p_scale(p_mul(abS, abS), r_iv)) + PBAR = p_mul(u1, u2) + wick = make_wick_iv(tuple(mu), tuple(tuple(row) for row in Sig)) + # piece 1: E[p 1_{qM in [I_LO, I_HI]}] + cw0 = conditional_wick_iv(mu, Sig, 0) + cp0 = cond_expect_poly_iv(P, cw0) + tm0 = trunc_mom_iv(mu[0], Sig[0][0], I_LO, I_HI, len(cp0) - 1) + EqI = sum((c * t for c, t in zip(cp0, tm0)), iv.mpf(0)) + # rotated coords (delta = qS - qM) already built from the series above + aqS2 = p_add(p_affine(0), p_affine(1)) + v1 = p_add(p_scale(p_mul(p_mul(aaM, aqM), p_mul(aaM, aqM)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + v1 = p_add(v1, p_scale(p_mul(abM, abM), r_iv)) + v2 = p_add(p_scale(p_mul(p_mul(aaS, aqS2), p_mul(aaS, aqS2)), iv.mpf(1) / 2), p_scale(one, iv.mpf(1) / 2)) + v2 = p_add(v2, p_scale(p_mul(abS, abS), r_iv)) + PBAR2 = p_mul(v1, v2) + Ebar = poly_expect_iv(PBAR, wick) + wick2 = make_wick_iv(tuple(mu2), tuple(tuple(row) for row in Sig2)) + Ebar2 = poly_expect_iv(PBAR2, wick2) + ck(Ebar.a <= Ebar2.b and Ebar2.a <= Ebar.b, 'CB6 pbar enclosures intersect ' + label) + Epbar2 = poly_expect_iv(p_mul(PBAR, PBAR), wick) + def piece_outside(PP, muX, SigX, cond, a, b, Etot, oneside=None, force_chern=False): + s00 = SigX[cond][cond] + if (not force_chern) and s00.a > 1e-4: + cw = conditional_wick_iv(muX, SigX, cond) + cp = cond_expect_poly_iv(PP, cw) + tm = trunc_mom_iv(muX[cond], SigX[cond][cond], a, b, len(cp) - 1) + return Etot - sum((c * t for c, t in zip(cp, tm)), iv.mpf(0)) + # near-singular: exact Gaussian tail (certified Mills via iv_Phi) + Cauchy-Schwarz + sb = mp.sqrt(mpf(s00.b)) + if oneside == 'gt': # P(X > b), b below mean + t0 = (mpf(b) - mpf(muX[cond].b)) / sb + elif oneside == 'lt': # P(X < a), a above mean + t0 = (mpf(muX[cond].a) - mpf(a)) / sb + else: # P(|X| > b), b = eta, a = -eta + m = max(abs(mpf(muX[cond].a)), abs(mpf(muX[cond].b))) + t0 = (mpf(b) - m) / sb + ck(t0 > 2, 'CB6 Chernoff tail margin ' + label) + P = iv_Phi(iv.mpf(-t0)).b + val = mp.sqrt(mpf(Epbar2.b) * mpf(P)) + return iv.mpf((0, val)) + Edelta = piece_outside(PBAR2, mu2, Sig2, 1, -ETA, ETA, Ebar2, force_chern=True) + Ebeta = piece_outside(PBAR, mu, Sig, 4, -BB, BB, Ebar) + EaM = piece_outside(PBAR, mu, Sig, 2, mpf('-100'), -AB, Ebar, oneside='gt', force_chern=True) + EaS = piece_outside(PBAR, mu, Sig, 3, AB, mpf('100'), Ebar, oneside='lt', force_chern=True) + ck(Edelta.b > -1e-6 and Ebeta.b > -1e-6, 'CB6 piece enclosures sane ' + label) + lo = EqI - Edelta - Ebeta - EaM - EaS + emit('CB6 %-14s lo in [%s, %s] (EqI %s, deltas %.2e %.2e %.1e %.1e)' % ( + label, mp.nstr(mpf(lo.a), 12), mp.nstr(mpf(lo.b), 6), mp.nstr(mpf(EqI.a), 8), + float(mpf(Edelta.b)), float(mpf(Ebeta.b)), float(mpf(EaM.b)), float(mpf(EaS.b)))) + return lo + +SUBS = [(mpf('0'), mpf('0.0025')), (mpf('0.0025'), mpf('0.005')), (mpf('0.005'), mpf('0.01')), (mpf('0.01'), mpf('0.02')), + (mpf('0.02'), mpf('0.03')), (mpf('0.03'), mpf('0.04')), (mpf('0.04'), mpf('0.05'))] +glomin = None +for (r1, r2) in SUBS: + lab = '(%s,%s]' % (mp.nstr(r1, 4), mp.nstr(r2, 4)) if r1 > 0 else '(0,%s]' % mp.nstr(r2, 4) + lo = band_lo(r1, r2, lab) + ck(lo.a > REQ, 'CB6 band lo > c_Z on ' + lab) + mrg = (mpf(lo.a) - REQ) / REQ + emit('CB6 %s CERTIFIED: E[G_r] >= %s > c_Z = 1.6154892676..., margin %.2f%%' % ( + lab, mp.nstr(mpf(lo.a), 15), float(mrg * 100))) + glomin = lo.a if glomin is None else min(glomin, lo.a) +emit('CB6 PASS: uniform certified floor on (0, 0.05]: min lo = %s' % mp.nstr(mpf(glomin), 15)) + +# ------------------------------------------------- CB7: rung cross-check + MC +# independent cross-check of the band formula at the rung point r = 0.05 +# (direct point law from ce.cov + same Wick formula, no series machinery) +def direct_point_law(rpt): + M = (-rpt / 2, mpf(0)); S = (rpt / 2, mpf(0)) + V = [[(M, (0, 0), mpf(1))], [(M, (1, 0), mpf(1))], [(M, (0, 1), mpf(1))], + [(S, (1, 0), 1 / rpt), (M, (1, 0), -1 / rpt)], [(S, (0, 1), 1 / rpt), (M, (0, 1), -1 / rpt)], + [(S, (0, 0), 1 / rpt ** 3), (M, (0, 0), -1 / rpt ** 3), (S, (1, 0), -1 / (2 * rpt ** 2)), (M, (1, 0), -1 / (2 * rpt ** 2))]] + Yv = [[(M, (0, 2), mpf(1))], [(S, (0, 2), mpf(1))], + [(M, (2, 0), 1 / rpt)], [(S, (2, 0), 1 / rpt)], + [(M, (1, 1), 1 / rpt)], [(S, (1, 1), 1 / rpt)]] + def lc(FA, FB): + tot = mpf(0) + for (xa, aa, ca) in FA: + for (xb, ab, cb) in FB: + tot += ca * cb * ce.cov(aa, ab, xa[0] - xb[0], xa[1] - xb[1], mode='mpf') + return tot + GP = [[lc(V[i], V[j]) for j in range(6)] for i in range(6)] + GY = [[lc(Yv[i], Yv[j]) for j in range(6)] for i in range(6)] + GYV = [[lc(Yv[i], V[j]) for j in range(6)] for i in range(6)] + zVd = [mpf(6) / 5, 0, 0, 0, 0, mpf(-1) / 6] + def solve6(GG, rhs): + A = [GG[i][:] + [rhs[i]] for i in range(6)] + for c in range(6): + p = max(range(c, 6), key=lambda rr: abs(A[rr][c])) + A[c], A[p] = A[p], A[c] + for rr in range(6): + if rr != c: + f = A[rr][c] / A[c][c] + A[rr] = [A[rr][j] - f * A[c][j] for j in range(7)] + return [A[i][6] / A[i][i] for i in range(6)] + csol = solve6(GP, zVd) + muD = [sum(GYV[i][k] * csol[k] for k in range(6)) for i in range(6)] + Gic = [solve6(GP, [1 if l == k else 0 for l in range(6)]) for k in range(6)] + SigD = [[GY[i][j] - sum(GYV[i][k] * sum(Gic[k][l] * GYV[j][l] for l in range(6)) for k in range(6)) for j in range(6)] for i in range(6)] + return muD, SigD +muD, SigD = direct_point_law(RMAX) +muN, SigN, TmN, TsN = neumann_law(RMAX, RMAX) +for a in range(6): + ck(muN[a].a <= muD[a] <= muN[a].b, 'CB7 Neumann mu contains direct mu at rung, coord %d' % a) +for a in range(6): + for b in range(6): + ck(SigN[a][b].a <= SigD[a][b] <= SigN[a][b].b, 'CB7 Neumann Sigma contains direct, %d %d' % (a, b)) +emit('CB7 PASS: Neumann (mu, Sigma) at r=0.05 contain the independent direct point law') + +import numpy as np +rng = np.random.default_rng(90210) +for rpt in [0.05, 0.01]: + muMc, SigMc, _Tm, _Ts = neumann_law(mpf(rpt), mpf(rpt)) + muNp = np.array([float(mpf(x.a) + mpf(x.b)) / 2 for x in muMc]) + SigNp = np.array([[float(mpf(SigMc[a][b].a) + mpf(SigMc[a][b].b)) / 2 for b in range(6)] for a in range(6)]) + SigNp = (SigNp + SigNp.T) / 2 + LA = np.linalg.cholesky(SigNp + 1e-14 * np.eye(6)) + NMC = 400000 + U = rng.standard_normal((NMC, 6)) + Y = muNp[None, :] + U @ LA.T + qM, qS, aM, aS, bM, bS = Y.T + DMv = aM * qM - rpt * bM ** 2 + DSv = aS * qS - rpt * bS ** 2 + G = np.where((qM < 0) & (DMv > 0) & (DSv < 0), -DMv * DSv, 0.0) + est = G.mean(); sig = G.std(ddof=1) / np.sqrt(NMC) + ck(est + 6 * sig >= float(mpf(glomin)), 'CB7 MC consistency (est >= certified lo) at r=%g' % rpt) + emit('CB7 MC DIAGNOSTIC r=%.2f: E[G] = %.5f +- %.5f (>= certified lo %.5f OK; NOT load-bearing)' % ( + rpt, est, sig, float(mpf(glomin)))) + +# ------------------------------------------------- CB8: receipts +print('CB8 total runtime %.1fs' % (time.time() - t0), file=sys.stderr) +emit('ALL_CHECKS_PASS') +body = '\n'.join(OUT) + '\n' +with open('band_out.txt', 'w') as f: + f.write(body) +emit('sha256(transcript-above) = ' + hashlib.sha256(body.encode()).hexdigest()) diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md new file mode 100644 index 000000000..ecf4adc43 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md @@ -0,0 +1,131 @@ +# H5 closure — TIGHTENING amendment (2026-09-15) + +Amendment to the frozen H5_CLOSURE.md (body-sha256 +465c97c0553ecc0a8f461a86c9315ce1c078a326f07b81498d7a74da8603d301, shipped to +D1 v2.0). Per the standing rule the frozen body is NOT altered; this package +carries (i) the H5-AXIS v3 statement IN FULL (cited by D1's register but +absent from the v1 carrier — Stage-E provenance/scope finding), and (ii) +the refine-3 improved totals (cited from the version-frozen +h5_totals_v2_2026-09-15.json, sha256 f3e672a3cb4d4016a117624493a8ce766c5bf21e1a7697b840da82e896f98ecf; +version discipline per H5_TOTALS_FREEZE_2026-09-15.md). The frozen v1 +interval remains the D1 v2.0 dependency; everything here is +improvement-only (downward drift of the upper end). + +## 1. H5-AXIS v3 (named lemma, full statement) + +**Regions.** With M = (−r/2, 0), S = (+r/2, 0), d_M/d_S the point distances +and θ_M/θ_S the unsigned polar angles about the +x axis (θ = 0 pointing +away from the segment on each side; the M–S segment itself is θ_S = 180° / +θ_M = 180°): + - S-cone wedges: {d_S < 0.105} ∩ ({θ_S < 18°} ∪ {θ_S > 162°}) (v1, widened 12°→18° in v3) + - M-forward wedge: {d_M < 0.10, θ_M < 12°} (v1) + - M-backward wedge: {d_M < 0.10, θ_M > 168°} (v1) + - S-disk: {d_S < 0.062}, ALL directions (v2: 0.03; v3: 0.062) + +**Statement.** ρ_w(y) ≤ C_region for every chart point y in each region, +with machine-certified constants (each = 2 × max over the region's +certified edge-probe ρ_hi values, CoarseBox + coarse_fine_hi, η = 2.5e-4, +K = 8): + - C_scone = 0.18998 (edge probes at θ_S ∈ {20°, 30°} × d_S ∈ {0.03, 0.06}, + all off-wedge; the θ_S = 12° v1-era sites are interior to the widened + wedge and included conservatively in the max) + - C_mfwd = 1.3254 (edge probes at θ_M ∈ {8°, 12°} × d_M ∈ {0.012, 0.03, 0.06}) + - C_mbwd = 1.6522e-05 (edge probes at θ_M ∈ {171°, 176°} × same radii) + - C_disk = 0.34268 (edge probes on the ring d_S = 0.040 at θ_S ∈ + {30°, 60°, 90°, 120°, 150°} from the M-ward axis — values 0.170, 0.064, + 0.020, 0.039, 0.171 — plus the v3 ring at d_S = 0.065, θ_S ∈ + {30°, 60°, 90°, 120°, 150°} and d_S = 0.085 at 90° — values ≤ 0.123 — + plus the scone d_S = 0.06 sites, all conservatively in the max) + +**Flatness hypothesis (the lemma's content).** ρ_w is O(1)-flat across each +region at the probe scale: the certified edge-ring values bound the +interior. Mechanism: the pins' collinear conditioning (det Σ_gg ~ 1e-15 +below the TM slack inside the wedges) makes the pgrad factor diverge as the +point approaches the M–S axis, while the windowed v-integral I is suppressed +by the same degeneracy; C1's exact values inside the wedges are ≤ 2.5e-5 +(mostly boosted-zero), two to four orders below the certified constants — +the constants are honest certified envelopes, not tight values. The +hypothesis is stated per region with the probe receipts banked +(h5_results_r0.05_sdisk.jsonl, h5_results_r0.05_sring.jsonl, +h5_results_r0.05_s0p1_rimprobes.jsonl). + +**Why the regions exist (obstruction record).** The Kac–Rice intensity +needs E[|det H| · 1_typed | six pins] via the 18-jet Gram; on the M–S axis +the pins are collinear and the conditional covariance Σ_gg degenerates +(machine-certified det Σ_gg.lo below the TD = 6 Taylor-model slack), so no +box straddling the axis certifies. The poison cell th15_dl0.066 (first +record hi = 6.47e7, certified but vacuous, preserved as the failed-cell +receipt in h5_results_r0.05_s1p2_cells.jsonl) sat in the off-cone near-S +band that v2's S-disk (0.03) and then v3's S-disk (0.062) absorbed; the +cell's machine-covered remainder recertified at hi = 2.17e-5 +(h5_results_r0.05_refine.jsonl, min-per-cell). + +**Grade.** Named-lemma (probe constants machine-certified; flatness stated +with receipts). **Production path (documented, not run):** the factored-det +expansion det Σ_gg = (d_M d_S)⁴·Q(1 + O(d)) with Q certified nonzero makes +the wedges and the disk machine-coverable (Grade-B fine path); the v3 +quantifiers then retire. + +**v1→v2→v3 amendment chain.** v1: cones only (12° S-wedges). v2 (poison +cell th15_dl0.066): S-disk d_S < 0.03. v3 (stitch execution): S-disk +extended to d_S < 0.062 absorbing the degenerate inner S-annulus band and +the S-disk boundary-exemption ring; S-cone wedges widened 12°→18° (the +[14°, 18°] sliver certified only vacuously); each extension with certified +edge probes banked BEFORE the envelope applied; the merger's coverage +self-test (81×73 grid) mirrors the final regions and fails closed on any +uncovered point. + +## 2. Refine-3 improved totals (h5_totals_v2_2026-09-15.json) + + I_lo = 1.2328893552e-08 (partial by construction: 2 × Σ 8 patch lowers) + I_hi = 8.0975589252e-02 (= 647.80 r³; 504.4× C1's 1.605315e-4) + part ledger: 2R1 = 1.2217e-2 (unchanged; cells2 phase targets it) + 2rim = 1.9492e-4 scone = 1.3161e-3 + mfwd = 2.7759e-3 mbwd = 3.4604e-8 + sdisk = 4.1383e-3 (v3: C_disk·π·0.062²) + stitch = 5.78896e-2 (refine-3 min-per-sector: M-ring sec 0 + collapsed to 0 via the v3 S-disk skip; M10/M2, S1/S9/S4/S6 + refine passes banked; v1's 6.8550e-2 → 5.7890e-2) + remote = 2.4438e-3 (D3 bracket; see §4) + vs frozen v1: I_hi 9.142887704e-02 → 8.0975589252e-02 (−11.4%), + I_lo 1.166721190e-08 → 1.2328893552e-08 (upward: more + patch mass banked — the lower end is partial by design). + +**Re-verified cks (this amendment's merge, h5_merge.py current):** 70/70 R1 +cells min-per-cell; 10 rim columns nonzero off-cone; probe buckets exact +(6 scone + 12 m-cone + 5 sdisk + 6 sring sites); 22 stitch sectors +(12 M-ring + 10 outer S-annulus; inner band excluded — superseded by the +v3 S-disk, documented); coverage self-test 81×73 grid every point ≥1 +mechanism PASS (census rim 365 / r1 2409 / stitch 2476 / remote 1761 / +env 2495 / multi 3108); ck(C1_TOTAL = 1.605315e-4 ∈ [I_lo, I_hi]) PASS +(consistency display only). + +## 3. Mutation-hardened merger + +h5_merge.py refactor: assemble(r, mutate_index, write_totals); versioned +totals writes ('x'-mode auto-increment, never overwriting; the v1 consumed +artifact untouched per H5_TOTALS_FREEZE_2026-09-15.md); exact-count +probe-site cks added; mutation suite 6 selector classes (R1 cell / rim +column / stitch sector / scone site / sdisk site / sring site deletion) — +6/6 trip fail-closed cks. + +## 4. Note on the remote part (D3 R3 correction) + +New work carries the remote as the symbolic bracket B_remote·r³; the D3 +lane's κ-inclusive correction lands as its own amendment and is consumed +then. This amendment's totals still consume the v1 bracket 19.55·r³ +(the frozen D1 v2.0 dependency; the correction is expected to move +B_remote, direction per D3). + +## 5. Receipts + +- h5_totals_v2_2026-09-15.json (sha256 above), H5_TOTALS_FREEZE_2026-09-15.md +- refine-3 records: h5_results_r0.05_stitchref3.jsonl (+ stitchout*.log transcripts) +- v3 probe records: h5_results_r0.05_sring.jsonl (6 sites ≤ 0.123) +- merger + certificate hashes: CODE_HASHES.txt (regenerated at this freeze) +- falsify.py modes A/B byte-identical (3ef903bbe260…), falsify_promote.sh + modes byte-identical (3c10935be0ca…), mutation suites 6/6 both + +--- + +body-sha256: 7fefa17b74836092c0dd5912e028e3b09c1bf4f68c02e35390b552d4479f0561 diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W3_numerics/W3_REPORT.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W3_numerics/W3_REPORT.md new file mode 100644 index 000000000..edd5162fb --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W3_numerics/W3_REPORT.md @@ -0,0 +1,118 @@ +# W3 — Rigorous WP Numerics (SIDE24/q0 lower-rate repair) — STATUS: DRIVER RUNNING (pre-freeze draft) + +## Model (exact, independent re-derivation) +Normalized periodized Bargmann–Fock field on T^2_24: Var f = 1, +K(x,y) = K1(x1-y1)K1(x2-y2), K1(s) = Z^{-1} sum_{j in (pi/12)Z} e^{-j^2/2} e^{ijs}. +Level b = 6/5; window [b-ell, b], ell = r^3/6, r = 0.025; +pins (f, d1f, d2f): M=(-0.0125,0) f=b; S=(0.0125,0) f=b-ell; Y=(-0.0315,0.006) f=mu_t=1.1999986986564927790, gradients 0. +Estimand rho_WP(y;r) = p_{grad f~}(0) * E[|det H| 1{det<0} 1{b-ell combined U4 (min of moment bounds and |D|^{-1/2}-decaying Bell bounds), per-panel Simpson–Peano remainders, Cauchy-series head, algebraic tail. **Interval explosion fixed rigorously**: |phi(t)| <= 1 (ch.f.) => h=(1-Re phi)/t^2 in [0, 2/t^2]; hval clamped to this (valid for all V in the box). +5. **dPhi**: certified Phi-differences (Taylor-in-h with probabilists'-Hermite terms and a Cramer remainder bound) replacing too-coarse Mills brackets — used in Pwin and all convolution pieces. +6. **Box-integral lower bound**: int_box rho dy >= pgrad_lo * g_lo * ell/sig_hi * area * F_lo with + - g_lo = lo of the interval g-quadrature over the box (contains every V in the box); + - F_lo = certified inf over the window of E[phi(max(1,(|c-X|+Rm)/sig_lo))], X = grad(mt).Uniform(box) (trapezoid convolution, closed-form pieces; validated against brute force to 6 digits); + - Rm = certified quadratic remainder of mt(y) from TM Hessian sups; + - psi(m;u) >= phi(max(1, |u-m|/sig_lo))/sig_hi (exact min over [sig_lo, sig_hi]). + +## Point-certified anchors (tight intervals, point law) +- rho(0, 0.60) = [1.0572974460e-04, 1.0581169866e-04] (harness CHECK1; mid-tier upper 1.0794e-4, only 2% above exact) +- g(anchor) = [0.647581909, 0.647787533] +- KIMI witness region (-0.04,-0.60): rho <= 1.945e-8 (type-killed). + +## Drivers (background, deterministic) +- **LOWER (primary)**: w3_lbox.py over x in [-0.08,0.08], y in [0.50,0.68], 0.0025 boxes (4608), two processes (y-halves), gtol 1e-5, 160-bit box phase. Per box: boxint_lo certified; running accumulator in lbox_A.txt / lbox_B.txt. Checkpoint/resume: append-only logs; rerun the same command to resume after a restart (W3_RESUME=1 default; 0 for fresh). +- Three accumulators per box: + * acc (LOWER): certified box-integral lower (boxint_lo); + * acc_up (UPPERBAND): min(cheap,mid)*area (CS-class ~1e-2); + * acc_ex (UPPEREX): hi(rho_exact_tier)*area — certified exact-tier band upper + (per-box rho interval contains rho(y) for all y in the box); expected ~3-50x truth, + i.e. ~1e-5-1e-4 class — sharper than the corrected-CS 1e-2 class on the band. +- Validation: brute-force true box integral at (-0.0037,0.5988) via 4 certified point + evals: true = [6.619e-10, 6.624e-10] >= certified boxint_lo = 1.3691e-10 (yield 20.7%). +- First certified boxes: boxint_lo = 1.3691e-10 at (-0.0037,0.5988); g_lo = 0.156 within g=[0.156,1.27]; F_lo = 0.1217. +- **Expected outcome (calibration)**: per-box yield ~20-30% of the estimated true box integral (dominant loss: interval g width over the box, factor ~4; psi bound factor ~1.3-1.65). With the band integral at the ~4.8e-6 scale, the certified LOWER will land ~1-1.5e-6, i.e. BELOW the 3.328125e-6 = 0.213 r^3 refutation threshold. **The formal refutation is expected to be INCONCLUSIVE (OPEN), not a refutation and not a confirmation.** +- **UPPER (secondary)**: full-plane adaptive driver queued behind the lower pass (2 cores); band-upper partial sums from the same TM pass. + +## Harness (fail-closed) — COMPLETE (post-restart) +w3_harness.py + w3_run_harness.sh; receipts/ holds .out/.err/.exit/.sha256 per run. +- CHECK0 law fingerprint (9-component target vector, 12 significant digits, hardcoded); + CHECK1 anchor truth; CHECK2 hierarchy exact <= min(cheap,mid); CHECK3 quadrature + convergence; CHECK4 F_conv vs brute force; CHECK5 dPhi width. +- harness_normal: exit 0; harness_O: exit 0; byteident.txt = BYTEIDENT PASS. +- Mutations (all fail closed, exit 1): + * sqrt (missing Cauchy–Schwarz sqrt restored): caught by CHECK2 + (exact_hi=1.058117e-04 > mutated min(cheap,mid)_hi=4.250869e-09); + * pin (pin M f-value +1e-2): caught by CHECK0 (law fingerprint mismatch); + * zone (level b +1e-3): caught by CHECK0 (law fingerprint mismatch, since pin + values include b and b-ell). +- failclosed.txt = FAILCLOSED PASS. + +## Restart state (sandbox restart at ~box 15/4608) +Drivers relaunched from box 0 (old logs kept as lbox_A_run1.txt / lbox_B_run1.txt): + python3 w3_lbox.py -0.08 0.08 0.50 0.565 0.0025 1e-5 lbox_A.txt + python3 w3_lbox.py -0.08 0.08 0.565 0.68 0.0025 1e-5 lbox_B.txt +Resumption: rerun the same two commands (W3_RESUME=1 default: skips completed boxes +and seeds acc/acc_up/acc_ex from the log). Throughput-rebalanced split: + python3 w3_lbox.py -0.08 0.08 0.50 0.575 0.0025 1e-5 lbox_A.txt (1920 boxes) + python3 w3_lbox.py -0.08 0.08 0.575 0.68 0.0025 1e-5 lbox_B.txt (2688 boxes) +EXACT PARTITION of the band (A y-centers 0.5012..0.5737; B 0.5762..0.6787); +LOWER = LOWER(A) + LOWER(B), UPPEREX = UPPEREX(A) + UPPEREX(B). +WARNING: lbox_B_run3.txt (superseded) contains boxes at y<0.575 now owned by A -- +do NOT sum it into the final result. lbox_A_run1/run2, lbox_B_run1/run2 are +superseded partial runs, likewise excluded. +Liveness: each box (and skip) rewrites lbox_{A,B}.txt.live (box id, driver clock); +watch.log heartbeats every 10 min include live_age seconds (dead vs slow +distinguishable: live_age > ~4x the per-box time means dead). +Automation: w3_deadman.sh (120s cadence) writes DEATH A/B or A/B COMPLETE + +ALL COMPLETE sentinels to watch.log; w3_supervisor.sh (300s cadence) relaunches a +dead driver from checkpoint (max 3 attempts per driver, then exits with a sentinel +line); a completed driver (EXITOK in log) is never relaunched. +Measured per-box cost at edge columns: A ~100s, B ~71s; ETA ~53h (both bands), +improving if interior boxes match the 23-45s smoke-test rates. +Completion marker: each log ends with DONE / LOWER= / UPPERBAND= / TIME= / EXITOK. +Final lower bound = LOWER(A) + LOWER(B) (+ the two run1 partial accumulators are +subsumed, since the rerun covers the same boxes). + +## Change log +- v1 (pre-restart): initial drivers, harness draft. +- v2 (post-restart-1): drivers relaunched; harness completed (normal/-O/3 mutations, + BYTEIDENT PASS, FAILCLOSED PASS); CHECK0 law fingerprint added; pin mutation + strengthened to +1e-2; zone mutation fixed (w3c.Fr). +- v3: checkpoint/resume added (append-only logs, W3_RESUME); acc_ex (exact-tier band + upper) accumulator added; hval clamp upgraded with the |D|-decaying bound; + F_conv sharpened to phi(max(1,(|c-X|+Rm)/sig_lo)) (1.32x). +- v4 (post-restart-2): REBALANCE BUG caught and fixed: an A/B re-split to + [0.50,0.575]/[0.575,0.68] had left old-B's seeded boxes at y in [0.565,0.575) + inside A's range (double-count) plus a 252-box hole at y in [0.565,0.575), + x > -0.0788. Fixed by restarting B FRESH on [0.575,0.68] (old log preserved as + lbox_B_run3.txt, marked DO-NOT-SUM) and resuming A on [0.50,0.575]; the final + cover is an exact partition. All superseded logs preserved (lbox_A_run1/run2.txt, + lbox_B_run1/run2/run3.txt). +- v5: .live liveness receipts (per-box rewrite of lbox_{A,B}.txt.live) + watcher + live_age heartbeats; approved as standard by the lead. Lead decision: full band + at the conservative ~53h, no schedule constraint; report only at band completion + or detected driver death. +- v6 (post-restart-3): SECOND infrastructure death (timeline: first death Sep 13 + 08:41 machine restart, A at 15 boxes / B at 22; second death Sep 14 08:27, + A at 26 boxes acc=1.466068e-10 / B at 19 boxes acc=4.282164e-10). Root cause + (identified by the lead, canary-verified): pgrep -f SELF-MATCHES its own pattern + in this environment (pgrep does not exclude itself), so every keeper/supervisor + guard checking liveness via pgrep -f '' saw itself and concluded the + drivers were alive forever -- no relaunch ever fired. Fix: bracket-trick + patterns (pgrep -f '[w]3_lbox.py ...' never self-matches) in w3_deadman.sh and + w3_supervisor.sh (w3_watch.sh uses no pgrep). Verified from a clean script + context: count 0 with drivers dead, 1 each with drivers running. Both bands + resumed from checkpoint (integrity re-verified: complete lines, monotone + accumulators): A from box 26 (acc=1.466068e-10), B from box 19 + (acc=4.282164e-10); heartbeats confirmed resetting live_age before idle. + +## Independence statement +No KIMI WP conclusions (KIMI-DER-025, verify_wp_witness_v1.py, THM-023 drafts), no W4 report, and no other subagent's pipeline were read or used. All kernel/law/estimand quantities re-derived from the model statement. + +## Freeze +Pending driver completion (~15h ETA from 05:12Z). Final numbers, hashes (sha256 of all code + transcripts + receipts) to follow at freeze. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md new file mode 100644 index 000000000..ca24f26a9 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md @@ -0,0 +1,109 @@ +# K3 SWARM Phase 3 — W8 Λ-side (DER-027b successor): FORMAL NONCLOSURE REPORT + +Artifact class: formal nonclosure report with the exact missing piece named (mandate item 4: "close or explicitly not-close at the certificate standard"). +Supersedes: AO48-WO-063 Task 4b frame and the draft KIMI-DER-027b.md (which contained placeholders; itemized in §1). +Certificate: verify_lambda_grid_v2.py (self-contained, fail-closed ck() → SystemExit; deterministic; byte-identical transcripts under python3 and python3 -O — see transcripts/ and HASHES.txt). +Mutation tests: mutate_lambda_grid.py (4 mutations, every one trips ck; receipts in mutation_receipts.txt). +Precision labels: EXACT (rationals / exact formulas) vs decimal-dps-70. All jet values carry junk allowance 1e-12. + +## 1. Placeholders and unfinished sections in DER-027b.md (mandate item 1, complete list) + +1. §5 "Numerical values ... are printed by the certificate — see §7 once transcripts are attached" — placeholder (no numbers). +2. §7 Verdict: "(to be completed from the transcripts; expected form: ...)" — placeholder + 'expected verdict' language (prohibited in the final artifact). +3. §8 "Remaining gap" marked "(to be completed ...)" — placeholder. +4. §6 dependency table row "File hashes: to be attached by the lead's packaging" — placeholder hash slot (prohibited). +5. The header line "Certificate: verify_lambda_grid_v1.py" referenced a v1 script whose transcripts had not completed (no receipts). +6. §3/§4 used the margin M_floor = 0.9001 and the premise H-B3 without a completed, receipted certificate run behind them. + +All six are resolved in this successor: no placeholder, no expected-verdict language, hashes attached, verdict replaced by the explicit nonclosure disposition in §7. + +## 2. The exact Λ-side event and measure (mandate item 2) + +Object of the theorem: the r→0 limit window-integral intensity of the C026/C027 engine, +λ(y) = (2π)^{-1} · c6v(y)^{-1/2} · e^{−q(y)/2} · Pwin(y) · |cM(y)·cS(y)·cY(y)| / DEN +on the typed support T = { cM>0, cS<0, cY<0, trc<0 }, λ = 0 off T, where: +- the field is the normalized periodized Bargmann–Fock Gaussian field on the side-24 torus: spectral lattice (π/12)ℤ², masses e^{−|k|²/2}, cutoff |k| ≤ 30, certified tail Σ_{|k|>30} e^{−|k|²/2}(1+|k|⁶) ≤ 2.87e-182 (decimal-dps-70) — exact covariance and normalization; +- pins M=(0,0), S=(1,0) (scaled coordinates), b = 6/5 (EXACT), ℓ = r³/6 (EXACT); +- DEN = (b²+2)Φ(b/√2) + √2·b·φ(b/√2) = 3.230978535287004948096246569018163150765 (decimal-dps-70; EXACT closed form) — the pairing-flow normalization; +- (2π)^{-1}c6v^{-1/2}e^{−q/2} — the conditional two-point Gaussian density factor (conditioning Jacobian); +- Pwin(y) = Φ(−m/√s2) − Φ((−1−m)/√s2) — the arch-window probability factor; +- |cM·cS·cY| — the Hessian-determinant (Kac–Rice) Jacobian product of the three vertices; +- typing/orientation: the sign conditions cM>0, cS<0, cY<0, trc<0 (the typed pair-Palm event); +- multiplicity: the two mirror lobes y2 ↔ −y2 (factor 2, certified by exact engine symmetry checks); +- the event whose measure the lower assembly needs: the typed pairing event in the Λ window at the r→0 limit, with rung anchors r ∈ {1/20, 1/40} (EXACT rationals) measured-grade in C020/C021 (0.946 anchor). The measured 0.946 anchor is hereby separated from any PROVED lower constant: this packet does not claim 0.946 as proved; it certifies the exact-jet coverage of the limit functional and names the one missing analytic constant (§5) needed for a proved positive lower constant at the continuum-quadrature standard. + +Exact-rung label (mandate item 3, rung clause): the certificate evaluates the r→0 LIMIT functional (C026/C027 exact Laurent-series extraction). A proof for every 0 < r ≤ r_Λ is not claimed; the rung anchors r = 1/20 and r = 1/40 remain measured-grade per C020/C021. + +Rung-scope against the W7 r₀ structure (W10 context, frozen): the assembly requires any positive r-uniform lower constant, not 0.946. Recorded tiers: 0.946 (measured, C021), 0.9091 (derived-on-grid, C037), 0.9001 (certified floor, H-B3-conditional — the tier this packet's certificate enforces via ck()). The W7 γ-LOC floor is the constant-floor class c_cond/2 > 0 with r₀³ = (20·0.089569/7)·P₀ (r₀ = 0.04343 at P₀ = 3.2e-4): the r = 0.05 rung is NOT certified by that floor, while "sufficiently small r" is P₀-unconditional. This packet's r_Λ scope is therefore stated as (0, r*) with r* the r-continuity radius of the limit functional: the certificate certifies the r→0 limit object; the existence of r* > 0 with c_Λ(r) ≥ (limit constant)/2 for 0 < r ≤ r* follows from the rung-ladder continuity structure of C026/C037 once the limit constant is proved, and the sufficiently-small-r regime is P₀-unconditional per W7. No numerical r* is certified here (part of the same nonclosure: r-continuity at the certificate standard would itself need the §5 constant at two rungs). + +## 3. What is machine-certified (certificate standard, receipts attached) + +All of the following are computed by verify_lambda_grid_v2.py with ck() fail-closed; see transcripts/transcript_normal.txt and transcripts/transcript_O.txt (byte-identical) and HASHES.txt. +(P0) Exact periodized-field certificate: lattice moments B_0..B_6 of the spectral measure at 70 dps; tail bound < 1e-60 (certified 2.87e-182). +(P1) DEN closed form to 30 digits against the engine constant. +(P2) Input integrity: sha256 of the archived C027 core40 sweep input against the embedded label 0003756d4075bbfa881edfeac68d6cca7242c54cee2c551f2814fd57759b4c18; certificate self-hash printed as receipt. +(P3) Engine validation: 12 archived stations reproduced with rel. diff. 1.438e-07 (exactly the archived DEN truncation 3.230979 vs the closed form); mirror symmetry exact at 3 pairs; jet correctness established during qualification by 12-digit/10-digit agreement with finite differences of the Fraction-exact engine. +(P4) Exact second-order jets (λ(y), ∇λ(y), D²λ(y)) at every station of the grid of record (regions C at h=1/40, M at 1/20, O at 1/10, F at 1/5 — EXACT spacings; upper lobe; lower lobe doubles by certified symmetry): 899 stations, each classified pure / typing-boundary / clip-kink / deep-untyped with margin factor MAR=3 (EXACT) on the exact jets, plus the raw typed-branch jet at off-support centers. +(P5) Exact assemblies: scanned sums; midpoint-rule second-order terms Σ(σ̃_c)h⁴/12 with σ̃_c = max(σ_typed(c), σ_branch(c)) + B₃(K)·ρ on pure and typing-boundary cells (λ is C¹ across typing boundaries with piecewise-bounded second derivative, so the midpoint form is valid there with the branch-max sigma); clip-kink cells add the exact gradient-jump term J(c)·ρ·h² (J computed by the frozen-variance assembly: |∇λ_full − ∇λ_{st2-frozen}|, exact-jet) to the same midpoint form; excursion constants L_R, Λ₁ = Σ L_R A_R (both lobes), and the kill condition h_kill(M) = √2·M/Λ₁ evaluated at the margins M* = 0.066 (C021 measured budget, used as margin only) and M_floor = 0.9001 (0.9091 − 0.009, C037 constants). +(P6) Coverage: every axis (y2 = 0 seam handled by the certified mirror doubling), region faces and overlaps (skip-rect bookkeeping, no double counting), singular charts (pin-coincidence degeneracies y → M,S are handled by the divided-difference frame machinery MON9A/MON9B with basis fallback — the singular charts of the C026/C027 engine), and the tail (region F to [−3,2]×[0,1.6]; beyond the zone the far-field envelope is the named dependency KIMI-DER-027a). +(P7) Mutation tests: corrupted archived input (hash mismatch), corrupted archived value (8% change, embedded hash bypassed), corrupted DEN closed form, corrupted kernel tail threshold — every mutation trips ck() (receipts in mutation_receipts.txt: certificate sha256 579ef6cd88d543ec14db45558e5e7c1899078095e0df295c7d46fd1810273831, ALL MUTATION TESTS PASSED). + +## 4a. Certificate outcome: the H-B3 evidence gate TRIPPED (fail-closed) + +The receipted run (transcripts/transcript_normal.txt, byte-identical twin transcripts/transcript_O.txt, identity stamp transcripts/identity_stamp.txt) executed P0–P7 through the full grid of record and then STOPPED at the quotient self-consistency check: + + quotient stability ratio Q_C(1/40)/Q_C2(1/20) = 3.5598022 (> 2.5) → FAIL-CLOSED TRIGGER: quotient self-consistency failed + +The max exact third-difference quotient on the C-rectangle grows by a factor 3.5598022 from the 1/20 rung to the 1/40 rung (receipted values: Q3max = 21402.923 at 1/20, Q3max = 76190.172 at 1/40), i.e. the coarse-rung quotients underestimate the local third derivative by more than a factor 3.5 — the quotients are not rung-converged at the certified window [0.4, 2.5]. Consequently H-B3 lacks its promised machine-checked evidence, the assembly section never executes, and E_cert, Λ₁, h_kill(M*), h_kill(M_floor) are NOT receipted. This is a certificate outcome (the fail-closed design fired as built), recorded here without any threshold adjustment: the [0.4, 2.5] window is part of the shipped, hash-receipted script and was not touched after seeing the data. + +## 4. The one non-certified constant (measured-grade, named) + +H-B3 (named premise, per-cell form): for every cell K of the grid of record, sup_{y∈K} σ(D³λ(y)) ≤ B₃(K) := SF · max{Q(p): p ∈ K ∪ ∂K-neighbor stations} with SF = 8 (EXACT), where Q(p) is the exact third-difference quotient of the Hessian jets at station p (Q(p) = max_{i∈{x,y}, f} |D²λ(p+h·e_i)_f − D²λ(p−h·e_i)_f| / (2h), f ranging over the three Hessian components). Machine-checked evidence: quotient rung-stability between the 1/40 and 1/20 grids on the C-rectangle (certified max-quotient ratio within [0.4, 2.5]). Falsifier: any cell K and point y ∈ K with σ(D³λ(y)) > B₃(K) (directly checkable by third-jet evaluation), or failure of the rung-stability check. All other constants in the assembly are exact-jet quantities, including the clip-kink gradient jump (frozen-variance assembly, exact); H-B3 is the single measured-grade input, in the KIMI-DER-009 naming discipline. + +## 5. THE EXACT MISSING PIECE (formal nonclosure statement) + +The unique missing piece for closure at the mandate standard ("interval or analytic enclosure rather than point-grid evidence") is: + + a certified bound sup_{y ∈ cell} σ(D²λ(y)) — equivalently a certified regional + bound sup_{y ∈ R} σ(D³λ(y)) — for the four regions of the grid of record. + +Why it is missing (both standard routes fail on this functional, documented): +(a) Interval/ball evaluation of the Laurent-series DAG: the leading coefficients (c6v ≈ 3.7e-3 on core cells) are residues of exact cancellations; interval evaluation amplifies rounding/cancellation junk to ≈ 7500 × box width (measured 47 at h=1/160), so the denominators straddle zero and the DAG cannot complete on core cells at any usable spacing. +(b) Global sup-bound (magnitude) arithmetic: sound by construction but compounds multiplicatively through the 9-pin divided-difference frame, the Neumann series inversion and the Schur divisions; observed regional bounds exceed 1e10 × true (intermediate quantities up to 1e64051 before the exact-6-pin freeze; ≥ 48^6 amplification after it), useless for the assembly. + +With B₃,R certified, the assembly in the certificate becomes a full theorem with the printed constants; without it, the certificate's E_cert is conditional on H-B3 exactly as labeled. + +Sharpening from the receipted run (§4a): within the H-B3 route the certificate's own evidence gate requires rung-stable third-difference quotients (ratio in [0.4, 2.5]); the measured ratio 3.5598022 shows the 1/20 rung is not yet in the converged regime, so even the measured-grade premise route requires a finer reference rung (1/80 vs 1/40 quotients) or a direct certified third-jet bound — it reduces to the same missing piece one derivative order up. + +## 6. Certified numbers (from the receipted transcripts) + +The authoritative receipt is transcripts/transcript_normal.txt with its byte-identical twin transcripts/transcript_O.txt (identity stamp transcripts/identity_stamp.txt: BYTE_IDENTICAL; both transcripts sha256 c520b19729a72ab41e914503a33bcb5841734d44f232a75fc726e591c370bac8), all hash-listed in HASHES.txt; transcripts/S6_EXCERPT.txt carries the extracted key lines. Receipted content: P0 kernel certificate (spectral tail bound 2.87e-182 < 1e-60), DEN closed form (decimal-dps-70), input integrity + script self-hash, cross-validation vs the archived C027 sweep (12 stations, worst rel diff 1.44e-7 = archived DEN truncation), mirror symmetry (max |diff| 0.0, 3 pairs), the full grid of record, and the fail-closed stop at the quotient self-consistency gate (§4a). Region-of-record lines: + +- region C: h=1/40 (EXACT), cells=320, typed=320, boundary=240, kink=0, deep=0, Q3max=76190.172, Jmax=5.5183312 +- region M: h=1/20 (EXACT), cells=312, typed=312, boundary=271, kink=114, deep=0, Q3max=93034.473, Jmax=7.8495268 (114 kink cells subdivided one level: 456 sub-stations, exact jets) +- region O: h=1/10 (EXACT), cells=122, typed=102, boundary=121, kink=58, deep=0, Q3max=7229.5523, Jmax=2.8196842 +- region F: h=1/5 (EXACT), cells=65, typed=24, boundary=65, kink=50, deep=0, Q3max=22.644864, Jmax=1.3930538 +- auxiliary C-rect at 1/20 (EXACT): cells=80, Q3max=21402.923 +- quotient stability ratio Q_C(1/40)/Q_C2(1/20) = 3.5598022 → FAIL-CLOSED TRIGGER: quotient self-consistency failed (assembly not executed; S, E_cert, Λ₁, h_kill values are NOT receipted — no values exist for them in the transcript) + +## 8. v3 ADDENDUM (1/80-rung repair, separate certificate — supersedes §7's blocker (i)) + +v3 certificate: verify_lambda_grid_v3.py, sha256 d54fc3bd8d5bf1445f16dd954fff6556c6f6d3998898efc42efe9387d313379e; transcripts transcripts/transcript_v3_normal.txt and transcript_v3_O.txt BYTE_IDENTICAL (both sha256 5e19da35a08fb737ce59b3dffb5453d19193931fc7c14803aa243985d54bf113). Provenance (printed in the v3 header): v3 names v2 (sha256 579ef6cd88d543ec14db45558e5e7c1899078095e0df295c7d46fd1810273831) as its predecessor — v2 hash-frozen, unpatched, receipted FAIL-CLOSED at the quotient gate. Differences v2→v3, disclosed: (a) added the auxiliary C-rectangle at h=1/80 (EXACT) and re-routed the rung-stability gate to the (1/80, 1/40) pair, the (1/40, 1/20) pair displayed with its v2 FAILED receipt; the certified window [0.4, 2.5] is unchanged; (b) a one-line type coercion (tomp) at the kill gate fixing a latent Fraction/mpf comparison that v2 never executed (v2 stopped earlier); (c) one misleading pre-gate label line corrected. No numerical content of v2 was altered. + +Receipted v3 outcomes: + +(i) Rung-stability evidence RESCUED at v3: Q(1/80)/Q(1/40) = 1.8846416 ∈ [0.4, 2.5] (receipted Q3max 143591.17 at 1/80 over 1280 cells vs 76190.172 at 1/40). Q(1/40)/Q(1/20) = 3.5598022 remains receipted FAILED at the window: the 1/20 rung is pre-asymptotic; the v2 failure was consistent with the reference rung being too coarse, so the premise was unproven, not disproven — and is now rescued at the finer reference rung. The rescue covers the C-rectangle (the quotient-hot region pair); the M/O/F regional B3 constants (receipted B3max 744275.79 / 57836.419 / 181.15891 vs C's 609521.37) inherit the premise at their record grids. + +(ii) Floor gate PASSED at v3: scanned sum (both lobes) S = 0.893625433353538, E_cert (both lobes) = 0.489909223604 < M_floor = 0.9001. The certified positive lower constant of this packet is therefore + + ∫_zone λ(y) dy ≥ S − E_cert = 0.403716209750 (decimal-dps-70; H-B3-conditional at v3's hash; r→0 limit object; zone plus the named far-field dependency KIMI-DER-027a) + +— an honest positive lower constant, NOT forced to reproduce 0.946 (the measured anchor stays measured-grade; 0.9091 derived-on-grid; the 0.9001 floor returns as ck-passed, H-B3-conditional at v3's hash, exactly as the lead's ruling framed it). Per-region assemblies receipted: C lam-sum 0.2930717214 E_cert 0.029668447; M 0.1478950712 / 0.084632951; O 0.005548400703 / 0.042800749; F 0.0002975234004 / 0.087852465; Λ₁ = 1729.76672773. + +(iii) Kill-condition gate FAILS at the grid of record (receipted FAIL-CLOSED: 'used core spacing violates kill condition at floor margin'): the net-spacing inequality at the used core spacing evaluates to (1/40)/√2·Λ₁ = 30.578245 > 0.9001, with h_kill(M_floor) = 7.35899012905663e-4 and h_kill(M*) = 5.39599320650747e-5 (decimal-dps-70). The excursion mechanism certifies exclusion only for uniform spacings below ≈ 1/1359 at the floor margin; at the used spacings it is insufficient by a factor ≈ 34. This is a displayed, receipted fact about the excursion mechanism, not about the lower constant in (ii). + +Updated disposition: blocker (i) of §7 is RESOLVED by v3 (rung-stability rescued; the 0.9001 floor returns H-B3-conditional at v3's hash). The Λ-side now delivers what the assembly requires — a positive r-uniform lower constant 0.403716209750 for the r→0 limit object at certificate standard with the single named premise H-B3 (evidence receipted at v3) — plus the receipted negative fact that the excursion kill mechanism requires h ≤ 7.36e-4. Blocker (ii) of §7 stands unchanged for a premise-FREE theorem: a certified cell-sup σ(D²λ) / regional sup σ(D³λ), both standard routes documented as failed on this functional. The r-scope statement of §2 applies to the 0.4037 constant unchanged (limit object; rung anchors measured-grade; sufficiently-small-r regime P₀-unconditional per W7). + +## 7. Disposition + +FORMAL NONCLOSURE at the certificate standard — now receipted by the certificate's own fail-closed gate (§4a): the completed, byte-identical twin transcripts show P0–P7 machine-certified through the full grid of record, followed by the FAIL-CLOSED stop at the quotient self-consistency check (ratio 3.5598022 outside [0.4, 2.5]). Two blockers are named, in order: (i) the H-B3 route's rung-stability evidence fails at the certified window — repair requires a finer reference rung (1/80 vs 1/40) or a direct certified third-jet bound; (ii) behind it stands the §5 missing piece, a certified cell-sup σ(D²λ) / regional sup σ(D³λ), with both standard routes documented as failed on this functional. The measured 0.946 anchor remains measured-grade (C020/C021); no PROVED positive lower constant is claimed by this packet; the tiers 0.946 / 0.9091 / 0.9001 are recorded as measured, derived-on-grid, and H-B3-conditional-floor respectively, with the H-B3 evidence now receipted as FAILED at the certified window. The mutation suite (4/4 tripped ck) and the byte-identity stamp are attached as the evidence package; the certificate script (sha256 579ef6cd88d543ec14db45558e5e7c1899078095e0df295c7d46fd1810273831) is unchanged since the mutation receipts and was not adjusted after the gate outcome. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md new file mode 100644 index 000000000..93500e8c7 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md @@ -0,0 +1,37 @@ +# PHASE-2 SCOPE DECISION (lead mandate 19fb9293, option (a) with (c)-scoping) + +## Scope: J3 certification runs on the Phase-1-certified cells only +(interior 623 + clip-1 214 = 837 of 1707 grid-of-record cells). + +## Dependency justification (mandated: no silent scope reduction) +1. Every Phase-2 certificate is POINTWISE-PER-CELL: cell C's sigma-sup + certificate closes over C's own box (its exact J3 center jets, its + region-level S4R, its Phase-1 6-block sups). No cell's certificate + formula references any other cell's sigma(D^2 lam)/sigma(D^3 lam) sups. +2. The only downstream consumption of per-cell sups is the certificate's + REPORTING aggregate (max over cells, rung ratios Q) — an aggregate over + the certified set, not a dependency of any cell's certificate. The + v4 certificate will state the conclusion's domain as EXACTLY the + certified cell set, with the failed-cell ledger as its boundary + (mirroring the v2/v3 disposition language). +3. The 864 Phase-1-ledgered cells CANNOT enter the J3 route without + further subdivision regardless: clip-mixed cells (783) have the m-range + straddling a clip kink — the lambda formula's branch is genuinely + ambiguous over the cell (a mathematical branch ambiguity, not + arithmetic); denominator-straddle cells (81) have c6v = 0 inside the + cell (the 6-block certificate itself fails). Both categories remain + ledgered exactly as Phase 1 recorded them; the v4 certificate names + this consumption chain explicitly: ledgered cells contribute NO sups + and the rung-conclusion EXCLUDES their boxes. + +## REFUSED-RUN RECORD (lead-mandated ledger entry) +The scalar-SV full sweep (31h projected, all-ledger outcome) was REFUSED +and never launched. Reason (receipted): the scalar chain's 'basis +straddle' ledger entries would be FALSELY ATTRIBUTED — the measured TRUE +Delta G09 over the test cells is 0.0182 (tame) while the scalar chain +certifies only 3536 (2e5x inflation through the W-congruence); an +all-ledger result would misrecord soundly-certifiable cells as failures. +Parameter changes on record: subdivision depth cap 3 -> 4 (ledger reason +strings carry '(depth 4)'); per-cell sigma^4 sup box = depth-0 cell box, +reused soundly at all depths; signed-center fixes (Phase-1 clip m0, +Phase-2 JetCache/tp_sigmas center) receipted as bug fixes 4-5. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md new file mode 100644 index 000000000..0224fa4ac --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md @@ -0,0 +1,190 @@ +# PHASE 2 STATUS (resume point) + +## RUN STATE (as of this update) +- 4 shard drivers running: `python3 -u phase2_cert.py {C,M,O,F}` (flock + driver_{C,M,O,F}.lock; per-shard phase2_cells_{s}.jsonl, + phase2_ledger_{s}.jsonl, phase2_{s}.live, phase2_receipt_{s}.txt). +- 2 keepers running: `bash keeper2.sh A` / `bash keeper2.sh B` (flock + singletons, peer respawn via `bash`, shard relaunch budget 4, receipt + stand-down, 30s heartbeats keeper2_{A,B}.hb). +- Cell order: easiest first (c6v inf descending) — hard small-c6v cells last. +- Resume after crash: just relaunch the same commands; banked jsonl/ledger + entries are skipped (done-set from both files). +- 2 cores only: drivers get ~35% CPU each; first cell lands ~10-20 min. + +## BUILD STATE (final, validated) +- Exact J3 jets mirror dag.py J2 (dag3.py import-time patch + build_frame + spy captures the 9-frame; ONE J3 station run per assembly, ~25s). +- Order-4 SV/CS everywhere (optional s4; Faà inv/sqrt/exp/Phi; Phi M4 = + 0.551 verified numerically vs true max 0.55058784). +- Tight G_k: gk_cs = exact J3 center jets + chain sigma^4 recipe with + FACTORED-det S4R sups (dets are exactly 2-term: xy^4(x-1), y^5(2x-1); + 7-13x loose, was 1e6x). +- Tight vser: symbolic reduction vser_k = red_k/c6v^e_k (e_k <= 5), pickled + vser_sym.pkl, validated EXACT 0.0 vs dag.sdiv at two stations; CSs from + J3-sdiv center jets + quotient-Leibniz sups (exact-Bernstein red sups, + (1/c6v^e) Faà) — Leibniz floor shrinks 16^-d with subdivision. +- Outputs: J3-center + chain-sigma^4 recipe (cM/cS/cY/trc); lambda recipe + [S0..S3] with lam.s4 from the chain. lam_assemble_J3 exact. +- Depth cap 6 (parameter change, recorded): C|0,0 measured to close at + depth 6 (floor 8e19 at depth 0; recipe closes when 16^-d * rho_d^4 beats + cM ~ 51.5). +- Per-cell sigma^4 sup box = depth-0 cell box (recorded). +- tp.DMAX runtime raises recorded (tp.py default 17 silently truncates): + vser_tight 100, vser_symbolic 400; all pickled artifacts audited clean. + +## KNOWN COSTS +- per-assembly ~2 min single-core (station_dag3 25s, vser Bernstein ~25s, + S4R 15s, chain ~30s, rest ~25s); depth-0 cell ~2 min, depth-6 cell hours. +- Expect: c6v >= ~0.01 cells (739/843) certify at depth <= 4; ~104 cells + c6v in [1e-3, 1e-2] need depth 5-6; ~26 cells c6v < 1e-3 may ledger at + depth 6 with 'type-gate straddle (cM) (depth 6)' — arithmetic-attributed + (vser sigma^4 conditioning), NOT a genuine obstruction (TRUE sigma4(cM) + ~ 1.5e6 measured by exact J3 sampling at C|0,0). + +## REMAINING WORK (in order) +1. Monitor shards (phase2_{s}.live); wait for 4 receipts. +2. Complete verify_lambda_grid_v4.py: full per-cell re-computation with + byte-exact record comparison (skeleton written: integrity, completeness + 1707 = certified + phase2-ledger + phase1-ledger, aggregate max + sigma(D^2 lam)/sigma(D^3 lam) sups, modes A/B byte-identical receipt, + FREEZE block). Add the mutation suite (tampered jsonl copies must FAIL) + and run both modes; merge shard receipts -> final report with hashes. +3. Ledger reconciliation: depth-6 ledgers stand as the failed-cell ledger + (complete, honest, arithmetic-attributed). CANNOT-VERIFY stays separate + (none so far). + +## OPEN ISSUE (update) +- M|0,13 + O|0,9 (high-c6v cells) ledgered 'type-gate straddle (cM) (depth 6)' + with the tight build — a residual cM-chain stage is still loose. Diag + running: /tmp/diag.py (certify_cell on O|12,9, driver-identical). If a bug: + fix -> clean phase2_* banks -> relaunch. If genuine deep arithmetic: ledgers + stand. NOTE: running shards predate the vser dps-25 Bernstein speedup + (~2-3x on the vser stage) — applies on next relaunch only; soundness + unaffected (iv rounds outward at any dps). + +## DIAGNOSIS RESOLVED (this session): the clip-1/high-c6v type-gate failures +Three stacked cancellation-blindness layers, ALL arithmetic (none genuine): +1. Constant-G_k sup blindness: 399/567 (9A) [391 9B] G_k entries are exactly + Q_k = c*det^2 (certified constants, zero sups); 100 [108] more have one + det factor (G_k = red/det). FIXED: s4r.GkSups.red reduction (const_val / + e=1 quotient / e=0 paths) + gk_cs const short-circuit with exactness + assert vs the J3 center value. +2. red sigma-sups now Bernstein-tight (sigma_sups_tp_bern) in e=1/e=2/poly + and factored paths. +3. ROOT of the depth-6 failures: the depth-0 sigma^4-box rule (recorded + parameter change earlier) FROZE the sups at coarse depth-0 values; the + X9 Neumann tower (measured s4 ~ 1e15 vs TRUE sigma4(X9) ~ 1.3e3 by exact + J3 finite differences at O|0,9) then never shrinks -> type gate + unclosable at any depth. REVERTED: sigma^4 sup box = current sub-box + (box-keyed caches were already per-box; sound, strictly tighter). + Measured at O|0,9: TRUE cM jets tame (cM=0.77, s1c=2.07, s3c=30.4); + W-path G0 T^1 sup 3.6e6 vs tight-path 54 (tight path 5 orders better). +VERDICT: bug (arithmetic), not a genuine obstruction. The 6 ledgered +Phase-2 cells (M|0,13, M|1,13, O|0,9, O|1,9, F|5,5,*) are INVALID under +the fixed build -> banks cleaned before relaunch. +- depth cap 6 -> 8: the X9 Neumann tower collapses ~1024^-d once + R(d) = sum_j s0(gk(j)) < 1 (measured depth ~5 at h=0.1); h=1/10 cells + certify at depth ~7-8, h=1/40 at ~3-5. (Measured: tower ratio 15-20 at + O|0,9 depth 3; TRUE sigma4(X9) ~ 1.3e3 by exact J3 FD.) + +## LEAD DECISION (Sep 15): run the full grid at cap 8 with the 3-layer fix; +map the frontier; report at completion or >=200 cells. STOP conditions: +ledgered fraction > 15% of grid, or any Phase-1-certified cell fails at +cap 8 (K9r decision re-opens then). F clip-mixed cells stay ledgered as +Phase-1 left them. +## OPS LESSON: box has 4GB RAM, no swap. Concurrent heavy diagnostics + +4 drivers -> OOM burst -> keepers exhaust relaunch budget. RULE: no +concurrent diagnostics while the run is live; stagger driver launches. + +## RESUME POINT (Sep 15 ~11:45): run live with all fixes: +3-layer fix (const/det-reduced G_k + Bernstein red sups + per-sub-box +sigma4 sups) + depth cap 8 + interior-first ascending-c6v order + +s4r sups at iv.dps=25 (~2x speedup) + per-assembly STAGE timing prints. +s4r._sups25 key bug found+fixed (11:25:22); all drivers post-fix. +Measured stage costs (C cell): dag3=11s vser=85s asm9=208s (pre-dps25). +First cell outcomes pending (cold GkSups init ~5-15 min/driver). +OPS RULES: no concurrent heavy diagnostics (4GB box, OOM kills all); +stagger driver launches; keepers self-heal code fixes via respawn. +NEXT: first outcomes -> frontier map -> report at >=200 cells or stop +conditions (ledgered >15% or any Phase-1 cell failing cap 8). +- sigma-sups method change (on record): vser red + gk red sigma-sups + switched from Bernstein to the certified termwise iv bound + (sound: triangle inequality + iv enclosure). Measured only 1.3-1.5x + looser than Bernstein (e1 red: 155 vs 107; e0 red: 848 vs 650) and + ~1000x faster; Bernstein cost (400-470s/assembly under contention) + priced out the run. Depth cost ~0.3 levels. +- stage costs now: dag3 ~11-55s, vser 0.5-2.3s, asm9 15-24s. +- tree visibility: STAGE/TREE(depth<=2)/CERT/LEDGER prints. +- turn-end reaping CONFIRMED as the recurring killer (all deaths + coincide with turn ends or concurrent-diagnostics OOM). Keepers + self-heal mid-turn; lead's :17 cron sweep wakes for relaunch. +- BUG (DMAX class, 3rd instance): tp_qk.pkl was built with tp.DMAX=17; + the Q_k = adj*Spp*adj products (true deg <= 41) were SILENTLY + TRUNCATED at deg 17. Effects: Q_6 wrong at 23 entries (X9 series + validation caught it: 36/567 X_k mismatches, all order 6); s4r's + reductions (red/const_val) for high-degree e=0/e=1 entries were built + on truncated polynomials -> their sups were WRONG (potentially unsound; + no cell certified under them, so no bad certs exist). Fix: rebuild + tp_qk with DMAX=100, then rebuild x9_series + revalidate. The + DMAX-17-vs-100 audit earlier covered tp_sections (deg <= 17 genuine) + and vser_sym (DMAX=400) but missed tp_qk -- recorded. +- BUG (DMAX class, 4th instance): s4r.py:315-316 sets _tp.DMAX=100 + inside GkSups construction. Any TP product AFTER a GkSups init with + degree > 100 silently truncates. This corrupted the x9_series X6 + numerators (deg ~142 -> 16 wrong entries, block pattern {1,2,7,8}^2). + In the Phase-2 run: s4r init happens before vser/gk products (all + deg <= 41+reductions) -- no truncation expected, and no cell + certified, so no unsound certs; recorded for the receipt. Fix + (x9_series only): reset DMAX=600 after build_R. +- X9 TOWER BROKEN (symbolic layer, all validated exact): + * detR = det(G_0) = dnum/det^4: dnum deg 24 / 13 terms (pair-Bareiss, + exact division collapses everything; validated == direct determinant + and == 1/det(X0) at the station). + * adjR via 81 pair-Bareiss cofactors; validated R.adjR == detR*I exactly. + * X_k series (k<=6) = N_k/(dnum^a det^b), a<=4 b<=1, numerators deg <= + 102 / <= 289 terms, built in 18s (x9_series.pkl); validated 0/567 + against the DAG's exact X9 at the O|0,9 station. Files: x9_exact.py, + x9_series.py, x9_css.py, x0_derivs.pkl (derivative polys, 2s build). + * TWO DMAX-class bugs found en route (3rd/4th instances): (i) tp_qk.pkl + was built with tp.DMAX=17 -> Q_6 silently truncated at deg 17 (true + deg <= 41); rebuilt with DMAX=100, revalidated 0/567. The s4r red + sups derived from the truncated Q were wrong for high-degree entries + (no cell certified under them -> no unsound certs; recorded). + (ii) s4r.py:315-316 resets _tp.DMAX=100 inside GkSups init; any TP + product after a GkSups init with degree >100 silently truncates + (corrupted x9_series X6; fixed by resetting DMAX=600 after build_R). + ratpoly.deriv_polys also hardcodes DMAX=60 (reimplemented at 600 in + x9_css._deriv_polys600). + * REMAINING BLOCKER (optimization, not mathematical): per-box tight + sigma^4 sups of the X_0 derivative polynomials P_a (deg <= 168, ~5k + terms). Measured routes: (a) quotient rule on adjR/detR: FAILS -- + depth-independent floor ~1e5-1e17 (the 24*b1^4/uinf^5 term; detR's + s1 doesn't shrink with depth) -- the true sigma4(X0) ~1e2-1e3 cancels + adj/detR-internally, invisible to the rule. (b) deriv_polys exact + derivative numerators + shifted-Taylor crude: CORRECT (cancellations + exact in P) and the P-build is fast (2s/81 entries, banked + x0_derivs.pkl) -- but the per-box tight sup evaluation of deg-168 P + is the wall: iv binomial shift ~30-90s/P -> 10-30h/box naive; exact + Fraction shift worse; origin-crude is cancellation-blind (useless). + NAMED ROUTE for the next build session: K-truncated exact shift + (exact Fraction Taylor coefficients for m+n<=K~8 via TP.diff + + tp_eval_fr ~45 evals/P ~5s, crude-bounded tail suppressed by + h^(K+1) ~ 1e-17) or iv-Horner substitution; target <= 2 min/box for + all 81 entries x 15 P's. With that, X_0 CSs seed neumann6_cs's + g0i_in (wired: phase2_frame.neumann6_cs(g0i_in=...), assemble9's + x9_in, phase2_cert.certify_cell) and the gate (5 cells, depth <= 2) + can run. cert wiring currently points at x0_cs_matrix (quotient + route, floor-bound) -- MUST be switched to x0_cs_matrix_dp once the + fast P-sup lands. + * Frontier run remains PAUSED (.paused in place; 4 ledgers banked). +- X_0 SUP ROUTE RESOLVED (measurement): the exact-Fraction center shift + of the banked derivative polynomials P_a (x0_derivs.pkl) is TIGHT + (sup 3.7e-29 for the order-4 P of X0[1][1] at O|0,9 -- the dnum^5- + scaled value scale) at 2.6s/P, while iv/Horner enclosures are ~25 + orders loose (dependency problem; measured). Per-box cost ~53 min + (81 entries x 15 P's). x9_css.x0_cs_matrix_dp now uses the exact + shift; phase2_cert wired to it (was the quotient route, floor-bound). + X_0 s4 estimate ~5e3 at depth 0 (vs 4.7e17 quotient floor). Gate + runner gate5.py written (5 cells, DEPTH_MAX=2); x0full.log measures + the per-depth sups at O|0,9 first (keeper_gate.sh, flock-guarded). diff --git a/incoming/claude-bundle-v3-native-copies-20260928/RESULT.md b/incoming/claude-bundle-v3-native-copies-20260928/RESULT.md new file mode 100644 index 000000000..8c7860f08 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/RESULT.md @@ -0,0 +1,77 @@ +# CL_ANTHROPIC_BUNDLE v3 native copies — recovered from Drive, 2026-09-28 + +**Scientific effect: NONE.** **Review status: REVIEW_REQUIRED.** +Byte custody only. This packet accepts no theorem and changes no `STATUS.md`, +`Math-/PROOF_INDEX.md`, `GRAPH.json` or landing-claim row. It does not recover +`CL_ANTHROPIC_BUNDLE_2026-09-17_v5.zip`, the carrier the Math- downstream gate records +as `BLOCKED_ABSENT` for SYM-Fw-jet, and it does not discharge SYM-Fw-jet. + +## What this is + +On 2026-09-15 Claude wrote the mirror manifest `CL-MIRROR-001_MANIFEST.sha256.txt`. It +lists 46 frozen Kimi/K3 carriers, each with SHA-256, size and original path, that had +never been mirrored to Drive. The manifest says the byte-native copies went into the +chat-delivered `CL_ANTHROPIC_BUNDLE_2026-09-16_v3.zip`, folder +`06_UNMIRRORED_FROZEN_CARRIERS_BYTE_NATIVES/`. It also says they are "present +byte-for-byte inside the operator's own `09152026OKComputer_Project_Gap_Closure.zip`". + +The bundle itself has not been found, but that zip is on Drive: + +- Drive id `1vSI-evINWskhXVyiZ0slt-rLT74sPpXH`; +- 30,148,285 bytes, SHA-256 + `a2136bc033f349382f9896896347da7a6dabde3334103276ad04db9205aa2b5b`, which matches the + manifest's own `a2136bc0…` reference. + +It was downloaded through its public link on 2026-09-28. **All 46 listed files were +found in it, and every one matches its manifest SHA-256 and size.** + +This packet publishes 45 of them. The 46th, `D3_percolation/PERC_DECAY.md`, was already +mirrored and is in `incoming/claude-audit-package-recovery-20260928/` (main #199). As of +2026-09-28, none of the 45 was on a current branch of the ten account repositories. + +## Layout + +Paths follow the manifest's `original_path` under `K3_SIDE24_LB/`, with three changes +that alter no bytes: + +- `[agent-tree]/19fcef2e-c1c2-8c6c-8000-0f5a243156d9/` becomes `agent-tree-19fcef2e/`, + because brackets are not intake-safe; +- `.py` and `.sha256` files get an added `.txt` suffix; +- the uploaded titles the manifest gives (for example `W8_PHASE2_STATUS.md`) are not + used as filenames. + +`SOURCE_MAP.json` records, for every file, its manifest `original_path`, uploaded title, +member name inside the zip, size and SHA-256. + +Folders: `UPPER2D/` (B4LOC damline, D3 percolation, H3 band floor and ceiling, D1 v3 +gate and receipts, H5 closure tightening, BRANCH_dir), `LPW_CONSTANT/` (v3 and v4), +`RETURN_06/` (executive state, theorem table, obligation ledger, dependency DAG, +adversarial report, addenda, source and tree manifests), `W3_numerics/`, `W8_lambda/`, +and `agent-tree-19fcef2e/work/` (W8 phase-2 scope and status). + +## What was searched and not found + +In all three gap-closure zips on Drive (`09152026…` above; `SepOKComputer…` +`16IVqTiZflqF4-IM9Q9rSIOernzdZwm0D`; `…(4).zip` `1Ykd9FO5oRUA5KoqOcDw64hwsQwXbs5ku`), each +hash-verified against its recorded inventory digest, the search covered 3,530 entries, +including nested zips, by filename and content. It found: + +- no `rnu_env.py`, `allcell_fdz_enclosures.json` or `CL_ANTHROPIC_BUNDLE_*` file; +- no 24-jet interval table. + +`RETURN_06/OBLIGATION_LEDGER.md` defines OBL-H5-JETMOD, the certified interval bounds +for the full 24-jet set over r-bands. That is the obligation, not its certificate. + +## Screening + +- Intake rules checked locally: safe paths, allowed suffixes, sizes, UTF-8, strict JSON. +- Privacy per `governance/OP-PRIVACY-20260927.md`: no e-mail addresses, phone numbers, + access-key links, local user paths, credentials or URLs. +- The material is SIDE24 research (Kimi/K3 carriers), within project scope. + +## Provenance + +Recovered by Anthropic Claude (Claude Code) on 2026-09-28 at Dylan Roy's explicit +instruction. The carriers' own authors are as stated inside them, mostly Kimi/K3 +sessions; this packet changes no authorship. Same-account custody: no independence +credit. diff --git a/incoming/claude-bundle-v3-native-copies-20260928/SOURCE_MAP.json b/incoming/claude-bundle-v3-native-copies-20260928/SOURCE_MAP.json new file mode 100644 index 000000000..3e8b2cd14 --- /dev/null +++ b/incoming/claude-bundle-v3-native-copies-20260928/SOURCE_MAP.json @@ -0,0 +1,384 @@ +{ + "schema": 1, + "scientific_effect": "NONE", + "drive_source": { + "drive_id": "1vSI-evINWskhXVyiZ0slt-rLT74sPpXH", + "title": "09152026OKComputer_Project_Gap_Closure.zip", + "bytes": 30148285, + "sha256": "a2136bc033f349382f9896896347da7a6dabde3334103276ad04db9205aa2b5b", + "downloaded_utc": "2026-09-28" + }, + "hash_authority": { + "repository": "d6g8k5htny-coder/main", + "commit": "b040bf0c30f33a9de220d19692e8dbcad9a1c5aa", + "path": "drive/mirrors/2026-09-15 — KIMI FINAL INTAKE — UPPER2D STAGE E + H5 + ASSEMBLY/06_UNMIRRORED_FROZEN_CARRIERS_BYTE_NATIVES/CL-MIRROR-001_MANIFEST.sha256.txt" + }, + "omitted": [ + { + "original_path": "K3_SIDE24_LB/UPPER2D/D3_percolation/PERC_DECAY.md", + "reason": "already published in incoming/claude-audit-package-recovery-20260928/06_UNMIRRORED_FROZEN_CARRIERS_BYTE_NATIVES/PERC_DECAY.md" + } + ], + "files": [ + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/OPTIMIZATION_ANALYSIS.md", + "uploaded_title": "LPW_OPTIMIZATION_ANALYSIS.md", + "bytes": 17083, + "sha256": "71aec64fd2f9da77512426fa18f713bfed72f9ee1d14138776cf1ef8cc16cc19" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v3/LPW_CONSTANT_V3_REPORT.md", + "uploaded_title": "LPW_CONSTANT_V3_REPORT.md", + "bytes": 5780, + "sha256": "76016d7bfe755a1b6c09be40393a46632e9b92711d744817a8f0a35fe9331b63" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v3/RECEIPTS_ERRATA_2026-09-15.md", + "uploaded_title": "LPW_V3_RECEIPTS_ERRATA_2026-09-15.md", + "bytes": 3931, + "sha256": "6a7e95be5e3a4abae26ce737c48662bec930d76dca818daba26aef4d6b76029c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py.txt", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v3/lpw_constant_v3.py", + "uploaded_title": "lpw_constant_v3.py", + "bytes": 32750, + "sha256": "4a015174d369eabc16c60f2c6f2aade2feee113ed60c5d0b8d505624e9b02a8c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v4/CHANGED_INTERFACES_REVIEW.md", + "uploaded_title": "LPW_V4_CHANGED_INTERFACES_REVIEW.md", + "bytes": 4160, + "sha256": "a269a2bcb03e4eb6342fac938d0d303a947950034eb46e17ae598f59badcd71a" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v4/LPW_CONSTANT_V4_REPORT.md", + "uploaded_title": "LPW_CONSTANT_V4_REPORT.md", + "bytes": 4536, + "sha256": "b06ee40c43f6e8aef266de2a7f4231fd8321676024f33c9132966b89b654b81c" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256.txt", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v4/MANIFEST.sha256", + "uploaded_title": "LPW_V4_MANIFEST.sha256", + "bytes": 4529, + "sha256": "4a63ada47c8bd6d189108358898c646af064c06755a6a855c4e7d3133acf4774" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v4/RECEIPT.json", + "uploaded_title": "LPW_V4_RECEIPT.json", + "bytes": 3915, + "sha256": "d232d2a0d6b37d8fb465d3de8a9141b92f2d366460c38e928ab9f70d29ab689e" + }, + { + "path": "K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py.txt", + "original_path": "K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py", + "zip_member": "K3_SIDE24_LB/LPW_CONSTANT/v4/lpw_constant_v4.py", + "uploaded_title": "lpw_constant_v4.py", + "bytes": 34538, + "sha256": "12732d3222828d61c0449c562c5e00a1f5c36fb7646d8c4d030914e4c3f50c86" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md", + "original_path": "K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/00_EXECUTIVE_STATE.md", + "uploaded_title": "RETURN_06_00_EXECUTIVE_STATE.md", + "bytes": 10442, + "sha256": "c1ac3bde91a86b8d78d02eee72f00ab04969bba2b39a1f5255b8692b04f67c1f" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md", + "original_path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_B4LOC_PERC_DECAY.md", + "uploaded_title": "RETURN_06_ADDENDUM_2_B4LOC_PERC_DECAY.md", + "bytes": 23695, + "sha256": "8f8c0bc0905ab9c0c339a85ae04d7156c97ebb6540b55114263e86995f793f24" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md", + "original_path": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/ADDENDUM_2026-09-15_H3_BAND_FLOOR.md", + "uploaded_title": "RETURN_06_ADDENDUM_1_H3_BAND_FLOOR.md", + "bytes": 9400, + "sha256": "1cb23846199cd82d0d6c64449af6dba08b6d0efc1ceecbf0f0975bf38ef05ec2" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md", + "original_path": "K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/ADVERSARIAL_REPORT.md", + "uploaded_title": "RETURN_06_ADVERSARIAL_REPORT.md", + "bytes": 14228, + "sha256": "82ac0bf28bb7266ba93d8f395812519dadb0645f92d3c486406d35e8d6749644" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md", + "original_path": "K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/DEPENDENCY_DAG.md", + "uploaded_title": "RETURN_06_DEPENDENCY_DAG.md", + "bytes": 6890, + "sha256": "345e71b048fde07597daf1b2aa33bf9dfb850314380959bd42a679d463f010d1" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md", + "original_path": "K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/OBLIGATION_LEDGER.md", + "uploaded_title": "RETURN_06_OBLIGATION_LEDGER.md", + "bytes": 9184, + "sha256": "cd248c950584678668076f4e9801c06f6c240b6d572af6707b9de823f56b78fe" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md", + "original_path": "K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/PACKAGE_VERIFICATION.md", + "uploaded_title": "RETURN_06_PACKAGE_VERIFICATION.md", + "bytes": 7774, + "sha256": "46d1eacf5ec83fa7eb91785d56ce86209533482c0c772a5a3bceea00bf1db9a5" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md", + "original_path": "K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/RUNNING_TASKS.md", + "uploaded_title": "RETURN_06_RUNNING_TASKS.md", + "bytes": 8268, + "sha256": "ed8075644e5e43f2a8236f1315a2c71b19edfbc3bb4547bcd3f53b73639a7122" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256.txt", + "original_path": "K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256", + "zip_member": "K3_SIDE24_LB/RETURN_06/SOURCE_CAPSULE.sha256", + "uploaded_title": "RETURN_06_SOURCE_CAPSULE.sha256", + "bytes": 29557, + "sha256": "5698f3fbdc70422438c2fd137f910cc973311d8c74d7cd579d7e8ae4d8789dc1" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md", + "original_path": "K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md", + "zip_member": "K3_SIDE24_LB/RETURN_06/THEOREM_TABLE.md", + "uploaded_title": "RETURN_06_THEOREM_TABLE.md", + "bytes": 7226, + "sha256": "0ec315e527ec0a57553229ba98b7afc2151fe61c13cad1d0aa6a0d4ec3808905" + }, + { + "path": "K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256.txt", + "original_path": "K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256", + "zip_member": "K3_SIDE24_LB/RETURN_06/TREE_MANIFEST.sha256", + "uploaded_title": "RETURN_06_TREE_MANIFEST.sha256", + "bytes": 129707, + "sha256": "f3e9fa669dc4bdfef28f1de0b0e9a2d0994498cc65c7757fda758566c01dee43" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md", + "original_path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/B4LOC_DAMLINE.md", + "uploaded_title": "B4LOC_DAMLINE.md", + "bytes": 15164, + "sha256": "ae4c9c82784aecfbd85056c316f792a331bccb774d952887fc5fe8ea7da615b4" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/FREEZE.txt", + "uploaded_title": "B4LOC_FREEZE.txt", + "bytes": 1213, + "sha256": "5235f98a59e5119444b8fda2ea16d2dd3333e0d46f0b52af6362a2b2a0ecd163" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_driver.py", + "uploaded_title": "b4loc_driver.py", + "bytes": 26271, + "sha256": "bf3b022580a7eea1b4797658fe77a74a92850d59478212f39bca2bb231f20f02" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/b4loc_falsifier.py", + "uploaded_title": "b4loc_falsifier.py", + "bytes": 3360, + "sha256": "d59ad79088dbf152b6e196bbd48ee0a79ef304d60611148eabaa575e7fd8b10f" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/B4LOC_damline/t_normal.txt", + "uploaded_title": "B4LOC_t_normal.txt", + "bytes": 2735, + "sha256": "11baaccc25da202be951731ea4bc91c76795b614a9925a3baf7c59f8b0112b53" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md", + "original_path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR.md", + "uploaded_title": "BRANCH_DIR.md", + "bytes": 6069, + "sha256": "8821c8facc7e36635c4b84967ba55037ff5a33fff09359f817032eecaab24286" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md", + "original_path": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/BRANCH_dir/BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md", + "uploaded_title": "BRANCH_DIR_RECEIPTS_ERRATA_2026-09-15.md", + "bytes": 6063, + "sha256": "7547e76a813d1a0c582139e2d31d9ec6a6480e1eaf670d3eed05173bffead3df" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/D1_assembly/D1_V2_2_RECEIPTS.txt", + "uploaded_title": "D1_V2_2_RECEIPTS.txt", + "bytes": 7954, + "sha256": "58edc293a1127407d49040856ad9546d2577578381a4ff62c1c60a3c9911ac1d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/D1_assembly/d1_falsify_v3.py", + "uploaded_title": "d1_falsify_v3.py", + "bytes": 11552, + "sha256": "5805e53d69541f00229e5e49e14d655afd1f471a2584a2117fedf0bb5298ddb0" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md", + "original_path": "K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/D3_percolation/D3_REMOTE_AMENDMENT_v2.md", + "uploaded_title": "D3_REMOTE_AMENDMENT_v2.md", + "bytes": 5701, + "sha256": "2527ab5a1b5ee208a30a672e2457de04708228f3c154185d95c236bd4f4f5e6f" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/D3_percolation/FREEZE_PERC_DECAY.txt", + "uploaded_title": "FREEZE_PERC_DECAY.txt", + "bytes": 3966, + "sha256": "6bbe6e27a91c777b7245294fc5740462af06e7f20b0f92ff4eae15cd2f05edef" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/D3_percolation/d3_perc_decay.py", + "uploaded_title": "d3_perc_decay.py", + "bytes": 19063, + "sha256": "ee68ac7510241947c64445cc6aa17f91ccc4f2e5f0dacc2b0de801ef72d8ab64" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_CEIL.md", + "uploaded_title": "H3_BAND_CEIL.md", + "bytes": 8311, + "sha256": "18e109bc2e7a186c307f689f940ad476d69fc543e828081e0e706de2c578800d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/H3_BAND_FLOOR.md", + "uploaded_title": "H3_BAND_FLOOR.md", + "bytes": 11133, + "sha256": "7a40e2675232244bc63fcab2304b4b9cd3cd59a5c4965a3be5e65db7436fcfc2" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/MANIFEST.sha256", + "uploaded_title": "H3_MANIFEST.sha256", + "bytes": 2741, + "sha256": "092d886ceb279ba09d473f2308e3e0495593d70c4ca614fd0deed2ccde281e55" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/RECEIPT_h3.json", + "uploaded_title": "RECEIPT_h3.json", + "bytes": 6254, + "sha256": "ee58ef8054109a24ea0dadd5f0147b883966374e539ff462f8500af932765264" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/band_normal.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/band_O.txt", + "uploaded_title": "H3_band_normal.txt", + "bytes": 2835, + "sha256": "dcb3c8e6152876021c8b116903c9a7c1ac6be7417a9b4042b89c00b911fe565d" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/ceil_normal.txt", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/ceil_O.txt", + "uploaded_title": "H3_ceil_normal.txt", + "bytes": 2698, + "sha256": "26d08534979083275fe14ce789d9cfc4f59ab9250a6cfc830e9acca80a14ae00" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_ceil.py", + "uploaded_title": "h3_band_ceil.py", + "bytes": 37950, + "sha256": "b97c5428a20e5dd33f3e53653d20447f1e27515dcc7dc7a7c2004ebe30029452" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py.txt", + "original_path": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py", + "zip_member": "K3_SIDE24_LB/UPPER2D/H3_closure/h3_band_floor.py", + "uploaded_title": "h3_band_floor.py", + "bytes": 37315, + "sha256": "a907eeedd767b0b97461df8e237cdca130a607b5dede50ad5ba4b05c957d22a5" + }, + { + "path": "K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md", + "original_path": "K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md", + "zip_member": "K3_SIDE24_LB/UPPER2D/H5_closure/H5_CLOSURE_TIGHTENING_2026-09-15.md", + "uploaded_title": "H5_CLOSURE_TIGHTENING_2026-09-15.md", + "bytes": 7540, + "sha256": "125352325b09062fdc1f49402222402f388240f44b0f60b1e2636f19888c0615" + }, + { + "path": "K3_SIDE24_LB/W3_numerics/W3_REPORT.md", + "original_path": "K3_SIDE24_LB/W3_numerics/W3_REPORT.md", + "zip_member": "K3_SIDE24_LB/W3_numerics/W3_REPORT.md", + "uploaded_title": "W3_REPORT.md", + "bytes": 9693, + "sha256": "70a3ba352f937384f79b0f9252afc0f1aa5ba1a24e318549c903838d7dfef059" + }, + { + "path": "K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md", + "original_path": "K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md", + "zip_member": "K3_SIDE24_LB/W8_lambda/KIMI-DER-027c_NONCLOSURE.md", + "uploaded_title": "KIMI-DER-027c_NONCLOSURE.md", + "bytes": 19043, + "sha256": "530c3038024964fd12ed2a6249f4f44d473181e0b49cb91f6cbdae0aff440d15" + }, + { + "path": "K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_SCOPE.md", + "original_path": "K3_SIDE24_LB/[agent-tree]/19fcef2e-c1c2-8c6c-8000-0f5a243156d9/work/PHASE2_SCOPE.md", + "zip_member": "19fcef2e-c1c2-8c6c-8000-0f5a243156d9/work/PHASE2_SCOPE.md", + "uploaded_title": "W8_PHASE2_SCOPE.md", + "bytes": 2332, + "sha256": "966c3d8f4934139017d8fadfd334ef473a8086ee4750a959831855b9f895428f" + }, + { + "path": "K3_SIDE24_LB/agent-tree-19fcef2e/work/PHASE2_STATUS.md", + "original_path": "K3_SIDE24_LB/[agent-tree]/19fcef2e-c1c2-8c6c-8000-0f5a243156d9/work/PHASE2_STATUS.md", + "zip_member": "19fcef2e-c1c2-8c6c-8000-0f5a243156d9/work/PHASE2_STATUS.md", + "uploaded_title": "W8_PHASE2_STATUS.md", + "bytes": 11956, + "sha256": "6cdb9dec403561cce2de17e4a48915afb3272880fb21edc53f6b99c11d236ea6" + } + ] +}