From 0f98ba50cdc510fa9f6d1c2508bf84405ebbc801 Mon Sep 17 00:00:00 2001 From: d3lerium Date: Sat, 24 Oct 2026 10:51:38 +1100 Subject: [PATCH] Independently verify fixed controller-family ceiling via convexity Scoped source-bound exchange, all-n convexity and directed-rational check; preserve all v1/v2/v3 raw receipts and logs plus the v3 optimized acceptance correction. --- .../INTEGRITY.json | 340 +++++ .../controller-ceiling-convexity/NOTICE.md | 3 + .../controller-ceiling-convexity/README.md | 59 + .../controller-ceiling-convexity/SOURCES.json | 18 + .../controller-ceiling-convexity/TASK.json | 112 ++ .../controller-ceiling-convexity/VERIFY.json | 30 + .../audit/AUDIT-CHECKS.json | 52 + .../audit/FREEZE.json | 76 + .../audit/HANDOFF.md | 15 + .../audit/REPORT.md | 65 + .../audit/SOURCE-BRIDGE.json | 18 + .../audit/SOURCE-FETCH.json | 16 + .../audit/STATIC-REVIEW.json | 10 + .../canonical/AGENTS.md | 86 ++ .../canonical/CONTRIBUTING.md | 101 ++ .../canonical/LICENSE | 201 +++ .../canonical/NOTICE | 415 ++++++ .../canonical/autoresearch.md | 104 ++ .../certificates/selected-result.json | 92 ++ .../docs/research/agent-task-catalog.json | 1242 +++++++++++++++++ .../canonical/docs/research/coordination.md | 137 ++ .../docs/research/current-priorities.md | 164 +++ .../docs/research/research-family-status.md | 197 +++ .../docs/research/research-package-guide.md | 368 +++++ .../numerical/FINAL-MANIFEST-v3.json | 197 +++ .../numerical/HANDOFF.md | 65 + .../numerical/PROOF.md | 290 ++++ .../numerical/RUNS-v3.json | 94 ++ .../numerical/RUNS.json | 94 ++ .../numerical/SOURCE-MANIFEST.json | 46 + .../SOURCE-REPRESENTATION-BRIDGE.json | 18 + .../numerical/THEORY-MANIFEST.json | 12 + .../numerical/check_ceiling.py | 384 +++++ .../numerical/inputs/5405-PROOF.md | 209 +++ .../inputs/5405-UPSTREAM-EXACT-PROOF.md | 208 +++ .../inputs/5405-UPSTREAM-SOURCE-FETCH.json | 16 + .../5405-concavity-exchange-reduction.md | 160 +++ ...405-discrete-convexity-three-value-gate.md | 128 ++ ...OINT-20261023-5405-DISCRETE-CONVEXITY.json | 33 + .../numerical/inputs/guidance__AGENTS.md | 86 ++ .../inputs/guidance__CONTRIBUTING.md | 101 ++ .../inputs/guidance__autoresearch.md | 104 ++ ...idance__docs__research__agent-procedure.md | 487 +++++++ ...nce__docs__research__current-priorities.md | 164 +++ ..._docs__research__research-family-status.md | 197 +++ .../numerical/receipts/arithmetic-v1.json | 925 ++++++++++++ .../receipts/arithmetic-v1.stderr.log | 23 + .../receipts/arithmetic-v1.stdout.log | 85 ++ .../numerical/receipts/arithmetic-v2.json | 925 ++++++++++++ .../receipts/arithmetic-v2.stderr.log | 23 + .../receipts/arithmetic-v2.stdout.log | 85 ++ .../receipts/arithmetic-v3-optimized.json | 925 ++++++++++++ .../arithmetic-v3-optimized.stderr.log | 23 + .../arithmetic-v3-optimized.stdout.log | 85 ++ .../numerical/receipts/arithmetic-v3.json | 925 ++++++++++++ .../receipts/arithmetic-v3.stderr.log | 23 + .../receipts/arithmetic-v3.stdout.log | 85 ++ .../numerical/receipts/check_ceiling-v1.py | 366 +++++ .../receipts/frozen-v2-FINAL-MANIFEST.json | 120 ++ .../numerical/receipts/frozen-v2-HANDOFF.md | 52 + .../numerical/receipts/frozen-v2-PROOF.md | 274 ++++ .../numerical/receipts/frozen-v2-RUNS.json | 46 + .../receipts/frozen-v2-check_ceiling.py | 380 +++++ .../original/PROOF.md | 208 +++ .../original/source/NOTICE.md | 10 + .../origins/CANONICAL.json | 266 ++++ .../origins/PR5405-NOTICE.json | 30 + .../origins/PR5405-PROOF.json | 25 + .../controller-ceiling-convexity/verify.py | 108 ++ 69 files changed, 13031 insertions(+) create mode 100644 research/controller-ceiling-convexity/INTEGRITY.json create mode 100644 research/controller-ceiling-convexity/NOTICE.md create mode 100644 research/controller-ceiling-convexity/README.md create mode 100644 research/controller-ceiling-convexity/SOURCES.json create mode 100644 research/controller-ceiling-convexity/TASK.json create mode 100644 research/controller-ceiling-convexity/VERIFY.json create mode 100644 research/controller-ceiling-convexity/audit/AUDIT-CHECKS.json create mode 100644 research/controller-ceiling-convexity/audit/FREEZE.json create mode 100644 research/controller-ceiling-convexity/audit/HANDOFF.md create mode 100644 research/controller-ceiling-convexity/audit/REPORT.md create mode 100644 research/controller-ceiling-convexity/audit/SOURCE-BRIDGE.json create mode 100644 research/controller-ceiling-convexity/audit/SOURCE-FETCH.json create mode 100644 research/controller-ceiling-convexity/audit/STATIC-REVIEW.json create mode 100644 research/controller-ceiling-convexity/canonical/AGENTS.md create mode 100644 research/controller-ceiling-convexity/canonical/CONTRIBUTING.md create mode 100644 research/controller-ceiling-convexity/canonical/LICENSE create mode 100644 research/controller-ceiling-convexity/canonical/NOTICE create mode 100644 research/controller-ceiling-convexity/canonical/autoresearch.md create mode 100644 research/controller-ceiling-convexity/canonical/certificates/selected-result.json create mode 100644 research/controller-ceiling-convexity/canonical/docs/research/agent-task-catalog.json create mode 100644 research/controller-ceiling-convexity/canonical/docs/research/coordination.md create mode 100644 research/controller-ceiling-convexity/canonical/docs/research/current-priorities.md create mode 100644 research/controller-ceiling-convexity/canonical/docs/research/research-family-status.md create mode 100644 research/controller-ceiling-convexity/canonical/docs/research/research-package-guide.md create mode 100644 research/controller-ceiling-convexity/numerical/FINAL-MANIFEST-v3.json create mode 100644 research/controller-ceiling-convexity/numerical/HANDOFF.md create mode 100644 research/controller-ceiling-convexity/numerical/PROOF.md create mode 100644 research/controller-ceiling-convexity/numerical/RUNS-v3.json create mode 100644 research/controller-ceiling-convexity/numerical/RUNS.json create mode 100644 research/controller-ceiling-convexity/numerical/SOURCE-MANIFEST.json create mode 100644 research/controller-ceiling-convexity/numerical/SOURCE-REPRESENTATION-BRIDGE.json create mode 100644 research/controller-ceiling-convexity/numerical/THEORY-MANIFEST.json create mode 100644 research/controller-ceiling-convexity/numerical/check_ceiling.py create mode 100644 research/controller-ceiling-convexity/numerical/inputs/5405-PROOF.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/5405-UPSTREAM-EXACT-PROOF.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/5405-UPSTREAM-SOURCE-FETCH.json create mode 100644 research/controller-ceiling-convexity/numerical/inputs/5405-concavity-exchange-reduction.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/5405-discrete-convexity-three-value-gate.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__AGENTS.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__CONTRIBUTING.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__autoresearch.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__agent-procedure.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__current-priorities.md create mode 100644 research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__research-family-status.md create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stderr.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stdout.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stderr.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stdout.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stderr.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stdout.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stderr.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stdout.log create mode 100644 research/controller-ceiling-convexity/numerical/receipts/check_ceiling-v1.py create mode 100644 research/controller-ceiling-convexity/numerical/receipts/frozen-v2-FINAL-MANIFEST.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/frozen-v2-HANDOFF.md create mode 100644 research/controller-ceiling-convexity/numerical/receipts/frozen-v2-PROOF.md create mode 100644 research/controller-ceiling-convexity/numerical/receipts/frozen-v2-RUNS.json create mode 100644 research/controller-ceiling-convexity/numerical/receipts/frozen-v2-check_ceiling.py create mode 100644 research/controller-ceiling-convexity/original/PROOF.md create mode 100644 research/controller-ceiling-convexity/original/source/NOTICE.md create mode 100644 research/controller-ceiling-convexity/origins/CANONICAL.json create mode 100644 research/controller-ceiling-convexity/origins/PR5405-NOTICE.json create mode 100644 research/controller-ceiling-convexity/origins/PR5405-PROOF.json create mode 100644 research/controller-ceiling-convexity/verify.py diff --git a/research/controller-ceiling-convexity/INTEGRITY.json b/research/controller-ceiling-convexity/INTEGRITY.json new file mode 100644 index 0000000000..fc8f22c571 --- /dev/null +++ b/research/controller-ceiling-convexity/INTEGRITY.json @@ -0,0 +1,340 @@ +{ + "schema": "controller5405-package-integrity-v1", + "files": [ + { + "path": "NOTICE.md", + "bytes": 819, + "sha256": "eb1c15665e10d59e9bf3679b0490ac41d7897261dcff4e398b002d2b62a1cb1e" + }, + { + "path": "README.md", + "bytes": 7898, + "sha256": "04d5acbc07f5b148cf9fa387f42ea485536a8f52c7793eb949d718c0b363b108" + }, + { + "path": "SOURCES.json", + "bytes": 584, + "sha256": "35c1612a830ec22b24b6f844270521333daf1b11c41c82a985069c27a5949828" + }, + { + "path": "TASK.json", + "bytes": 6982, + "sha256": "0918cae1ec15ee7692f9094c5ccc65d00856f0196cb5e137a1494f3a283caf87" + }, + { + "path": "VERIFY.json", + "bytes": 826, + "sha256": "029f72d004705da4eb53e5e629e043f8d5fb09c8c5455baeee974626b1f04b5e" + }, + { + "path": "audit/AUDIT-CHECKS.json", + "bytes": 2210, + "sha256": "9df76d3207f2125c55fbb8b024e1096bc0291a0b23149829c9fdd0c415dda2a1" + }, + { + "path": "audit/FREEZE.json", + "bytes": 2879, + "sha256": "57c19562fa648a8a194e2f779b3c47acdfcf6f010d09dd47b8f67d6142be4f9a" + }, + { + "path": "audit/HANDOFF.md", + "bytes": 2977, + "sha256": "52cbbb5e0eb38a872eddf3e4eba9e611f6e8c0b057d767d0d91aa1c6b8d319cf" + }, + { + "path": "audit/REPORT.md", + "bytes": 12391, + "sha256": "eca3f5606d251f6a782a12144b59fd9aed6ee055a51cddb38a3768597fe516a9" + }, + { + "path": "audit/SOURCE-BRIDGE.json", + "bytes": 997, + "sha256": "69b3623459ea1586abbe0499e2eb9d7dd5526db26d3641747ad9c81191fd2c51" + }, + { + "path": "audit/SOURCE-FETCH.json", + "bytes": 10676, + "sha256": "4771e2948b448e5488bdb33a872e49ce0251c8acff5c294e70c5544d0f2e95f2" + }, + { + "path": "audit/STATIC-REVIEW.json", + "bytes": 399, + "sha256": "2d6cdccc2dbdef21128fd8c71b56bd406340aa000609d5c74ba510600a913a58" + }, + { + "path": "canonical/AGENTS.md", + "bytes": 5580, + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347" + }, + { + "path": "canonical/CONTRIBUTING.md", + "bytes": 7143, + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215" + }, + { + "path": "canonical/LICENSE", + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + { + "path": "canonical/NOTICE", + "bytes": 24973, + "sha256": "b49022cb4104d90b182e4c335f670faf45529025b15db77bf0291835083c28bd" + }, + { + "path": "canonical/autoresearch.md", + "bytes": 5986, + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + { + "path": "canonical/certificates/selected-result.json", + "bytes": 5495, + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + }, + { + "path": "canonical/docs/research/agent-task-catalog.json", + "bytes": 77545, + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + }, + { + "path": "canonical/docs/research/coordination.md", + "bytes": 7598, + "sha256": "26e92961dadecaa08288303ad256d23a637b49f9fb2c972d4f0879e16bf1ccd9" + }, + { + "path": "canonical/docs/research/current-priorities.md", + "bytes": 11950, + "sha256": "7ea971a336bf526719ae1f21617038301ab95d9853a38b92c332a9ffb968297a" + }, + { + "path": "canonical/docs/research/research-family-status.md", + "bytes": 18401, + "sha256": "21ea61004c0270388258c4251b1c586b65f06bc807395b281deacfb886204934" + }, + { + "path": "canonical/docs/research/research-package-guide.md", + "bytes": 20824, + "sha256": "53a9ee0bf04e40ff14964b2a48605a78de513207b7141df451233868453858fa" + }, + { + "path": "numerical/FINAL-MANIFEST-v3.json", + "bytes": 6505, + "sha256": "40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841" + }, + { + "path": "numerical/HANDOFF.md", + "bytes": 3712, + "sha256": "b22e34a3fc93ca0c3f0c8289c73ed45324b539218a9e6a50deeb8a7e5fa3805d" + }, + { + "path": "numerical/PROOF.md", + "bytes": 14664, + "sha256": "b0aff27dd9203ef42e5b8898d6659819205f13c1d251ff043564fcab656bf7f4" + }, + { + "path": "numerical/RUNS-v3.json", + "bytes": 4442, + "sha256": "ce81ac1a91ef600699e515eab53ab7b830ff3f99109bb5a9099dd452c1ee0d02" + }, + { + "path": "numerical/RUNS.json", + "bytes": 4442, + "sha256": "ce81ac1a91ef600699e515eab53ab7b830ff3f99109bb5a9099dd452c1ee0d02" + }, + { + "path": "numerical/SOURCE-MANIFEST.json", + "bytes": 2135, + "sha256": "c9e036ae8bce17023e6e47682e548e7b23f0eea745175516c66c9f34ba5d1cca" + }, + { + "path": "numerical/SOURCE-REPRESENTATION-BRIDGE.json", + "bytes": 738, + "sha256": "a7cae5f36f5d0cd87b92af22115b46f8e692f8b9a734d0049ed46e7587e522c7" + }, + { + "path": "numerical/THEORY-MANIFEST.json", + "bytes": 545, + "sha256": "21ec2a198c3201c2fc83a2bfd2a4622987e15b490b64c632925e399e84510054" + }, + { + "path": "numerical/check_ceiling.py", + "bytes": 16531, + "sha256": "8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01" + }, + { + "path": "numerical/inputs/5405-PROOF.md", + "bytes": 10030, + "sha256": "5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37" + }, + { + "path": "numerical/inputs/5405-UPSTREAM-EXACT-PROOF.md", + "bytes": 10029, + "sha256": "77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b" + }, + { + "path": "numerical/inputs/5405-UPSTREAM-SOURCE-FETCH.json", + "bytes": 10676, + "sha256": "4771e2948b448e5488bdb33a872e49ce0251c8acff5c294e70c5544d0f2e95f2" + }, + { + "path": "numerical/inputs/5405-concavity-exchange-reduction.md", + "bytes": 10145, + "sha256": "0e575a88d28db5aecc5ccf24504923a0508ff976d05f92e91e6d48408b7688ea" + }, + { + "path": "numerical/inputs/5405-discrete-convexity-three-value-gate.md", + "bytes": 7372, + "sha256": "bdad476f31b450e1ac4d1fd0d9530b43e33ebac48accc0956b38a9634b40a929" + }, + { + "path": "numerical/inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json", + "bytes": 1795, + "sha256": "ce98cb10c028e3a512599e715043e8a26dd9b88278d1c600d2b4b29c7b909d6d" + }, + { + "path": "numerical/inputs/guidance__AGENTS.md", + "bytes": 5580, + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347" + }, + { + "path": "numerical/inputs/guidance__CONTRIBUTING.md", + "bytes": 7143, + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215" + }, + { + "path": "numerical/inputs/guidance__autoresearch.md", + "bytes": 5986, + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + { + "path": "numerical/inputs/guidance__docs__research__agent-procedure.md", + "bytes": 29397, + "sha256": "6433f302cbc129ea986bf88ba1e94422bbf2aa6ba1d1d11b067c92736fa4a139" + }, + { + "path": "numerical/inputs/guidance__docs__research__current-priorities.md", + "bytes": 11950, + "sha256": "7ea971a336bf526719ae1f21617038301ab95d9853a38b92c332a9ffb968297a" + }, + { + "path": "numerical/inputs/guidance__docs__research__research-family-status.md", + "bytes": 18401, + "sha256": "21ea61004c0270388258c4251b1c586b65f06bc807395b281deacfb886204934" + }, + { + "path": "numerical/receipts/arithmetic-v1.json", + "bytes": 43821, + "sha256": "a5a3e35b420ba30407ddeaacc91770e7c03da5ff8139b73585c4ceae9db6d744" + }, + { + "path": "numerical/receipts/arithmetic-v1.stderr.log", + "bytes": 890, + "sha256": "475f7f876455d7e4e115381c138854462e487b182e4a1b9006cb634627ae33dc" + }, + { + "path": "numerical/receipts/arithmetic-v1.stdout.log", + "bytes": 5061, + "sha256": "b9e6beac377d81121cc2fc62f4cb49f70b209209717653418ef17da466e3c6f1" + }, + { + "path": "numerical/receipts/arithmetic-v2.json", + "bytes": 43820, + "sha256": "86f84dd374d831c3e4f907cd3e5f4789cee4ae2efb68f55dd0f679caec7b4736" + }, + { + "path": "numerical/receipts/arithmetic-v2.stderr.log", + "bytes": 890, + "sha256": "6c806fac227571242e9ccc31e1db08b2cd886c843bb24c26e2d21b8faafa4361" + }, + { + "path": "numerical/receipts/arithmetic-v2.stdout.log", + "bytes": 5060, + "sha256": "b7e05a760ad11a7507b662b6d991ae89f05cab80fecb0226d69e2e809fd46714" + }, + { + "path": "numerical/receipts/arithmetic-v3-optimized.json", + "bytes": 43820, + "sha256": "6d4b1c890bed07576ef4f76c47e27ce9effe903b7646f650f0092c03c69a6bda" + }, + { + "path": "numerical/receipts/arithmetic-v3-optimized.stderr.log", + "bytes": 905, + "sha256": "8598ee3084306350af165ab758918f1d4125d2856c1de979ddcee7ae0b0a2e0a" + }, + { + "path": "numerical/receipts/arithmetic-v3-optimized.stdout.log", + "bytes": 5060, + "sha256": "10082755c70523929349bd4310fe6a867e8ae54d225b24c0372bc5f146287de9" + }, + { + "path": "numerical/receipts/arithmetic-v3.json", + "bytes": 43820, + "sha256": "32d3adfc837ba4f66c899e7cb23adea441a3af48d96700f2e14e6c9f8b1c6729" + }, + { + "path": "numerical/receipts/arithmetic-v3.stderr.log", + "bytes": 890, + "sha256": "e7fc3facecd37c1ea1e9f3e9b94221f7f1f456bee467f1ad37b192a49d359df2" + }, + { + "path": "numerical/receipts/arithmetic-v3.stdout.log", + "bytes": 5060, + "sha256": "a98a5c1760fd0c1f69c342d39c9d213872b2e4b3e850742e05caeacf5620f9cc" + }, + { + "path": "numerical/receipts/check_ceiling-v1.py", + "bytes": 14242, + "sha256": "42cec3a635e22785929ca47d1da1d9b11041c1244945f21145a69b25c7527a3e" + }, + { + "path": "numerical/receipts/frozen-v2-FINAL-MANIFEST.json", + "bytes": 3875, + "sha256": "cbcacfbefbe07b32a5df57f31ddaa7baaabe2a2e72f7cb7df9252886339bfcfe" + }, + { + "path": "numerical/receipts/frozen-v2-HANDOFF.md", + "bytes": 2767, + "sha256": "9a49c75d894869c8d37bd6bd983c4e43ef9a7f6f40944539e3dc0bb353a9c5f6" + }, + { + "path": "numerical/receipts/frozen-v2-PROOF.md", + "bytes": 13468, + "sha256": "85f92f5b1a90148ba6a6857c41035d805cc18e4442a618dd107b2b7988bd0f6c" + }, + { + "path": "numerical/receipts/frozen-v2-RUNS.json", + "bytes": 2009, + "sha256": "815146645a539dd9cf5c262fbbe9649101c32fd06da455a339627a62880bcda2" + }, + { + "path": "numerical/receipts/frozen-v2-check_ceiling.py", + "bytes": 14844, + "sha256": "3352d5c6dd0da6e988efcab7b6a8cfd5ff85655390bef472523e7022db431cd9" + }, + { + "path": "original/PROOF.md", + "bytes": 10029, + "sha256": "77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b" + }, + { + "path": "original/source/NOTICE.md", + "bytes": 1933, + "sha256": "d4199d37458047d62f374c991de694a7db8579cecdee4dd1d809fab1435c3cb3" + }, + { + "path": "origins/CANONICAL.json", + "bytes": 134708, + "sha256": "9aa65eab0659241548959560260c0c6fdcccc749d8d42e13393d4d64a748209f" + }, + { + "path": "origins/PR5405-NOTICE.json", + "bytes": 295981, + "sha256": "52d4e29b90d097faa3c7dbc5da176d0bb2657b8b3164ada724e37549679a7440" + }, + { + "path": "origins/PR5405-PROOF.json", + "bytes": 295733, + "sha256": "c3f56e426114616aa8229858bcecc1ca5ad10faf5cd0554c5076103e56f8b1e7" + } + ] +} diff --git a/research/controller-ceiling-convexity/NOTICE.md b/research/controller-ceiling-convexity/NOTICE.md new file mode 100644 index 0000000000..42c2d8a2d1 --- /dev/null +++ b/research/controller-ceiling-convexity/NOTICE.md @@ -0,0 +1,3 @@ +New research, verification and packaging by Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0. + +Ali Romman retains credit for PR5405 family, invoice, original unbounded ceiling/DP and owned/transposed profile. Cinna Davis retains paired path/query controller credit; Cao Yifan native source; zxv interval/preflight/compiler/precision; Chris R prior independent admission/controller screening; Dugongue, Jacob Alan Sussman and all original native/helper/compiler/analytic contributors retain their exact source notices. Root proposed exchange/convexity conjectures; the sole Astra theory worker supplied the frozen analytic proofs. No new construction priority, independent human review or formal-kernel proof is claimed. Read original/source/NOTICE.md and unchanged source credit statements. diff --git a/research/controller-ceiling-convexity/README.md b/research/controller-ceiling-convexity/README.md new file mode 100644 index 0000000000..04a4a99a9b --- /dev/null +++ b/research/controller-ceiling-convexity/README.md @@ -0,0 +1,59 @@ +# Independent PR5405 controller ceiling via exchange and discrete convexity + +Every invoice in Ali Romman's fixed PR5405 FULL/QUERY prefix/suffix controller family has strictly positive paid-minus-target moment for **0.00302728825 <= κ < 1**. This package independently checks the three exact rational signs needed by the retained exchange and strict-discrete-convexity proofs, and separately audits the normalized monotonicity extension. It answers a scoped fixed-family ceiling question. It supplies no κ gain, physical/native/compiler admission, global circuit optimum, formal-kernel theorem, independent human review or transfer to PR5402. + +The exact source head is `314b56a6c0056c2358538f072c6fde9d365be44d`, retained against canonical main `1ec1119972c9aefe42525172d07b332fcff81cb4`. The premise is source equation (1), the fixed paid/helper profiles, rank-eight stages, rank-one query price and prefix/suffix idle law. Derivation from the original Laurent/native controller and its framework assumptions remains separate. No selected record is changed. + +## Proof and scope + +Read [the full independent proof](numerical/PROOF.md), [the exchange reduction](numerical/inputs/5405-concavity-exchange-reduction.md), and [the all-n discrete-convexity proof](numerical/inputs/5405-discrete-convexity-three-value-gate.md). The exchange argument reduces every source invoice with n FULL stages to an attainable canonical invoice C_n. Strict discrete convexity on every nonnegative integer, including the small-count junction, then makes the following signs sufficient: + +| Exact quantity | Strict rational bound | +|---|---:| +| C18 | > 0.000000014914967918767741908079 | +| C18−C17 | < −0.271338621904872494155700553536 | +| C19−C18 | > 0.022748156490424972863108432493 | + +These displayed decimals are rationals with denominator 10^30. The raw receipts retain finer integer endpoints over 2^256. They establish the unique minimizing FULL count n=18 and positivity for every n at κ0=.00302728825. A separate normalized whole-invoice monotonicity argument, with the n=0 and zero-partial-count cases explicit, extends this conclusion to κ0<=κ<1. The finite tiny-mask checks are indexing controls; all-n coverage comes from the analytic proofs. + +The new standard-library engine implements directed integer log/exp intervals with rigorous remainders. It independently reconstructs the complete invoice from paid/target histograms, checks 456 tiny invoice identities, verifies canonical coefficient identities at n=0,...,5 and 16,...,20, and rejects changed source bytes, reversed sign, a missing 112-rank-one QUERY invoice, omitted full-path targets and a changed paid-profile coefficient. Omitting targets is numerically favorable, so that control must fail accounting identity rather than a final sign. It imports no original numerical engine and runs no author 10,290,000-state DP, native/cold replay or Lean process. + +[The independent read-only audit](audit/REPORT.md) records its exact scope and final freeze. It is an independent agent check, with no claim of human acceptance. + +## Source binding and correction history + +The original source is retained in [original/PROOF.md](original/PROOF.md), Git blob `5ad89d4ba1836d47798bdb856e3726c70a7b1922` (10,029 bytes; SHA256 `77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b`). The monitor copy consumed by the frozen theory/numerical work is 10,030 bytes, SHA256 `5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37`, exactly the original plus one LF. The wrapper checks this representation bridge without replacing either frozen source. [Git-free origin proofs](origins/) authenticate the raw commit and every tree edge to the source blob; canonical guidance, catalogue and selected-record provenance have their own origin proofs. The PR head is not represented as a canonical ancestor. + +The raw v1 and v2 receipts and exact executed checkers remain preserved under [numerical/receipts](numerical/receipts/). The independent auditor identified that v2's acceptance `assert` statements disappear under optimized Python. V2's ordinary arithmetic endpoints remain retained; v3 supersedes its acceptance checker with explicit require/raise predicates. The final v3 ordinary/optimized runs agree on every scientific output and the earlier arithmetic endpoints. [RUNS-v3.json](numerical/RUNS-v3.json) and the frozen manifests preserve this correction. No historical receipt is silently repaired. + +[INTEGRITY.json](INTEGRITY.json) inventories retained scientific/source/theory/audit/metadata bytes. The wrapper pins that inventory, authenticates both source representations and Merkle origins, then reruns the small independent engine in a temporary directory and compares every scientific result; environment/timing fields are excluded from scientific equality. A changed-byte control and a forged-tree control exercise authentication. Canonical source pins in [SOURCES.json](SOURCES.json) are historical provenance; every scientific input is retained inside this package, so a Git-free export runs offline. + +## Reproduce + +From the repository root: + +```sh +python3 -B scripts/research_package.py --package research/controller-ceiling-convexity +python3 -B scripts/check_research_commit.py --package research/controller-ceiling-convexity --check-source-history +``` + +The registered command pair runs the same explicit acceptance conditions in normal and `-O` Python. Each independent arithmetic run takes about 0.1 seconds on the recorded Linux workstation, within a 60-second/256MiB engine cap. This bounded wrapper execution is separate from the original expensive author replay. There are no third-party Python dependencies. + +In an extracted Git-free bundle: + +```sh +python3 -I -B research/controller-ceiling-convexity/verify.py +python3 -I -O -B research/controller-ceiling-convexity/verify.py +``` + +Add `--integrity-only` to authenticate frozen inputs, exact origins and corrections without arithmetic replay. Publication-byte/source-history checks and export integrity are transport checks; hosted CI and maintainer selection remain distinct. + +## Open next questions + +The structured questions in [TASK.json](TASK.json) identify relevance, a feasible first step and blockers. A human or formal-kernel reviewer can check the exchange inequalities, the small-count convexity junction and the rational remainder derivations. Binding the original physical/native controller to equation (1) is a separate admission task. Escaping this obstruction requires a changed premise and a complete new bill, such as provider/consumer contract, stage rank or idle law; the scalar signs do not transfer to changed-profile PR5402. + +## Credit + +Ali Romman supplied PR5405's invoice family, original unbounded ceiling and DP, and the owned/transposed local profile. Preserve Cinna Davis's paired path/query controller, Cao Yifan's native source, zxv's interval/preflight and compiler/precision lineage, Chris R's prior controller screening and independent admission, Dugongue's frames and compiler contributions, Jacob Alan Sussman's recursion, and all retained native/helper/compiler/analytic contributors and source notices. The root coordinator proposed the exchange and discrete-convexity conjectures; the sole Astra theory worker supplied the frozen independent analytic proofs. The successor worker independently reconstructed the numerical invoice, implemented the new rational engine and audited normalized monotonicity; a separate agent audited the resulting proof and acceptance controls. + +New independent research, review and packaging by **Chris R / Clear1nsight, with substantial OpenAI Codex assistance**. New work is Apache-2.0. [The original source notice](original/source/NOTICE.md) and [canonical LICENSE/NOTICE](canonical/) remain unchanged. No new construction priority, independent human review or global theorem is claimed. diff --git a/research/controller-ceiling-convexity/SOURCES.json b/research/controller-ceiling-convexity/SOURCES.json new file mode 100644 index 0000000000..eeb3af8971 --- /dev/null +++ b/research/controller-ceiling-convexity/SOURCES.json @@ -0,0 +1,18 @@ +{ + "schema_version": 1, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b288ae44032fd84dd5564243422836cbcd29835e", + "sha256": "f9ed52bb642cd1e1486cf2743557ac5fa23cf1514a3277d786a644e39a565038" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602", + "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72" + } + ] +} diff --git a/research/controller-ceiling-convexity/TASK.json b/research/controller-ceiling-convexity/TASK.json new file mode 100644 index 0000000000..db882d97d1 --- /dev/null +++ b/research/controller-ceiling-convexity/TASK.json @@ -0,0 +1,112 @@ +{ + "schema_version": 1, + "task_id": "independent-moment", + "priority_revision": 7, + "base_commit": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "original_card": { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Independently verify the PR5405 fixed equation-(1) invoice-family ceiling through exact three-value rational gates and separately audited all-n analytic proofs.", + "scope_change_reason": "The explicit donor assignment is a fixed-family independent ceiling check, not a changed-mechanism kappa gain.", + "bottleneck_link": "Necessary-moment obstruction for the fixed FULL/QUERY prefix/suffix controller family; stage rank, profiles and idle law remain fixed.", + "budget_minutes": 60, + "stop_rule": "Stop after exact-source-bound normal/O independent replay, analytic audit, publication-byte/source-history check and Git-free export; no author DP/native/Lean replay.", + "outcome": "completed", + "evidence": "PROOF in numerical/PROOF.md, sole Astra analytic notes under numerical/inputs, independent read-only audit under audit, frozen normal/O v3 receipts and transparent v1/v2 history.", + "author": "Chris R / Clear1nsight", + "ai_assistance": "Substantial OpenAI Codex assistance; sole Astra supplied analytic theory proofs; additional agents independently audited and packaged. No independent human or formal-kernel review.", + "open_questions": [ + { + "question": "Can an independent human or formal-kernel audit discharge the retained analytic derivations?", + "why_it_matters": "Numerical signs depend on the exchange and all-n convexity proof.", + "first_step": "Check exchange inequalities and the n=2 to n=3 correction junction against the exact source invoice.", + "blocked_by": "Separate human or formal proof effort." + }, + { + "question": "Does every intended native/physical controller satisfy source equation (1)?", + "why_it_matters": "This package treats the invoice and autonomous profile as premises.", + "first_step": "Bind one original controller construction to the full paid/target ledger.", + "blocked_by": "Physical/native/compiler admission was outside this bounded check." + }, + { + "question": "Which changed premise can escape this fixed-family obstruction?", + "why_it_matters": "More digits or fixed-invoice searches do not provide a new saving.", + "first_step": "Specify a different provider/consumer, stage rank or idle law and its complete invoice before pricing.", + "blocked_by": "No transfer to changed-profile PR5402 or any new mechanism is established." + } + ] +} diff --git a/research/controller-ceiling-convexity/VERIFY.json b/research/controller-ceiling-convexity/VERIFY.json new file mode 100644 index 0000000000..1e5f9fb212 --- /dev/null +++ b/research/controller-ceiling-convexity/VERIFY.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Authenticate immutable source/theory/audit/receipt bytes, Git-free exact commit/tree/blob origins and LF bridge; freshly rerun independent rational engine, exact invoice identities and five surgical mutations; compare every scientific output." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Repeat identical explicit acceptance predicates under optimized Python; changed source and forged Merkle path reject." + } + ] +} diff --git a/research/controller-ceiling-convexity/audit/AUDIT-CHECKS.json b/research/controller-ceiling-convexity/audit/AUDIT-CHECKS.json new file mode 100644 index 0000000000..0091599ea0 --- /dev/null +++ b/research/controller-ceiling-convexity/audit/AUDIT-CHECKS.json @@ -0,0 +1,52 @@ +{ + "normal_optimized_proof_fields_equal": true, + "v2_v3_values_identical": true, + "v2_v3_differences_identical": true, + "no_assert_ast_nodes": true, + "recorded_normal_status": "PASS_SCOPED_ARITHMETIC", + "recorded_optimized_status": "PASS_SCOPED_ARITHMETIC", + "recorded_three_exact_endpoint_signs": true, + "recorded_symbolic_count": 456, + "recorded_canonical_count": 11, + "recorded_negative_control_count": 5, + "reviewed_files": [ + { + "path": "outputs/controller5405-exact-successor-20261024/check_ceiling.py", + "sha256": "8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/PROOF.md", + "sha256": "b0aff27dd9203ef42e5b8898d6659819205f13c1d251ff043564fcab656bf7f4" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/SOURCE-MANIFEST.json", + "sha256": "c9e036ae8bce17023e6e47682e548e7b23f0eea745175516c66c9f34ba5d1cca" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/THEORY-MANIFEST.json", + "sha256": "21ec2a198c3201c2fc83a2bfd2a4622987e15b490b64c632925e399e84510054" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/SOURCE-REPRESENTATION-BRIDGE.json", + "sha256": "a7cae5f36f5d0cd87b92af22115b46f8e692f8b9a734d0049ed46e7587e522c7" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/FINAL-MANIFEST-v3.json", + "sha256": "40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3.json", + "sha256": "32d3adfc837ba4f66c899e7cb23adea441a3af48d96700f2e14e6c9f8b1c6729" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3-optimized.json", + "sha256": "6d4b1c890bed07576ef4f76c47e27ce9effe903b7646f650f0092c03c69a6bda" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v2.json", + "sha256": "86f84dd374d831c3e4f907cd3e5f4789cee4ae2efb68f55dd0f679caec7b4736" + } + ], + "performed_utc": "2026-10-23T23:48:14.168383+00:00", + "no_arithmetic_engine_executed": true +} diff --git a/research/controller-ceiling-convexity/audit/FREEZE.json b/research/controller-ceiling-convexity/audit/FREEZE.json new file mode 100644 index 0000000000..07a4cc21d2 --- /dev/null +++ b/research/controller-ceiling-convexity/audit/FREEZE.json @@ -0,0 +1,76 @@ +{ + "status": "PASS_SCOPED_FIXED_FAMILY_CEILING", + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "numeric_manifest_sha256": "40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841", + "audit_files": [ + { + "path": "AUDIT-CHECKS.json", + "bytes": 2210, + "sha256": "9df76d3207f2125c55fbb8b024e1096bc0291a0b23149829c9fdd0c415dda2a1" + }, + { + "path": "HANDOFF.md", + "bytes": 2977, + "sha256": "52cbbb5e0eb38a872eddf3e4eba9e611f6e8c0b057d767d0d91aa1c6b8d319cf" + }, + { + "path": "REPORT.md", + "bytes": 12391, + "sha256": "eca3f5606d251f6a782a12144b59fd9aed6ee055a51cddb38a3768597fe516a9" + }, + { + "path": "SOURCE-BRIDGE.json", + "bytes": 997, + "sha256": "69b3623459ea1586abbe0499e2eb9d7dd5526db26d3641747ad9c81191fd2c51" + }, + { + "path": "SOURCE-FETCH.json", + "bytes": 10676, + "sha256": "4771e2948b448e5488bdb33a872e49ce0251c8acff5c294e70c5544d0f2e95f2" + }, + { + "path": "STATIC-REVIEW.json", + "bytes": 399, + "sha256": "2d6cdccc2dbdef21128fd8c71b56bd406340aa000609d5c74ba510600a913a58" + } + ], + "reviewed_inputs": [ + { + "path": "outputs/controller5405-exact-successor-20261024/check_ceiling.py", + "sha256": "8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/PROOF.md", + "sha256": "b0aff27dd9203ef42e5b8898d6659819205f13c1d251ff043564fcab656bf7f4" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/SOURCE-MANIFEST.json", + "sha256": "c9e036ae8bce17023e6e47682e548e7b23f0eea745175516c66c9f34ba5d1cca" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/THEORY-MANIFEST.json", + "sha256": "21ec2a198c3201c2fc83a2bfd2a4622987e15b490b64c632925e399e84510054" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/SOURCE-REPRESENTATION-BRIDGE.json", + "sha256": "a7cae5f36f5d0cd87b92af22115b46f8e692f8b9a734d0049ed46e7587e522c7" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/FINAL-MANIFEST-v3.json", + "sha256": "40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3.json", + "sha256": "32d3adfc837ba4f66c899e7cb23adea441a3af48d96700f2e14e6c9f8b1c6729" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3-optimized.json", + "sha256": "6d4b1c890bed07576ef4f76c47e27ce9effe903b7646f650f0092c03c69a6bda" + }, + { + "path": "outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v2.json", + "sha256": "86f84dd374d831c3e4f907cd3e5f4789cee4ae2efb68f55dd0f679caec7b4736" + } + ], + "created_utc": "2026-10-23T23:49:59.906041+00:00" +} diff --git a/research/controller-ceiling-convexity/audit/HANDOFF.md b/research/controller-ceiling-convexity/audit/HANDOFF.md new file mode 100644 index 0000000000..454c57d781 --- /dev/null +++ b/research/controller-ceiling-convexity/audit/HANDOFF.md @@ -0,0 +1,15 @@ +HANDOFF + +**Research discussion / PR / artifact:** LOCAL-ONLY independent read-only mathematical/code audit of the PR5405 successor. Final report: `outputs/controller5405-successor-audit-20261024/REPORT.md`; source connector and exact LF bridge, metadata receipt and hash inventory are alongside it. Root owns publication. + +**Exact commit:** PR5405 `314b56a6c0056c2358538f072c6fde9d365be44d`; canonical guidance `1ec1119972c9aefe42525172d07b332fcff81cb4`. Actual proof Git blob `5ad89d4ba1836d47798bdb856e3726c70a7b1922`. Final numerical source `8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01`; final numerical manifest `40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841`. + +**What is established:** PASS_SCOPED_FIXED_FAMILY_CEILING. Independently reviewed Eq1 accounting, all exchange deltas and termination, p/FULL/QUERY census, small-n branch, balanced attained minima, strict all-n discrete convexity including the junction, the three-value gate, the directed log/exp remainder arithmetic and the separate normalized whole-kappa extension. These yield E>0 for all defined invoices and `0.00302728825<=kappa<1`. Reviewed v3 normal/-O proof fields agree; all acceptance/domain/control predicates survive optimization. No numerical engine was rerun by the auditor. + +**What remains uncertain:** Eq1/P/H derivation from the native/controller sources and complete inherited framework premises were not replayed. Physical/global optimality, arbitrary-mask physical admission, compiler/supplier admission, exact root supremum, a kappa gain, PR5398 admission and PR5402 transfer remain outside scope. Package-origin/export/publication gates remain with root/packager. Earlier v2 assertion-only optimized acceptance is explicitly superseded; raw evidence remains preserved. + +**Smallest useful next task:** Package the exact frozen numerical/theory/audit objects and the upstream-versus-monitor one-LF bridge, then complete source-origin/export/claim review. No further mathematical engine is needed. Reopen only for an identified source change or concrete proof defect. + +**Reproduction command and expected runtime:** The auditor's review is read-only and has no scientific replay. For the independently implemented numeric certificate, choose a fresh receipt: `python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt /tmp/controller5405-new.json`; use `python3 -O -B` for optimized acceptance. Existing v3 normal/-O runs took 0.10/0.31 seconds external wall time under 60 seconds and 256MiB; explicit checks remain active. Root owns permission to rerun if needed. + +**Predecessor credit:** Ali Romman, Cinna Davis, Cao Yifan, zxv, Chris R/Clear1nsight, Dugongue, Jacob Alan Sussman and retained source notices; root's two conjectures; sole Astra worker's frozen exchange/convexity proofs; separate numerical implementer. Substantial OpenAI Codex assistance disclosed. No independent human/formal-kernel review is implied. diff --git a/research/controller-ceiling-convexity/audit/REPORT.md b/research/controller-ceiling-convexity/audit/REPORT.md new file mode 100644 index 0000000000..9296d38c24 --- /dev/null +++ b/research/controller-ceiling-convexity/audit/REPORT.md @@ -0,0 +1,65 @@ +# Independent audit of the PR5405 successor certificate + +**Decision: PASS_SCOPED_FIXED_FAMILY_CEILING.** The reviewed v3 arithmetic and the two frozen analytic notes establish the necessary-moment obstruction for the exact family defined by PR5405 equation (1), at source head `314b56a6c0056c2358538f072c6fde9d365be44d`, throughout `0.00302728825 <= kappa < 1`. No missing mathematical implication was found within that stated family. The original optimized-mode acceptance defect and a source-representation discrepancy were found during review and resolved transparently before this decision. + +This is a second mathematical/code review, independent of both the sole Astra theory worker and the numerical implementer. I read the source proof, both analytic notes, the numerical implementation and its remainder proofs, and the existing normal/optimized receipts. I did not execute the numerical checker, the author's DP or interval engine, a native/compiler/scientific replay, Lean, or a construction search. The metadata checks in `AUDIT-CHECKS.json` only inspect already retained JSON, AST and hashes. No public write or selected-result change occurred. New review material is confined to this directory. + +## Exact reviewed objects and source binding + +The exchange note has SHA256 `0e575a88d28db5aecc5ccf24504923a0508ff976d05f92e91e6d48408b7688ea`; the discrete-convexity note has SHA256 `bdad476f31b450e1ac4d1fd0d9530b43e33ebac48accc0956b38a9634b40a929`. Their frozen copies and original local files were preserved. + +The final numerical directory is `outputs/controller5405-exact-successor-20261024/`. Reviewed final hashes: + +| Object | SHA256 | +|---|---| +| `check_ceiling.py` | `8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01` | +| `PROOF.md` | `b0aff27dd9203ef42e5b8898d6659819205f13c1d251ff043564fcab656bf7f4` | +| `receipts/arithmetic-v3.json` | `32d3adfc837ba4f66c899e7cb23adea441a3af48d96700f2e14e6c9f8b1c6729` | +| `receipts/arithmetic-v3-optimized.json` | `6d4b1c890bed07576ef4f76c47e27ce9effe903b7646f650f0092c03c69a6bda` | +| `FINAL-MANIFEST-v3.json` | `40a066e930adc821acf08fe6652f38626ef8c776ba111c8b7b8205ec2fa91841` | + +I fetched `research/global-query-controller-ceiling/PROOF.md` independently through the GitHub connector from `aliromman/integer-mult-bounds` at the exact head. Its real Git blob is `5ad89d4ba1836d47798bdb856e3726c70a7b1922`, independently recomputed from the returned 10,029 bytes. Its SHA256 is `77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b`. The retained monitor proof is 10,030 bytes, SHA256 `5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37`, and equals the exact upstream bytes plus one LF. This is an exact representation bridge, not byte-identical upstream retention. There is no mathematical text change. Both the connector response and the bridge are retained here; the numerical owner also added an explicit bridge and exact upstream copy without altering the frozen monitor. + +The six guidance files AGENTS, CONTRIBUTING, autoresearch, agent-procedure, current-priorities and research-family-status were checked through `git show` at canonical `1ec1119972c9aefe42525172d07b332fcff81cb4` in `swarm-provider-audit-sol-high-20261024/repository`. Their SHA256 values agree with the numerical worker's frozen guidance manifest. The task is an expressly assigned bounded audit; root owns fresh overlap, publication and repository packaging. + +## Mathematical chain + +1. **Actual equation and census: PASS within the source premise.** The local contribution is exactly `nL+112(2p+1-n)`. Each retained idle contributes the three terms specified in equation (1), with zero-rank paid idles omitted. Reading the right side from its outside endpoint reverses its pair order exactly as required by the suffix definition; the central bit belongs to neither side prefix. Setting `J=p+sum g` gives `E=224J+112+(L-112)n-224f(1+8n)`. Thus fixed-n comparisons genuinely cancel only fixed-n terms. This checks the invoice algebra; it does not independently derive the Laurent/native construction supplying equation (1). + +2. **Pair exchanges: PASS.** With `delta(z)=f(z+1)-f(z)`, deleting 00 changes J by `-1+delta(8k)<=0`; exchanging 01 for 10 changes it by `f(8k+8)-f(8k)-f(8)<=0`. Splitting 11 into 10,10 changes it by `1+f(8k+16)-f(8k+9)-f(8)<0`: the seven-unit increment on `[8k+9,8k+16]` is at most the increment on `[9,16]`, strictly less than that on `[1,8]`. The added pair includes two new paid QUERY stages, represented by the +1 in J. All moves preserve n and later partial FULL counts. Replacing each original pair terminates and leaves only 10 pairs; no illicit fixed-p constraint is assumed. + +3. **Unpaired transfers and small counts: PASS.** A QUERY side end with a first 10 pair can absorb its FULL bit while deleting that pair, changing J by `-1+delta(8)<0`. Any remaining QUERY endpoint lies on an empty side. A last donor 10 pair can then fill such an endpoint or the center, changing J by `-1+delta(8k)<0`; its removal affects no later donor count. A donor exists whenever `qL+qR=n-(l+r+c)>0`. Consequently n>=3 gives all three unpaired positions FULL, `qL+qR=n-3`, `p=n-2`; n<=2 gives p=1 with all n FULL bits unpaired. In particular n=0 is exactly E=112 for every original p, not an omitted logarithmic corner case. + +4. **Balancing and attainment: PASS.** With FULL side ends, a q-pair side contributes `F(q)=-sum(k=2..q+1)delta(8k)`. Its increments `-delta(8(q+2))` strictly increase. A side-count imbalance at least two can be strictly improved by transferring the final pair to the shorter side. The balanced split is therefore attained and minimizes every fixed-n invoice over all allowed p, splits and masks. Reflected balanced masks agree; equality moves at zero FULL prefixes mean this does not establish uniqueness of the minimizing original mask. + +5. **Strict discrete convexity and gate: PASS on every n>=0.** Put `A_n=f(8n+9)-f(8n+1)`. This strictly decreases. The first differences are `D_n=L-112-224A_n` for n=0,1,2, and `D_n=L+112-224A_n-224delta(8 floor((n+1)/2))` for n>=3. The first side correction is delta(16), repeated twice. The only junction has `D3-D2=224[1-delta(16)+A2-A3]>0`; later second differences are strictly positive because the A difference is strict and the delta correction nonnegative. The affine L term cancels. Hence `C18>0, D17<0, D18>0` prove `C_n>=C18>0` for all n>=0. Strict neighbor signs make 18 the unique minimizing FULL count. Neither the author's n>=96 tail nor its 10,290,000-state DP is a dependency of this successor implication. + +6. **Directed arithmetic and remainder proofs: PASS by code/derivation review.** The new code uses integers on Q=2^256 and exact Fraction tails, with correct sign reversal for subtraction/integer scaling and reversed endpoints for positive reciprocals. The atanh-log truncation after 128 terms has the stated positive geometric remainder `2 z^(257)/(257(1-z^2))`; directed term recurrence encloses the finite sum. Range reduction gives z in `[0,1/3]`. The positive exponential Taylor sum through degree64 has remainder at most `Xhi^65/65!/(1-Xhi/66)`. Its recurrence rounds each multiplication/division outward; the reciprocal then bounds `r exp(-kappa log r)`. The r=0,1 values are exact. All finitely requested positive ranks are integers at most161, so the range `0<=kappa0 log r<1` is also analytically closed; the code checks its outward version explicitly. No floating value enters acceptance. The already executed v3 normal/optimized receipts have identical proof-relevant JSON and the same exact arithmetic endpoints as v2. + +7. **Full saving interval: PASS by a separate whole-invoice argument.** Delete 00 pairs at the t under consideration, preserving a no-greater invoice and n. For n>=1 normalize the fixed reduced invoice by 8^t. Its QUERY coefficient is `112(2p+1-n)>=0`; the main target base is `n+1/8>1`. Every reduced side summand is `h^t+e-(h+e+1/8)^t`. For h>=1 its t derivative is negative since `z^t log z` increases on z>=1. When h=0 reduction forces e=1 and gives `1-(9/8)^t`, also strictly decreasing. In `L/8^t`, the only positive derivative term is less than `7 log(8/7)<1`; the negative rank-one term alone has magnitude greater than `2193 log8/8>274`. All remaining derivative terms are nonpositive. Thus the normalized reduced whole invoice strictly decreases with t. Positivity at t0 persists for `0 0.000000014914967918767741908079 +D17 < -0.271338621904872494155700553536 +D18 > 0.022748156490424972863108432493 +``` + +These displayed bounds are exact decimal rationals. Finer integer/Q endpoints are in the receipts. My metadata inspection checked those recorded exact endpoint signs, equality of normal/optimized mathematical fields, and the recorded 456 symbolic mask/split checks, 11 canonical checks and five rejection controls. It did not re-evaluate powers. + +## Resolved review findings and trust boundary + +**Optimized acceptance defect resolved in v3.** In reviewed v2 code SHA256 `3352d5c6dd0da6e988efcab7b6a8cfd5ff85655390bef472523e7022db431cd9`, the three-sign gate, coefficient equalities, domain guards and control checks were assertions and would vanish under `python -O`. I notified root and the numerical owner. V3 replaces every assertion with explicit require/raise; AST inspection finds no Assert node. The direct normal and optimized executions retain every acceptance predicate and agree in all proof-relevant output. Earlier code/receipts are preserved as earlier versions; their normal-mode numeric endpoints remain valid, while they must not be represented as optimized acceptance evidence. + +The source +LF discrepancy is resolved by the explicit exact-byte bridge above and in the numerical v3 packet. No frozen input was repaired silently. + +The checker and manifests are trusted Python/source artifacts, not a formal-kernel certificate or a self-authenticating adversarial verifier. A source file and its self-reported digest are not independent authority; this audit's external fixed hashes and the package worker's separate Git-origin/export checks supply that boundary. The arithmetic engine's correctness is justified by the directed-rounding/remainder review, not by interval overlap checks alone. Small symbolic controls check indexing and mutations; the all-n claims rest on the analytic proof. Broader publication and package integrity remain root/package-worker gates. + +## Remaining implications and next questions + +There is **no remaining blocker for this scoped mathematical ceiling**. Broader claims would still lack an independently repeated derivation of the autonomous P/H profile and equation (1) from all claimed native/physical programs, the complete source construction and its five framework assumptions, physical legality of arbitrary masks, compiler/supplier admission and any complete multiplication theorem. This audit does not validate PR5398 by comparison and does not establish the exact supremum in the tiny gap below kappa0. It establishes no physical/global optimum, new kappa, native-query lower bound, or transfer to changed/coupled PR5402 outputs. + +The next useful step is the isolated package's exact-source, export and final claim review. No further arithmetic is needed to finish this audit. Reopen the mathematical decision for a concrete counterexample or changed source/formula; reopen construction work only with an explicitly changed provider/consumer, stage-rank, graph or idle-law premise and a complete bill. + +Credit Ali Romman for PR5405's family, invoice and original unbounded proof/DP; Cinna Davis for the paired path/query controller; Cao Yifan, zxv, Chris R/Clear1nsight, Dugongue, Jacob Alan Sussman and the retained native/helper/compiler/analytic contributors. Root proposed the exchange and discrete-convexity conjectures, and the sole Astra worker supplied the two frozen theory notes. The numerical worker supplied the independent rational engine and executed receipts. This separate review was prepared with substantial OpenAI Codex assistance, under Apache-2.0 for new material. It is not an independent human or formal-kernel review. diff --git a/research/controller-ceiling-convexity/audit/SOURCE-BRIDGE.json b/research/controller-ceiling-convexity/audit/SOURCE-BRIDGE.json new file mode 100644 index 0000000000..dd2f7c4e3e --- /dev/null +++ b/research/controller-ceiling-convexity/audit/SOURCE-BRIDGE.json @@ -0,0 +1,18 @@ +{ + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "source_repository": "aliromman/integer-mult-bounds", + "source_path": "research/global-query-controller-ceiling/PROOF.md", + "upstream_git_blob": "5ad89d4ba1836d47798bdb856e3726c70a7b1922", + "upstream_bytes": 10029, + "upstream_sha256": "77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b", + "local_monitor_path": "outputs/upstream-monitor-resume-20261024/5405-PROOF.md", + "local_monitor_bytes": 10030, + "local_monitor_sha256": "5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37", + "exact_transformation": "local_monitor_bytes = upstream_bytes + one ASCII LF byte", + "mathematical_text_identical": true, + "upstream_git_blob_hash_independently_recomputed": true, + "frozen_monitor_unchanged": true, + "connector_receipt": "SOURCE-FETCH.json", + "connector_receipt_sha256": "4771e2948b448e5488bdb33a872e49ce0251c8acff5c294e70c5544d0f2e95f2", + "status": "PASS_TRANSPARENT_REPRESENTATION_BRIDGE" +} diff --git a/research/controller-ceiling-convexity/audit/SOURCE-FETCH.json b/research/controller-ceiling-convexity/audit/SOURCE-FETCH.json new file mode 100644 index 0000000000..4aec8029ba --- /dev/null +++ b/research/controller-ceiling-convexity/audit/SOURCE-FETCH.json @@ -0,0 +1,16 @@ +{ + "content": [ + { + "type": "text", + "text": "Action completed." + } + ], + "structuredContent": { + "content": "# A ceiling for every prefix/suffix FULL/QUERY allocation\n\n## Result and scope\n\nFix the bidirectional local profiles from PR5392:\n\n```\npaid P = {1:2193, 2:412, 3:510, 4:127, 5:40}\nhelper targets H = {4:28, 7:7, 8:47, 9:318}.\n```\n\nA full stage has 112 main ports and a fresh block of rank eight. A query stage\ncosts 112 H1 jobs and has no helper targets. Use the paired path controller\nwith any integer p >= 1, any split 0 <= a <= p-1, and b = p-1-a. Keep the\nfirst a initial idle windows, all middle idle windows, and the last b terminal\nidle windows. Each of the 2p+1 stages can independently be FULL or QUERY.\nSpecialize D_s=1 at each QUERY stage in both the main and idle products.\n\n**Theorem.** Every invoice in this family has paid moment greater than target\nmoment for every `0.00302728825 <= kappa < 1`. Thus this entire family fails\nthe necessary strict moment test in that range. The result includes arbitrarily\nmany pairs, every split, and all stage masks. It is not restricted to a small\nnumber of changes from the current mask.\n\nThis is an upper bound for the invoices defined by (1) and the strict moment\nmethod. A different target list or idle law is outside the theorem. It is\nnot a lower bound for all native circuits or all multiplication algorithms.\nIt does not raise kappa. In particular, it does not prove the physical validity\nof every masked word, a new compiler bound, or an unconditional multiplication\ntheorem. We grant the listed diagonal jobs to the entire family. A member that\nfails a separate native or endpoint requirement cannot evade this ceiling.\n\nThe local profile is a premise supplied by PR5392. The source receipt is retained\nbyte for byte. The complete source construction and its five framework assumptions\nare not re-proved here. PR5398 uses the same recursive profile and reports complete\nconditional kappa .00302728823. Its distance from this universal family ceiling\nis less than 2e-11. This comparison does not independently admit PR5398.\n\n## 1. Complete interval invoice\n\nPut t=1-kappa, f(r)=r^t for r>0, and f(0)=0. Define\n\n L(t) = sum_r P[r] f(r) - sum_r H[r] f(r).\n\nWrite x_s in {0,1} for the FULL indicator of stage s, and\n`n=sum_{s=0}^{2p} x_s`. The local and query part of paid minus target is\n\n 112(2p+1) + (L(t)-112)n.\n\nThere are 224 full-path main targets of rank 1+8n. For j=1,...,a, put\n\n h_j = sum_{s=0}^{2j-1} x_s, e_j = x_(2j).\n\nFor j=a+1,...,p-1, put\n\n h_j = sum_{s=2j+1}^{2p} x_s, e_j = x_(2j).\n\nEach j contributes a retained whole idle of rank 8h_j, a main target of rank\n`1+8(h_j+e_j)`, and a middle idle of rank eight if e_j=1. Each multiplicity is\n224. Zero-rank idles are omitted. The complete difference is therefore\n\n E(t) = 112(2p+1) + (L(t)-112)n - 224 f(1+8n)\n + 224 sum_j [f(8h_j) + e_j f(8) - f(1+8(h_j+e_j))]. (1)\n\nThis includes every lost helper and every changed main and idle factor.\nIn particular, a FULL even stage restores its middle idle charge. The source\nLaurent controller supplies the prefix/suffix products. Substitution of D_s=1\npreserves any established source identity; it does not preserve a removed\nstage's helper credit.\n\nThe verifier compares (1), as separate paid and target histograms, with the\nretained literal Laurent controller on every mask for p=1,...,5 and every a.\nIt also compares the current p16/a7 invoice with the retained PR5392 receipt\nand the separate main diagonal in `joint-helper-lattice/CONTROLLER.json`.\nThese checks bind the general formula to the source family. They are not a\nnative admission of all p or a proof from finite examples.\n\n## 2. An infinite tail becomes finite\n\nFor 0=0 and e in {0,1},\n\n f(8h) + e f(8) - f(1+8(h+e)) >= -1. (2)\n\nFor e=0, use `f(z+1)-f(z) <= f(1)=1`. For e=1, use\n`f(z+8+1) <= f(z)+f(8)+f(1)`. There are p-1 summands. Equation (1) gives\n\n E(t) >= B_t(n) := 336 + (L(t)-112)n - 224(1+8n)^t. (3)\n\nAt `kappa_0 = 0.00302728825`, exact outward rational arithmetic proves\n\n B_t(96) > 104.185162541469147567554569434096,\n B_t'(96) > 5.188985973480417120924401618389.\n\nHere `B_t'(n)=L(t)-112-1792t(1+8n)^(t-1)`. Since t<1, this derivative\nincreases with n. Thus every n>=96 has E(t)>0, for every p and split.\nThe program uses a lower bound for L and an upper bound for the power in\nboth comparisons. No floating tolerance is used.\n\nIt remains to bound p when n<=95. Read the left side in the order\n`x_0,(x_1,x_2),...,(x_(2a-1),x_(2a))`. Read the right side from the opposite\nend in the same form. The central stage is `x_(2a+1)`. If a side pair has\nboth indicators zero, delete that pair and reduce p by one. The full-stage\ncount n and every later partial count stay fixed. The two removed queries\nreduce the first term in (1) by 224. The removed summand is\n\n -224 [f(8h+1)-f(8h)] >= -224.\n\nThe deletion therefore cannot increase E. It produces another member of the\nsame invoice family after reindexing. Repeat until each remaining side pair\ncontains a FULL stage. Then `p-1=a+b <= n`, so p<=96. Consequently, positivity\nfor all p<=96 and n<=95, together with (3), proves positivity at kappa_0 for\nthe unbounded family. This reduction does not claim that deletion preserves\na particular caller's input set; it compares the optimistic invoices needed\nfor this ceiling.\n\n## 3. Exact dynamic program for the finite part\n\nFor a side with q pairs and k FULL stages, let D_q(k) be the minimum sum of\nits summands in (1), including their factor 224. The single end stage gives\n\n D_0(0)=D_0(1)=0.\n\nAppend the next odd/even indicators o,e in {0,1}. The recurrence is\n\n D_(q+1)(k+o+e) = min [D_q(k)\n +224 (f(8(k+o)) + e f(8) - f(1+8(k+o+e)))]. (4)\n\nThe minimum is over all predecessors. This follows directly from the partial\ncount before the even stage. Induction on q proves that (4) covers every side\nmask. States with k>=96 can be omitted because total FULL count cannot decrease.\n\nFor p=a+b+1, combine left count l, right count r, and central indicator c:\n\n 112(2p+1) + (L-112)(l+r+c) + D_a(l) + D_b(r)\n -224 f(1+8(l+r+c)). (5)\n\nDiscard only totals at least 96. Reflection exchanges a and b, so it suffices\nto check a<=b. The program checks p=1,...,96 and 10,290,000 state combinations.\nIt uses integer bounds on the exact grid 2^192. Positive terms use lower\npower bounds; negative terms use upper bounds. Taking a minimum of lower\nbounds remains a lower bound, so interval overlap cannot create a false\npositive certificate. The minimum certified lower bound is\n\n E(t) > 0.000000014914967918767741908079.\n\nIt occurs at p=16, a=7, with eight FULL stages on the left, nine on the right,\nand a FULL central stage. The receipt retains the exact rational bound and\nthe minimum for each p. Independent exhaustive mask enumeration through p=5\nagrees exactly with the integer dynamic-program minima.\n\nThe interval engine is the unchanged rational logarithm/exponential engine\nfrom `higher-moment-strictification`. The dynamic program is new. Neither is\na solver result, and no SciPy or floating arithmetic is used for acceptance.\n\n## 4. Extend the ceiling to all larger savings\n\nIt is not enough to reject one value of kappa. We now show that no larger\nvalue can become favorable in this family.\n\nFirst delete zero/zero side pairs as above, at the t under consideration.\nIf n=0, (1) gives E(t)=112, which is positive. Otherwise n>=1. Normalize (1)\nby 8^t. In a reduced side pair, h>=1 if e=0, while h>=0 if e=1. Its normalized\nsummand is\n\n h^t + e - (h+e+1/8)^t.\n\nFor h>=1 its derivative in t is negative, because `z^t log z` strictly\nincreases for z>=1. For h=0, reduction forces e=1, and the derivative of\n`1-(9/8)^t` is also negative. The normalized full-path target term has negative\nderivative, since n+1/8>1. The query term is nonnegative and nonincreasing.\n\nFinally the local term is strictly decreasing after the same normalization:\n\n L(t)/8^t = 2193(1/8)^t + 412(1/4)^t + 510(3/8)^t\n + 99(1/2)^t + 40(5/8)^t\n - 7(7/8)^t - 47 - 318(9/8)^t.\n\nIts only positive derivative term is less than `7 log(8/7) < 1`. The negative\nterm from `2193(1/8)^t` alone has magnitude at least `2193 log(8)/8 > 274`\non 0=1.\n\nTherefore a reduced invoice that is positive at t_0=1-kappa_0 remains\npositive for every 0 Contribute one useful, independently reviewable result to +> https://github.com/CrocSwap/integer-mult-bounds. Read AGENTS.md, autoresearch.md +> and CONTRIBUTING.md from the current main branch first. Use the repository's +> task-selection and overlap process unless I assigned a specific task. In a loop, +> fetch canonical main and recheck priorities at every round using the guide's +> checkpoint procedure; preserve in-progress work and frozen inputs. Work for +> one session of about 60 minutes unless I specify another budget, keeping the +> final quarter for verification and a concise handoff, +> and report the exact scope, evidence, remaining obligations and predecessor +> credit. You may post routine claims, questions, findings, handoffs and feedback +> in Discussions and open a focused PR without asking me again for each action. +> Do not merge, close others' PRs or change the selected frontier. + +Maintainers should update the catalogue when new evidence changes priorities. +External donation prompts should point here rather than freeze a second set of +weights, frontier values or supposedly open problems. + +Prepared by Douglas Colkitt with OpenAI Codex assistance. Apache-2.0. diff --git a/research/controller-ceiling-convexity/canonical/certificates/selected-result.json b/research/controller-ceiling-convexity/canonical/certificates/selected-result.json new file mode 100644 index 0000000000..b288ae4403 --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/certificates/selected-result.json @@ -0,0 +1,92 @@ +{ + "status": "Selected maintainer-reviewed conditional PR4610 construction, with independent PR5241 admission evidence and explicit inherited foundation reuse", + "kappa": "15108879/5000000000", + "decimal": "0.0030217758", + "source_prs": [ + 4610, + 5241, + 4470, + 4447, + 4441, + 4440, + 4416, + 4433, + 4359, + 4268, + 3945, + 4085, + 2979, + 4076, + 4088, + 1673, + 1758, + 1786, + 23, + 555, + 589 + ], + "source_manifest": "certificates/frontier4610-source.json", + "certificate": "certificates/frontier4610/CLAIM.json", + "certificate_sha256": "c48376a8365a4c7b67adb368bafa128bede4cd5589a41fa276f96a350d45606c", + "proof": "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md", + "proof_supplements": { + "notes/batched-bit-rows.tex": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c", + "notes/batched-complex-rows.tex": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c", + "notes/compact-control-movement.tex": "b963c3d2f4e1b7059aa289bb4b4ac89b688920bcf42f5b20d7698cdef0132cc6", + "notes/general-clifford-frames.tex": "c9bb9655b594583c6b4bab8cb485233f1d1e588f83858cf1e4c3530cee8fed54", + "notes/stopped-product-complex.tex": "4738089103a4b263b3b0ef458f5ef35519c696f1ea871ae79e508d3720f5870a", + "notes/three-stage-cover-bit.tex": "47123a756f823c83a0d48cca2bf5add6472cd88410b13aed345e70c8834fb511", + "notes/three-stage-cover-rows.tex": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8", + "references/semantic-bulk/pr23/semantic-bulk-17-note.tex": "652242b05174bb776ffc6165af170df9c8cf220dbd0fc26c24d778f320dbabc8", + "research/e8-bit-carrier-skeleton/code/bit/export_records.py": "8a5999601f917dbb492bb9ae9a344611f18cc7cedc53dc3c76496a369e530eb3", + "research/e8-bit-carrier-skeleton/code/nine/geometry.py": "36eeda3184bd009e89462b65c8725d10860c444f8da8f1f87e5f6e50120011ca", + "research/e8-bit-p111-tuned/code/gen_p3.py": "438b83f10d70ceca7cf78049420204b7de2dc61682f913c50a62596106ad84cd", + "research/e8-bit-p111-tuned/code/xcheck_p.py": "af3decc877e27c00001cf56f50c6c09566e8e101297ab34c7860aed96a06d80e", + "research/e8-bit-p111-tuned/tune/EXPECTED.json": "b9f0e5ca038abe837b0007c8fe006f366a6f02009244ac57705a8a200e2301f4", + "research/e8-bit-p111-tuned/tune/apply.py": "806ae4cb2648e4f05dcf56bd089891fd3ba33a6ee5fe76d3329e322c6770c1a1", + "research/e8-bit-p111-tuned/tune/wlib.py": "a37fdf3cdf5f62945c2a90193401c0e9edc9dd3cda8d8cb36a3b9c329ebe4dbc", + "research/t74-native-fast/vendor/native/new/code/borrow/vendor/clifford/clifford_exact.py": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962", + "docs/research/pr-intake-evidence/pr4359/PROOF-REVIEW.md": "7d67bb814285f7634029fbd378c6457156545f0b38858cc1c6ec34b68cd9d162", + "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md": "5c111dd56beb53dc44ab727d96e1af03aaf50f3023d4342e2b0a89ede6cf585b", + "docs/research/pr-intake-evidence/pr4416/PROOF-REVIEW.md": "2c2bbe6fe1bab44778192118f27e59a0d23dbe02c47aa8a42845093f1ce46f49", + "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md": "b84f833e3072cbab372fbda2ece98fbc031c15e590cf73003ddea35a5222e148", + "research/final4610-independent-admission/PROOF.md": "e573cbbe6fa5481c0533e773de404e10f4dc7907b5ebfe404bdcd02dcf9844d8", + "research/final4610-independent-admission/SPECIALIZATION.md": "70430114f744108223bc1d44b98bc25b696c4b408b7b044c2a8bbdfdb434ac5c" + }, + "review": "docs/research/pr-intake-evidence/pr4610/PROOF-REVIEW.md", + "validation": "docs/research/pr-intake-evidence/pr4610/VALIDATION.json", + "integration": "docs/research/pr-intake-evidence/pr4610/INTEGRATION.json", + "reproduce": "make frontier4610-verify", + "scope": "Maintainer-reviewed conditional PR4610 construction using the PR5241 independent audit. The five PR4470 framework assumptions are unchanged. Uniform words are not materialized.", + "previous_kappa": "60403/20000000", + "previous_record": "certificates/checkpoints/frontier4470.json", + "audited_source_head": "20bb93cd990d2ff683e4d0fc56b87a42cd5d3296", + "source_certificate": "research/kappa-round6-compiler-tightening-20261022/ARITHMETIC.json", + "source_certificate_sha256": "b4f720a7ccbb5b46e472eaf85dc8739a40598986f19b37d26c4f9ecfbd31f0de", + "replay_mode": "Fresh complete independent admission replay; source-bound preceding controller, ordinary BIT and physical/compiler foundation reuse", + "contributors": "docs/research/community-native4610-contributors.md", + "assumptions": [ + { + "id": "native_all_columns", + "statement": "Retained native operators, phase conventions, spectators and whole-job adapters work at every positive column multiplicity." + }, + { + "id": "owned_erasure", + "statement": "Owned streams and suspended centers obey the retained allocation, erasure and ownership contracts." + }, + { + "id": "compiler", + "statement": "The finite mixed-target compiler and chronological product, completion and splitting satisfy the retained uniform closure contract." + }, + { + "id": "precision_tape", + "statement": "Retained fixed-tape movement and precision/storage prescriptions apply to the new fixed finite template." + }, + { + "id": "analytic_recovery", + "statement": "Analytic decomposition, fine-prime avoidance and exact integer recovery follow the retained upstream/outer framework." + } + ], + "audit_pr": 5241, + "audit_head": "13efb5fc5f3b7c14ec2cfa181dd9eb6480972cf2" +} diff --git a/research/controller-ceiling-convexity/canonical/docs/research/agent-task-catalog.json b/research/controller-ceiling-convexity/canonical/docs/research/agent-task-catalog.json new file mode 100644 index 0000000000..f126dd2e2d --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/docs/research/agent-task-catalog.json @@ -0,0 +1,1242 @@ +{ + "schema_version": 1, + "priority_revision": 7, + "priority_log": "docs/research/research-priority-log.md", + "assessed_on": "2026-10-20", + "status": "Research suggestions, not reservations or assertions that these questions are unclaimed. Check current main and live PRs.", + "tracks": [ + { + "id": "bit-mechanisms", + "weight": 20, + "tasks": [ + { + "id": "bit-helper-contract", + "question": "Can one precisely specified helper-mixing word satisfy a replacement for the inherited H2/K interface?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/r439-bsection-stars-seed01/README.md", + "research/r439-copy-path-sharing-barrier/README.md" + ], + "methods": [ + "Derive a replacement interface lemma and price its implementation.", + "Seek an exact dirty-input or chronological-cut counterexample to the proposed replacement." + ], + "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/r439-bsection-stars-seed01/verify.py" + ], + "expected": "PASS_R439_BSECTION_STARS", + "inspect": "Compare the two false H2/K flags with the unchanged paid profile in its README.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write one replacement H2/K implication for a single helper-star operation, then try to falsify it on dirty inputs.", + "bottleneck_link": "A legitimate replacement could admit a cheaper bit circuit; scalar savings alone do not alter the selected moment.", + "allowed_variations": [ + "Choose one helper-star or quartet instance; narrow to one boundary implication." + ], + "scope_change_triggers": [ + "Changing only source count or scalar addition count without an interface argument." + ], + "overlap_terms": [ + "H2_D_frame0_targets_from_helpers", + "K_equals_D", + "helper-star" + ] + }, + { + "id": "bit-new-register-model", + "question": "Can an explicitly larger or nonabelian register model escape the scoped three-register obstruction?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/bit-three-register-lower-bound/README.md", + "certificates/selected-result.json", + "research/bit-gl3-mixed-targets-length10/README.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct the smallest exact identity in a newly specified legal operation alphabet.", + "Derive a target-specific relaxation bound for that same explicit alphabet." + ], + "acceptance_gate": "Name the changed hypothesis, all counted roles and a uniform identity; finite column tests alone do not certify it. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read Model section 1 of the three-register bound and identify the exact excluded free operations.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "First compare the alphabet, role count and length with the fully replayed #1974 census and #2027 mixed-root tariff. Identify a changed premise and a legal native implementation; then price one smallest completed instance before searching larger words.", + "bottleneck_link": "A small-width completed saving changes the bit primitive; a finite-address identity alone is insufficient.", + "allowed_variations": [ + "Choose a fixed larger register count or a specified nonabelian operation family." + ], + "scope_change_triggers": [ + "Remaining inside the already-excluded three-register abelian model.", + "Repeating the two-register GL3 census or a covered three-register length without changing a hypothesis; a formal group-algebra word without native conversion is a partial result." + ], + "overlap_terms": [ + "three-register", + "nonabelian", + "group algebra" + ] + }, + { + "id": "r437-carrier-integration", + "question": "Can the paid R437 two-window carrier improvement be admitted by the actual pooled compiler and physical caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/r437-two-window-carrier/README.md", + "research/r437-reverse-row-coefficient/README.md" + ], + "methods": [ + "Close one compiler/request, caller or precision/stock implication for the pinned paid exchange.", + "Falsify that exact interface with an arbitrary-dirty-state or chronology counterexample." + ], + "acceptance_gate": "Pin the complete source and destination contracts, exact paid and scalar deltas, and all remaining assumptions. A local moment gain is not a physical or all-size supplier admission.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4067 paid profile and open integration obligations; #4147 covers the reverse row coefficient. Three additional ADDs per call and all helpers remain charged. This is not a selected supplier.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Choose one unclaimed obligation: pooled compiler codebook/request alignment, actual physical caller, or precision/stock envelope using the already reported reverse coefficient. Pin the input and receiver, preserve dirty/source windows, and test one binding with a rejection control. Stop at unresolved dependencies; do not rederive the coefficient or quote the local moment as a completed bound.", + "bottleneck_link": "The exchange changes the paid profile; integration must establish that its gain survives the complete caller.", + "allowed_variations": [ + "One compiler rebind, one actual caller boundary, or one precision/stock implication." + ], + "scope_change_triggers": [ + "Ignoring added ADDs, retaining an obsolete reverse coefficient, or declaring global admission from the local histogram." + ], + "overlap_terms": [ + "R437", + "two-window carrier", + "4067", + "4147", + "pooled compiler", + "request alignment", + "reverse row coefficient" + ], + "existing_checks": [ + { + "scope": "PR #4067: source-bound two-window carrier with (2,2) to (1,3) paid exchange and fixed OQ4 host.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Pooled compiler/request rebind, physical caller and precision/stock admission.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4147: reverse row coefficient follow-up.", + "evidence": "research/r437-reverse-row-coefficient/README.md", + "remaining": "Use the exact coefficient in a caller-bound precision/stock proof rather than repeat the arithmetic.", + "status": "author-checked", + "source_commit": "72e7bb797adf82aeb525a399f56ab8adbab8e93c", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + } + ] + }, + { + "id": "complex-mechanisms", + "weight": 20, + "tasks": [ + { + "id": "p104-side-correction", + "question": "Can a changed P104 producer/consumer contract escape the scoped slot, chart and completion obstructions with a favorable full bill?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/p104-literal-slot-defect/README.md", + "research/p104-uniform-commutation-gap/README.md", + "research/p104-uniform-encoding-gap/README.md", + "research/p104-source-chart-shortcut/README.md", + "research/p104-fiber-tag-seam/README.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the named successor obstructions before extending #2981 static flags. Distinguish literal-slot action, commutation, uniform encoding, source-chart shortcut and fiber-tag seam scopes; none excludes all P104 mechanisms.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Name one hypothesis changed from these exact interfaces. Write a literal producer-to-consumer timeline and an arbitrary-dirty-input positive/control pair, then charge acquisition, coefficients, completion, hosting and restoration. Stop if the same slot/fiber mismatch persists or the favorable full budget already fails. A scoped independent audit remains useful; another static count is not a new completion.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier.", + "Repeating a correction or physical conversion already supplied by a pending follow-up without adding independent coverage or a different unresolved obligation.", + "Repeating the 208-flag static matching or calling a static nested cover a chronological correction program. Independent audit of that certificate is distinct and remains useful.", + "Repeating a static cover, source-chart shortcut or fiber-tag seam without changing the hypothesis responsible for its obstruction." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991", + "2586", + "endpoint transport", + "physical dual", + "relay composition", + "2981", + "joint unit flags", + "acquisition delivery", + "static nesting", + "4133", + "4136", + "4140", + "4153", + "4154", + "p104-literal-slot-defect", + "p104-uniform-commutation-gap", + "p104-uniform-encoding-gap", + "p104-source-chart-shortcut", + "p104-fiber-tag-seam" + ], + "existing_checks": [ + { + "scope": "PR #4133: literal-slot defect", + "evidence": "research/p104-literal-slot-defect/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "88666f1dee93fbd85b31fd5d6f91a219e111b5f4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4136: uniform commutation gap", + "evidence": "research/p104-uniform-commutation-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "281ce601a8be9db470de630759179c23e1dfaa88", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4140: uniform encoding gap", + "evidence": "research/p104-uniform-encoding-gap/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "de25c6525aa866962309df5d107b32d55e6e5628", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4153: source-chart shortcut exhausts its optimistic allowance", + "evidence": "research/p104-source-chart-shortcut/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "9123241fea53df77e51ffe30d9aca1625d4bf3a8", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4154: fiber-tag seam mismatch", + "evidence": "research/p104-fiber-tag-seam/README.md", + "remaining": "Independently validate the stated scope or change its producer/consumer premise and pay the complete boundary.", + "status": "author-checked", + "source_commit": "4ffcdaee5d6255a9cea1fe53a5424435068089d0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json", + "research/selected-k8-unrestricted-ends/README.md" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + } + ] + }, + { + "id": "recursive-interfaces", + "weight": 20, + "tasks": [ + { + "id": "joint-query-controller", + "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/qq16-caller-install/README.md" + ], + "methods": [ + "Derive the matched whole-caller physical bill for installed and baseline protocols.", + "Change the actual demanded observations and prove a cheaper legal producer/consumer contract." + ], + "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.", + "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.", + "allowed_variations": [ + "One paid query, one changed first pair, or one precisely specified affine helper state.", + "A counterexample or lower bound for that exact proposed repair.", + "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain." + ], + "scope_change_triggers": [ + "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.", + "Treating cover-map counts as zero-cost physical address operations.", + "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.", + "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.", + "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.", + "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving." + ], + "overlap_terms": [ + "QQ16", + "joint-query", + "changing-chart controller", + "selected observation", + "1969", + "2540", + "early record", + "output-bank retention", + "complete native decoder", + "2965", + "producer defect", + "dirty-helper range", + "F17 consumer", + "4166", + "qq16-caller-install" + ], + "existing_checks": [ + { + "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.", + "evidence": "research/qq16-caller-install/README.md", + "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.", + "status": "author-checked", + "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "centre-path-sharing", + "question": "Can the 64-per-call centre path (eight rank-8 COPY/ERASE totals through the private temporary) be shared across calls or shrunk?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/split-centres-global/proofs/PR386-BIT-GEOMETRY.txt", + "certificates/selected-result.json" + ], + "methods": [ + "Derive a fully charged favorable relaxation for sharing one centre path across k calls, including restoration, hosting and precision.", + "Prove a lower bound on copied information per call for the selected decoder contract." + ], + "acceptance_gate": "Show the changed centre charge and copy profile per call with every added restoration or hosting cost charged, and its ceiling via ceiling.ceiling(centre=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Write the per-call centre charge and copy children for sharing across k = 2 calls, charge the sharing overhead, and screen it; stop this route if even the ideal sharing gains under 10%. Ideal budgets: free 2.80x, shared by two 1.90x (levers.py).", + "bottleneck_link": "The centre path consumes 64 of about 99.6 unpaid coordinates per call, i.e. about 64% of the raw deficit.", + "allowed_variations": [ + "One sharing pattern across a fixed number of calls.", + "One reduced copied-total contract for the existing decoder.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Removing copies without a replacement contract for the decoder's copied totals.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "centre path", + "copied totals", + "private temporary", + "shared centre", + "batching" + ] + }, + { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts." + ], + "overlap_terms": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment.", + "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + } + ] + }, + { + "id": "adversarial-audit", + "weight": 15, + "tasks": [ + { + "id": "selected-stock-envelope", + "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "starting_points": [ + "research/selected-bootstrap-stock-audit/README.md", + "research/bootstrap-cutoff-time-space-split/README.md", + "certificates/selected-result.json", + "docs/research/community-efficient1000-review.md", + "research/stock-margin-chain/README.md" + ], + "methods": [ + "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.", + "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope." + ], + "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2972 stock-margin chain and the selected stock audit. The new source archive reports the remaining cutoff comparisons, but leaves every actual stock coefficient unresolved; it is not an independently validated reserve envelope.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.", + "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.", + "allowed_variations": [ + "One stage or one explicit reserve/depth implication.", + "An independently checked same-domain proof repair, retaining all remaining assumptions." + ], + "scope_change_triggers": [ + "Importing the historical 57604 or 252 allowance without a selected-producer binding.", + "Calling a conditional fit lemma a full outer-proof adoption.", + "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality." + ], + "overlap_terms": [ + "selected stock", + "stock envelope", + "bootstrap cutoff", + "1956", + "1965", + "1990", + "2972", + "stock-margin-chain", + "actual_stock_coefficient" + ], + "existing_checks": [ + { + "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.", + "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation", + "remaining": "Derive one actual reserve/depth coefficient from the selected producer.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "supplier-boundary-audit", + "question": "Can the #4088 four-provider dispatch satisfy the complete ordinary/outer admission contract?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/scatter-boundary-decision/README.md" + ], + "methods": [ + "Trace one hypothesis through the source, checker and complete caller.", + "Construct one semantically invalid but superficially well-formed fixture and test rejection." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4088 Scope and Open next questions: local words, native receipts and literal fill do not include a rerun of the mixed four-provider ordinary/outer engine. #3801 is the newer scatter-boundary decision; do not restart #2977 as if untouched.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Pin the provider registry, four native source closures and dispatch. Make a bounded acceptance coverage map or one registry adapter preserving every inherited admission predicate and rejection control (including an omitted fourth provider). Record remaining ordinary/outer obligations and a resource estimate before heavy execution. Stop at unresolved source/caller dependencies; no selected-result promotion from a local pass.", + "bottleneck_link": "Closing a current acceptance gap or proof obligation strengthens reliability even without changing kappa.", + "allowed_variations": [ + "One provider-registry, dispatch, native-closure or admission-predicate obligation; separate branches must name distinct coverage." + ], + "scope_change_triggers": [ + "Reporting the historical timing-only diagnostic as a new current acceptance bug.", + "Calling a malformed mutant a failure of the selected construction, or importing an opt-in repair without testing the exporter boundary.", + "Running another root enclosure instead of validating dispatch or weakening an inherited predicate to make mixed admission pass." + ], + "overlap_terms": [ + "owner boundary", + "bridge omission", + "hosting", + "2977", + "scatter export", + "duplicate index", + "parity semantics", + "4088", + "3801", + "staged544-mixed-fourth-entry", + "scatter-boundary-decision" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "uniform-transfer-audit", + "question": "Does one quantified step of the proposed #4100 all-size construction hold at its actual caller?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Prove one missing implication with explicit quantified hypotheses.", + "Find an exact counterexample at the claimed interface boundary." + ], + "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read PROOF.md and AUDIT.md in #4100. Select one distinct obligation: CRT total repair, native/free-algebra lifting, precision/conditioning, or complete fixed-tape cost. This is an author-submitted proof, not an accepted unconditional theorem.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Check live handoffs; name one proposition, its caller, quantified domain and dependency closure. Independently prove the implication or exhibit a precise gap/counterexample. Prioritize CRT.md total repair or COMPLEX.md free-algebra lift only if unclaimed. Stop at the chosen obligation; do not substitute finite samples or root arithmetic for an all-size proof, or launch the complete package by default.", + "bottleneck_link": "Finite supplier improvements are useful only under the retained transfer obligations.", + "allowed_variations": [ + "One CRT repair, native lift, precision/conditioning or tape-cost proposition, with its exact caller." + ], + "scope_change_triggers": [ + "Replacing a quantified obligation with another finite smoke test.", + "Treating archive intake, an author PASS receipt or a finite composed fixture as discharge of the universal hypotheses." + ], + "overlap_terms": [ + "uniform transfer", + "all-size", + "precision", + "4100", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "census-pruning-audit", + "question": "Does the reported word-census parity-pruning error invalidate a specific exclusion we still rely on, and what bounded repair is justified?", + "starting_points": [ + "research/f7-weight-parity-census-correction/README.md", + "docs/research/research-family-status.md" + ], + "methods": [ + "Independently reconstruct the tiny counterexample and trace one affected exclusion to its exact pruning code.", + "Compare corrected and unpruned enumeration on a small exhaustive domain, then audit the changed pruning implication." + ], + "acceptance_gate": "Pin the old and proposed corrected engines, distinguish a disproved pruning rule from a disproved final bound, and state exactly which downstream exclusions need revalidation. #2973 is an author-checked source archive; neither its new f(7) claim nor all old conclusions are automatically accepted or rejected.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2973 error description and MATH.md; manually reconstruct the prefix states of 01021323 before running any large census.", + "scope": "Source-binding orientation only; no full enumeration or mathematical validation." + }, + "first_experiment": "Reconstruct the eight prefix states of 01021323 and compare bit-0 versus Hamming-weight parity budgets independently. Trace the reported false prune to one pinned predecessor (#2542, #2634 or #2691), then test a small exhaustive domain. Stop after a source-impact handoff or corrected-prune proof; a full seven-label replay needs a separate resource budget and a named research decision it can change.", + "bottleneck_link": "An unsound exclusion can wrongly close a mechanism; correcting its dependency boundary is more useful than extending the same census.", + "allowed_variations": [ + "One predecessor pruning rule, one independently exhaustive small domain, or one downstream dependency audit." + ], + "scope_change_triggers": [ + "Launching a larger census before validating the prune and explaining which active decision it changes.", + "Treating a small-domain counterexample to the old rule as a counterexample to every reported seven-label bound." + ], + "overlap_terms": [ + "2973", + "2542", + "2634", + "2691", + "weight parity", + "bit-0", + "01021323", + "census pruning" + ] + } + ] + }, + { + "id": "independent-verification", + "weight": 10, + "tasks": [ + { + "id": "independent-moment", + "question": "Does a new paid-profile or mixture-ceiling claim have independent source-bound coverage of its actual changed ledger?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-mixed-fourth-entry/README.md", + "research/staged-fourth-mixture-ceiling/README.md", + "research/r437-two-window-carrier/README.md" + ], + "methods": [ + "Independently reconstruct one changed paid ledger or pooled dual with exact source and model binding.", + "Check a genuinely uncovered moment implication with a different enclosure method and semantic controls." + ], + "acceptance_gate": "Demonstrate independence, source binding, positive cases and semantic failure controls. Name the existing checks and the missing coverage. More digits or another equivalent evaluation of an unchanged root is not by itself new verification coverage.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Choose one uncovered implication in #4088 literal mixed fill, #4091 pooled dual/model binding or #4067 changed frame/host bill. #4091 pins an earlier #4088 head: validate word, capacity and stock equivalence before applying that ceiling to the later fill.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Independently reconstruct one changed ledger or pooled certificate with a positive case and a semantic failure control. Compare exact sources and name what existing checks miss. Keep this separate from supplier-boundary-audit (ordinary/outer dispatch) and uniform-transfer-audit (all-size proof). Stop after the chosen implication; more digits of an unchanged root are not additional mechanism coverage.", + "bottleneck_link": "Independent pricing prevents unsupported frontier claims and can reveal genuine accounting slack.", + "allowed_variations": [ + "Reconstruct either a source ledger or a numeric enclosure with a different method." + ], + "scope_change_triggers": [ + "Importing the primary function and calling its output independent verification.", + "Calling an aggregate histogram or source archive an independently accepted physical supplier." + ], + "overlap_terms": [ + "independent moment", + "rank histogram", + "exact enclosure", + "2979", + "rank7 joint endframes", + "paired extraction", + "joint lowering", + "4088", + "4091", + "4067", + "staged544-mixed-fourth-entry", + "staged-fourth-mixture-ceiling", + "r437-two-window-carrier" + ], + "existing_checks": [ + { + "scope": "PR #4088: mixed local/owner/phase ledger and moment reported.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Independent binding of changed construction to paid histogram, distinct from full admission.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4091: sharp pooled ceiling proposed for fixed THREE/FOUR words and inventory.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Validate dual, exhaustive pattern scope and exact source equivalence before applying to newer fills.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4067: paid (2,2) to (1,3) exchange and fixed OQ4 host reported.", + "evidence": "research/r437-two-window-carrier/README.md", + "remaining": "Independent full cost delta; remaining caller/precision/stock obligations are separate.", + "status": "author-checked", + "source_commit": "a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "formal-interface-lemma", + "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/gate-operand-parity-lean/README.md", + "research/staged544-certified-endpoint/README.md", + "research/unconditional-batched-crt/README.md" + ], + "methods": [ + "Formalize a missing boundary lemma identified by the selected review.", + "Audit a formal theorem-to-certificate binding independently." + ], + "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Inventory the gate-operand parity lemma (#3807) and certified endpoint arithmetic (#3857). Neither is a full multiplication proof. For #4100, audit the compact-switch statement and its hypotheses before formalizing it.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.", + "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.", + "allowed_variations": [ + "Narrow to one formal lemma or one theorem-to-certificate binding." + ], + "scope_change_triggers": [ + "Formalizing already-covered arithmetic and claiming the full multiplication theorem." + ], + "overlap_terms": [ + "hyperplane end", + "formal interface", + "Lean binding", + "3807", + "3857", + "4100", + "gate-operand-parity-lean", + "staged544-certified-endpoint", + "unconditional-batched-crt" + ], + "existing_checks": [ + { + "scope": "PR #3807: scoped gate-operand parity formalization.", + "evidence": "research/gate-operand-parity-lean/README.md", + "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.", + "status": "author-checked", + "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3857: certified real-power moment/endpoint arithmetic.", + "evidence": "research/staged544-certified-endpoint/README.md", + "remaining": "Uniform algorithmic implications, not another endpoint digit.", + "status": "author-checked", + "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4100: compact-switch formalization proposed as future validation.", + "evidence": "research/unconditional-batched-crt/README.md", + "remaining": "Audit the statement and assumptions before a formal proof campaign.", + "status": "author-checked", + "source_commit": "337d04939571a637aeab54a0f58f54fde811663a", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + } + ] + }, + { + "id": "verifier-engineering", + "weight": 8, + "tasks": [ + { + "id": "replay-runtime", + "question": "Can one measured replay bottleneck be sped up without dropping coverage?", + "starting_points": [ + "scripts/run_isolated_tests.py", + "scripts/verify_replay_coverage.py", + "certificates/selected-result.json" + ], + "methods": [ + "Profile one isolated replay and optimize the measured bottleneck.", + "Design source-bound reuse with explicit dependency invalidation and negative controls." + ], + "acceptance_gate": "Report before/after wall time on the same fixture, retained checks and invalidation behavior.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the selected reproduction command and choose a single replay stage for profiling.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Measure one unchanged fixture, preserve check coverage, and test one optimization with invalidation controls.", + "bottleneck_link": "Faster trustworthy replays increase review throughput and let mechanism candidates be checked sooner.", + "allowed_variations": [ + "Profile one stage or design one source-bound cache boundary." + ], + "scope_change_triggers": [ + "Skipping coverage or comparing different fixtures to claim speedup." + ], + "overlap_terms": [ + "replay runtime", + "cache invalidation", + "isolated tests" + ] + }, + { + "id": "portable-replay", + "question": "Can one reproducible environment or artifact-comparison failure be repaired?", + "starting_points": [ + "research/gzip-container-reproducibility/README.md", + "docs/ci-verification.md" + ], + "methods": [ + "Reproduce one portability failure and add a minimal cross-environment fix.", + "Audit one canonical-payload comparison for omitted proof-relevant fields." + ], + "acceptance_gate": "Preserve immutable source hashes and proof-relevant content; a different compressed byte stream alone is not a mathematical mismatch.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the gzip-container reproducibility examples and distinguish frozen source bytes from regenerated payloads.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Reproduce one specific mismatch or audit one canonical comparison for omitted proof-relevant fields.", + "bottleneck_link": "Portable exact checks prevent environment failures from blocking valid contributions.", + "allowed_variations": [ + "One interpreter/version mismatch or one payload field comparison." + ], + "scope_change_triggers": [ + "Removing immutable-source pins because generated compressed bytes differ." + ], + "overlap_terms": [ + "gzip container", + "reproducibility", + "canonical payload" + ] + } + ] + }, + { + "id": "consolidation", + "weight": 5, + "tasks": [ + { + "id": "overlap-receipt", + "question": "What exact content and credit of a small named PR set has already been retained?", + "starting_points": [ + "docs/research/pr-ledger.md", + "CONTRIBUTORS.md" + ], + "methods": [ + "Compare exact heads and retained artifacts to write a source-bound disposition receipt.", + "Audit an existing receipt for missing content or predecessor attribution." + ], + "acceptance_gate": "Separate complete integration, partial retention and changed heads; make no autonomous closures.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read one small PR set in the ledger and identify exact reviewed heads and unresolved content.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Compare that set to retained artifacts; produce a complete or explicitly partial disposition receipt.", + "bottleneck_link": "Reliable overlap evidence preserves credit and prevents repeated review of already-retained material.", + "allowed_variations": [ + "One small related PR family or one existing integration receipt." + ], + "scope_change_triggers": [ + "Treating matching titles or one shared blob as proof of full incorporation." + ], + "overlap_terms": [ + "overlap receipt", + "partial integration", + "attribution" + ] + }, + { + "id": "scope-navigation", + "question": "Can one misleading historical-current claim or missing research cross-reference be corrected?", + "starting_points": [ + "docs/research/current-status.md", + "docs/research/pr-ledger.md", + "certificates/selected-result.json" + ], + "methods": [ + "Trace one confusing path from onboarding to its authoritative source.", + "Index one tightly related family of obstructions with explicit excluded and open hypotheses." + ], + "acceptance_gate": "Produce evidence-backed navigation, preserve historical records and avoid a duplicate global survey.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Follow one link from the selected record to its review and compare a potentially stale historical claim.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Repair one confusing path or produce a scoped map of one related obstruction family.", + "bottleneck_link": "Clear navigation lowers entry cost for central research; a global survey without a concrete fix is not required.", + "allowed_variations": [ + "One historical-current ambiguity or one bounded family index." + ], + "scope_change_triggers": [ + "Rewriting frozen scientific packages just to change their historical wording." + ], + "overlap_terms": [ + "current status", + "historical checkpoint", + "scope navigation" + ] + } + ] + }, + { + "id": "incumbent-optimization", + "weight": 2, + "tasks": [ + { + "id": "selected-packing", + "question": "Does a named residual packing task have meaningful uncovered headroom after its exact fixed-inventory ceiling?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged-fourth-mixture-ceiling/README.md", + "research/staged544-mixed-fourth-entry/README.md" + ], + "methods": [ + "Check a fixed-inventory ceiling and source equivalence before any explicitly bounded residual search.", + "Price a genuinely changed word/interface under a newly applicable model." + ], + "acceptance_gate": "Check live overlap and exact model/source binding first. Distinguish a chronological construction from a pooled optimum. State the applicable fixed-inventory ceiling and remaining headroom; changed words or interfaces require a new fully charged model. Do not launch a residual search without an explicit scope and time cap.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #4091 fixed-word pooled ceiling and #4088 later 1090-call literal fill. Bind the unchanged local invoices/capacities/stock before transferring the ceiling; its earlier 1080-call residual-bin recipe is historical.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Default to a bounded headroom/source-equivalence check. Only start residual search with an explicit unclaimed domain, time cap and reason the tiny remaining gain matters. Otherwise hand off or select a changed-word mechanism. A changed word or interface needs a fresh cost model, not the old ceiling. Stop at the fixed-inventory cap; do not extend by new random seeds.", + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing", + "4091", + "4088", + "staged-fourth-mixture-ceiling", + "staged544-mixed-fourth-entry" + ], + "existing_checks": [ + { + "scope": "PR #4091: pooled optimum at one-third staging for pinned fixed words; not a chronological fill.", + "evidence": "research/staged-fourth-mixture-ceiling/README.md", + "remaining": "Independent scope/source check; any residual optimization is explicitly bounded and optional.", + "status": "author-checked", + "source_commit": "a29bdd8f56cd18b805917775cdec09ff935eddc4", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4088: later 1090-call literal fill improves the earlier 1080-call witness.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Complete admission remains separate; old residual-bin instructions must not be copied blindly.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + { + "id": "scalar-to-moment", + "question": "Can a changed frame itinerary remove a paid transition beyond the already covered scalar A2 contractions?", + "starting_points": [ + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "research/staged544-a2-graph-rewrite/README.md", + "research/staged544-separated-a2/README.md", + "research/staged544-a2-composition-audit/README.md", + "research/staged544-a1858-contraction-audit/README.md" + ], + "methods": [ + "Derive the changed legal frame itinerary and exact child histogram.", + "Prove a scoped obstruction showing why that scalar gain cannot change the paid contract." + ], + "acceptance_gate": "An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the A2 and separated-A2 constructions and their composition/contraction audits. Scalar contractions can preserve the complete recursive histogram; fewer ADDs alone do not justify further scans.", + "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately." + }, + "first_experiment": "Identify an actual paid transition to remove and construct a legal replacement frame itinerary, charging restoration, source windows and changed helpers. Compare complete before/after histograms. Stop if only scalar count changes; report that benefit honestly, without expanding the same scalar-only census.", + "bottleneck_link": "A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.", + "allowed_variations": [ + "One existing scalar simplification and one proposed frame-path change." + ], + "scope_change_triggers": [ + "Submitting only another scalar count as completion of a paid-profile task." + ], + "overlap_terms": [ + "scalar simplification", + "paid profile", + "R439", + "3998", + "4019", + "4112", + "4152", + "staged544-a2-graph-rewrite", + "staged544-separated-a2", + "staged544-a2-composition-audit", + "staged544-a1858-contraction-audit" + ], + "existing_checks": [ + { + "scope": "PR #3998: consecutive A2 scalar contraction", + "evidence": "research/staged544-a2-graph-rewrite/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "389268a6b5e0373a3125d5c6fcd6995f4ea324f5", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4019: separated A2 sites with unchanged recursive histogram", + "evidence": "research/staged544-separated-a2/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "f408e09df300b575235f7f77f81948071397e16d", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4112: composition audit", + "evidence": "research/staged544-a2-composition-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "205b7380656ba4b6316a8a493b1a3c679b8f7a0e", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #4152: A1858 contraction audit", + "evidence": "research/staged544-a1858-contraction-audit/README.md", + "remaining": "A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.", + "status": "author-checked", + "source_commit": "caaa14cde5962adc372fdca71f63d0f29e73c8b2", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + } + ] + } + ], + "selection_context": { + "refreshed_on": "2026-10-22", + "kappa": "60403/20000000", + "source_pr": 4470, + "record": "certificates/selected-result.json", + "review": "docs/research/pr-intake-evidence/pr4470/PROOF-REVIEW.md", + "orientation_command": "python3 -B scripts/research_selected_baseline.py", + "scope": "Metadata refresh only. Revision-7 weights and cards remain historical suggestions pending separate strategic reassessment; check current contracts and overlap before adopting them." + } +} diff --git a/research/controller-ceiling-convexity/canonical/docs/research/coordination.md b/research/controller-ceiling-convexity/canonical/docs/research/coordination.md new file mode 100644 index 0000000000..96db59be31 --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/docs/research/coordination.md @@ -0,0 +1,137 @@ +# Posting updates and optional board metadata + +Start with [handoffs #1166](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +before drawing a task. Follow the [standing procedure](agent-procedure.md) and +check prose-only posts too. Structured metadata improves retrieval; it is not +required for participation, a reservation, or evidence of scientific review. + +## Post from a file + +The standard donation prompt authorizes routine Discussion participation. Respect +any narrower user instructions. The helper does not grant account permissions. + +```sh +python3 scripts/post_update.py --discussion 1166 --body-file /tmp/handoff.md --dry-run +python3 scripts/post_update.py --discussion 1166 --body-file /tmp/handoff.md +# reply-to is a DiscussionComment node ID, not a PR number or URL fragment. +python3 scripts/post_update.py --discussion 1166 --reply-to DC_NODE_ID --body-file /tmp/reply.md +``` + +The helper fixes the destination repository to CrocSwap/integer-mult-bounds, +checks that a reply belongs to the requested discussion, rejects nested replies +before any mutation with the parent comment ID and URL, and sends UTF-8 text +through JSON variables, preserving newlines and literal shell characters. +It returns the created comment ID and URL. `--dry-run` makes no network calls. +It never retries a mutation: after an uncertain response, inspect the discussion +before repeating the command. Routine status changes belong in the original +post; this helper adds a comment/reply and does not edit existing comments. + +No public message is needed merely to test this helper; use its mock tests and +dry run. Opening a PR, reviewing it, and merging it remain distinct actions. + +## Optional structured footer + +End a canonical CLAIM, HANDOFF, FINDING, DONE or RELEASED post with **one** +fenced JSON block. Alternatively pass the JSON file with `--metadata-file`. +The helper validates it and appends it to the prose. + +```json +{ + "schema": "integer-mult-coordination/v1", + "kind": "HANDOFF", + "task": "p104-side-correction", + "scope": "One chronological correction program for the pinned endpoint flags", + "base": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "expiry": null, + "artifact": "https://github.com/CrocSwap/integer-mult-bounds/pull/2981" +} +``` + +Use an exact 40-character source/base commit. `artifact` is a public HTTPS URL or +null; null does not make local evidence publicly reproducible. CLAIM requires an +offset-aware ISO timestamp in `expiry`, normally about two hours ahead. Expired +claims do not reserve work. HANDOFF remains open until its canonical block is +edited to DONE/RELEASED; update the prose and block together. A short session +expected to finish within an hour may skip an advance claim, after checking +overlap. Claim a handoff when taking it, likely overlapping work, and work +continuing across sessions. Never manufacture a retrospective claim. + +DONE means the author reports that scoped work finished. It does not mean +accepted, independently verified, closed, merged, or a new selected result. +The reader does not allow a separate DONE post to cancel somebody else's claim. +Edit the canonical block; link it from replies and hub threads. A claimed task +can still benefit from an explicitly independent audit. + +## Read existing cached metadata + +```sh +python3 scripts/find_overlap.py 'correction program' --cache /tmp/overlap.json --refresh +python3 scripts/choose_research_task.py --coordination-cache /tmp/overlap.json +``` + +The picker reuses the overlap cache; it does not fetch the board again. It shows +handoffs and claims next to matching cards, with URLs, expiry and freshness. +Missing/incomplete snapshots or those older than 15 minutes are flagged. +It does not automatically change track weights, suppress tasks, or infer that +unstructured discussions are inactive. Multiple/malformed metadata blocks are +reported, not silently treated as valid claims. Task IDs should match the +catalogue where possible; a genuinely different scope can use a descriptive ID. + +## Local overlap coverage + +`find_overlap.py` searches working-tree `research/*/README.md`, +`research/*/TASK.json`, and `docs/research/pr-ledger.md`. A sparse checkout can +omit most of these notes even when both remote snapshots are complete. +`coverage.local` records the searched count (`records`), the pinned `head`, +and the count of regular note files tracked there (`head_records`). +In `--json` output, `unsearched_head_paths` lists every tracked note path absent +from the searched corpus. Text output shows `unsearched_head_paths_count` to +avoid printing thousands of omitted paths. Omissions produce a warning even +with no matches or `--limit 1`. +They can arise from sparse checkout, ordinary deletion, or a skipped symlink; +the report does not infer the cause. Materialize relevant missing notes and +rerun the search before relying on their coverage. + +`complete_head_inventory` is true only when every in-scope regular HEAD note +path was searched. It is false for known omissions and null when Git or the +HEAD inventory is unavailable, with an explicit warning. A complete empty +inventory has count zero and completeness true. This compares paths, not +content identities: local edits and untracked notes remain searchable, so +`records` can exceed `head_records`. Nested vendor notes, arbitrary package +files, and historical versions remain outside this local search. Git tree +metadata is inspected without reading omitted blobs or expanding the checkout; +local coverage is computed on each invocation and is not stored in the remote +cache. Regression fixtures cover full, non-cone sparse, and cone sparse-index +checkouts in `tests/test_research_overlap_local.py`. + +## Changed-path overlap snapshots + +A `find_overlap.py --path PATTERN` report binds each file inventory to both +`head` and `base` commits. GitHub's changed-file pages depend on both endpoints; +a fixed head and unchanged file count do not by themselves identify one diff. +Every continuation page must preserve both OIDs and the advertised count. A +mismatch rejects that refresh and retains the previous cache with a warning. + +Joined path results show `head`/`base` for the file snapshot, +`body_head`/`body_base` for PR metadata, and separate `head_matches` and +`base_matches` flags. Check both flags and `truncated`. Coverage also lists +`unverified_heads` and `unverified_bases`, even when no path matches the query. +It also lists PRs with unavailable file lists or advertised-count shortfalls +in `truncated_prs`, with a warning even when those PRs do not match +the requested path or fall outside `--limit`. A true `complete_pagination` +means the list paging finished; it does not mean every PR's file inventory +is complete. Term-and-path intersections retain each match's `truncated` flag. +A missing legacy base remains unknown; it is never copied from another snapshot. +Online path queries refresh endpoint-incomplete sources. Offline or failed +refreshes keep the old evidence and explicitly report the missing binding. +Body-only searches do not pay for the file index. + +This is a consistency check, not an atomic GitHub snapshot, a diff-content +search, proof of novelty or scientific review. A base can advance between +requests even when its head does not; recheck relevant live PRs before claiming +work. The same-head/same-count base-change regression is in +`tests/test_research_pr_file_pages.py`; migration and joined-report controls are +in `tests/test_research_pr_base_binding.py`. + +Tekalign, with substantial OpenAI Codex assistance, extending the retained +changed-file pagination and head-binding work. Apache-2.0. diff --git a/research/controller-ceiling-convexity/canonical/docs/research/current-priorities.md b/research/controller-ceiling-convexity/canonical/docs/research/current-priorities.md new file mode 100644 index 0000000000..b4ece97a60 --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/docs/research/current-priorities.md @@ -0,0 +1,164 @@ +# Current research priorities + +This is the changing diagnosis and allocation; [autoresearch.md](../../autoresearch.md) +links the standing session procedure. Refresh this file and the task catalogue +at each research checkpoint. + +**Priority revision 7 — October 20, 2026**, assessed against main +`9200177938843d92957bbfe6f1fdbe88768d8cc5`. +**Selection refresh — October 23, 2026:** the +[selected conditional result](../../certificates/selected-result.json) is now +**κ = 0.0030217758 (#4610, independently audited in #5241)**. Read the +[changed-construction review](pr-intake-evidence/pr4610/PROOF-REVIEW.md) and +[contributor map](community-native4610-contributors.md). Cao Yifan's native/helper +changes retain the PR4470 controller and productive profile; Chris R / Clear1nsight +supplies the complete independent admission package. The same five framework +assumptions remain. This small improvement does not change the mechanism-search +allocation. Admission of this exact #4610 witness is complete; source-sensitive +follow-ups must use its final word and compiler parameters. +Use `python3 -B scripts/research_selected_baseline.py` for source-bound orientation; +the older `research_baseline.py` uses a historical balanced-transfer schema. +The revision-7 allocation below is retained pending a separate strategic review. +Its old-inventory ceilings, stale admission tasks and a/(1+a) conversion are +not constraints on this mixed-target selection. Check the selected assumptions +and latest handoffs before adopting an old card. + +**Keep broad mechanism exploration; update the exact missing work.** Roughly +60% of the portfolio remains on bit mechanisms, complex mechanisms and recursive +interfaces. The latest packages justify fresher assignments, not a measured +claim that any track has a higher success rate. Use the +[family record](research-family-status.md#revision-7-evidence-and-assignments) +for source pins, attribution, remaining obligations and stop rules. Check live +[handoffs](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +before selecting a card. + +| Card | Current evidence, author-checked unless stated otherwise | Next bounded decision | +|---|---|---| +| `uniform-transfer-audit` | #4100 proposed all-size construction | Audit **one** quantified implication at its actual caller: CRT total repair, native/free-algebra lift, precision/conditioning, or fixed-tape cost. Independent acceptance is absent. | +| `supplier-boundary-audit` | #4088 mixed four-provider local construction | Rebind the ordinary/outer admission engine to all four providers and dispatch, preserving every predicate and rejection control. The full mixed engine has not been rerun. | +| `joint-query-controller` | #4166 actual QQ16 caller installation | Compare the complete matched parent park/restore and external-call protocols, retaining all later calls; or change the actual demand to remove paid work. The native-component profile loses. | +| `r437-carrier-integration` | #4067 paid two-window carrier; #4147 reverse coefficient | Close one pooled compiler/request, physical caller, or precision/stock obligation. Do not rederive the covered coefficient. | +| `p104-side-correction` | #4133/#4136/#4140/#4153/#4154 scoped slot, commutation, encoding, chart and fiber-seam objections | Name a changed producer/consumer premise, then test literal action, dirty restoration and the fully charged boundary. Static flags alone do not supply it. | +| `independent-moment` | #4088 changed ledger; #4091 proposed fixed-inventory ceiling; #4067 paid exchange | Independently bind a changed mechanism to its bill or check the scoped pooled dual. More digits of the same root are not additional mechanism coverage. | +| `formal-interface-lemma` | #3807 gate-operand and #3857 endpoint formalizations | Target an uncovered interface statement. Audit the proposed compact-switch contract before a formalization campaign. | + +**Separate admission from proof audit.** #4088 needs finite/compiler integration; +#4100 claims to discharge all-size premises. Those are different tasks, and neither +is closed by checking the other's numerical root. Partition work by proposition, +caller and domain, with one canonical thread and exact source pins. A short session +can produce an acceptance coverage map, a counterexample or a single proved lemma. +A complete ordinary/outer replay or Lean build needs a separate resource budget; +no heavy run is part of default orientation. + +**Pause repetitive searches within a fixed invoice.** #4091 proposes a sharp +pooled ceiling for the fixed THREE/FOUR words and inventory. It is pinned to an +earlier #4088 revision: verify local-word, capacity and stock equivalence before +applying it to the later 1090-call fill. Its pooled witness is not a chronological +implementation. The `selected-packing` card now starts with this scope/headroom +check; any tiny residual search is explicitly bounded and optional. Changed words +or interfaces require a fresh model, not the old ceiling. + +Likewise, #3998/#4019 and #4112/#4152 cover scalar A2 contractions and related +audits. The `scalar-to-moment` card requires an actual removed paid transition, +a legal replacement itinerary and the complete cost delta. Stop if only scalar +ADD counts change; that may have a separate benefit, but does not justify a larger +κ-oriented scan of the same domain. + +**Local contributions remain welcome.** A checked partial identity, interface +lemma or scoped obstruction can be valuable without a complete supplier. Before +expanding a family, update its full producer/consumer ledger: proved costs, +constructive upper bounds, unknowns, and why the consumer does not repay the gain. +Unknown costs are not zero. Use the [five-point expansion gate](research-family-status.md#contribution-acceptance-and-family-expansion-are-different-gates). +This is an evidence checkpoint, not an approval queue or an extra reporting task. + +The selected stock coefficients remain a targeted audit obligation; cutoff +arithmetic does not provide them. For census and exporter work, check successor +corrections and their exact scope before repeating a tiny example. Independent +verification must name missing coverage. The reviewed #1995/#2013 fixed-word +frame bounds, #2017 fixed-model C=40 result and #1974 bounded census remain scoped +predecessors, not universal barriers. The maintainer's older product checkpoint +also remains local-only evidence as labelled in the family record. + +**Retained selected-profile diagnosis (revision 3; scoped arithmetic independently replayed for #1240 and #1264).** This paragraph and its lever table concern the frozen selected profile, not the changed #4088 words or every possible supplier. On the binding complex side, a ≈ D/E: + +- **D is small.** Each call has about 99.6 live families. The coverage identity leaves one unpaid + coordinate per family, and the centre path then takes back 64. Only about 35.6 of 7,232 paid + coordinates per call remain unpaid. +- **E comes from small children.** The effective child rank is about 3.9, and rank-1 children are + about half of the recursive cost. + +[The packing ceiling](../../research/complex-local-word-ceiling/README.md) caps every hosting, owner or +idle repacking of the selected word at **+0.87%** (κ < 0.001687203). The open-claim census in #1264 +finds no covered claim able to pass κ ≈ 0.0016873 by packing. Its leading claims use paid local profiles with +*lower* relaxation caps than the selected profile; this does not compare attainable packing optima. + +A target-scale gain must change the structure. Ideal one-at-a-time budgets (`levers.py`): + +| Lever | Ideal primitive-saving ceiling multiplier | +|---|---:| +| Centre path free | 2.80× | +| Centre path shared by two calls | 1.90× | +| Rank-16 local children | 2.31× | +| Two unpaid coordinates per family | 3.77× | +| Centre free and rank-16 combined | 6.5× (κ cap ≈ 0.0109) | + +These are favorable relaxations, not expected gains. Screen any changed local profile with +`ceiling.ceiling()` before building a network when its coverage law and halving guard apply. +For a changed interface outside those hypotheses, state the replacement model and derive its own +fully charged optimistic moment bound; do not force it into the incumbent calculator. + +For a supplier with width `m`, role count `W`, and `n_r` children of rank `r`, +price the **whole completed construction**, including its additional charges: + +\[ +\frac1W\sum_r n_r(r/m)^{1-a}<1. +\] + +The useful small-saving diagnostic is `a < D/E`, where +`D = mW − Σ n_r r` and `E = Σ n_r r log(m/r)` (when `E > 0`, before extra +charges). The exact moment is the acceptance test. Fewer scalar additions alone +do not imply a better moment or multiplication exponent. + +Under the retained limiting balanced transfer `κ = a/(1+a)`, the ambitious +`κ > .01` objective needs both effective supplier budgets above approximately +`1/99`, with strict margins and all interface hypotheses. This is a planning +target, not a theorem about every possible multiplication algorithm or a +minimum acceptable contribution. Supplier improvements and proof repairs are +valuable even when the other supplier prevents an immediate headline change. + +The helper allocates effort as follows. These are portfolio weights, not success +probabilities; the catalogue is the machine-readable source for assignments. +Revision 7 keeps the track weights: current evidence supports fresher tasks and +stronger expansion decisions, not a measured reason to reallocate the portfolio. +Prefer a live, unclaimed central handoff over a generic card when it matches your track or expertise; +record the scoped override and check overlap. + +| Track | Share | Useful outcome | +|---|---:|---| +| Bit mechanisms (`bit-mechanisms`) | 20% | A changed decoder/frame contract with a full paid budget | +| Complex mechanisms (`complex-mechanisms`) | 20% | A completed P104 correction or changed decoder with a favorable full bill | +| Recursive interfaces (`recursive-interfaces`) | 20% | A changed joint-query controller, centre path or coverage law with real eliminated work | +| Adversarial audit (`adversarial-audit`) | 15% | A selected stock envelope or another specific missing implication/counterexample | +| Independent verification/formalization (`independent-verification`) | 10% | A separately implemented check or scoped formal lemma | +| Verifier engineering (`verifier-engineering`) | 8% | Faster, reproducible checks with unchanged coverage | +| Consolidation (`consolidation`) | 5% | Evidence-backed overlap, attribution or navigation repair | +| Incumbent optimization (`incumbent-optimization`) | 2% | A genuinely new, fully priced improvement, reported against its packing cap | + +Before reopening a negative result, name the hypothesis you change. The +[eight-term decoder bound](../../research/complex-decoder-field-extension-seed44/README.md), +[frozen provider-catalogue bound](../../research/heterogeneous-owner-assembly/README.md), +[fixed connector alphabet](../../research/universal-connector-boundary/README.md), and +[three-register abelian bound](../../research/bit-three-register-lower-bound/README.md) +have restricted scopes. Do not repeat the excluded experiment; do not generalize +their conclusions to every architecture either. Read only the relevant evidence, +not the entire repository, before starting. + +For the five-source dirty connector, consult the +[call-count, tariff and contract map](five-source-connector-scope-map.md) +before repricing the original alphabet. The retained #2063 theorem already +optimizes every positive source/readout tariff; delivery cuts, paid frames and +pair-source operations have different boundaries and separately scoped results. + +For complex E8 decoder work, use the [decoder scope map](complex-decoder-scope-map.md) +to distinguish the eight-term all-pairs floor, the fixed-reader ninth-term +obstruction and the independent finite support lemma before refining a candidate. diff --git a/research/controller-ceiling-convexity/canonical/docs/research/research-family-status.md b/research/controller-ceiling-convexity/canonical/docs/research/research-family-status.md new file mode 100644 index 0000000000..743a1afcbc --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/docs/research/research-family-status.md @@ -0,0 +1,197 @@ +# Research family status and expansion decisions + +Revision 7, assessed 2026-10-20 against main +`9200177938843d92957bbfe6f1fdbe88768d8cc5`. +This is a navigation and decision record, not supplier admission or a complete +survey. **Selection refresh (October 22): κ = 0.00302015 (#4470).** The family survey below is historical; resolve current +sources and assumptions through [selected-result.json](../../certificates/selected-result.json). + +The newer package claims and intake receipts were read for this guidance update. +Their mathematics was **not independently replayed in this pass**. Merged archives +retain contributors' work; they do not certify the claims. Pin and validate any +pending dependency your work uses. Check live heads and handoffs before assignment. + +## Current leads + +| Family | Decision and next useful work | Stop / reopening condition | +|---|---|---| +| Proposed all-size proof #4100 | **Audit**, partitioned into CRT repair, native/free-algebra lift, precision/conditioning and tape costs. Name one proposition and actual caller. | Stop at a precise missing implication or proved scoped result. Finite checks do not discharge universal premises. Broaden only after that dependency is resolved. | +| Mixed four-provider construction #4088 | **Complete admission**, beginning with registry/dispatch and coverage of every ordinary/outer predicate and mutation control. | No frontier promotion from a local/root pass. Budget full execution separately after source/caller bindings are concrete. | +| QQ16 #4166 | **Narrow** to matched whole-caller protocol cost or changed source-compatible demand. Caller installation exists as an author-checked proposal; native-component comparison loses. | Stop if the full necessary inequality fails or remains unpriced. Reopen with a consumer/demand that removes paid work, retaining all later root calls. | +| R437 #4067/#4147 | **Integrate or audit** the paid carrier exchange at compiler/request, caller and precision/stock boundaries. | Reverse coefficient is already covered. No claim of global admission from local moment or fixed-host checks alone. | +| P104 successor interfaces | **Change premise or audit scope**: literal slots, commutation, encoding, source charts and fiber seams are now the relevant obstacles. | Stop repeated static counts or the same mismatched seam. Reopen with a changed producer/consumer and fully charged completion, not a new seed. | +| Fixed-inventory packing / scalar contractions | **Narrow** to source-bound ceiling checks or actual paid-transition changes. | No default fixed-invoice repacking or scalar-only scan. Residual packing is an explicitly bounded opt-in after its headroom is established. | +| New geometry and recursive boundaries | **Continue broad exploration**, roughly 60% of allocation. | Name the obligation that disappears, price the completed consumer and test a discriminating example before expansion. No universal exclusion follows from these families. | +| Selected stock and formal interfaces | **Retain targeted audits** of actual coefficients and uncovered caller-bound lemmas. | Cutoff comparisons and formal endpoint arithmetic do not replace uniform implementation proofs. | + +## Revision-7 evidence and assignments + +Each row is **author-checked source evidence**, not independent maintainer scientific +acceptance. Exact heads identify the retained contributions; package notices retain +full predecessor credit. The catalogue carries the same pins and selected-record hash. + +| PR / source | Retained head | Covered claim and remaining task | +|---|---|---| +| #4100, Cinna Davis — [batched CRT](../../research/unconditional-batched-crt/README.md) | `337d04939571a637aeab54a0f58f54fde811663a` | Proposed unconditional construction. Start independent audit at CRT.md total repair or COMPLEX.md free-algebra lifting if unclaimed; separate precision and tape-cost assignments. | +| #4088, Cinna Davis — [mixed fourth entry](../../research/staged544-mixed-fourth-entry/README.md) | `72d7efc181edb21806a878f174847c96dd410ab0` | 1090 fourth-entry calls with local/native/owner/phase evidence and conditional pricing. Full ordinary/outer four-provider admission remains open. | +| #4091, Ross Richardson — [pooled mixture ceiling](../../research/staged-fourth-mixture-ceiling/README.md) | `a29bdd8f56cd18b805917775cdec09ff935eddc4` | Proposed sharp fixed-inventory root ceiling near 0.001730980256. Pins an earlier #4088 head; check model equivalence before using it on the later fill. No chronological fill follows from its pooled witness. | +| #4166, Chris R / Clear1nsight — [QQ16 caller](../../research/qq16-caller-install/README.md) | `0b082d22a0e9a442d264ab0633e35ef26c790630` | Actual caller connection, with losing native-component bill and unresolved matched physical comparison. Preserve parent parking, external protocols, all retained calls and service costs. | +| #4067, Chris R / Clear1nsight — [R437 carrier](../../research/r437-two-window-carrier/README.md) | `a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e` | Paid (2,2)→(1,3) exchange, three added ADDs per call and fixed OQ4 host. Pooled compiler/request, physical caller, precision and stock remain. | +| #4147 — [reverse coefficient](../../research/r437-reverse-row-coefficient/README.md) | `72e7bb797adf82aeb525a399f56ab8adbab8e93c` | Use the covered reverse coefficient in the missing source-bound admission proof; do not repeat it as a new task. | +| #4133 — [literal slot](../../research/p104-literal-slot-defect/README.md) | `88666f1dee93fbd85b31fd5d6f91a219e111b5f4` | Scoped slot defect; changed literal action or independent audit required. | +| #4136 — [commutation](../../research/p104-uniform-commutation-gap/README.md) | `281ce601a8be9db470de630759179c23e1dfaa88` | Scoped uniform commutation gap; identify the changed interface. | +| #4140 — [encoding](../../research/p104-uniform-encoding-gap/README.md) | `de25c6525aa866962309df5d107b32d55e6e5628` | Scoped encoding gap; static representation is not uniform completion. | +| #4153 — [source chart](../../research/p104-source-chart-shortcut/README.md) | `9123241fea53df77e51ffe30d9aca1625d4bf3a8` | Shortcut exhausts its favorable allowance before other costs. Change the source/consumer premise to reopen. | +| #4154 — [fiber seam](../../research/p104-fiber-tag-seam/README.md) | `4ffcdaee5d6255a9cea1fe53a5424435068089d0` | Scoped tag/fiber mismatch, not a universal P104 obstruction. | +| #3998 — [A2 rewrite](../../research/staged544-a2-graph-rewrite/README.md); #4019 — [separated A2](../../research/staged544-separated-a2/README.md) | `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`; `f408e09df300b575235f7f77f81948071397e16d` | Scalar contraction is not a paid-profile gain. Next work must remove an actual paid transition. | +| #4112 — [composition audit](../../research/staged544-a2-composition-audit/README.md); #4152 — [contraction audit](../../research/staged544-a1858-contraction-audit/README.md) | `205b7380656ba4b6316a8a493b1a3c679b8f7a0e`; `caaa14cde5962adc372fdca71f63d0f29e73c8b2` | Check existing audit coverage before rediscovering the same local identity. | +| #3807 — [gate operand formalization](../../research/gate-operand-parity-lean/README.md); #3857 — [endpoint formalization](../../research/staged544-certified-endpoint/README.md) | `4c3530f42a6abcc48e7a6bcffd6c901911dc8269`; `ef4315b8caa605e47a2515004845eb2d2ed71a86` | Scoped formal results; choose an uncovered interface lemma, not another endpoint digit. | +| #3801 — [scatter decision](../../research/scatter-boundary-decision/README.md) | `911f8800ba7a4b03603ef62c5ffc6240e53cb5fd` | Successor acceptance-boundary work; consult it before repeating #2977. | + +**Assignment separation.** A #4100 proof auditor selects a proposition and caller; +a #4088 admission contributor selects a registry/predicate obligation; an independent +ledger reviewer selects a changed cost or dual certificate. These are distinct even +when they share a package. Check live claims, and do not launch full native, Lean, +Docker or all-history replays as orientation. Source-binding commands are not +scientific validation. Reassess after an independently resolved implication, +a complete-cost decision, changed supplier, or substantial new intake. + +Historical revision-5 inspected heads (preserved as predecessor context, not a +fresh statement of their GitHub status): + +- #2540: `630d557af5088f66b45c447969cee9576600e50b`, author **ywz65**. + The stated added invoice is 224 rank-one and 16 rank-eight children, 480 + native wrappers, 208 full-cover maps and 17,472 real scalar primitives. + Inherited F0/B1 costs are additional. It lists 224 owned output banks, + 16 early banks and local scratch; this is not a storage-saving claim. + Its retained lineage includes Ali Romman, starship-s, thakrarsagar, + Ross Richardson and the credited geometry/native sources. +- #2586: `7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1`, author **ywz65**. + The stated rank mass is 3,542, including 416 rank-one endpoint transports. + Frame-decreasing input/output conversions fall outside the stated monotone + owner contract. It credits #2497, #2551, Nick Petalas/#2550 and the retained + native/correction lineage. The other 102 forward rows remain Gram/2; + do not reinterpret this partial correction as a complete identity supplier. + +These predecessor inventories are reported claims, not invoices recertified here. The +source PRs retain full attribution and detailed limitations. Follow-up activity +already includes [QQ16 output-bank retention](https://github.com/CrocSwap/integer-mult-bounds/discussions/2617) +and [P104 endpoint fusion](https://github.com/CrocSwap/integer-mult-bounds/discussions/2619). +Their claims are advisory: check current status before independently taking +the same question. Neither thread is evidence of a stronger selected result. + +## Revision-6 handoffs: source archives awaiting independent validation + +Historical revision-6 assignments below are retained for provenance; the revision-7 table supersedes their default next tasks. The following exact heads are retained on the assessed main. Their intake +records certify source retention, not their mathematics. Credit stays with the +named contributors and all predecessor attribution in their packages. + +| PR / contributor | Retained head | Evidence and next bounded test | +|---|---|---| +| #2979, Dugongue / mdumitrean; builds on Jeremy Kothe's rewrites and the credited predecessor chain | `be191346391661f4d35fc0d1508d0a6029572576` | Reports 22 coordinated helper lowerings, five extra paired extractions, and κ ≈ 0.001729. Independently reconstruct one shared rank-7 group and its single-change control, then account for frames, idle widths, cleanup buffers, chronology and both supplier caps. | +| #2981, Nick Petalas | `3d24b92d8ba057b57cb2d480170ec407520e6882` | Reports a matching of 208 departure and arrival flags. Use one collection as a calibration fixture for chronological source acquisition, coefficient delivery and restoration; it does not refute stronger program-level lifetime bounds. | +| #2965, Nick Petalas | `526f2c242202b31b15e09a7502dfb8ff757b2bad` | Reports completed-output defect transfer, not producer interiors. Pin one literal producer, derive its intermediate magnitude/dirty-state ledger and output defects, and include the F17 consumer's physical costs. | +| #2972, Hiroki KUMAZAKI | `d6b883f97d2fd176171553b695005a132156d961` | Reports the remaining cutoff comparisons; every actual stock coefficient is unresolved. Bind one reserve recurrence to the selected implementation. | +| #2977, Nick Petalas | `cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2` | Reports XOR multiplicity versus exporter membership semantics on duplicate scatter entries, plus an opt-in guard. Reproduce the tiny mutant and selected unique-row control; decide and test the production boundary contract before adoption. | +| #2973, Nicholas Stone | `d48f3945dbb1ef5d06835744c4082b3bd04181c0` | Reports a bit-0 versus weight-parity pruning error in #2542/#2634/#2691. Independently reconstruct `01021323`, trace the exact affected rule and compare a small exhaustive domain. Do not infer that every old final bound is false, or that the replacement f(7) claim is independently verified. | + +**Stop and expansion rules.** Finish one specified implication, counterexample +or source-impact handoff. For P104/QQ16, stop implementation expansion if legal +access, restoration or the complete cost allowance is unspecified or fails; +a static certificate or output-error inequality cannot fill those gaps. For +#2979, unresolved admission dependencies warrant a bounded audit handoff, not +an automatic new lowering census. For #2973, a full seven-label replay requires +its own resource budget and a named decision it can change. Check live follow-ups +before taking any of these tasks; no new full replay, Lean or Docker run is a +default orientation step. + +Continue independent geometry and interface exploration. These local claims +justify fresher tasks, not a universal obstruction or a measured reallocation +of the portfolio. Reassess after independent validation, a complete-cost rejection, +a changed selected supplier, or the next substantial intake. + +## Local product checkpoint: lesson and limits + +The maintainer branch `research/paired-interface-round-20261014` has audit commit +`4b44c26ba` and strategy checkpoint `aff5269d0`. At this assessment those commits +are local-only; this page does not pretend to provide reproducible public access +to their packages. Do not cite this paragraph as an independently checked proof. +When available, consult `research/product-preparation-audit/` and its pinned +predecessors before relying on the obstruction. + +The reported scalar/frame constructions reduced a particular two-pass excess +bill from about 16,732 to 12,587 to 10,440. Its optimistic allowance is 7,068, +before other product costs. A scoped normalization proof exhausts retiming +within the fixed source-preserving graph, common kernel frames, nesting and +endpoints. It does not exhaust changed graphs, source-consuming programs, +general frames, coupled coordinates or every product decoder. Dirty-response +compensation by a legal consumer, central readout and full native/supplier +admission remain unproved. + +The actionable process lesson does not require accepting that theorem: +**a sequence of local cost improvements is not evidence that the complete +construction fits.** Retain useful modules, but require an explicit expansion +decision before assigning further dependent optimizations. Do not redirect +the whole community into this local product branch. + +## Contribution acceptance and family expansion are different gates + +**A contributor may finish one useful subproblem.** A checked local identity, +counterexample, interface lemma, cost bound or independent audit can merit a +focused PR without a complete supplier or a new kappa. State the exact result, +dependencies and remaining obligations. No additional standalone session report +is required. A handoff without a PR is also useful. + +**Expanding a family requires an explicit research decision.** This is an +evidence checkpoint, not an approval queue. A solo or looping agent can make +and record the decision in its existing task/thread; no new permission or +separate director agent is required. Before another large search, +implementation expansion or round of downstream optimization, update the +canonical investigation thread or this record with: + +1. The exact source heads, declared target and current evidence status: + reviewed, independently reproduced, author-checked, proposed or local-only. +2. A boundary specification: inputs, outputs, frames, owned/borrowed state, + required reads, dirty compensation and eventual restoration. +3. A complete obligation ledger. Mark each cost **proved**, **constructively + upper-bounded**, or **unknown**. Unknowns are not zero. A favorable optimistic + relaxation can keep an idea open but cannot admit a supplier. An unfavorable + relaxation may reject its stated model. +4. Why the next subtask can change the decision: what work disappears, what + replaces it and why it does not return in the consumer or cleanup. Explain + the cost allowance for a missing module before optimizing that module. +5. Continue, narrow, expand, pause or replace; a bounded next test; a stop rule; + and the evidence that would reopen a paused route. Compare a different + mechanism before continuing solely because existing code is easy to extend. + +Design exploration is allowed before a constructive upper bound exists. Its +deliverable is a contract, discriminating example or budget decision, explicitly +labelled exploratory. It should not silently grow into an implementation campaign. +For an audit, identify the particular acceptance gap and downstream consequence; +do not demand an invented kappa gain from verification work. + +## Distributing many agents + +Keep the broad track allocation and prefer live unclaimed handoffs. Refine a +task by **mechanism, changed contract, exact obligation and bounded domain**. +Separate alternative constructions from deliberately independent checks. +Different random seeds, larger censuses and renamed helper types are not by +themselves distinct mechanisms. Useful small improvements remain welcome. + +Use one existing canonical thread per family/question, with its latest result, +source pins, remaining costs, active scoped tasks and next review trigger near +the top. Do not require every contributor to maintain a second status file. +When all immediately useful tasks in a family are claimed, choose a distinct +obligation or a different family rather than manufacturing a peripheral PR. + +Keep negative proofs tied to decisions. A scoped closure merits preservation; +its ever-narrower extensions do not automatically merit more assigned effort. +Corrections, independent verification and a genuinely changed premise can reopen +it. No finite failed search establishes a universal limitation. + +Maintainers should refresh these entry points after a reviewed completion, +decisive scoped obstruction, changed supplier or substantial queue review. +Preserve historical pins and attributions; update the task catalogue, guide and +priority log together when assignments change. Current weights are allocation +choices, not estimates of success probabilities or proof that the portfolio is +optimal. diff --git a/research/controller-ceiling-convexity/canonical/docs/research/research-package-guide.md b/research/controller-ceiling-convexity/canonical/docs/research/research-package-guide.md new file mode 100644 index 0000000000..b73c495451 --- /dev/null +++ b/research/controller-ceiling-convexity/canonical/docs/research/research-package-guide.md @@ -0,0 +1,368 @@ +# Minimal research packages and explicit replay + +Use a package for a reusable result or verifier. A discussion finding or handoff +is enough when a session has not established something worth a PR. Existing +packages need not be retrofitted, and frozen source archives must not be edited +to satisfy a new documentation convention. + +## Create a draft + +From a checkout with committed source inputs: + +```sh +python3 scripts/new_research_package.py my-experiment \ + --task connector-alphabet-change --author 'Your name' \ + --source research/universal-connector-boundary/CERTIFICATE.json +``` + +The generator creates five files and refuses to overwrite an existing directory: + +- `README.md`: scope, result/evidence, reproduction, **Open next questions**, credit. +- `TASK.json`: original card, actual scope, scope-change reason, bottleneck link, + time budget, outcome, evidence and structured next questions. +- `SOURCES.json`: exact base commit, Git blob IDs and SHA256 hashes. +- `VERIFY.json`: explicit replay commands, inputs, dependency pins and timeouts. +- `verify.py`: a failing draft stub, to replace with a real scoped check. + +The original card and selected record are historical **provenance** in Git, so +future priority changes do not invalidate a package. Explicit `--source` entries +are **live inputs**: their working bytes must match their pins. Full Git history +is needed for provenance checks. A source export can instead use an existing +archive-based package format; the generator is optional. + +Do not make a new copy of a predecessor package merely to acquire provenance. +Preserve any license/NOTICE obligations if you actually vendor third-party work. +Extra files such as separate `CLAIM.md`, `EXPECTED.json` or `NOTICE.md` are needed +only when they serve a real purpose or a source license requires them. + +## Pin exact sources and declare live inputs + +Every `SOURCES.json` `files` row records `path`, `usage`, `git_blob` and `sha256`. +`usage: "input"` marks a live input and `usage: "provenance"` binds through the +Git blob at the recorded commit. **Every `usage: "input"` row must also appear in +`VERIFY.json` `inputs`**, because declared inputs drive CI invalidation; the +metadata check (including `--check-only`) rejects an undeclared live pin and +names the path. `inputs` may list more than the live pins (a provenance-only +path can still be declared), never fewer. + +A row without an explicit `pin` resolves as `base_commit:`. A file vendored +from a pull-request head can instead carry `"pin": "head:<40-hex sha>:"`, +whose bytes resolve at that commit rather than at the package base. Any other +pin form fails closed. Both forms preserve the exact path, including any LF or +CRLF characters in a Git filename; encode them as JSON escapes in the manifest. +The originating task catalogue +`docs/research/agent-task-catalog.json` must stay pinned at `base_commit`, so a +later catalogue revision cannot replace the card a package answers. Pins resolve +only against Git objects reachable in this repository (the base commit or an +explicit head sha); there is no `external` pin for bytes that are not a Git +object here. For such an input, record its source and a byte-equality check in +the verifier and explain the gap in the README. + +Shared Git source readers ignore local replacement refs, including a custom +`GIT_REPLACE_REF_BASE` namespace. Otherwise Git can report the original blob ID +while returning a replacement's bytes, allowing locally generated pins to fail +in a clean checkout. The generator, metadata validator, HEAD input inventory, +committed-byte preflight and package exporter use the stored objects. Replacement +refs are left intact; the policy applies only to these Git subprocesses and does +not change the caller's environment or verifier subprocesses. This authenticates +source bytes, not publication ancestry or mathematical claims; the optional +source-history preflight below remains separate. + +Regression controls use temporary Git repositories with blob and commit +replacements, the legacy batch fallback, newline paths, a custom replacement +namespace, forged live pins and an exported payload: + +```sh +python3 -W error -B -m unittest discover -s tests -p 'test_research_git_replacements.py' -v +``` + +This extends the immutable-object policy of Nick Petalas's +[source-history preflight (PR3304)](https://github.com/CrocSwap/integer-mult-bounds/pull/3304) +to the shared source readers. The runner and scaffold retain Douglas Colkitt's +attribution, and the exporter retains Tekalign's. Added regression coverage and +reader policy prepared for roger-sato with substantial OpenAI Codex assistance; +Apache-2.0. + +`original_card` in `TASK.json` must equal the full pinned catalogue card object. +Hand authors can print the exact object instead of copying it by hand: + +```sh +python3 scripts/research_package.py --package research/my-experiment --print-card +``` + +Paste the printed object verbatim as `original_card`; the checker reports every +key by which a copied card differs from its pin. + +## Declare the actual scope + +`scope_status` is `unchanged`, `refined` or `changed`. The latter two require a +reason. The original card is checked against its pinned catalogue. Keeping an +alphabet and increasing source count is a changed investigation when the card +asked for a new operation alphabet. It may be useful, but say what it contributes. + +The metadata checker catches missing declarations and mismatches. It cannot +decide whether a mathematical argument genuinely meets an acceptance gate. +Reviewers must compare the actual work to the original premise. + +For each open next question, give `question`, `why_it_matters`, `first_step` and +`blocked_by`. “f(7) is open” is not enough. If no next step is justified, an empty +list with `no_open_questions_reason` is valid. The overlap helper searches the +README; link the structured questions there so people can find them. + +## Register a bounded verification command + +Replace TODOs, implement the verifier and its meaningful controls, then set +`VERIFY.json` status to `ready`. Its commands are argument arrays, not shell +strings. `{python}` selects the active interpreter and `{package}` the package +directory. They run from the repository root. + +The launcher removes inherited `PYTHONOPTIMIZE` from each command's environment. +Otherwise a caller's shell setting can silently disable a verifier's assertions, +including assertions in its Python subprocesses. Other environment settings and +explicit command options remain intact. A manifest can still request `-O` or +`-OO` for a deliberate control; its author must account for disabled assertions. + +Each registered verification command also receives a fresh private Python +bytecode-cache namespace, removed after success, failure or timeout. This keeps +preexisting `.pyc` files from replacing source-authenticated modules: `-B` +disables cache writes but still permits cache reads. The runner replaces any +interpreter-level `-X pycache_prefix` with its own namespace; other interpreter +options and script arguments are preserved. This policy covers imports in that +registered interpreter, not separately launched child Python processes or direct +verifier calls. See the [source-binding reproduction and limits](bytecode-replay-isolation.md). + +```sh +python3 scripts/research_package.py --package research/my-experiment --check-only +python3.12 scripts/research_package.py --package research/my-experiment +``` + +The generic environment is Python 3.12. Standard-library packages need no +dependencies; exact numpy/sympy/scipy pins can be declared in `requirements`. +`--install-deps` explicitly permits installing those pins, preferably in a fresh +venv. Other dependencies, native/Lean builds and long replays need a dedicated +workflow or the package's existing reproducible environment. + +Declare every external proof-relevant input in `inputs`; package-local changes +already trigger replay. Use canonical repository-relative POSIX paths, such as +`research/example/input.json`, with forward slashes and no leading `./`, repeated +slashes or dot components. Each input must use its exact UTF-8 spelling in the +current `HEAD` tree. Validation and planning read that tree with NUL-delimited +Git output; neither filesystem case folding nor Unicode normalization defines +input identity. Untracked and staged-only inputs must be committed before they +can be validated. The index cannot override the spelling in `HEAD`. + +Planning also permits exact paths reported by its Git diff, so deleted inputs +and both sides of case-only renames still select their consumers. Validation +continues to require a present file: remove or update obsolete declarations +before replaying the selected package. A stale missing declaration outside the +current diff fails planning rather than silently becoming irrelevant. Git +failures publish no matrix. These shared boundaries require a Git checkout with +a valid `HEAD`; direct standalone verifiers keep their own source-export +contracts. The generic hook does not infer transitive imports. + +Existing components below the repository root must +also be free of symbolic links. The planner and metadata validator reject these +aliases because Git reports changes under the target's path. Declare that +target path instead. Missing inputs still participate in replay selection, so +deleting an input or its parent directory cannot suppress its consumer's replay. +The checkout must remain stable during planning, validation and execution; these +checks do not provide an atomic filesystem snapshot. The generic hook does not +infer transitive imports. + +Each command has a maximum 600-second timeout and the package total is at most +1200 seconds. On POSIX, the launcher terminates the command's local process +group on every exit, including success, failure, timeout and interruption, so +background solver processes in that group cannot continue into another replay. +Verification commands must wait for all proof-relevant children and propagate +their failures before returning; cleanup is not evidence that unfinished checks +passed. Descendants that deliberately detach into another group/session are +outside this cleanup contract. On Windows, tree cleanup uses `taskkill` while +the leader is still running; cleanup after leader exit needs a separate native +lifetime mechanism and is not provided here. A timeout still fails. These +bounds limit a verification job, not the mathematical search budget. + +The [registered-package workflow](../../.github/workflows/research-packages.yml) +selects **only opt-in packages**, using their directories, declared inputs, and shared replay controls. +Its planning job runs for pull requests and pushes to `main` without path filters, +because declared inputs can live anywhere in the repository. Unrelated changes +produce no replay jobs. Git renames count as removal of the old path and addition +of the new path, so packages that depend on either path receive a replay. +Changes to the package runner or this workflow select every registered package. +Each gets a fresh runner and explicit commands. It does not run every historical +`verify.py`. New hooks do not replace existing cold-replay obligations, and a +passing metadata check is not acceptance of a mathematical result. + +## Export committed bytes + +Use the [committed package exporter](package-export.md) to snapshot one package +and its declared inputs with deterministic archive metadata and an offline +integrity check. Export is separate from mathematical verification and does +not infer transitive dependencies. + +## Explain replay selection + +```sh +python3 scripts/research_package.py --changed-since origin/main \ + --explain-plan /tmp/replay-reasons.json +``` + +The normal stdout matrix and `--github-output` fields stay unchanged. The +optional JSON sidecar names every selected package and all three independent +causes: changed files inside its directory, changed declared inputs, and changed +shared replay controls. It includes the resolved base/head, exact changed and +unmatched paths, and SHA256 of each selected working `VERIFY.json`. A removed +or renamed input is reported under its old spelling when that triggers a replay. +The all-zero base mode is labelled `all-tracked` with a null base. + +Selection and explanation use one pass. A validation or sidecar-write failure +publishes no new stdout/GitHub matrix; a previous complete sidecar is left alone +on validation failure. Use the command exit status and base/head to distinguish +an old report. The sidecar is atomically replaced after complete serialization. +It explains selection from working manifests or authenticated unchanged sparse +HEAD manifests; it is not a claim that working manifests equal HEAD or that dependencies +were inferred transitively. Keep the checkout stable during planning. No verifier +runs and no mathematical acceptance follows from selection. + +Regression command: + +```sh +python3 -B -m unittest discover -s tests -p 'test_research_plan_explanations.py' -v +``` +Tekalign, with substantial OpenAI Codex assistance; the existing selector and +its invalidation rules retain Douglas Colkitt and Charles Bethin's attribution. + +## Check publication bytes + +After committing a package and before publishing it, optionally compare its +working files and declared inputs with the exact commit: + +```sh +python3 scripts/check_research_commit.py --package research/my-experiment +# For a different publication commit: +python3 scripts/check_research_commit.py --package research/my-experiment --ref COMMIT +``` + +Git attributes or clean filters can make a valid local source-hash receipt +describe different bytes from those committed, even when `git diff` is empty. +This read-only check compares raw bytes and reports missing, extra or changed +files. It includes tracked and nonignored untracked package files plus the +explicit `VERIFY.json` inputs, and rejects committed links/submodules. +Ignored runtime files and undeclared external dependencies are outside scope. + +If a mismatch is intentional, use an explicitly documented source adapter; +otherwise correct the working bytes or publication commit and rerun the +affected verifier before regenerating its receipt. The preflight never changes +files or normalizes scientific evidence. Passing it does not run the verifier, +validate the mathematics, or establish equivalence to a hosted CI environment. + +### Check declared source history before publication + +A correct source pin can work locally because another research branch left its +commit in the shared object store. A clean hosted checkout may not contain that +unmerged commit. To reject that dependency before pushing, opt in to the +publication preflight's history check: + +```sh +python3 -B scripts/check_research_commit.py --package research/my-experiment \ + --check-source-history +``` + +After the existing byte comparison, this reads `SOURCES.json` from the exact +publication commit. It requires the base commit and every supported explicit +`head:` source-pin commit to be ancestors of that publication. Separate local +branches and cached objects do not satisfy the check. Git replacement objects +and legacy grafts cannot supply the ancestry. A shallow repository fails with +a request for full history. The successful result lists the checked commit IDs +in `source_history_commits`; the default byte-only command is unchanged. + +If a pending predecessor fails, retain its exact bytes, hashes and credit in +your own published history or a self-contained committed export, then bind the +package to that retained source. Do not weaken hash or mathematical assertions. +The repaired PR3234 and PR3227 provenance chains motivated this opt-in check. +An intentional external dependency can remain external, but this stricter +publication check will not pass it. Document and test its explicit fetch step +instead of treating the local object cache as evidence of cold availability. + +This is a conservative check of **declared Git-history availability**, not full +metadata validation or a cold replay. Run the registered metadata and verifier +commands separately. It does not discover pins embedded in scripts or archives, +transitive imports, submodules, LFS payloads, dependencies or network services. +No source bytes, pins, Git refs or frozen evidence are changed. The new path +limits source metadata to 16 MiB, 100,000 rows and 256 distinct commits, with a +30-second timeout on each Git query. The checkout must remain stable. + +Regression commands: + +```sh +python3 -W error -B -m unittest discover -s tests -p 'test_research_source_history.py' -v +python3 -W error -B -m unittest discover -s tests -p 'test_research_commit_bytes.py' -v +``` + +The tests build synthetic Git histories and a bare object-only fixture, without +cloning the project or fetching remote objects. A valid side-commit pin passes +byte-only comparison but fails ancestry; exporting only the publication's +reachable objects confirms that the foreign commit is missing. Ancestor pins +pass the same cold object test. Replacement/graft, shallow-history, malformed +metadata, resource-limit, Git-failure and actual CLI controls remain active +under optimized Python. This is not a theorem or supplier-admission check. + +Open next questions are explicit dependency declarations for script-embedded +Git references and separately fetched sources. Start with one actual replay's +source manifest and fetch command. Automatic import inference is not supplied +by this check and would need its own contract and failure controls. + +The planner groups at most 256 package paths into each reusable-workflow batch, +so a shared-runner change can select more than GitHub's single-matrix limit. +Batches run one at a time and each batch runs at most four isolated package jobs; +the per-package fresh checkout, environment and 30-minute job bound are retained. +Changing either workflow selects all registered packages. Selection is never +truncated: more than 256 batches fails explicitly. The ordinary planner CLI keeps +its flat matrix format unless `--matrix-batch-size 256` is requested. +This is a matrix-count bound, not a promise that the largest grouping fits every +GitHub execution limit; the 1 MB job-output limit (estimated in UTF-16) and other +platform limits still apply. The submission measured 450 selected packages; later repository inventories may be larger. + +## Optional workflow feedback + +If something helped or obstructed the session, add a few sentences to your PR +or the [feedback discussion](https://github.com/CrocSwap/integer-mult-bounds/discussions/1200). +Link an existing retrospective instead of duplicating it. Include the task or +priority revision, outcome, largest friction/detour and one suggested change. +Directors record resulting decisions in the priority log, not a log entry for +every agent session. + +## Planning in a sparse checkout + +Replay selection inventories both committed `research/*/VERIFY.json` paths and +working manifests. Omitting a package directory from a sparse checkout must not +omit its declared input dependencies from the matrix. Absent manifests are read +from Git only when one stage-zero, regular, `skip-worktree` index entry has the +same mode and blob as HEAD. The planner reports the number of such declarations +on stderr; stdout and GitHub matrix formats stay unchanged. + +An ordinary missing file, staged content/mode change, unmerged index entry, +symlink manifest or unreadable inventory still fails. Commit an intentional opt-in +removal before planning that deletion. Existing working edits and new local +manifests are read as before, and all declared input spelling checks still run. +A fully omitted `research/` directory is supported when its manifests satisfy +the same Git/index checks. The checkout must remain stable during planning. + +This discovers declarations; it does **not** make sparse packages executable. +Materialize a selected package and its required inputs before actual validation +or replay. Partial clones may need Git's normal fetches for missing manifest +blobs. The fix needs only those declarations, not the full source packages. +Immutable inputs and upstream archives are unchanged. + +At base `997e6a9ca7b4f95d50e366f61412fd640d72a88a`, HEAD contains 1,244 registered +manifests, while the contributor's sparse checkout initially materialized 18. +The earlier filesystem-only scan returned an 18-package global-trigger matrix. +The real sparse/full fixture and rejection controls can be reproduced with: + +```sh +python3 -B -m unittest discover -s tests -p 'test_research_sparse_planning.py' -v +``` + +Tekalign, with substantial OpenAI Codex assistance. Apache-2.0. The exact +HEAD/index fallback premise follows Arham-Tahir64's PR3102 sparse-reference work; +this applies it to replay declarations. The original planner, canonical Git +spelling, symlink and inventory-error controls retain their predecessor credit. diff --git a/research/controller-ceiling-convexity/numerical/FINAL-MANIFEST-v3.json b/research/controller-ceiling-convexity/numerical/FINAL-MANIFEST-v3.json new file mode 100644 index 0000000000..af4531351f --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/FINAL-MANIFEST-v3.json @@ -0,0 +1,197 @@ +{ + "version": 3, + "files": [ + { + "path": "HANDOFF.md", + "bytes": 3712, + "sha256": "b22e34a3fc93ca0c3f0c8289c73ed45324b539218a9e6a50deeb8a7e5fa3805d" + }, + { + "path": "PROOF.md", + "bytes": 14664, + "sha256": "b0aff27dd9203ef42e5b8898d6659819205f13c1d251ff043564fcab656bf7f4" + }, + { + "path": "RUNS-v3.json", + "bytes": 4442, + "sha256": "ce81ac1a91ef600699e515eab53ab7b830ff3f99109bb5a9099dd452c1ee0d02" + }, + { + "path": "RUNS.json", + "bytes": 4442, + "sha256": "ce81ac1a91ef600699e515eab53ab7b830ff3f99109bb5a9099dd452c1ee0d02" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 2135, + "sha256": "c9e036ae8bce17023e6e47682e548e7b23f0eea745175516c66c9f34ba5d1cca" + }, + { + "path": "SOURCE-REPRESENTATION-BRIDGE.json", + "bytes": 738, + "sha256": "a7cae5f36f5d0cd87b92af22115b46f8e692f8b9a734d0049ed46e7587e522c7" + }, + { + "path": "THEORY-MANIFEST.json", + "bytes": 545, + "sha256": "21ec2a198c3201c2fc83a2bfd2a4622987e15b490b64c632925e399e84510054" + }, + { + "path": "check_ceiling.py", + "bytes": 16531, + "sha256": "8f443aa005f5c7c4e2286524e815074787cc109a06cc66e56f362f8cc7854b01" + }, + { + "path": "inputs/5405-PROOF.md", + "bytes": 10030, + "sha256": "5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37" + }, + { + "path": "inputs/5405-UPSTREAM-EXACT-PROOF.md", + "bytes": 10029, + "sha256": "77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b" + }, + { + "path": "inputs/5405-UPSTREAM-SOURCE-FETCH.json", + "bytes": 10676, + "sha256": "4771e2948b448e5488bdb33a872e49ce0251c8acff5c294e70c5544d0f2e95f2" + }, + { + "path": "inputs/5405-concavity-exchange-reduction.md", + "bytes": 10145, + "sha256": "0e575a88d28db5aecc5ccf24504923a0508ff976d05f92e91e6d48408b7688ea" + }, + { + "path": "inputs/5405-discrete-convexity-three-value-gate.md", + "bytes": 7372, + "sha256": "bdad476f31b450e1ac4d1fd0d9530b43e33ebac48accc0956b38a9634b40a929" + }, + { + "path": "inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json", + "bytes": 1795, + "sha256": "ce98cb10c028e3a512599e715043e8a26dd9b88278d1c600d2b4b29c7b909d6d" + }, + { + "path": "inputs/guidance__AGENTS.md", + "bytes": 5580, + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347" + }, + { + "path": "inputs/guidance__CONTRIBUTING.md", + "bytes": 7143, + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215" + }, + { + "path": "inputs/guidance__autoresearch.md", + "bytes": 5986, + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + { + "path": "inputs/guidance__docs__research__agent-procedure.md", + "bytes": 29397, + "sha256": "6433f302cbc129ea986bf88ba1e94422bbf2aa6ba1d1d11b067c92736fa4a139" + }, + { + "path": "inputs/guidance__docs__research__current-priorities.md", + "bytes": 11950, + "sha256": "7ea971a336bf526719ae1f21617038301ab95d9853a38b92c332a9ffb968297a" + }, + { + "path": "inputs/guidance__docs__research__research-family-status.md", + "bytes": 18401, + "sha256": "21ea61004c0270388258c4251b1c586b65f06bc807395b281deacfb886204934" + }, + { + "path": "receipts/arithmetic-v1.json", + "bytes": 43821, + "sha256": "a5a3e35b420ba30407ddeaacc91770e7c03da5ff8139b73585c4ceae9db6d744" + }, + { + "path": "receipts/arithmetic-v1.stderr.log", + "bytes": 890, + "sha256": "475f7f876455d7e4e115381c138854462e487b182e4a1b9006cb634627ae33dc" + }, + { + "path": "receipts/arithmetic-v1.stdout.log", + "bytes": 5061, + "sha256": "b9e6beac377d81121cc2fc62f4cb49f70b209209717653418ef17da466e3c6f1" + }, + { + "path": "receipts/arithmetic-v2.json", + "bytes": 43820, + "sha256": "86f84dd374d831c3e4f907cd3e5f4789cee4ae2efb68f55dd0f679caec7b4736" + }, + { + "path": "receipts/arithmetic-v2.stderr.log", + "bytes": 890, + "sha256": "6c806fac227571242e9ccc31e1db08b2cd886c843bb24c26e2d21b8faafa4361" + }, + { + "path": "receipts/arithmetic-v2.stdout.log", + "bytes": 5060, + "sha256": "b7e05a760ad11a7507b662b6d991ae89f05cab80fecb0226d69e2e809fd46714" + }, + { + "path": "receipts/arithmetic-v3-optimized.json", + "bytes": 43820, + "sha256": "6d4b1c890bed07576ef4f76c47e27ce9effe903b7646f650f0092c03c69a6bda" + }, + { + "path": "receipts/arithmetic-v3-optimized.stderr.log", + "bytes": 905, + "sha256": "8598ee3084306350af165ab758918f1d4125d2856c1de979ddcee7ae0b0a2e0a" + }, + { + "path": "receipts/arithmetic-v3-optimized.stdout.log", + "bytes": 5060, + "sha256": "10082755c70523929349bd4310fe6a867e8ae54d225b24c0372bc5f146287de9" + }, + { + "path": "receipts/arithmetic-v3.json", + "bytes": 43820, + "sha256": "32d3adfc837ba4f66c899e7cb23adea441a3af48d96700f2e14e6c9f8b1c6729" + }, + { + "path": "receipts/arithmetic-v3.stderr.log", + "bytes": 890, + "sha256": "e7fc3facecd37c1ea1e9f3e9b94221f7f1f456bee467f1ad37b192a49d359df2" + }, + { + "path": "receipts/arithmetic-v3.stdout.log", + "bytes": 5060, + "sha256": "a98a5c1760fd0c1f69c342d39c9d213872b2e4b3e850742e05caeacf5620f9cc" + }, + { + "path": "receipts/check_ceiling-v1.py", + "bytes": 14242, + "sha256": "42cec3a635e22785929ca47d1da1d9b11041c1244945f21145a69b25c7527a3e" + }, + { + "path": "receipts/frozen-v2-FINAL-MANIFEST.json", + "bytes": 3875, + "sha256": "cbcacfbefbe07b32a5df57f31ddaa7baaabe2a2e72f7cb7df9252886339bfcfe" + }, + { + "path": "receipts/frozen-v2-HANDOFF.md", + "bytes": 2767, + "sha256": "9a49c75d894869c8d37bd6bd983c4e43ef9a7f6f40944539e3dc0bb353a9c5f6" + }, + { + "path": "receipts/frozen-v2-PROOF.md", + "bytes": 13468, + "sha256": "85f92f5b1a90148ba6a6857c41035d805cc18e4442a618dd107b2b7988bd0f6c" + }, + { + "path": "receipts/frozen-v2-RUNS.json", + "bytes": 2009, + "sha256": "815146645a539dd9cf5c262fbbe9649101c32fd06da455a339627a62880bcda2" + }, + { + "path": "receipts/frozen-v2-check_ceiling.py", + "bytes": 14844, + "sha256": "3352d5c6dd0da6e988efcab7b6a8cfd5ff85655390bef472523e7022db431cd9" + } + ], + "top_level_final_manifests_excluded": true, + "previous_manifest_retained": "receipts/frozen-v2-FINAL-MANIFEST.json" +} diff --git a/research/controller-ceiling-convexity/numerical/HANDOFF.md b/research/controller-ceiling-convexity/numerical/HANDOFF.md new file mode 100644 index 0000000000..9854f9b733 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/HANDOFF.md @@ -0,0 +1,65 @@ +# Local handoff: independent PR5405 three-value ceiling verification + +Status: **PASS for the exact scoped arithmetic and independent monotonicity audit**. +The frozen exchange and strict-discrete-convexity proofs, plus this numerical +certificate, imply the unbounded source equation-(1) invoice-family ceiling for +`0.00302728825 <= kappa < 1`. No author DP/tail replay is needed. No kappa gain, +changed-profile PR5402 transfer, physical optimum, native or compiler admission, +or complete multiplication theorem is claimed. + +Review `PROOF.md`, `check_ceiling.py`, the two manifests and +`receipts/arithmetic-v3.json` and `FINAL-MANIFEST-v3.json`. The exact gate gives + +``` +C18 > 0.000000014914967918767741908079 +C18-C17 < -0.271338621904872494155700553536 +C19-C18 > 0.022748156490424972863108432493 +``` + +Every displayed decimal is a rational with denominator 10^30. Exact finer +integer/Q endpoints are retained. The checker uses a fresh independent 2^256 +integer interval implementation with rigorous atanh-log and Taylor-exp tails. +No source engine, author DP, numerical library, solver, native or Lean code is +imported. All 456 tiny invoice identity controls and five explicit negative +controls passed. Canonical n=0,...,5 and 16,...,20 masks match the closed formula +by exact symbolic coefficients. + +The first arithmetic stage completed under the 60-second/256MiB cap in about +0.11 seconds external wall time and 19,248KiB maximum RSS. The independent +reviewer identified that v2's assertion-based acceptance checks could disappear +under `python -O`. V3 replaces every assertion with explicit require/raise code. +Both final ordinary and optimized runs pass, with identical proof-relevant output +and the same arithmetic endpoints as v1/v2. Exact v2 checker, proof, handoff and +manifest bytes and all raw run receipts remain retained under `receipts/`. See +the raw `/usr/bin/time -v` logs and `RUNS-v3.json` for final runtime, commands, +source hashes and the transparent correction. No arithmetic run failed and no +raw receipt was overwritten; v2 is superseded as the acceptance checker. + +Reproduce from the project root, choosing a fresh output filename: + +``` +/usr/bin/time -v timeout 60s python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt /tmp/controller5405-independent-new-run.json +``` + +The script itself enforces RLIMIT_AS=256MiB, a 60-second alarm and exclusive +receipt creation. Refusing an existing receipt is intentional. + +Source PR5405 head: `314b56a6c0056c2358538f072c6fde9d365be44d`. +Retained canonical main: `1ec1119972c9aefe42525172d07b332fcff81cb4`. +The source equation and local profile remain premises; no standalone derivation +from the original Laurent/native construction was executed. Root owns fresh +upstream overlap, packaging and public writes. This worker stops at the local +reviewable handoff; no GitHub, Discussion, package or publication write occurred. + +Credit and open next questions are in `PROOF.md`. Preserve Ali Romman, Cinna +Davis, zxv and all retained native/helper/compiler lineage, as well as root's +conjectures and the sole Astra theory proof. The result is local and has not had +independent human or formal-kernel review. + +Source representation correction: `SOURCE-REPRESENTATION-BRIDGE.json` binds the +original 10,030-byte monitor copy (SHA256 `5c82c9f...`) to the independently +fetched 10,029-byte upstream proof (SHA256 +`77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b`, Git blob +`5ad89d4ba1836d47798bdb856e3726c70a7b1922`). Exact byte comparison proves the +monitor is upstream followed by one extra LF. The original copies/theory pins +remain unchanged, and both upstream bytes and reviewer fetch response are retained. diff --git a/research/controller-ceiling-convexity/numerical/PROOF.md b/research/controller-ceiling-convexity/numerical/PROOF.md new file mode 100644 index 0000000000..f9a60f7f98 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/PROOF.md @@ -0,0 +1,290 @@ +# Independent three-value verification of the PR5405 fixed-family ceiling + +This local check proves the three required strict rational inequalities for the +actual PR5405 profile at `kappa0=0.00302728825`, using a new standard-library +interval implementation. Together with the separately frozen analytic exchange +and discrete-convexity proofs, these inequalities imply positivity of every +equation-(1) invoice at this exponent. The monotonicity argument below extends +that fixed-family conclusion to `kappa0 <= kappa < 1`. + +This is a necessary-moment obstruction for the specified invoice family. It is +not a new exponent saving, a physical or global circuit optimum, native execution, +supplier admission, a formal-kernel proof, or a complete multiplication theorem. +The changed/coupled profile of PR5402 is excluded. Equation (1) and its autonomous +local profile are explicit source premises; their derivation from the original +Laurent controller, native circuit and framework assumptions is not replayed here. + +The source is Ali Romman's PR5405, head +`314b56a6c0056c2358538f072c6fde9d365be44d`, against retained canonical main +`1ec1119972c9aefe42525172d07b332fcff81cb4`. The frozen monitor representation has SHA256 +`5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37`. +The independent reviewer fetched the exact upstream proof: 10,029 bytes, +SHA256 `77dc9ce552be7dc9c9a32850c2f2cf0eff92cfe2e0a0e316db210a1667a8d32b`, +Git blob `5ad89d4ba1836d47798bdb856e3726c70a7b1922`. The retained monitor file is +10,030 bytes and equals those exact upstream bytes followed by one additional +LF byte. `SOURCE-REPRESENTATION-BRIDGE.json` records the exact byte comparison, +both hashes and the retained fetch response. The checker uses the original +authenticated monitor representation; no mathematical text differs. Neither +the monitor copy nor the frozen theory notes was silently normalized. +`SOURCE-MANIFEST.json` and `THEORY-MANIFEST.json` identify immutable copies of +the source, guidance and the two independent analytic notes. Root owns upstream +freshness, overlap, publication and any final admission gate. No separate upstream +feed, package publication or public write was performed by this checker. + +## Complete invoice and independent coefficient reconstruction + +Put `t=1-kappa`, `f(r)=r^t` for positive r and `f(0)=0`. The source profiles are + +``` +P={1:2193,2:412,3:510,4:127,5:40} +H={4:28,7:7,8:47,9:318} +L(t)=sum_r P[r]f(r)-sum_r H[r]f(r). +``` + +For p>=1, choose a+b=p-1 and a bit mask x of length 2p+1. A bit one means FULL; +its contribution is P on the paid side and H on the target side. A bit zero +means QUERY; it contributes exactly 112 paid rank-one jobs and no local helpers. +Let n be the number of ones. The complete local net contribution is therefore + +``` +nL+112(2p+1-n) =112(2p+1)+(L-112)n. +``` + +There are 224 full-path main targets of rank 1+8n. For retained idle slot j, +1<=j<=p-1, the FULL count on its exterior side is + +``` +h_j=sum_(s=0)^(2j-1)x_s, j<=a, +h_j=sum_(s=2j+1)^(2p)x_s, j>a. +e_j=x_(2j). +``` + +Its paid terms are 224 jobs of rank 8h_j (omit when h_j=0), plus 224 jobs of +rank eight when e_j=1. Its targets are 224 jobs of rank 1+8(h_j+e_j). Adding +all items, with no helper credit at QUERY stages, gives exactly source equation +(1): + +``` +E=112(2p+1)+(L-112)n-224f(1+8n) + +224 sum_(j=1)^(p-1)[f(8h_j)+e_j f(8)-f(1+8(h_j+e_j))]. +``` + +The checker builds paid and target integer histograms from those item lists, +expands equation (1) separately into signed coefficients of the formal symbols +f(r), and compares the coefficient dictionaries exactly. This identity check +uses no floating-point tolerance or interval overlap. It covers every mask and +split for p=1,2,3 (456 cases) as an index control. The invoice formula for arbitrary +p remains the source premise; finite examples are not promoted to its proof. + +## Canonical minimum and its two neighboring differences + +The frozen exchange note +`inputs/5405-concavity-exchange-reduction.md` proves that every invoice with n +FULL stages has E>=C_n, and that C_n is attained in this family. For n=0,1,2 the +canonical controller has p=1 and no retained side idles, so + +``` +C_n=336+(L-112)n-224f(1+8n). +``` + +For n>=3, all two exterior endpoints and the central stage are FULL. Every +remaining side pair, read from outside inward, is 10. There are n-3 such pairs, +split with a=floor((n-3)/2), b=ceil((n-3)/2), hence p=n-2. There are 2p+1=2n-3 +stages and n-3 QUERY stages. The j-th side pair has h=j+1 and e=0, so its +net summand is `-delta(8(j+1))`, where delta(z)=f(z+1)-f(z). This independently +reconstructs + +``` +C_n=nL+112(n-3)-224f(1+8n) + -224[sum_(k=2)^(a+1)delta(8k)+sum_(k=2)^(b+1)delta(8k)]. +``` + +The two formulas agree at n=3. Symbolic coefficients of this closed expression +are checked exactly against the canonical mask's paid-minus-target histogram +for n=0,...,5 and n=16,...,20. In particular n=18 gives p=16,a=7,b=8, with +18 FULL and 15 QUERY stages. Its first side increment is delta(16), not delta(8). + +Let D_n=C_(n+1)-C_n. Adding one FULL count grows the full-path rank from 1+8n +to 9+8n. For n>=3 it also adds one side pair at partial count +k=floor((n+1)/2), on the previously shorter side. The local and QUERY term +increases by L+112, and the added idle difference is -224delta(8k). Thus + +``` +D_n=L+112-224[f(9+8n)-f(1+8n)+delta(8 floor((n+1)/2))], n>=3. +``` + +For the two required neighbors k=9 in both cases. Consequently + +``` +C18=18L+1680-224f(145) + -224[2 sum_(k=2)^8 delta(8k)+delta(72)], +D17=L+112-224[f(145)-f(137)+delta(72)], +D18=L+112-224[f(153)-f(145)+delta(72)]. +``` + +The checker evaluates the differences both by subtracting independent enclosures +for C values and through these shorter formulas. Interval intersection is an +additional numerical crosscheck; the analytic difference identity is the algebra +above and in the frozen discrete-convexity note. + +For completeness, discrete convexity is not a tail extrapolation. Write +`B_n=336+(L-112)n-224f(1+8n)` and `C_n=B_n+224T_n`. Concavity of f gives strict +discrete convexity of B on n>=0. The correction has increments zero for n=0,1,2, +and `1-delta(8 floor((n+1)/2))` for n>=3. They are nondecreasing, including the +jump from zero. Hence C is strictly discretely convex on every nonnegative +integer. This includes the small-count junction. The frozen independent proof +supplies full details. Therefore C18>0, D17<0 and D18>0 make n=18 the unique +minimizing FULL count and prove C_n>=C18>0 for every n>=0, with no DP or n>=96 +tail certificate. + +## New directed-rational interval implementation + +All acceptance arithmetic uses integers on Q=2^256. An interval `(lo,hi)` +represents `[lo/Q,hi/Q]`. Addition, subtraction and integer multiplication take +the appropriate directed endpoints. Products of nonnegative intervals use +integer floor for the lower endpoint and integer ceiling for the upper endpoint. +The only floating values are resource timing fields, which never affect acceptance. + +For a positive integer r, write r=2^m y with 1<=y<2. Compute +`log r=m log2+log y`. For z=(y-1)/(y+1), 0<=z<=1/3, + +``` +log y=2 sum_(j=0)^(N-1) z^(2j+1)/(2j+1)+R, +0<=R<=2 z^(2N+1)/[(2N+1)(1-z^2)]. +``` + +The bound follows by replacing every omitted denominator by its first value +2N+1 and summing a geometric series. The implementation uses N=128, directed +integer recurrence for included terms and exact Fraction arithmetic followed by +upward quantization for the remainder. log2 uses this same formula with y=2. + +Use the exact saving `kappa0=12109153/4000000000`; then +`r^t=r*exp(-kappa0 log r)`. For the finitely used r, the outward argument +X=kappa0 log r lies in [0,1], checked before exponentiation. To bound exp(X), +sum its Taylor series through term N=64 with directed nonnegative arithmetic. +For its first omitted term U=X_hi^(N+1)/(N+1)!, all subsequent ratios are at most +X_hi/(N+2)<1. Thus + +``` +0<=exp(X)-sum_(k=0)^N X^k/k!<=U/[1-X_hi/(N+2)]. +``` + +This upper remainder is computed as an exact rational at X_hi and rounded +upward. Invert the positive exp enclosure with reversed endpoints to bound +exp(-X), and multiply by the exact integer r. For r=0 and r=1 the result is +exact by definition. No author engine, source import, numerical package, solver, +native execution or Lean process is used. + +## Rational result and controls + +`receipts/arithmetic-v3.json` retains both exact integer endpoints over Q, every +power enclosure used, histogram lists, resource fields and all control outcomes. +The following shorter decimal bounds are exact rational outer bounds with +denominator 10^30; both inequalities are strict: + +| Quantity | Lower bound | Upper bound | +|---|---:|---:| +| C17 | 0.271338636819840412923442461615 | 0.271338636819840412923442461616 | +| C18 | 0.000000014914967918767741908079 | 0.000000014914967918767741908080 | +| C19 | 0.022748171405392891630850340572 | 0.022748171405392891630850340573 | +| C18-C17 | -0.271338621904872494155700553537 | -0.271338621904872494155700553536 | +| C19-C18 | 0.022748156490424972863108432493 | 0.022748156490424972863108432494 | + +The enclosing interval for C18 has width less than 3e-70; the positive margin +is more than 1.49e-8. The gate is strict on exact rational endpoints, independent +of displayed decimal truncation. The v1, v2 and v3 arithmetic endpoints agree. +The independent read-only reviewer identified that v2's `assert` acceptance +conditions would disappear under `python -O`. The preserved v2 run used ordinary +Python and its numeric intervals remain valid, but v2 is superseded as the +acceptance checker. V3 replaces every assertion, including domain checks, the +three-value gate, symbolic identities and mutation checks, with explicit +`require`/raise code. Both ordinary and optimized Python runs passed with identical +proof-relevant output. All previous raw receipts and the exact v2 checker, proof, +handoff and manifests are retained under `receipts/`; `RUNS-v3.json` records the +repair and both final runs. + +Five controls have their explicit expected rejection recorded: changed source +bytes fail SHA256 authentication; reversing paid-minus-target fails the gate; +omitting one 112-rank-one QUERY charge fails the exact symbolic invoice identity +and gives a negative value; omitting the 224 full-path targets fails that exact +identity; changing P[4] from 127 to 126 fails comparison with the authenticated +source profile. The omitted-target mutant is deliberately favorable numerically, +so its rejection depends on invoice accounting rather than a bad final sign. + +## Independent normalized monotonicity audit + +Discrete convexity above is a fixed-t argument. A separate proof is needed for +the interval of savings, and it concerns whole invoices rather than just C18. + +First delete side pairs 00. If their preceding FULL count is h, deletion removes +two QUERY stages, reducing paid cost by 224, and removes a retained summand +`-224delta(8h)`. Thus E decreases by `224[1-delta(8h)]>=0`; equality is possible +at h=0. It preserves n and all later partial FULL counts and remains in the +source invoice family after reindexing. Repeat until no 00 pairs remain. This +reduction is valid separately for every 00` for every p and every t. Handle that case without +logarithms of zero or a full-path derivative claim. + +For n>=1 fix any reduced invoice. Normalize its complete expression by 8^t: + +``` +E/8^t =112(2p+1-n)8^(-t)+nL(t)/8^t-224(n+1/8)^t + +224 sum_j [h_j^t+e_j-(h_j+e_j+1/8)^t]. +``` + +The QUERY coefficient is nonnegative, so that term is nonincreasing in t. +The full-path term has strictly negative derivative because n+1/8>1. For each +side summand, if e=0 then reduction forces the other bit to be one, so h>=1. +If h>=1, the derivative is negative because `z^t log z` is strictly increasing +on z>=1: its derivative in z is `z^(t-1)(1+t log z)>0`, and the second base is +larger than h. If h=0, reduction forces e=1 and the summand is +`1-(9/8)^t`, whose derivative is strictly negative. These cases avoid treating +0^t log0 as an ordinary expression. + +Finally combining the common rank-four terms gives + +``` +L/8^t=2193(1/8)^t+412(1/4)^t+510(3/8)^t+99(1/2)^t + +40(5/8)^t-7(7/8)^t-47-318(9/8)^t. +``` + +Its only positive derivative term is `7(7/8)^t log(8/7)`, less than +`7 log(1+1/7)<1`. The negative derivative from its first term alone has magnitude +greater than `2193 log8/8>274`, since 01. All other nonconstant +derivative terms are nonpositive. Thus the local normalized derivative is +strictly negative throughout 0=1 invoice. + +At t0=1-kappa0, every reduced invoice is positive by the all-n gate. For any +0= 0 else (a[1] * k, a[0] * k) + +def positive_mul(a, b): + require(a[0] >= 0 and b[0] >= 0, 'failed required condition: a[0] >= 0 and b[0] >= 0') + return a[0] * b[0] // Q, ceildiv(a[1] * b[1], Q) + +def constant(n): + return n * Q, n * Q + +def log_unit_interval(y): + """ln(y) for exact 1<=y<=2 via 2 atanh((y-1)/(y+1)).""" + require(1 <= y <= 2, 'failed required condition: 1 <= y <= 2') + z = (y - 1) / (y + 1) + zz = z * z + z_iv = frac_down(z), frac_up(z) + zz_iv = frac_down(zz), frac_up(zz) + term = z_iv + total = (0, 0) + for j in range(LOG_TERMS): + d = 2 * j + 1 + total = plus(total, (term[0] // d, ceildiv(term[1], d))) + term = positive_mul(term, zz_iv) + # All omitted terms positive, denominators >=2N+1: + # R <=2*z^(2N+1)/((2N+1)*(1-z^2)). + tail = 2 * z ** (2 * LOG_TERMS + 1) / ((2 * LOG_TERMS + 1) * (1 - zz)) + return 2 * total[0], 2 * total[1] + frac_up(tail) + +LOG2 = log_unit_interval(Fraction(2)) + +def log_integer(r): + require(isinstance(r, int) and r >= 1, 'failed required condition: isinstance(r, int) and r >= 1') + if r == 1: + return 0, 0 + m = r.bit_length() - 1 + return plus(scale(LOG2, m), log_unit_interval(Fraction(r, 1 << m))) + +def exp_positive(x): + """exp(x) for 0<=x<=1; directed Taylor and exact geometric tail.""" + require(0 <= x[0] <= x[1] <= Q, 'failed required condition: 0 <= x[0] <= x[1] <= Q') + term = (Q, Q) + total = term + for k in range(1, EXP_TERMS + 1): + # Bounds for x^k/k!; all factors nonnegative. + prod = positive_mul(term, x) + term = prod[0] // k, ceildiv(prod[1], k) + total = plus(total, term) + upper_x = Fraction(x[1], Q) + # First omitted term bounds remainder with subsequent ratios <=x/(N+2). + first = upper_x ** (EXP_TERMS + 1) + for k in range(1, EXP_TERMS + 2): + first /= k + tail = first / (1 - upper_x / (EXP_TERMS + 2)) + return total[0], total[1] + frac_up(tail) + +class Powers: + def __init__(self, kappa=KAPPA): + require(0 < kappa < 1, 'failed required condition: 0 < kappa < 1') + self.kappa = kappa + self.cache = {0: (0, 0), 1: (Q, Q)} + + def __call__(self, r): + if r not in self.cache: + log = log_integer(r) + num, den = self.kappa.numerator, self.kappa.denominator + x = log[0] * num // den, ceildiv(log[1] * num, den) + ex = exp_positive(x) + reciprocal = Q * Q // ex[1], ceildiv(Q * Q, ex[0]) + self.cache[r] = scale(reciprocal, r) + return self.cache[r] + +def moment(hist, f): + total = (0, 0) + for r, count in sorted(hist.items()): + total = plus(total, scale(f(r), count)) + return total + +def local(f): + return minus(moment(P, f), moment(H, f)) + +def delta(r, f): + return minus(f(r + 1), f(r)) + +def canonical_parts(n): + require(n >= 0, 'failed required condition: n >= 0') + if n <= 2: + return 1, 0, 0 + a = (n - 3) // 2 + b = n - 3 - a + return n - 2, a, b + +def canonical_mask(n): + p, a, b = canonical_parts(n) + x = [0] * (2 * p + 1) + if n <= 2: + for i in range(n): + x[i] = 1 + else: + x[0] = x[2 * p] = x[2 * a + 1] = 1 + for j in range(1, a + 1): + x[2 * j - 1] = 1 + for j in range(1, b + 1): + x[2 * p - 2 * j + 1] = 1 + require(sum(x) == n, 'failed required condition: sum(x) == n') + return p, a, x + +def invoice_histograms(p, a, x): + """Reconstruct paid/target lists from Eq1's individual invoice items.""" + require(p >= 1 and 0 <= a < p and len(x) == 2 * p + 1 and set(x) <= {0, 1}, 'failed required condition: p >= 1 and 0 <= a < p and len(x) == 2 * p + 1 and set(x) <= {0, 1}') + n = sum(x) + paid = Counter({r: n * count for r, count in P.items()}) + target = Counter({r: n * count for r, count in H.items()}) + paid[1] += 112 * (2 * p + 1 - n) + target[1 + 8 * n] += 224 + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + if h: + paid[8 * h] += 224 + if e: + paid[8] += 224 + target[1 + 8 * (h + e)] += 224 + return +paid, +target + +def clean_signed(c): + return {r: count for r, count in sorted(c.items()) if count} + +def signed_histograms(paid, target): + c = Counter(paid) + c.subtract(target) + return clean_signed(c) + +def equation_one_coefficients(p, a, x): + """Literal Eq1 expanded as integer coefficients of independent f(r).""" + n = sum(x) + c = Counter({1:112*(2*p+1)-112*n}) + for r, count in P.items(): c[r] += n*count + for r, count in H.items(): c[r] -= n*count + c[1+8*n] -= 224 + for j in range(1,p): + h = sum(x[:2*j]) if j<=a else sum(x[2*j+1:]) + e = x[2*j] + if h: c[8*h] +=224 + c[8] +=224*e + c[1+8*(h+e)] -=224 + return clean_signed(c) + +def canonical_coefficients(n): + """Closed formula expanded symbolically; no interval overlap acceptance.""" + c = Counter() + for r,count in P.items(): c[r] += n*count + for r,count in H.items(): c[r] -= n*count + c[1] +=336-112*n if n<=2 else 112*(n-3) + c[1+8*n] -=224 + if n>=3: + _,a,b=canonical_parts(n) + for q in (a,b): + for k in range(2,q+2): + c[8*k+1]-=224 + c[8*k]+=224 + return clean_signed(c) + +def equation_one(p, a, x, f): + n = sum(x) + val = plus(constant(112 * (2*p+1)), scale(minus(local(f), constant(112)), n)) + val = minus(val, scale(f(1+8*n), 224)) + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + g = minus(plus(f(8*h), scale(f(8), e)), f(1+8*(h+e))) + val = plus(val, scale(g, 224)) + return val + +def canonical(n, f): + if n <= 2: + return minus(plus(constant(336), scale(minus(local(f), constant(112)), n)), scale(f(1+8*n), 224)) + p, a, b = canonical_parts(n) + val = minus(plus(scale(local(f), n), constant(112*(n-3))), scale(f(1+8*n), 224)) + for q in (a, b): + for k in range(2, q+2): + val = minus(val, scale(delta(8*k, f), 224)) + return val + +def overlap(a, b): + return a[0] <= b[1] and b[0] <= a[1] + +def exact_grid_text(n, digits=40): + sign = '-' if n < 0 else '' + a = abs(n) + whole, remain = divmod(a, Q) + return sign + str(whole) + '.' + str(remain * (10**digits) // Q).zfill(digits) + +def packed(iv): + # Decimal strings are display only, exact integer/Q endpoints certify signs. + return dict(lower_integer=str(iv[0]), upper_integer=str(iv[1]), denominator=str(Q), + lower_decimal_truncated=exact_grid_text(iv[0]), upper_decimal_truncated=exact_grid_text(iv[1]), + width_grid_units=str(iv[1]-iv[0])) + +def authenticate(data, expected): + if sha256(data).hexdigest() != expected: + raise ValueError('source hash mismatch') + +def validate_profile(p,h,source): + source_p=ast.literal_eval(re.search(r'paid P = (\{[^\n]+\})',source).group(1)) + source_h=ast.literal_eval(re.search(r'helper targets H = (\{[^\n]+\})',source).group(1)) + if p!=source_p or h!=source_h: + raise ValueError('profile differs from authenticated source') + +def gate(c18,d17,d18): + return c18[0]>0 and d17[1]<0 and d18[0]>0 + +def verify_sources(): + manifest = json.loads((ROOT/'SOURCE-MANIFEST.json').read_text()) + for row in manifest['inputs']: + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + source = (ROOT/'inputs/5405-PROOF.md').read_text() + require('paid P = {1:2193, 2:412, 3:510, 4:127, 5:40}' in source, "failed required condition: 'paid P = {1:2193, 2:412, 3:510, 4:127, 5:40}' in source") + require('helper targets H = {4:28, 7:7, 8:47, 9:318}' in source, "failed required condition: 'helper targets H = {4:28, 7:7, 8:47, 9:318}' in source") + validate_profile(P,H,source) + for row in json.loads((ROOT/'THEORY-MANIFEST.json').read_text()): + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + return manifest + +def run(): + start = time.monotonic() + manifest = verify_sources() + f = Powers() + values = {n: canonical(n, f) for n in range(16, 21)} + # Recompute differences in both literal canonical expression and the short formula. + differences = {n: minus(values[n+1], values[n]) for n in range(16, 20)} + neighbor_short = {} + for n in (17, 18): + # Independently: newly added full stage contributes L+112; rank main + # grows by 8, and one side sum gains delta at 8*floor((n+1)/2). + cost = plus(minus(f(1+8*(n+1)), f(1+8*n)), delta(8*((n+1)//2), f)) + neighbor_short[n] = minus(plus(local(f), constant(112)), scale(cost, 224)) + require(overlap(differences[n], neighbor_short[n]), 'failed required condition: overlap(differences[n], neighbor_short[n])') + require(gate(values[18],differences[17],differences[18]), 'failed required condition: gate(values[18],differences[17],differences[18])') + hist_checks = [] + for n in list(range(0, 6)) + list(range(16, 21)): + p, a, mask = canonical_mask(n) + paid, target = invoice_histograms(p, a, mask) + require(signed_histograms(paid,target)==equation_one_coefficients(p,a,mask)==canonical_coefficients(n), 'failed required condition: signed_histograms(paid,target)==equation_one_coefficients(p,a,mask)==canonical_coefficients(n)') + direct = minus(moment(paid, f), moment(target, f)) + eq1 = equation_one(p, a, mask, f) + require(overlap(direct, eq1) and overlap(direct, canonical(n, f)), 'failed required condition: overlap(direct, eq1) and overlap(direct, canonical(n, f))') + hist_checks.append(dict(n=n, p=p, a=a, mask=''.join(map(str,mask)), + paid=dict(sorted(paid.items())), target=dict(sorted(target.items())), + direct=packed(direct), equation_one=packed(eq1),symbolic_identity=True)) + # Small exhaustive identity control checks the prefix/suffix index branches, + # with affine counts compared symbolically. It is not an all-mask proof. + tiny_identity_count=0 + for p in range(1,4): + for a in range(p): + for bits in range(1<<(2*p+1)): + x=[(bits>>i)&1 for i in range(2*p+1)] + paid,target=invoice_histograms(p,a,x) + require(signed_histograms(paid,target)==equation_one_coefficients(p,a,x), 'failed required condition: signed_histograms(paid,target)==equation_one_coefficients(p,a,x)') + tiny_identity_count+=1 + controls=[] + # Source mutation must be caught before accepting any arithmetic. + src=(ROOT/'inputs/5405-PROOF.md').read_bytes() + try: + authenticate(src+b'\nMUTANT\n', manifest['inputs'][0]['sha256']) + except ValueError: + controls.append(dict(name='changed_source_bytes',expected='rejected',observed='rejected')) + else: + raise AssertionError('source mutant survived') + reversed_sign=neg(values[18]) + require(reversed_sign[1] < 0 and not gate(neg(values[18]),neg(differences[17]),neg(differences[18])), 'failed required condition: reversed_sign[1] < 0 and not gate(neg(values[18]),neg(differences[17]),neg(differences[18]))') + controls.append(dict(name='reverse_paid_minus_target_sign',expected='positive_certificate_fails', + observed='fails',interval=packed(reversed_sign))) + p,a,x=canonical_mask(18) + paid,target=invoice_histograms(p,a,x) + # Dropping one query invoice is a concrete 112-rank-one omission. + mutant=paid.copy(); mutant[1]-=112 + mutant_val=minus(moment(mutant,f),moment(target,f)) + require(signed_histograms(mutant,target)!=equation_one_coefficients(p,a,x), 'failed required condition: signed_histograms(mutant,target)!=equation_one_coefficients(p,a,x)') + require(not overlap(mutant_val,equation_one(p,a,x,f)) and mutant_val[1]<0, 'failed required condition: not overlap(mutant_val,equation_one(p,a,x,f)) and mutant_val[1]<0') + controls.append(dict(name='omit_one_112_rank_one_query',expected='invoice_identity_fails_and_sign_negative', + observed='fails_as_expected',interval=packed(mutant_val))) + mutant_target=target.copy(); mutant_target[145]-=224 + mutant_main=minus(moment(paid,f),moment(mutant_target,f)) + require(signed_histograms(paid,mutant_target)!=equation_one_coefficients(p,a,x), 'failed required condition: signed_histograms(paid,mutant_target)!=equation_one_coefficients(p,a,x)') + require(not overlap(mutant_main,equation_one(p,a,x,f)), 'failed required condition: not overlap(mutant_main,equation_one(p,a,x,f))') + controls.append(dict(name='omit_224_full_path_targets',expected='invoice_identity_fails', + observed='fails_as_expected',interval=packed(mutant_main))) + changed_profile = dict(P); changed_profile[4] -= 1 + try: + validate_profile(changed_profile,H,src.decode()) + except ValueError: + controls.append(dict(name='alter_paid_profile_count',expected='profile_pin_fails',observed='fails_as_expected')) + else: + raise AssertionError('profile mutant survived') + return dict(status='PASS_SCOPED_ARITHMETIC', source_head=manifest['source_head'], + canonical_main=manifest['canonical_main'], + exponent=dict(kappa=str(KAPPA),t=str(1-KAPPA)), + arithmetic=dict(bits=BITS,log_terms=LOG_TERMS,exp_terms=EXP_TERMS, + floating_point_used_for_acceptance=False), + local_moment=packed(local(f)), values={str(n):packed(v) for n,v in values.items()}, + differences={str(n)+'_to_'+str(n+1):packed(v) for n,v in differences.items()}, + short_difference_crosschecks={str(n):packed(v) for n,v in neighbor_short.items()}, + canonical_histogram_checks=hist_checks,tiny_symbolic_identity_count=tiny_identity_count, + negative_controls=controls, + power_enclosures={str(r):packed(v) for r,v in sorted(f.cache.items())}, + environment=dict(python=sys.version,platform=platform.platform(), + elapsed_seconds=time.monotonic()-start, + maximum_resident_set_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss), + excluded=['author interval engine','author 10290000-state DP','native replay','Lean', + 'physical circuit admission','global circuit optimum','kappa gain','changed-profile PR5402']) + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument('--receipt',type=Path,required=True) + args=parser.parse_args() + # Local cap applies even when called without an external runner. + resource.setrlimit(resource.RLIMIT_AS,(256*1024*1024,256*1024*1024)) + signal.alarm(60) + try: + result=run() + except Exception as exc: + result=dict(status='FAIL',error_type=type(exc).__name__,error=str(exc)) + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + raise + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + print(json.dumps({k:result[k] for k in ('status','values','differences','environment')},indent=2)) + +if __name__=='__main__': + main() diff --git a/research/controller-ceiling-convexity/numerical/inputs/5405-PROOF.md b/research/controller-ceiling-convexity/numerical/inputs/5405-PROOF.md new file mode 100644 index 0000000000..ddf53ecd85 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/5405-PROOF.md @@ -0,0 +1,209 @@ +# A ceiling for every prefix/suffix FULL/QUERY allocation + +## Result and scope + +Fix the bidirectional local profiles from PR5392: + +``` +paid P = {1:2193, 2:412, 3:510, 4:127, 5:40} +helper targets H = {4:28, 7:7, 8:47, 9:318}. +``` + +A full stage has 112 main ports and a fresh block of rank eight. A query stage +costs 112 H1 jobs and has no helper targets. Use the paired path controller +with any integer p >= 1, any split 0 <= a <= p-1, and b = p-1-a. Keep the +first a initial idle windows, all middle idle windows, and the last b terminal +idle windows. Each of the 2p+1 stages can independently be FULL or QUERY. +Specialize D_s=1 at each QUERY stage in both the main and idle products. + +**Theorem.** Every invoice in this family has paid moment greater than target +moment for every `0.00302728825 <= kappa < 1`. Thus this entire family fails +the necessary strict moment test in that range. The result includes arbitrarily +many pairs, every split, and all stage masks. It is not restricted to a small +number of changes from the current mask. + +This is an upper bound for the invoices defined by (1) and the strict moment +method. A different target list or idle law is outside the theorem. It is +not a lower bound for all native circuits or all multiplication algorithms. +It does not raise kappa. In particular, it does not prove the physical validity +of every masked word, a new compiler bound, or an unconditional multiplication +theorem. We grant the listed diagonal jobs to the entire family. A member that +fails a separate native or endpoint requirement cannot evade this ceiling. + +The local profile is a premise supplied by PR5392. The source receipt is retained +byte for byte. The complete source construction and its five framework assumptions +are not re-proved here. PR5398 uses the same recursive profile and reports complete +conditional kappa .00302728823. Its distance from this universal family ceiling +is less than 2e-11. This comparison does not independently admit PR5398. + +## 1. Complete interval invoice + +Put t=1-kappa, f(r)=r^t for r>0, and f(0)=0. Define + + L(t) = sum_r P[r] f(r) - sum_r H[r] f(r). + +Write x_s in {0,1} for the FULL indicator of stage s, and +`n=sum_{s=0}^{2p} x_s`. The local and query part of paid minus target is + + 112(2p+1) + (L(t)-112)n. + +There are 224 full-path main targets of rank 1+8n. For j=1,...,a, put + + h_j = sum_{s=0}^{2j-1} x_s, e_j = x_(2j). + +For j=a+1,...,p-1, put + + h_j = sum_{s=2j+1}^{2p} x_s, e_j = x_(2j). + +Each j contributes a retained whole idle of rank 8h_j, a main target of rank +`1+8(h_j+e_j)`, and a middle idle of rank eight if e_j=1. Each multiplicity is +224. Zero-rank idles are omitted. The complete difference is therefore + + E(t) = 112(2p+1) + (L(t)-112)n - 224 f(1+8n) + + 224 sum_j [f(8h_j) + e_j f(8) - f(1+8(h_j+e_j))]. (1) + +This includes every lost helper and every changed main and idle factor. +In particular, a FULL even stage restores its middle idle charge. The source +Laurent controller supplies the prefix/suffix products. Substitution of D_s=1 +preserves any established source identity; it does not preserve a removed +stage's helper credit. + +The verifier compares (1), as separate paid and target histograms, with the +retained literal Laurent controller on every mask for p=1,...,5 and every a. +It also compares the current p16/a7 invoice with the retained PR5392 receipt +and the separate main diagonal in `joint-helper-lattice/CONTROLLER.json`. +These checks bind the general formula to the source family. They are not a +native admission of all p or a proof from finite examples. + +## 2. An infinite tail becomes finite + +For 0=0 and e in {0,1}, + + f(8h) + e f(8) - f(1+8(h+e)) >= -1. (2) + +For e=0, use `f(z+1)-f(z) <= f(1)=1`. For e=1, use +`f(z+8+1) <= f(z)+f(8)+f(1)`. There are p-1 summands. Equation (1) gives + + E(t) >= B_t(n) := 336 + (L(t)-112)n - 224(1+8n)^t. (3) + +At `kappa_0 = 0.00302728825`, exact outward rational arithmetic proves + + B_t(96) > 104.185162541469147567554569434096, + B_t'(96) > 5.188985973480417120924401618389. + +Here `B_t'(n)=L(t)-112-1792t(1+8n)^(t-1)`. Since t<1, this derivative +increases with n. Thus every n>=96 has E(t)>0, for every p and split. +The program uses a lower bound for L and an upper bound for the power in +both comparisons. No floating tolerance is used. + +It remains to bound p when n<=95. Read the left side in the order +`x_0,(x_1,x_2),...,(x_(2a-1),x_(2a))`. Read the right side from the opposite +end in the same form. The central stage is `x_(2a+1)`. If a side pair has +both indicators zero, delete that pair and reduce p by one. The full-stage +count n and every later partial count stay fixed. The two removed queries +reduce the first term in (1) by 224. The removed summand is + + -224 [f(8h+1)-f(8h)] >= -224. + +The deletion therefore cannot increase E. It produces another member of the +same invoice family after reindexing. Repeat until each remaining side pair +contains a FULL stage. Then `p-1=a+b <= n`, so p<=96. Consequently, positivity +for all p<=96 and n<=95, together with (3), proves positivity at kappa_0 for +the unbounded family. This reduction does not claim that deletion preserves +a particular caller's input set; it compares the optimistic invoices needed +for this ceiling. + +## 3. Exact dynamic program for the finite part + +For a side with q pairs and k FULL stages, let D_q(k) be the minimum sum of +its summands in (1), including their factor 224. The single end stage gives + + D_0(0)=D_0(1)=0. + +Append the next odd/even indicators o,e in {0,1}. The recurrence is + + D_(q+1)(k+o+e) = min [D_q(k) + +224 (f(8(k+o)) + e f(8) - f(1+8(k+o+e)))]. (4) + +The minimum is over all predecessors. This follows directly from the partial +count before the even stage. Induction on q proves that (4) covers every side +mask. States with k>=96 can be omitted because total FULL count cannot decrease. + +For p=a+b+1, combine left count l, right count r, and central indicator c: + + 112(2p+1) + (L-112)(l+r+c) + D_a(l) + D_b(r) + -224 f(1+8(l+r+c)). (5) + +Discard only totals at least 96. Reflection exchanges a and b, so it suffices +to check a<=b. The program checks p=1,...,96 and 10,290,000 state combinations. +It uses integer bounds on the exact grid 2^192. Positive terms use lower +power bounds; negative terms use upper bounds. Taking a minimum of lower +bounds remains a lower bound, so interval overlap cannot create a false +positive certificate. The minimum certified lower bound is + + E(t) > 0.000000014914967918767741908079. + +It occurs at p=16, a=7, with eight FULL stages on the left, nine on the right, +and a FULL central stage. The receipt retains the exact rational bound and +the minimum for each p. Independent exhaustive mask enumeration through p=5 +agrees exactly with the integer dynamic-program minima. + +The interval engine is the unchanged rational logarithm/exponential engine +from `higher-moment-strictification`. The dynamic program is new. Neither is +a solver result, and no SciPy or floating arithmetic is used for acceptance. + +## 4. Extend the ceiling to all larger savings + +It is not enough to reject one value of kappa. We now show that no larger +value can become favorable in this family. + +First delete zero/zero side pairs as above, at the t under consideration. +If n=0, (1) gives E(t)=112, which is positive. Otherwise n>=1. Normalize (1) +by 8^t. In a reduced side pair, h>=1 if e=0, while h>=0 if e=1. Its normalized +summand is + + h^t + e - (h+e+1/8)^t. + +For h>=1 its derivative in t is negative, because `z^t log z` strictly +increases for z>=1. For h=0, reduction forces e=1, and the derivative of +`1-(9/8)^t` is also negative. The normalized full-path target term has negative +derivative, since n+1/8>1. The query term is nonnegative and nonincreasing. + +Finally the local term is strictly decreasing after the same normalization: + + L(t)/8^t = 2193(1/8)^t + 412(1/4)^t + 510(3/8)^t + + 99(1/2)^t + 40(5/8)^t + - 7(7/8)^t - 47 - 318(9/8)^t. + +Its only positive derivative term is less than `7 log(8/7) < 1`. The negative +term from `2193(1/8)^t` alone has magnitude at least `2193 log(8)/8 > 274` +on 0=1. + +Therefore a reduced invoice that is positive at t_0=1-kappa_0 remains +positive for every 0= 1, any split 0 <= a <= p-1, and b = p-1-a. Keep the +first a initial idle windows, all middle idle windows, and the last b terminal +idle windows. Each of the 2p+1 stages can independently be FULL or QUERY. +Specialize D_s=1 at each QUERY stage in both the main and idle products. + +**Theorem.** Every invoice in this family has paid moment greater than target +moment for every `0.00302728825 <= kappa < 1`. Thus this entire family fails +the necessary strict moment test in that range. The result includes arbitrarily +many pairs, every split, and all stage masks. It is not restricted to a small +number of changes from the current mask. + +This is an upper bound for the invoices defined by (1) and the strict moment +method. A different target list or idle law is outside the theorem. It is +not a lower bound for all native circuits or all multiplication algorithms. +It does not raise kappa. In particular, it does not prove the physical validity +of every masked word, a new compiler bound, or an unconditional multiplication +theorem. We grant the listed diagonal jobs to the entire family. A member that +fails a separate native or endpoint requirement cannot evade this ceiling. + +The local profile is a premise supplied by PR5392. The source receipt is retained +byte for byte. The complete source construction and its five framework assumptions +are not re-proved here. PR5398 uses the same recursive profile and reports complete +conditional kappa .00302728823. Its distance from this universal family ceiling +is less than 2e-11. This comparison does not independently admit PR5398. + +## 1. Complete interval invoice + +Put t=1-kappa, f(r)=r^t for r>0, and f(0)=0. Define + + L(t) = sum_r P[r] f(r) - sum_r H[r] f(r). + +Write x_s in {0,1} for the FULL indicator of stage s, and +`n=sum_{s=0}^{2p} x_s`. The local and query part of paid minus target is + + 112(2p+1) + (L(t)-112)n. + +There are 224 full-path main targets of rank 1+8n. For j=1,...,a, put + + h_j = sum_{s=0}^{2j-1} x_s, e_j = x_(2j). + +For j=a+1,...,p-1, put + + h_j = sum_{s=2j+1}^{2p} x_s, e_j = x_(2j). + +Each j contributes a retained whole idle of rank 8h_j, a main target of rank +`1+8(h_j+e_j)`, and a middle idle of rank eight if e_j=1. Each multiplicity is +224. Zero-rank idles are omitted. The complete difference is therefore + + E(t) = 112(2p+1) + (L(t)-112)n - 224 f(1+8n) + + 224 sum_j [f(8h_j) + e_j f(8) - f(1+8(h_j+e_j))]. (1) + +This includes every lost helper and every changed main and idle factor. +In particular, a FULL even stage restores its middle idle charge. The source +Laurent controller supplies the prefix/suffix products. Substitution of D_s=1 +preserves any established source identity; it does not preserve a removed +stage's helper credit. + +The verifier compares (1), as separate paid and target histograms, with the +retained literal Laurent controller on every mask for p=1,...,5 and every a. +It also compares the current p16/a7 invoice with the retained PR5392 receipt +and the separate main diagonal in `joint-helper-lattice/CONTROLLER.json`. +These checks bind the general formula to the source family. They are not a +native admission of all p or a proof from finite examples. + +## 2. An infinite tail becomes finite + +For 0=0 and e in {0,1}, + + f(8h) + e f(8) - f(1+8(h+e)) >= -1. (2) + +For e=0, use `f(z+1)-f(z) <= f(1)=1`. For e=1, use +`f(z+8+1) <= f(z)+f(8)+f(1)`. There are p-1 summands. Equation (1) gives + + E(t) >= B_t(n) := 336 + (L(t)-112)n - 224(1+8n)^t. (3) + +At `kappa_0 = 0.00302728825`, exact outward rational arithmetic proves + + B_t(96) > 104.185162541469147567554569434096, + B_t'(96) > 5.188985973480417120924401618389. + +Here `B_t'(n)=L(t)-112-1792t(1+8n)^(t-1)`. Since t<1, this derivative +increases with n. Thus every n>=96 has E(t)>0, for every p and split. +The program uses a lower bound for L and an upper bound for the power in +both comparisons. No floating tolerance is used. + +It remains to bound p when n<=95. Read the left side in the order +`x_0,(x_1,x_2),...,(x_(2a-1),x_(2a))`. Read the right side from the opposite +end in the same form. The central stage is `x_(2a+1)`. If a side pair has +both indicators zero, delete that pair and reduce p by one. The full-stage +count n and every later partial count stay fixed. The two removed queries +reduce the first term in (1) by 224. The removed summand is + + -224 [f(8h+1)-f(8h)] >= -224. + +The deletion therefore cannot increase E. It produces another member of the +same invoice family after reindexing. Repeat until each remaining side pair +contains a FULL stage. Then `p-1=a+b <= n`, so p<=96. Consequently, positivity +for all p<=96 and n<=95, together with (3), proves positivity at kappa_0 for +the unbounded family. This reduction does not claim that deletion preserves +a particular caller's input set; it compares the optimistic invoices needed +for this ceiling. + +## 3. Exact dynamic program for the finite part + +For a side with q pairs and k FULL stages, let D_q(k) be the minimum sum of +its summands in (1), including their factor 224. The single end stage gives + + D_0(0)=D_0(1)=0. + +Append the next odd/even indicators o,e in {0,1}. The recurrence is + + D_(q+1)(k+o+e) = min [D_q(k) + +224 (f(8(k+o)) + e f(8) - f(1+8(k+o+e)))]. (4) + +The minimum is over all predecessors. This follows directly from the partial +count before the even stage. Induction on q proves that (4) covers every side +mask. States with k>=96 can be omitted because total FULL count cannot decrease. + +For p=a+b+1, combine left count l, right count r, and central indicator c: + + 112(2p+1) + (L-112)(l+r+c) + D_a(l) + D_b(r) + -224 f(1+8(l+r+c)). (5) + +Discard only totals at least 96. Reflection exchanges a and b, so it suffices +to check a<=b. The program checks p=1,...,96 and 10,290,000 state combinations. +It uses integer bounds on the exact grid 2^192. Positive terms use lower +power bounds; negative terms use upper bounds. Taking a minimum of lower +bounds remains a lower bound, so interval overlap cannot create a false +positive certificate. The minimum certified lower bound is + + E(t) > 0.000000014914967918767741908079. + +It occurs at p=16, a=7, with eight FULL stages on the left, nine on the right, +and a FULL central stage. The receipt retains the exact rational bound and +the minimum for each p. Independent exhaustive mask enumeration through p=5 +agrees exactly with the integer dynamic-program minima. + +The interval engine is the unchanged rational logarithm/exponential engine +from `higher-moment-strictification`. The dynamic program is new. Neither is +a solver result, and no SciPy or floating arithmetic is used for acceptance. + +## 4. Extend the ceiling to all larger savings + +It is not enough to reject one value of kappa. We now show that no larger +value can become favorable in this family. + +First delete zero/zero side pairs as above, at the t under consideration. +If n=0, (1) gives E(t)=112, which is positive. Otherwise n>=1. Normalize (1) +by 8^t. In a reduced side pair, h>=1 if e=0, while h>=0 if e=1. Its normalized +summand is + + h^t + e - (h+e+1/8)^t. + +For h>=1 its derivative in t is negative, because `z^t log z` strictly +increases for z>=1. For h=0, reduction forces e=1, and the derivative of +`1-(9/8)^t` is also negative. The normalized full-path target term has negative +derivative, since n+1/8>1. The query term is nonnegative and nonincreasing. + +Finally the local term is strictly decreasing after the same normalization: + + L(t)/8^t = 2193(1/8)^t + 412(1/4)^t + 510(3/8)^t + + 99(1/2)^t + 40(5/8)^t + - 7(7/8)^t - 47 - 318(9/8)^t. + +Its only positive derivative term is less than `7 log(8/7) < 1`. The negative +term from `2193(1/8)^t` alone has magnitude at least `2193 log(8)/8 > 274` +on 0=1. + +Therefore a reduced invoice that is positive at t_0=1-kappa_0 remains +positive for every 0= 1, any split 0 <= a <= p-1, and b = p-1-a. Keep the\nfirst a initial idle windows, all middle idle windows, and the last b terminal\nidle windows. Each of the 2p+1 stages can independently be FULL or QUERY.\nSpecialize D_s=1 at each QUERY stage in both the main and idle products.\n\n**Theorem.** Every invoice in this family has paid moment greater than target\nmoment for every `0.00302728825 <= kappa < 1`. Thus this entire family fails\nthe necessary strict moment test in that range. The result includes arbitrarily\nmany pairs, every split, and all stage masks. It is not restricted to a small\nnumber of changes from the current mask.\n\nThis is an upper bound for the invoices defined by (1) and the strict moment\nmethod. A different target list or idle law is outside the theorem. It is\nnot a lower bound for all native circuits or all multiplication algorithms.\nIt does not raise kappa. In particular, it does not prove the physical validity\nof every masked word, a new compiler bound, or an unconditional multiplication\ntheorem. We grant the listed diagonal jobs to the entire family. A member that\nfails a separate native or endpoint requirement cannot evade this ceiling.\n\nThe local profile is a premise supplied by PR5392. The source receipt is retained\nbyte for byte. The complete source construction and its five framework assumptions\nare not re-proved here. PR5398 uses the same recursive profile and reports complete\nconditional kappa .00302728823. Its distance from this universal family ceiling\nis less than 2e-11. This comparison does not independently admit PR5398.\n\n## 1. Complete interval invoice\n\nPut t=1-kappa, f(r)=r^t for r>0, and f(0)=0. Define\n\n L(t) = sum_r P[r] f(r) - sum_r H[r] f(r).\n\nWrite x_s in {0,1} for the FULL indicator of stage s, and\n`n=sum_{s=0}^{2p} x_s`. The local and query part of paid minus target is\n\n 112(2p+1) + (L(t)-112)n.\n\nThere are 224 full-path main targets of rank 1+8n. For j=1,...,a, put\n\n h_j = sum_{s=0}^{2j-1} x_s, e_j = x_(2j).\n\nFor j=a+1,...,p-1, put\n\n h_j = sum_{s=2j+1}^{2p} x_s, e_j = x_(2j).\n\nEach j contributes a retained whole idle of rank 8h_j, a main target of rank\n`1+8(h_j+e_j)`, and a middle idle of rank eight if e_j=1. Each multiplicity is\n224. Zero-rank idles are omitted. The complete difference is therefore\n\n E(t) = 112(2p+1) + (L(t)-112)n - 224 f(1+8n)\n + 224 sum_j [f(8h_j) + e_j f(8) - f(1+8(h_j+e_j))]. (1)\n\nThis includes every lost helper and every changed main and idle factor.\nIn particular, a FULL even stage restores its middle idle charge. The source\nLaurent controller supplies the prefix/suffix products. Substitution of D_s=1\npreserves any established source identity; it does not preserve a removed\nstage's helper credit.\n\nThe verifier compares (1), as separate paid and target histograms, with the\nretained literal Laurent controller on every mask for p=1,...,5 and every a.\nIt also compares the current p16/a7 invoice with the retained PR5392 receipt\nand the separate main diagonal in `joint-helper-lattice/CONTROLLER.json`.\nThese checks bind the general formula to the source family. They are not a\nnative admission of all p or a proof from finite examples.\n\n## 2. An infinite tail becomes finite\n\nFor 0=0 and e in {0,1},\n\n f(8h) + e f(8) - f(1+8(h+e)) >= -1. (2)\n\nFor e=0, use `f(z+1)-f(z) <= f(1)=1`. For e=1, use\n`f(z+8+1) <= f(z)+f(8)+f(1)`. There are p-1 summands. Equation (1) gives\n\n E(t) >= B_t(n) := 336 + (L(t)-112)n - 224(1+8n)^t. (3)\n\nAt `kappa_0 = 0.00302728825`, exact outward rational arithmetic proves\n\n B_t(96) > 104.185162541469147567554569434096,\n B_t'(96) > 5.188985973480417120924401618389.\n\nHere `B_t'(n)=L(t)-112-1792t(1+8n)^(t-1)`. Since t<1, this derivative\nincreases with n. Thus every n>=96 has E(t)>0, for every p and split.\nThe program uses a lower bound for L and an upper bound for the power in\nboth comparisons. No floating tolerance is used.\n\nIt remains to bound p when n<=95. Read the left side in the order\n`x_0,(x_1,x_2),...,(x_(2a-1),x_(2a))`. Read the right side from the opposite\nend in the same form. The central stage is `x_(2a+1)`. If a side pair has\nboth indicators zero, delete that pair and reduce p by one. The full-stage\ncount n and every later partial count stay fixed. The two removed queries\nreduce the first term in (1) by 224. The removed summand is\n\n -224 [f(8h+1)-f(8h)] >= -224.\n\nThe deletion therefore cannot increase E. It produces another member of the\nsame invoice family after reindexing. Repeat until each remaining side pair\ncontains a FULL stage. Then `p-1=a+b <= n`, so p<=96. Consequently, positivity\nfor all p<=96 and n<=95, together with (3), proves positivity at kappa_0 for\nthe unbounded family. This reduction does not claim that deletion preserves\na particular caller's input set; it compares the optimistic invoices needed\nfor this ceiling.\n\n## 3. Exact dynamic program for the finite part\n\nFor a side with q pairs and k FULL stages, let D_q(k) be the minimum sum of\nits summands in (1), including their factor 224. The single end stage gives\n\n D_0(0)=D_0(1)=0.\n\nAppend the next odd/even indicators o,e in {0,1}. The recurrence is\n\n D_(q+1)(k+o+e) = min [D_q(k)\n +224 (f(8(k+o)) + e f(8) - f(1+8(k+o+e)))]. (4)\n\nThe minimum is over all predecessors. This follows directly from the partial\ncount before the even stage. Induction on q proves that (4) covers every side\nmask. States with k>=96 can be omitted because total FULL count cannot decrease.\n\nFor p=a+b+1, combine left count l, right count r, and central indicator c:\n\n 112(2p+1) + (L-112)(l+r+c) + D_a(l) + D_b(r)\n -224 f(1+8(l+r+c)). (5)\n\nDiscard only totals at least 96. Reflection exchanges a and b, so it suffices\nto check a<=b. The program checks p=1,...,96 and 10,290,000 state combinations.\nIt uses integer bounds on the exact grid 2^192. Positive terms use lower\npower bounds; negative terms use upper bounds. Taking a minimum of lower\nbounds remains a lower bound, so interval overlap cannot create a false\npositive certificate. The minimum certified lower bound is\n\n E(t) > 0.000000014914967918767741908079.\n\nIt occurs at p=16, a=7, with eight FULL stages on the left, nine on the right,\nand a FULL central stage. The receipt retains the exact rational bound and\nthe minimum for each p. Independent exhaustive mask enumeration through p=5\nagrees exactly with the integer dynamic-program minima.\n\nThe interval engine is the unchanged rational logarithm/exponential engine\nfrom `higher-moment-strictification`. The dynamic program is new. Neither is\na solver result, and no SciPy or floating arithmetic is used for acceptance.\n\n## 4. Extend the ceiling to all larger savings\n\nIt is not enough to reject one value of kappa. We now show that no larger\nvalue can become favorable in this family.\n\nFirst delete zero/zero side pairs as above, at the t under consideration.\nIf n=0, (1) gives E(t)=112, which is positive. Otherwise n>=1. Normalize (1)\nby 8^t. In a reduced side pair, h>=1 if e=0, while h>=0 if e=1. Its normalized\nsummand is\n\n h^t + e - (h+e+1/8)^t.\n\nFor h>=1 its derivative in t is negative, because `z^t log z` strictly\nincreases for z>=1. For h=0, reduction forces e=1, and the derivative of\n`1-(9/8)^t` is also negative. The normalized full-path target term has negative\nderivative, since n+1/8>1. The query term is nonnegative and nonincreasing.\n\nFinally the local term is strictly decreasing after the same normalization:\n\n L(t)/8^t = 2193(1/8)^t + 412(1/4)^t + 510(3/8)^t\n + 99(1/2)^t + 40(5/8)^t\n - 7(7/8)^t - 47 - 318(9/8)^t.\n\nIts only positive derivative term is less than `7 log(8/7) < 1`. The negative\nterm from `2193(1/8)^t` alone has magnitude at least `2193 log(8)/8 > 274`\non 0=1.\n\nTherefore a reduced invoice that is positive at t_0=1-kappa_0 remains\npositive for every 0=3, all three unpaired endpoint/central stages are FULL, every side pair is `10`, and the pair counts are as balanced as possible. For n=0,1,2, p=1 suffices. The proof is elementary concavity and does not need a new published theorem or a replay of the author's dynamic program. + +This is an independent mathematical verification of the reduction, not a new kappa certificate. No values of the actual profile moment L, the proposed ceiling exponent, or the author's tail interval bounds were recomputed. The frozen autonomous provider profile, port count and idle law are essential. The coupled #5402 contract is outside this result. + +## Exact source and reduced objective + +The primary source is the sole monitor's [#5405 proof](../../upstream-monitor-resume-20261024/5405-PROOF.md), source head `314b56a6c0056c2358538f072c6fde9d365be44d`. The full equation (1), recurrence, tail and scope sections were read. Its local profiles are + +``` +P={1:2193,2:412,3:510,4:127,5:40}, +H={4:28,7:7,8:47,9:318}. +``` + +Fix t in (0,1), `f(r)=r^t` for r>0, `f(0)=0`, and `L=sum P[r]f(r)-sum H[r]f(r)`. For any p>=1, split a+b=p-1 and FULL/QUERY stage mask x, the source defines + +``` +E = 112(2p+1)+(L-112)n-224 f(1+8n) + +224 sum_j g(h_j,e_j), +g(h,e)=f(8h)+e f(8)-f(1+8(h+e)). +``` + +At fixed n, all terms except + +``` +J := p + sum_j g(h_j,e_j) +``` + +are constant: `E=224J+112+(L-112)n-224f(1+8n)`. Thus every change below compares J exactly and preserves the local FULL/helper census n. It also accounts explicitly for every added/deleted QUERY and retained idle summand. It does not preserve a given physical caller or its productive input set; the resulting mask is another member of the source's optimistic invoice family. + +Read each side from its outside end toward the central stage. The left side is `x0,(x1,x2),...,(x_(2a-1),x_(2a))`; the right side is `x_(2p),(x_(2p-1),x_(2p-2)),...,(x_(2a+3),x_(2a+2))`. The central indicator is `c=x_(2a+1)`. For a pair `(o,e)` preceded by k FULL stages on that side, its summand is `g(k+o,e)`. A change preserving the total o+e leaves every later partial count unchanged. + +Write `delta(z)=f(z+1)-f(z)`. Strict concavity gives `00, `delta(0)=1`, and delta strictly decreases with z. For each fixed positive length d, `f(z+d)-f(z)` also strictly decreases with z. + +## 1. Reduce side pairs to 10 + +**Delete 00.** This reduces p by one and removes `g(k,0)=-delta(8k)`. Therefore + +``` +Delta J = -1+delta(8k) <= 0. +``` + +Equality occurs exactly when k=0. The side may become empty; p remains at least one because a side pair existed before deletion. + +**Replace 01 by 10.** This leaves p and n fixed, and leaves all later partial counts fixed. The exact change is + +``` +Delta J = f(8k+8)-f(8k)-f(8) <= 0. +``` + +This is subadditivity of the concave power. Equality holds exactly at k=0; it is strict for k>0. + +**Split 11 into 10,10 on the same side.** This adds one pair, so p increases by one, while n and all later partial counts are unchanged. It adds two QUERY stages and their paid cost, which is the `+1` below in units of 224: + +``` +Delta J = 1+g(k+1,0)+g(k+2,0)-g(k+1,1) + = 1+f(8k+16)-f(8k+9)-f(8). +``` + +For k>=0, decreasing seven-step increments imply + +``` +f(8k+16)-f(8k+9) <= f(16)-f(9) < f(8)-f(1). +``` + +The last strict inequality compares the integrals of `t z^(t-1)` over [9,16] and [1,8]. Since f(1)=1, the split strictly decreases J for every k>=0. Equivalently, the equal-sum pair (16,1) is more spread than (9,8), but no separate majorization theorem is required. + +Apply these replacements independently to the finitely many original side pairs. No replacement introduces a pair type other than 10, so the process terminates. Afterwards every side consists only of 10 pairs. The three unpaired indicators are still arbitrary bits. + +## 2. Move FULL stages to the unpaired positions + +Let q_L,q_R count the remaining 10 pairs, and let l,r,c be the left-end, right-end and central indicators. Then + +``` +n = l+r+c+q_L+q_R, p=q_L+q_R+1. +``` + +**A nonempty side with QUERY end.** Replace its first 10 pair and QUERY end by a FULL end, deleting the pair. The removed pair had h=1. Later partial counts are identical: both old and new prefixes contain one FULL before the next pair. Thus + +``` +Delta J = -1+delta(8) < 0. +``` + +Perform this on each side that qualifies. Every remaining QUERY end is now on an empty side. + +**Fill a QUERY central stage or an empty QUERY side end.** Remove the last 10 pair from any nonempty donor side and turn that unpaired QUERY indicator into FULL. Removing the last pair affects no later donor partial count. The central indicator belongs to no side partial count; an empty recipient side has no summands. If the donor pair ends with k FULL stages on its side, k>=1, and + +``` +Delta J = -1+delta(8k) < 0. +``` + +The donor side loses one pair, p decreases by one, and the moved FULL keeps n fixed. A donor always exists while an unpaired position needs filling and the target number of FULL unpaired positions has not been reached: `q_L+q_R=n-(l+r+c)>0`. + +For n>=3, repeat until l=r=c=1. The final number of pairs is n-3 and `p=n-2`. For n<=2, repeat only until all n FULL stages occupy unpaired positions; then q_L=q_R=0 and p=1. The same reasoning gives p=1 for n=3 with all three indicators FULL. The construction works also when one side initially has no pairs or both sides are empty. + +This proves the small-count reduction without assuming n>=3 during a transfer. For n=0, deleting 00 pairs has equality throughout, and every all-QUERY invoice already has E=112. + +## 3. Balance the two sides + +For n>=3 both side ends are FULL. The j-th 10 pair on either side therefore has `h=j+1`, including h=2 for the first pair. Define + +``` +F(q) = -sum_(k=2)^(q+1) delta(8k), F(0)=0. +``` + +The side contribution is F(q), and + +``` +F(q+1)-F(q)=-delta(8(q+2)). +``` + +These increments strictly increase with q, so F is strictly discretely convex. If a>=b+2, moving the last pair of the longer side to the end of the shorter side changes the score by + +``` +F(a-1)+F(b+1)-F(a)-F(b) + = delta(8(a+1))-delta(8(b+2)) < 0. +``` + +Thus at fixed a+b=n-3, the minimum has + +``` +a=floor((n-3)/2), b=ceil((n-3)/2), +``` + +up to reflection. Balanced reflected masks have the same invoice. This balancing changes the permitted split and the mask; it does not claim a free physical retiming of one caller. + +## 4. Exact canonical minimum for each n + +Every original invoice has been transformed to an admissible canonical invoice with no larger E. Conversely the canonical invoice is itself in the stated family. Consequently its value is the **global minimum over all p, splits and stage masks with that FULL count n**. + +For n=0,1,2, + +``` +C_n(t) = 336+(L(t)-112)n-224(1+8n)^t. +``` + +For n>=3, put a=floor((n-3)/2), b=ceil((n-3)/2). Then + +``` +C_n(t) = n L(t)+112(n-3)-224(1+8n)^t + -224[sum_(k=2)^(a+1) delta(8k) + +sum_(k=2)^(b+1) delta(8k)]. +``` + +The formulas agree at n=3 if the first expression is extended there. For n=18 they select p=16,a=7,b=8, with side FULL counts eight and nine and a FULL central stage, matching the location reported by the author's dynamic program. This is an index/formula comparison, not a replay of its numerical minimum. + +The result holds separately for every 0=96 tail certificate at its specified exponent is accepted, the finite part can be independently checked using only **96 canonical invoices, n=0,...,95**, instead of 10,290,000 dynamic-program combinations. This note does not rerun that tail certificate, those 96 numerical inequalities, the author's interval engine, or the extension to all larger kappa. It establishes the analytic reduction that would permit the smaller independent verification. + +The [bounded exact controls](../tests/5405-EXCHANGE-TOY-CONTROLS.json) use t=1/2, p<=4 and n<=6 so both compared invoices stay within p<=4. They compare square-root expressions using symbolic square-factor normalization and outward rational bounds on a 2^80 grid, under a ten-second alarm. They check the side-index translation against equation (1), the zero/strict cases of each exchange, balancing, and attainment of the canonical minimum in the bounded domain. No actual profile moment L is evaluated because it cancels at fixed n. + +The previous #5397 primary PR body describes classical concave-order invoice preflight and explicitly separates that arithmetic from physical legality and funding. The existing literature ledger was checked first; no earlier paper dependency is needed for the elementary derivative proof above. This is not an application of Douglas's unrelated operator-majorization theorem. No new paper was added. + +The local P/H profiles are autonomous jobs, each FULL has 112 ports and a fresh rank-eight stage block, and the prefix/suffix idle law is fixed. Coded or coupled helper outputs, altered target lists, changed stage ranks, different idle incidence, or another controller graph require a new comparison. In particular this does not apply to #5402. No physical optimum, native query lower bound, compiler admission or improved exponent follows. + +Credit Ali Romman for #5405's source family, equation, original unbounded ceiling and exact dynamic program; Cinna Davis for the paired controller; the retained native/helper/compiler/interval contributors; and root for proposing the exchange conjecture checked here. This note independently checks the moves, indices, strictness and small counts, with substantial OpenAI Codex assistance. Local only; no external publication. diff --git a/research/controller-ceiling-convexity/numerical/inputs/5405-discrete-convexity-three-value-gate.md b/research/controller-ceiling-convexity/numerical/inputs/5405-discrete-convexity-three-value-gate.md new file mode 100644 index 0000000000..d464faf030 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/5405-discrete-convexity-three-value-gate.md @@ -0,0 +1,128 @@ +# #5405: strict discrete convexity and a three-value gate for the unbounded family + +**The analytic claim is valid.** For every fixed `0=0. This includes the small-count junction. Consequently one positive candidate value and the two correct neighboring signs prove positivity of the entire unbounded invoice family at that fixed t. The n>=96 tail and the author's dynamic program are unnecessary for that implication. + +This note supplies the analytic gate only. It does not evaluate the actual local profile moment, any claimed kappa, or the three numerical inequalities. A separately assigned numerical worker owns that certificate. No new paper dependency, physical caller transformation, source/native execution or coupled #5402 transfer is introduced. + +## Premises and exact canonical sequence + +The underlying primary source is [#5405 equation (1)](../../upstream-monitor-resume-20261024/5405-PROOF.md), pinned at head `314b56a6c0056c2358538f072c6fde9d365be44d`. The preceding frozen exchange proof establishes that each invoice with FULL count n has E>=C_n and that C_n is attained by another invoice in the same permitted family. That reduction, including its accounting and source scope, is a premise here. + +Write + +``` +f(z)=z^t for z>0, f(0)=0, +delta(z)=f(z+1)-f(z), +A_n=f(8n+9)-f(8n+1), +D_n=C_(n+1)-C_n. +``` + +Since 00. These follow directly by integrating the strictly decreasing positive derivative `t z^(t-1)` over intervals of fixed length eight and one respectively. + +The canonical values are + +``` +C_n=336+(L-112)n-224f(1+8n), n=0,1,2, +C_n=nL+112(n-3)-224f(1+8n) + -224[sum_(k=2)^(a+1)delta(8k) + +sum_(k=2)^(b+1)delta(8k)], n>=3, +a=floor((n-3)/2), b=ceil((n-3)/2). +``` + +Empty sums are zero. The first formula, extended to n=3, agrees with the second. + +## Exact first differences and the small-count junction + +The two balanced side counts increase alternately. When n increases to n+1, the shorter side gains a pair; on the next step the other side gains a pair at the same partial FULL count. Therefore, putting `k_n=floor((n+1)/2)` for n>=3, + +``` +D_n=L-112-224A_n, n=0,1,2, +D_n=L+112-224A_n-224delta(8k_n), n>=3. +``` + +The side correction appears twice at each successive k: k_3=k_4=2, k_5=k_6=3, and so on. In particular its first argument is 16, not 8. + +Explicit small values check both the branch point and that first repeated correction: + +``` +C_0=112, +C_1=L+224-224f(9), +C_2=2L+112-224f(17), +C_3=3L-224f(25), +C_4=4L+112-224f(33)-224delta(16), +C_5=5L+224-224f(41)-448delta(16). +``` + +For n=0,1, + +``` +D_(n+1)-D_n=224(A_n-A_(n+1))>0. +``` + +At the only junction, n=2, + +``` +D_3-D_2=224[1-delta(16)+A_2-A_3]>0. +``` + +For every n>=3, + +``` +D_(n+1)-D_n + =224[A_n-A_(n+1) + +delta(8k_n)-delta(8k_(n+1))]>0. +``` + +The first term is strictly positive. The last difference is nonnegative because k_(n+1)>=k_n; it is zero on alternate steps. Thus **D_(n+1)>D_n for every n>=0**, which is strict discrete convexity on the whole nonnegative integer domain. L cancels from each second difference, so the result is independent of its value. Dependence of L on t causes no issue because t is fixed throughout this argument. + +Equivalently, define B_n=336+(L-112)n-224f(1+8n) and C_n=B_n+224T_n. Then + +``` +T_(n+1)-T_n=0, n=0,1,2, +T_(n+1)-T_n=1-delta(8 floor((n+1)/2)), n>=3. +``` + +These increments are nondecreasing, including the positive jump at n=3. B_n is already strictly discretely convex, and T_n is discretely convex. This gives the same proof without treating the balanced side contribution as strictly convex on each step: its increments deliberately repeat. + +## The exact three-value gate + +For any integer m>=1, suppose at one fixed t that + +``` +C_m>0, D_(m-1)<=0, D_m>=0. +``` + +For nm, every D_j with m<=j<=n-1 is at least D_m>=0, so + +``` +C_n-C_m=sum_(j=m)^(n-1)D_j>=0. +``` + +Hence C_n>=C_m>0 for every n>=0, and every original invoice has E>=C_n>0. This is an exact unbounded conclusion from finite neighboring comparisons; no tail estimate, large-n limit or assumption of eventual growth is used. If both neighboring inequalities are strict, m is the unique minimizing FULL count. Non-strict signs still suffice for positivity, with a possible adjacent tie. Strict discrete convexity prevents a longer interval of tied minima. For m=0, the one-sided condition D_0>=0 is sufficient. + +At m=18, the numerical worker can use the directly simplified expressions + +``` +C_18=18L+1680-224f(145) + -224[2 sum_(k=2)^8 delta(8k)+delta(72)], +D_17=L+112-224[f(145)-f(137)+delta(72)], +D_18=L+112-224[f(153)-f(145)+delta(72)]. +``` + +Thus the needed outward certificates are a positive lower bound for C_18, a nonpositive upper bound for D_17, and a nonnegative lower bound for D_18. Direct evaluation of these differences can avoid extra interval widening from subtracting separately enclosed C values. This is an evaluation plan, not an asserted sign or numerical result. + +## Verification, provenance and limits + +The [exact bounded controls](../tests/5405-DISCRETE-CONVEXITY-CONTROLS.json) use t=1/2 and only small n. They check the first-difference formula against the original canonical expression, all junction values, the convex correction decomposition, strict second differences, independence from an arbitrary affine L term, and a synthetic local-minimum example. Square-factor normalization detects exact identities; outward integer square-root bounds certify signs. The script has a ten-second alarm and imports no author/source code. Its finite examples check indexing and implementation; the all-n, all-t proof is the analytic argument above. + +The source profile remains P={1:2193,2:412,3:510,4:127,5:40}, H={4:28,7:7,8:47,9:318}, with 112 ports, fresh rank-eight FULL stages, rank-one QUERY price, and the same prefix/suffix idle law. The theorem's affine-L independence does not alter the validity obligations of the source equation or grant a changed helper/coded-output contract. Coupled #5402 outputs remain outside this family. + +The three-value implication is at a **fixed t=1-kappa**. Extending a certified sign to a whole interval of kappa requires a separate monotonicity argument; discrete convexity in n alone does not provide it. No actual kappa inequality, interval-tail certificate, DP replay, source/native execution, physical optimum, recursive admission or improved exponent is established by this note. + +Credit Ali Romman for the primary invoice family, original unbounded ceiling and exact dynamic program; Cinna Davis for the paired controller; the retained source/helper/compiler/interval contributors; and root for proposing the discrete-convexity conjecture. This independent check and its exact controls were prepared with substantial OpenAI Codex assistance. Local only; no external publication. The preceding 66-entry checkpoint and its frozen exchange note remain unchanged. diff --git a/research/controller-ceiling-convexity/numerical/inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json b/research/controller-ceiling-convexity/numerical/inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json new file mode 100644 index 0000000000..00fedd3f45 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json @@ -0,0 +1,33 @@ +{ + "created_utc": "2026-10-23T23:42:15.532126+00:00", + "status": "5405_discrete_convexity_analytic_gate_pass_numerics_separately_owned", + "owner": "/root/astra_mathematics_papers_resume", + "ledger_entries": 68, + "main_papers": 18, + "precision_papers": 3, + "screened_papers": 10, + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "source_proof_path": "outputs/upstream-monitor-resume-20261024/5405-PROOF.md", + "source_proof_sha256": "5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37", + "exchange_proof_sha256": "0e575a88d28db5aecc5ccf24504923a0508ff976d05f92e91e6d48408b7688ea", + "artifact_sha256": { + "README.md": "e5cd233ba45ef173eaad2152415d5b219940708d7d4437d8ba86f4380980bee4", + "RESUME.json": "bf9dddfcf09018ed41264ec013ac2416633a5413168b6aaa3b992125e354151b", + "SEARCH-AND-REJECTION-LEDGER.jsonl": "dc315aca5b108d1e3bef0eff7b6c88cc5215ead3fe74985ff95e5093739e00c5", + "notes/5405-discrete-convexity-three-value-gate.md": "bdad476f31b450e1ac4d1fd0d9530b43e33ebac48accc0956b38a9634b40a929", + "tests/check_5405_discrete_convexity.py": "42c33591d7878cc26c402b041b7d21e048531f1b0825b80ad196d5aebd2bb3a6", + "tests/5405-DISCRETE-CONVEXITY-CONTROLS.json": "5eb054264a9c36ee4a394f0ff8576c52a64e12256514b63bfa4176e4a6f0d462" + }, + "preserved_earlier_ledger": { + "entries": 66, + "sha256": "8a2d8f359bee8694f06c99ae7c5a18f4cf1055a0c9a05976dd20696720b15a80", + "prefix_bytes": 33154 + }, + "controls": { + "count": 8, + "t": "1/2", + "canonical_n_max": 13, + "elapsed_seconds": 0.0047299709985964 + }, + "scope": "All-n all0 Contribute one useful, independently reviewable result to +> https://github.com/CrocSwap/integer-mult-bounds. Read AGENTS.md, autoresearch.md +> and CONTRIBUTING.md from the current main branch first. Use the repository's +> task-selection and overlap process unless I assigned a specific task. In a loop, +> fetch canonical main and recheck priorities at every round using the guide's +> checkpoint procedure; preserve in-progress work and frozen inputs. Work for +> one session of about 60 minutes unless I specify another budget, keeping the +> final quarter for verification and a concise handoff, +> and report the exact scope, evidence, remaining obligations and predecessor +> credit. You may post routine claims, questions, findings, handoffs and feedback +> in Discussions and open a focused PR without asking me again for each action. +> Do not merge, close others' PRs or change the selected frontier. + +Maintainers should update the catalogue when new evidence changes priorities. +External donation prompts should point here rather than freeze a second set of +weights, frontier values or supposedly open problems. + +Prepared by Douglas Colkitt with OpenAI Codex assistance. Apache-2.0. diff --git a/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__agent-procedure.md b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__agent-procedure.md new file mode 100644 index 0000000000..9294c540bf --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__agent-procedure.md @@ -0,0 +1,487 @@ +# Standing agent procedure + +Return to [autoresearch.md](../../autoresearch.md) for the short entry point. + +**Use this procedure when contributing without a specific task.** Aim for +one useful, independently reviewable result in the time available. Default to +one session of about **60 minutes** unless the donor supplies another budget. +A verified +construction, a missing-lemma audit, an independent checker, or a precisely +scoped obstruction can all help. A larger κ is better; it is an exponent saving, +not a measured runtime speedup. + +Start with [the one-page bottleneck brief](bottleneck-brief.md) and +[the small glossary](research-glossary.md) if the construction is +unfamiliar. A useful finding, falsification or handoff can complete a session; +there is no requirement to produce a PR when no new artifact is warranted. + +**Coordinate on the [discussion board](https://github.com/CrocSwap/integer-mult-bounds/discussions).** +Read [Start here](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163), +check [handoffs and requests for independent checks](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166), +and use [mechanism proposals](https://github.com/CrocSwap/integer-mult-bounds/discussions/1167) +for early architectural ideas. A concrete investigation should have its own +scoped thread; join an existing one when it covers your question. + +## Looping agents: refresh upstream at each research checkpoint + +A loop must not keep choosing tasks from the checkout it started with. The task +picker reads **local files only**: it neither fetches upstream nor detects a newer +priority revision. A successful overlap refresh does not update those files. + +At the start of each round, before a major pivot, and before submission, fetch +canonical main. During a longer round, do this at a safe checkpoint roughly once +per hour; do not interrupt an artifact-writing replay just to refresh guidance. +For a fork, `origin/main` may be stale: check `git remote -v` and use the remote +pointing to `CrocSwap/integer-mult-bounds`. This explicit URL works for either: + +```sh +git fetch --no-tags https://github.com/CrocSwap/integer-mult-bounds.git main +# Pin the fetched commit immediately, before another fetch changes FETCH_HEAD. +research_main=$(git rev-parse FETCH_HEAD) +git show "$research_main:AGENTS.md" +git show "$research_main:autoresearch.md" +git show "$research_main:docs/research/current-priorities.md" +git show "$research_main:docs/research/agent-task-catalog.json" +git show "$research_main:certificates/selected-result.json" +``` + +If `origin` is the canonical repository, `git fetch origin main` followed by +pinning `origin/main` is equivalent. Fetching does **not** update the working +files or the local task picker. Compare the fetched commit, `priority_revision`, +selected record and relevant predecessor/review changes with your last checkpoint; +when changed, read the priority log and the linked evidence for your task. + +- **New round:** start an isolated branch/worktree from the fetched commit and + run its task picker and overlap helper there. Reuse a checkout only if clean + and safely updatable; do not reset an existing research branch to main. +- **Work in progress:** preserve the current branch, exact inputs and partial + evidence. Decide whether to continue, narrow, hand off or retire the task. + A weight change alone is not a reason to abandon useful work; an applicable + new obstruction or completed overlapping result may be. Record the decision + in the existing task/claim rather than creating a duplicate session report. +- **Before submission:** refresh live overlap and check compatibility against + fetched main. Merge/rebase only on your isolated branch with work safely saved, + and rerun checks affected by changed inputs. Keep frozen source pins immutable; + report an older scientific baseline explicitly when retaining it is intentional. +- **Record freshness:** note the upstream commit, priority revision, UTC check + time and any relevant change in the existing task metadata or handoff. If the + fetch fails or access is offline, report the last checked version and limitation; + continue independent work where useful without claiming current coverage. + +This checkpoint is a reread of upstream instructions, not an automatic migration +of an experiment or a guarantee that an already-running agent has seen an update. +External loop controllers should explicitly invoke it between iterations. + +## 1. Orient briefly, then choose a distinct task + +Read [CONTRIBUTING.md](../../CONTRIBUTING.md), then +[the selected record](../../certificates/selected-result.json). Follow its `review`, +`source_manifest`, `certificate` and `reproduce` fields. Use +[current status](current-status.md) for context and +[the PR ledger](pr-ledger.md) for previous disposition. Neither a +historical note nor an unaudited PR supersedes the selected record. + +**Posting and PR permissions:** the standard donation prompt below authorizes +routine claims, questions, findings, handoffs, feedback and focused PRs. If that +is your assignment, proceed without asking again for each action. Respect a +donor's narrower instructions and your account/tool permissions; this document +does not grant additional account access. Merging, closing others' work and +changing the selected frontier remain separate maintainer actions. + +**Before drawing a card**, check [open handoffs in #1166](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +for a concrete request matching your track or expertise. Follow its evidence, +check current overlap and take a complementary scope. An advisory claim does +not prevent an explicitly independent audit. If no suitable request fits, use +the helper below. Do not reroll a task the user already assigned. + +The picker displays `existing_checks` when known: exact source, checked scope, +evidence status and remaining obligations. A changed selected-record hash flags +old context; an empty list means coverage is unknown, not that nobody tried it. + +Run this standard-library helper: + +```sh +# Python 3.10 or later; no third-party dependencies. +python3 scripts/choose_research_task.py +# To reproduce a selection, pass the emitted 32-hex-digit nonce: +python3 scripts/choose_research_task.py --seed YOUR_NONCE +# Expertise or an explicit user preference may override the allocation: +python3 scripts/choose_research_task.py --track complex-mechanisms +# Retrieve a specific card after assignment: +python3 scripts/choose_research_task.py --task connector-alphabet-change +# Optional: surface structured handoffs/claims from an existing overlap cache. +python3 scripts/choose_research_task.py --coordination-cache /tmp/overlap.json +``` + +It reads [the task catalogue](agent-task-catalog.json), draws a +128-bit OS-random nonce, and proposes a weighted track and a short list of task +cards with independently selected methods. It reports your checkout's commit +and selected-record hash. It does not contact GitHub, reserve work, or establish +that a task is open. A deterministic seed is a reproducibility aid, not novelty. +Each card supplies a first-step command, expected evidence, a next experiment, +its connection to the bottleneck, allowed variations and scope-change triggers. + +**Resolve the generic orientation command before running a historical card.** +If its `first_step.command` is `python3 -B scripts/research_baseline.py`, use the +current orientation command in [current priorities](current-priorities.md). +For the selected #4470 productive-helper schema, that command is: + +```sh +python3 -B scripts/research_selected_baseline.py +``` + +The older helper expects `bit_lower` and `complex_lower`, which this certificate +does not contain. This substitution applies only to the generic selected-baseline +step; retain the card's question, inspection instructions and any named scientific +replay command. A future selection must be checked against its own reviewed schema. +The [startup compatibility audit](task-startup-compatibility.md) explains why the +historical catalogue, picker and baseline bytes remain intact. The replacement +authenticates selected sources and checks metadata consistency; it is not a cold +replay or supplier admission. + +In a sparse checkout, the helper can validate omitted catalogue references when +they are regular files in `HEAD` with matching skip-worktree index entries. It +reports these as `sparse_checkout.omitted_catalogue_paths`. For absent paths, +ordinary deletions and staged content replacements still fail. Materialize the +chosen card's inputs before running its commands. This reference check does not +resolve replay dependencies. + +For missing selected-baseline inputs, run +`python3 -B scripts/research_baseline_sparse.py`, inspect its materialization +command, and use its schema-aware `next` command after materializing the inputs. +Its omission report does not authenticate sources; the baseline still must pass. + +Use the overlap helper before choosing a card and refresh before submission: + +```sh +python3 scripts/find_overlap.py --task connector-alphabet-change +python3 scripts/find_overlap.py 'helper inventory' 'masked decoder' --refresh +# Include remote closed/merged PR bodies when checking historical overlap. +python3 scripts/find_overlap.py 'helper inventory' --include-closed +# Path search is available; it may require a slower separate index refresh. +python3 scripts/find_overlap.py --path 'research/joint-query/*' +# Parallel sessions may choose distinct --cache paths outside the checkout. +# Without network access: local notes plus any cached remote snapshot. +python3 scripts/find_overlap.py 'connector' --offline --json +``` + +It searches all open PR titles/bodies (including drafts), discussion bodies and +comments/replies, top-level package READMEs/TASK metadata and the local PR ledger. +By default, closed PRs are represented only through local notes and the ledger. +`--include-closed` additionally fetches every page of closed/merged PR titles +and bodies, with a separate cached coverage timestamp. It costs an extra REST +scan and does not include closed-PR file paths; use it without `--path`. +An offline run can use that corpus only after it has been cached. A failed +refresh retains the previous complete corpus and reports a warning. When no +usable corpus exists, coverage is reported as missing. Open/closed snapshots are not atomic, +so duplicate PR numbers use the record with the newer PR update time. +The helper does not search every code diff or nested source file. Remote pagination is complete when +reported as such; snapshots are cached outside the checkout for five minutes. +Output includes excerpts, source links, exact PR heads, timestamps and warnings +for unavailable or stale coverage. No matches does not establish novelty. +For path matches, `head` identifies the file-list snapshot and `body_head` the +PR metadata snapshot. `head_matches` and coverage's `unverified_heads` flag +missing or disagreeing bindings, including PRs with no path hit. Recheck those +PRs before treating the path search as current; offline legacy caches retain +unknown file heads rather than borrowing a head from PR metadata. +Canonical positive integers in task overlap terms match PR references, rather than +decimal or commit-hash fragments. Explicit positional terms retain literal matching; +leading-zero words stay literal. See [reference matching](overlap-task-reference-matching.md) +for examples and the report’s `reference_terms` field. + +Before choosing one card: + +1. Check fresh [open PRs](https://github.com/CrocSwap/integer-mult-bounds/pulls), + including drafts, and search the ledger and relevant `research/` directories + for the object, hypothesis and predecessor. PR title searches alone miss overlap. +2. Check [active discussions](https://github.com/CrocSwap/integer-mult-bounds/discussions) + and the [coordination conventions](https://github.com/CrocSwap/integer-mult-bounds/discussions/1163) + for claims, findings and handoffs. Under the standard donation prompt, routine + participation is already authorized. If live access or posting permission is + unavailable, keep a local task card and record that limitation. Do not create + a reservation issue for every agent. +3. Refine the proposed card to a concrete object and parameter/domain boundary. + Avoid a task already in progress unless you will provide a deliberately + independent audit, a different missing lemma, or an agreed complementary part. + +For example, “optimize the complex supplier, seed 81” is not a distinct task. +“Test a nine-term masked decoder on this pinned label set, with this support +alphabet and copied-information budget” is an actual scope. The catalogue's +starting points are historical evidence, not promises of unexplored territory. + +## 2. Where effort is most useful + +Read [current priorities](current-priorities.md) for the versioned +diagnosis, allocation table and stopping rules. The +[task catalogue](agent-task-catalog.json) is the machine-readable +assignment source. Keep both in sync; this standing procedure does not freeze +another copy of the priorities. + +## 3. Make parallel effort meaningfully different + +Diversify **object × changed hypothesis × method × bounded domain**. Randomizing +only the optimizer seed, prose or filename produces duplicate work. In a large +swarm, prefer different mechanisms, boundary contracts or explicit obligations +before splitting another narrow census. A separate independent audit should name +its distinct failure mode. Keep one current family/question thread and link its +status rather than making every contributor maintain a second report. + +Write a local task card before substantial computation: + +```text +Task ID / proposed scope key: +Base commit; exact predecessor and dependency heads: +Concrete object and question: +Scope status: unchanged / refined / changed; reason for refinement or change: +Existing restriction being changed (or exact claim being audited): +Method; explicit parameter ranges/candidate alphabet: +Nearest overlapping PRs and why this adds something: +Declared milestone: local module / complete supplier / integrated kappa / audit: +Optimistic full cost budget; required observable improvement: +Unresolved consumer/restoration costs; family expansion decision if continuing: +Success evidence; falsification test; time/compute cap: +Predecessor authors; intended artifact and reproduction command: +``` + +If a card asks for a changed operation alphabet and you instead increase the +source count inside the old alphabet, record a **changed** scope. Explain the +new question's relevance and label a side result as such. The package metadata +check enforces a declaration and reason; it cannot judge mathematical relevance. + +The helper's `scope_key` fingerprints a catalogue question and method. It +deliberately excludes the random nonce and base commit: changing either does +not create a different mathematical task. Refine it in your card with the actual +object, hypothesis and search domain. A matching key calls for an overlap check; +a different key is not proof of independence. + +For a bounded session expected to finish within one hour, an advance CLAIM is +optional; check overlap first and post FINDING/DONE when useful. Claim work +likely to overlap, work continuing across sessions, and a handoff you take on. +Do not manufacture retrospective claims. + +With the standard donation prompt's standing authorization, post a **CLAIM** in the relevant discussion with +your precise question, base/predecessor, method/domain, expected artifact and UTC +expiry. Use roughly two-hour claims and extend them when continuing. Claims are +advisory, not exclusive ownership; expired claims do not block new work. Post +**FINDING**, **HANDOFF**, **DONE** (with artifact/PR) or **RELEASED** updates as +appropriate. Update the original claim for routine status. Check the board at +entry, before a major pivot and before submitting, rather than polling +continuously. Independent audits are welcome when explicitly identified. + +**Keep discussions usable as the board grows.** Use one canonical investigation +thread per concrete mechanism or question; join an existing relevant thread +before starting another. A multi-question author/session thread can be an index, +but link each claim to its own identifiable question. Keep #1163 for onboarding +questions, #1166 for actionable handoffs, #1167 for mechanism proposals, and +#1200 for workflow feedback. Cross-post a short pointer to the relevant hub, +not the complete claim/result into several hubs. + +Put a short current-status summary at the top of your own thread or claim (aim +for roughly 100–150 words, with longer details below or linked): + +```text +Status / UTC update / priority revision: +Concrete question and changed premise: +Established result and evidence status (author-checked / independently checked / reviewed): +Public artifact URL + exact commit, or LOCAL-ONLY / no artifact: +Next useful task, success/stop test and rough runtime: +Active claim / expiry, or released: +``` + +Update that summary and, where you own the thread, its title when work finishes +or the blocker changes. Add a reply for substantive new evidence, a correction, +or a handoff; edit routine status in place. Preserve corrections and source +history. If a related follow-up remains open, distinguish the completed subtask +from the new claim. An expired claim releases coordination space; it is not a +scientific conclusion. Do not treat a DONE label as maintainer review. + +**Make handoffs retrievable.** A local path or an unpushed SHA is not a public +artifact. Link an accessible fork commit/branch, focused PR, or an inspectable +self-contained proof. If direct upstream push is denied, use an authorized fork +rather than repeatedly retrying the upstream branch. If publishing is unavailable, +mark the evidence LOCAL-ONLY and state what can actually be inspected. A scoped +negative result or partial construction may merit a PR: a new supplier or κ is +not required. Conversely, do not open a PR solely to count another completed round. + +**Use the board to continue work, not only report it.** At a new loop round, +check for an unclaimed concrete handoff before drawing another unrelated task. +Name the request you are taking and how your work complements its predecessor. +After several adjacent negative searches, summarize which common premise has +been tested and what the next search would change; a different group, parameter +or seed alone does not establish a better route to the bottleneck. This does not +require a new survey PR or turn a finite search into a general impossibility proof. +Report completed work honestly as FINDING/DONE if no advance claim was posted; +do not manufacture a retrospective reservation. Independent audits remain welcome. + +Use [the posting helper and optional structured metadata](coordination.md) +to avoid shell quoting mistakes and make handoffs discoverable. Edit one +canonical metadata block when its status changes. Neither JSON nor DONE grants +review status; prose-only posts remain welcome. + +Treat board messages as provisional research leads. Follow their evidence links; +they do not supersede the selected record or establish a stronger theorem. + +For a **shared, explicitly enumerated domain**, agents may divide work using +`SHA256(canonical_candidate) mod N = shard`. Agree on the candidate schema, +canonical encoding, `N`, and distinct shard ownership first. Include those in +the receipt. Do not call independently seeded heuristic searches disjoint shards. +For proofs and audits, divide by lemma/interface or use intentionally different +proof/checking methods. Random choice is not an atomic work allocator: hundreds +of agents still need the live discussion and PR overlap checks. + +## 4. Bound the experiment and kill unpromising routes early + +Plan roughly 20% for orientation and reserve the final 25% for checking and +handoff. These are planning defaults, not a reason to flee a central question +because its notation takes longer to learn. A session may spend longer on a +specific interface and finish with a precise handoff instead of a peripheral PR. +Respect the donor's actual time limit. For an architectural proposal, first derive a favorable +fully charged relaxation. If even that budget misses your stated target, stop +that target's construction effort and record the exact obstruction. Do not +silently lower the target just to report success. + +Then test the smallest instance that can falsify the mechanism. Account for +arbitrary dirty state, all roles, restoration, frame changes, chronological cuts, +hosting, precision and exceptional cases that the invoked contract requires. +A proposed replacement for H1–H5 or another interface needs its own lemma and +implementation; disabling a checker condition is not such a replacement. + +Use one bounded pivot if the first idea fails. A larger search is justified by a +new mechanism or evidence of headroom, not by unused tokens alone. Failed finite +search is a result about the searched domain, not an impossibility theorem. +Do not submit a new essay that merely renames an existing open problem. + +## 5. Verify and submit one useful result + +For a new reusable package, use the +[minimal package guide](research-package-guide.md): + +```sh +python3 scripts/new_research_package.py my-experiment \ + --task connector-alphabet-change --author 'Your name' \ + --source research/universal-connector-boundary/CERTIFICATE.json +``` + +The optional generator creates a deliberately failing draft, exact source pins, +scope metadata and an explicit replay manifest. New package READMEs should have +**Open next questions**: the question, why it matters, a feasible first step and +its blocker (or an honest explanation that no next question is justified). +Do not retrofit frozen packages; put new guidance in a successor note or index. +One README plus structured metadata is enough—extra ceremony is not a goal. + +Work on an isolated branch/worktree. Preserve upstream inputs and frozen source +pins. Use exact arithmetic or certified bounds for acceptance; finite-field and +floating-point searches can propose candidates but cannot certify a rational +rank identity or universal theorem on their own. + +For scalar linear programs with independent noncommuting unary operators, the +[universal dirty-circuit guide](universal-dirty-circuit-guide.md) offers compact +exact certificates for complete dirty endpoints and termwise tensor substitution. +Its grammar and independent-symbol hypotheses must match the actual caller; +native, inverse/group, nonlinear and physical cost obligations remain separate. + +Run checks relevant to your change, with a positive fixture and meaningful +failure controls when adding a verifier. State which obligations were **not** +checked. Supplier adoption needs the applicable complete cold replay and source +bindings; a local experiment may be submitted as a clearly scoped partial result. +Do not run every historical replay just to change documentation. Do not run +artifact-regenerating suites concurrently in the same worktree. Cache immutable, +source-bound evidence only when coverage and invalidation remain explicit. + +A new complex κ claim within this model should report its paid local profile's packing cap +(`research/complex-local-word-ceiling/ceiling.py`) and the fraction of it realized. +For claims outside the model, state which hypothesis changes and give an appropriate replacement bound. +Matching rank profiles alone does not establish identical circuits or a purely packing-based implementation change. + +Before submission, refresh the overlap check. Keep one focused PR with the task +card, precise delta, exact heads, commands, evidence, limitations and credit. +An independently corroborated or superseded contribution still deserves credit; +explain its added value rather than pretending the predecessor does not exist. +Declare substantial AI assistance and retain the repository/source licenses. + +Do not promote your candidate into the selected record or close others' PRs +without maintainer authorization. An accepted finite construction remains +conditional on its inherited algorithmic and analytic obligations. Lean proofs +should name exactly the statements formalized. + +**Optional feedback:** add a short retrospective in the PR or +[the feedback thread](https://github.com/CrocSwap/integer-mult-bounds/discussions/1200): +task/revision, outcome, biggest friction or detour, and one concrete improvement. +Link an existing report instead of repeating it. Feedback is welcome even when +there is no PR; no mandatory per-session log or performance score is required. + +## 6. Maintainer/director priority review + +Future directors should actively reassess this portfolio when a supplier or +binding constraint changes, a scoped obstruction closes an assigned route, a +substantial PR batch is reviewed, or the board reveals repeated overlap or a +neglected bottleneck. During a large active influx, roughly daily assessment is +reasonable. This is a review procedure, not an automatic scheduled job. + +**Use verified evidence to change allocations.** Read the selected record and +its review, the latest PR dispositions, the +[workflow feedback thread](https://github.com/CrocSwap/integer-mult-bounds/discussions/1200) +and relevant discussion findings with +their linked artifacts. Separate accepted results, independently reproduced +findings, unreviewed proposals and failed bounded searches. Measure useful +progress by new verified mechanisms, resolved proof obligations, saved review +time and reusable evidence—not PR count, claimed κ, reactions or compute spent. +Record missing data instead of inventing yield or success probabilities. +Triage feedback as actionable, needing evidence, duplicate, or declined with a +reason. Link the reports behind a decision in the priority log. Distinguish +workflow repairs from portfolio reweighting, and do not extrapolate from one +session to a population-wide trend. Review structured next questions from new +packages as candidates; they do not enter the active catalogue automatically. + +Use the [family expansion gate](research-family-status.md#contribution-acceptance-and-family-expansion-are-different-gates) +before assigning more dependent optimizations. Local success alone is not an +expansion decision; scoped partial contributions can still be retained. + +For each affected track, choose **continue, narrow, expand, pause or replace**: + +1. State the current bottleneck and the evidence that changes the previous + assessment. Check both primitive budgets and the actual outer contract. +2. Name what the next bounded experiment would decide. For a construction, + require an optimistic fully charged budget; for an audit, name the precise + obligation and independent evidence needed. +3. Specify a stop rule and what evidence would reopen a paused route. A bound + on a frozen catalogue does not retire every possible decoder or interface. +4. Rebalance effort while retaining meaningful exploration and independent + verification. Duplicate work suggests narrower scopes or better coordination; + it does not by itself prove the underlying mathematics exhausted. + +Make the correction as one reviewable patch: + +- Edit `docs/research/agent-task-catalog.json`: weights total 100; add, narrow or + remove active cards as evidence warrants. Preserve task IDs for unchanged + questions. Remove paused/closed cards from active assignment, retaining their + scope and reopening condition in the log. The helper needs no code change. +- Increment `priority_revision`, update `assessed_on`, and append a dated entry + to [the priority log](research-priority-log.md). Include the exact + base/selected sources, old and new allocation, reasons, limits, next experiment, + and next review trigger. The initial allocation is a hypothesis, not a mandate. +- Update `docs/research/current-priorities.md`'s diagnosis and allocation table in the same patch. + Refresh affected cards' `existing_checks`, including source pins, remaining scope + and selected-record context. Never mark an entire topic closed from a partial check. Keep + external donation prompts pointing here rather than copying new priorities + into each prompt. Do not repin frozen scientific inputs to change strategy. +- Run the bounded onboarding checks: `python3 -B tests/test_research_assignment.py` + and `python3 -B tests/test_research_coordination.py`. Run changed-tool tests too; + do not launch every historical research test for a guidance edit. + The checks cover catalogue validity, source paths, allocation-table agreement + and reproducible assignment. Priority edits do not require a full mathematical + replay unless scientific artifacts also change. + +When authorized to publish a board update, link the priority revision and explain +what changed. Existing agents should reassess at their next checkpoint, preserve +useful partial evidence and update their claims; avoid abandoning reproducible +work merely because weights changed. Claim assignment remains advisory, and a +director role alone does not grant permission to merge, close PRs or announce a +new mathematical result. + +## Short prompt for donating a session + +Use the [canonical short prompt](../../autoresearch.md#short-prompt-for-donating-a-session). +Keep external prompts pointing to the entry point rather than copying allocations. + +Prepared by Douglas Colkitt with OpenAI Codex assistance. Apache-2.0. diff --git a/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__current-priorities.md b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__current-priorities.md new file mode 100644 index 0000000000..b4ece97a60 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__current-priorities.md @@ -0,0 +1,164 @@ +# Current research priorities + +This is the changing diagnosis and allocation; [autoresearch.md](../../autoresearch.md) +links the standing session procedure. Refresh this file and the task catalogue +at each research checkpoint. + +**Priority revision 7 — October 20, 2026**, assessed against main +`9200177938843d92957bbfe6f1fdbe88768d8cc5`. +**Selection refresh — October 23, 2026:** the +[selected conditional result](../../certificates/selected-result.json) is now +**κ = 0.0030217758 (#4610, independently audited in #5241)**. Read the +[changed-construction review](pr-intake-evidence/pr4610/PROOF-REVIEW.md) and +[contributor map](community-native4610-contributors.md). Cao Yifan's native/helper +changes retain the PR4470 controller and productive profile; Chris R / Clear1nsight +supplies the complete independent admission package. The same five framework +assumptions remain. This small improvement does not change the mechanism-search +allocation. Admission of this exact #4610 witness is complete; source-sensitive +follow-ups must use its final word and compiler parameters. +Use `python3 -B scripts/research_selected_baseline.py` for source-bound orientation; +the older `research_baseline.py` uses a historical balanced-transfer schema. +The revision-7 allocation below is retained pending a separate strategic review. +Its old-inventory ceilings, stale admission tasks and a/(1+a) conversion are +not constraints on this mixed-target selection. Check the selected assumptions +and latest handoffs before adopting an old card. + +**Keep broad mechanism exploration; update the exact missing work.** Roughly +60% of the portfolio remains on bit mechanisms, complex mechanisms and recursive +interfaces. The latest packages justify fresher assignments, not a measured +claim that any track has a higher success rate. Use the +[family record](research-family-status.md#revision-7-evidence-and-assignments) +for source pins, attribution, remaining obligations and stop rules. Check live +[handoffs](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166) +before selecting a card. + +| Card | Current evidence, author-checked unless stated otherwise | Next bounded decision | +|---|---|---| +| `uniform-transfer-audit` | #4100 proposed all-size construction | Audit **one** quantified implication at its actual caller: CRT total repair, native/free-algebra lift, precision/conditioning, or fixed-tape cost. Independent acceptance is absent. | +| `supplier-boundary-audit` | #4088 mixed four-provider local construction | Rebind the ordinary/outer admission engine to all four providers and dispatch, preserving every predicate and rejection control. The full mixed engine has not been rerun. | +| `joint-query-controller` | #4166 actual QQ16 caller installation | Compare the complete matched parent park/restore and external-call protocols, retaining all later calls; or change the actual demand to remove paid work. The native-component profile loses. | +| `r437-carrier-integration` | #4067 paid two-window carrier; #4147 reverse coefficient | Close one pooled compiler/request, physical caller, or precision/stock obligation. Do not rederive the covered coefficient. | +| `p104-side-correction` | #4133/#4136/#4140/#4153/#4154 scoped slot, commutation, encoding, chart and fiber-seam objections | Name a changed producer/consumer premise, then test literal action, dirty restoration and the fully charged boundary. Static flags alone do not supply it. | +| `independent-moment` | #4088 changed ledger; #4091 proposed fixed-inventory ceiling; #4067 paid exchange | Independently bind a changed mechanism to its bill or check the scoped pooled dual. More digits of the same root are not additional mechanism coverage. | +| `formal-interface-lemma` | #3807 gate-operand and #3857 endpoint formalizations | Target an uncovered interface statement. Audit the proposed compact-switch contract before a formalization campaign. | + +**Separate admission from proof audit.** #4088 needs finite/compiler integration; +#4100 claims to discharge all-size premises. Those are different tasks, and neither +is closed by checking the other's numerical root. Partition work by proposition, +caller and domain, with one canonical thread and exact source pins. A short session +can produce an acceptance coverage map, a counterexample or a single proved lemma. +A complete ordinary/outer replay or Lean build needs a separate resource budget; +no heavy run is part of default orientation. + +**Pause repetitive searches within a fixed invoice.** #4091 proposes a sharp +pooled ceiling for the fixed THREE/FOUR words and inventory. It is pinned to an +earlier #4088 revision: verify local-word, capacity and stock equivalence before +applying it to the later 1090-call fill. Its pooled witness is not a chronological +implementation. The `selected-packing` card now starts with this scope/headroom +check; any tiny residual search is explicitly bounded and optional. Changed words +or interfaces require a fresh model, not the old ceiling. + +Likewise, #3998/#4019 and #4112/#4152 cover scalar A2 contractions and related +audits. The `scalar-to-moment` card requires an actual removed paid transition, +a legal replacement itinerary and the complete cost delta. Stop if only scalar +ADD counts change; that may have a separate benefit, but does not justify a larger +κ-oriented scan of the same domain. + +**Local contributions remain welcome.** A checked partial identity, interface +lemma or scoped obstruction can be valuable without a complete supplier. Before +expanding a family, update its full producer/consumer ledger: proved costs, +constructive upper bounds, unknowns, and why the consumer does not repay the gain. +Unknown costs are not zero. Use the [five-point expansion gate](research-family-status.md#contribution-acceptance-and-family-expansion-are-different-gates). +This is an evidence checkpoint, not an approval queue or an extra reporting task. + +The selected stock coefficients remain a targeted audit obligation; cutoff +arithmetic does not provide them. For census and exporter work, check successor +corrections and their exact scope before repeating a tiny example. Independent +verification must name missing coverage. The reviewed #1995/#2013 fixed-word +frame bounds, #2017 fixed-model C=40 result and #1974 bounded census remain scoped +predecessors, not universal barriers. The maintainer's older product checkpoint +also remains local-only evidence as labelled in the family record. + +**Retained selected-profile diagnosis (revision 3; scoped arithmetic independently replayed for #1240 and #1264).** This paragraph and its lever table concern the frozen selected profile, not the changed #4088 words or every possible supplier. On the binding complex side, a ≈ D/E: + +- **D is small.** Each call has about 99.6 live families. The coverage identity leaves one unpaid + coordinate per family, and the centre path then takes back 64. Only about 35.6 of 7,232 paid + coordinates per call remain unpaid. +- **E comes from small children.** The effective child rank is about 3.9, and rank-1 children are + about half of the recursive cost. + +[The packing ceiling](../../research/complex-local-word-ceiling/README.md) caps every hosting, owner or +idle repacking of the selected word at **+0.87%** (κ < 0.001687203). The open-claim census in #1264 +finds no covered claim able to pass κ ≈ 0.0016873 by packing. Its leading claims use paid local profiles with +*lower* relaxation caps than the selected profile; this does not compare attainable packing optima. + +A target-scale gain must change the structure. Ideal one-at-a-time budgets (`levers.py`): + +| Lever | Ideal primitive-saving ceiling multiplier | +|---|---:| +| Centre path free | 2.80× | +| Centre path shared by two calls | 1.90× | +| Rank-16 local children | 2.31× | +| Two unpaid coordinates per family | 3.77× | +| Centre free and rank-16 combined | 6.5× (κ cap ≈ 0.0109) | + +These are favorable relaxations, not expected gains. Screen any changed local profile with +`ceiling.ceiling()` before building a network when its coverage law and halving guard apply. +For a changed interface outside those hypotheses, state the replacement model and derive its own +fully charged optimistic moment bound; do not force it into the incumbent calculator. + +For a supplier with width `m`, role count `W`, and `n_r` children of rank `r`, +price the **whole completed construction**, including its additional charges: + +\[ +\frac1W\sum_r n_r(r/m)^{1-a}<1. +\] + +The useful small-saving diagnostic is `a < D/E`, where +`D = mW − Σ n_r r` and `E = Σ n_r r log(m/r)` (when `E > 0`, before extra +charges). The exact moment is the acceptance test. Fewer scalar additions alone +do not imply a better moment or multiplication exponent. + +Under the retained limiting balanced transfer `κ = a/(1+a)`, the ambitious +`κ > .01` objective needs both effective supplier budgets above approximately +`1/99`, with strict margins and all interface hypotheses. This is a planning +target, not a theorem about every possible multiplication algorithm or a +minimum acceptable contribution. Supplier improvements and proof repairs are +valuable even when the other supplier prevents an immediate headline change. + +The helper allocates effort as follows. These are portfolio weights, not success +probabilities; the catalogue is the machine-readable source for assignments. +Revision 7 keeps the track weights: current evidence supports fresher tasks and +stronger expansion decisions, not a measured reason to reallocate the portfolio. +Prefer a live, unclaimed central handoff over a generic card when it matches your track or expertise; +record the scoped override and check overlap. + +| Track | Share | Useful outcome | +|---|---:|---| +| Bit mechanisms (`bit-mechanisms`) | 20% | A changed decoder/frame contract with a full paid budget | +| Complex mechanisms (`complex-mechanisms`) | 20% | A completed P104 correction or changed decoder with a favorable full bill | +| Recursive interfaces (`recursive-interfaces`) | 20% | A changed joint-query controller, centre path or coverage law with real eliminated work | +| Adversarial audit (`adversarial-audit`) | 15% | A selected stock envelope or another specific missing implication/counterexample | +| Independent verification/formalization (`independent-verification`) | 10% | A separately implemented check or scoped formal lemma | +| Verifier engineering (`verifier-engineering`) | 8% | Faster, reproducible checks with unchanged coverage | +| Consolidation (`consolidation`) | 5% | Evidence-backed overlap, attribution or navigation repair | +| Incumbent optimization (`incumbent-optimization`) | 2% | A genuinely new, fully priced improvement, reported against its packing cap | + +Before reopening a negative result, name the hypothesis you change. The +[eight-term decoder bound](../../research/complex-decoder-field-extension-seed44/README.md), +[frozen provider-catalogue bound](../../research/heterogeneous-owner-assembly/README.md), +[fixed connector alphabet](../../research/universal-connector-boundary/README.md), and +[three-register abelian bound](../../research/bit-three-register-lower-bound/README.md) +have restricted scopes. Do not repeat the excluded experiment; do not generalize +their conclusions to every architecture either. Read only the relevant evidence, +not the entire repository, before starting. + +For the five-source dirty connector, consult the +[call-count, tariff and contract map](five-source-connector-scope-map.md) +before repricing the original alphabet. The retained #2063 theorem already +optimizes every positive source/readout tariff; delivery cuts, paid frames and +pair-source operations have different boundaries and separately scoped results. + +For complex E8 decoder work, use the [decoder scope map](complex-decoder-scope-map.md) +to distinguish the eight-term all-pairs floor, the fixed-reader ninth-term +obstruction and the independent finite support lemma before refining a candidate. diff --git a/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__research-family-status.md b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__research-family-status.md new file mode 100644 index 0000000000..743a1afcbc --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/inputs/guidance__docs__research__research-family-status.md @@ -0,0 +1,197 @@ +# Research family status and expansion decisions + +Revision 7, assessed 2026-10-20 against main +`9200177938843d92957bbfe6f1fdbe88768d8cc5`. +This is a navigation and decision record, not supplier admission or a complete +survey. **Selection refresh (October 22): κ = 0.00302015 (#4470).** The family survey below is historical; resolve current +sources and assumptions through [selected-result.json](../../certificates/selected-result.json). + +The newer package claims and intake receipts were read for this guidance update. +Their mathematics was **not independently replayed in this pass**. Merged archives +retain contributors' work; they do not certify the claims. Pin and validate any +pending dependency your work uses. Check live heads and handoffs before assignment. + +## Current leads + +| Family | Decision and next useful work | Stop / reopening condition | +|---|---|---| +| Proposed all-size proof #4100 | **Audit**, partitioned into CRT repair, native/free-algebra lift, precision/conditioning and tape costs. Name one proposition and actual caller. | Stop at a precise missing implication or proved scoped result. Finite checks do not discharge universal premises. Broaden only after that dependency is resolved. | +| Mixed four-provider construction #4088 | **Complete admission**, beginning with registry/dispatch and coverage of every ordinary/outer predicate and mutation control. | No frontier promotion from a local/root pass. Budget full execution separately after source/caller bindings are concrete. | +| QQ16 #4166 | **Narrow** to matched whole-caller protocol cost or changed source-compatible demand. Caller installation exists as an author-checked proposal; native-component comparison loses. | Stop if the full necessary inequality fails or remains unpriced. Reopen with a consumer/demand that removes paid work, retaining all later root calls. | +| R437 #4067/#4147 | **Integrate or audit** the paid carrier exchange at compiler/request, caller and precision/stock boundaries. | Reverse coefficient is already covered. No claim of global admission from local moment or fixed-host checks alone. | +| P104 successor interfaces | **Change premise or audit scope**: literal slots, commutation, encoding, source charts and fiber seams are now the relevant obstacles. | Stop repeated static counts or the same mismatched seam. Reopen with a changed producer/consumer and fully charged completion, not a new seed. | +| Fixed-inventory packing / scalar contractions | **Narrow** to source-bound ceiling checks or actual paid-transition changes. | No default fixed-invoice repacking or scalar-only scan. Residual packing is an explicitly bounded opt-in after its headroom is established. | +| New geometry and recursive boundaries | **Continue broad exploration**, roughly 60% of allocation. | Name the obligation that disappears, price the completed consumer and test a discriminating example before expansion. No universal exclusion follows from these families. | +| Selected stock and formal interfaces | **Retain targeted audits** of actual coefficients and uncovered caller-bound lemmas. | Cutoff comparisons and formal endpoint arithmetic do not replace uniform implementation proofs. | + +## Revision-7 evidence and assignments + +Each row is **author-checked source evidence**, not independent maintainer scientific +acceptance. Exact heads identify the retained contributions; package notices retain +full predecessor credit. The catalogue carries the same pins and selected-record hash. + +| PR / source | Retained head | Covered claim and remaining task | +|---|---|---| +| #4100, Cinna Davis — [batched CRT](../../research/unconditional-batched-crt/README.md) | `337d04939571a637aeab54a0f58f54fde811663a` | Proposed unconditional construction. Start independent audit at CRT.md total repair or COMPLEX.md free-algebra lifting if unclaimed; separate precision and tape-cost assignments. | +| #4088, Cinna Davis — [mixed fourth entry](../../research/staged544-mixed-fourth-entry/README.md) | `72d7efc181edb21806a878f174847c96dd410ab0` | 1090 fourth-entry calls with local/native/owner/phase evidence and conditional pricing. Full ordinary/outer four-provider admission remains open. | +| #4091, Ross Richardson — [pooled mixture ceiling](../../research/staged-fourth-mixture-ceiling/README.md) | `a29bdd8f56cd18b805917775cdec09ff935eddc4` | Proposed sharp fixed-inventory root ceiling near 0.001730980256. Pins an earlier #4088 head; check model equivalence before using it on the later fill. No chronological fill follows from its pooled witness. | +| #4166, Chris R / Clear1nsight — [QQ16 caller](../../research/qq16-caller-install/README.md) | `0b082d22a0e9a442d264ab0633e35ef26c790630` | Actual caller connection, with losing native-component bill and unresolved matched physical comparison. Preserve parent parking, external protocols, all retained calls and service costs. | +| #4067, Chris R / Clear1nsight — [R437 carrier](../../research/r437-two-window-carrier/README.md) | `a95f11c52e3ca1e4c5171b3c20d8f4b0815aee2e` | Paid (2,2)→(1,3) exchange, three added ADDs per call and fixed OQ4 host. Pooled compiler/request, physical caller, precision and stock remain. | +| #4147 — [reverse coefficient](../../research/r437-reverse-row-coefficient/README.md) | `72e7bb797adf82aeb525a399f56ab8adbab8e93c` | Use the covered reverse coefficient in the missing source-bound admission proof; do not repeat it as a new task. | +| #4133 — [literal slot](../../research/p104-literal-slot-defect/README.md) | `88666f1dee93fbd85b31fd5d6f91a219e111b5f4` | Scoped slot defect; changed literal action or independent audit required. | +| #4136 — [commutation](../../research/p104-uniform-commutation-gap/README.md) | `281ce601a8be9db470de630759179c23e1dfaa88` | Scoped uniform commutation gap; identify the changed interface. | +| #4140 — [encoding](../../research/p104-uniform-encoding-gap/README.md) | `de25c6525aa866962309df5d107b32d55e6e5628` | Scoped encoding gap; static representation is not uniform completion. | +| #4153 — [source chart](../../research/p104-source-chart-shortcut/README.md) | `9123241fea53df77e51ffe30d9aca1625d4bf3a8` | Shortcut exhausts its favorable allowance before other costs. Change the source/consumer premise to reopen. | +| #4154 — [fiber seam](../../research/p104-fiber-tag-seam/README.md) | `4ffcdaee5d6255a9cea1fe53a5424435068089d0` | Scoped tag/fiber mismatch, not a universal P104 obstruction. | +| #3998 — [A2 rewrite](../../research/staged544-a2-graph-rewrite/README.md); #4019 — [separated A2](../../research/staged544-separated-a2/README.md) | `389268a6b5e0373a3125d5c6fcd6995f4ea324f5`; `f408e09df300b575235f7f77f81948071397e16d` | Scalar contraction is not a paid-profile gain. Next work must remove an actual paid transition. | +| #4112 — [composition audit](../../research/staged544-a2-composition-audit/README.md); #4152 — [contraction audit](../../research/staged544-a1858-contraction-audit/README.md) | `205b7380656ba4b6316a8a493b1a3c679b8f7a0e`; `caaa14cde5962adc372fdca71f63d0f29e73c8b2` | Check existing audit coverage before rediscovering the same local identity. | +| #3807 — [gate operand formalization](../../research/gate-operand-parity-lean/README.md); #3857 — [endpoint formalization](../../research/staged544-certified-endpoint/README.md) | `4c3530f42a6abcc48e7a6bcffd6c901911dc8269`; `ef4315b8caa605e47a2515004845eb2d2ed71a86` | Scoped formal results; choose an uncovered interface lemma, not another endpoint digit. | +| #3801 — [scatter decision](../../research/scatter-boundary-decision/README.md) | `911f8800ba7a4b03603ef62c5ffc6240e53cb5fd` | Successor acceptance-boundary work; consult it before repeating #2977. | + +**Assignment separation.** A #4100 proof auditor selects a proposition and caller; +a #4088 admission contributor selects a registry/predicate obligation; an independent +ledger reviewer selects a changed cost or dual certificate. These are distinct even +when they share a package. Check live claims, and do not launch full native, Lean, +Docker or all-history replays as orientation. Source-binding commands are not +scientific validation. Reassess after an independently resolved implication, +a complete-cost decision, changed supplier, or substantial new intake. + +Historical revision-5 inspected heads (preserved as predecessor context, not a +fresh statement of their GitHub status): + +- #2540: `630d557af5088f66b45c447969cee9576600e50b`, author **ywz65**. + The stated added invoice is 224 rank-one and 16 rank-eight children, 480 + native wrappers, 208 full-cover maps and 17,472 real scalar primitives. + Inherited F0/B1 costs are additional. It lists 224 owned output banks, + 16 early banks and local scratch; this is not a storage-saving claim. + Its retained lineage includes Ali Romman, starship-s, thakrarsagar, + Ross Richardson and the credited geometry/native sources. +- #2586: `7953c9a8f788a8de5cf2ced63d9a61b67c22c6f1`, author **ywz65**. + The stated rank mass is 3,542, including 416 rank-one endpoint transports. + Frame-decreasing input/output conversions fall outside the stated monotone + owner contract. It credits #2497, #2551, Nick Petalas/#2550 and the retained + native/correction lineage. The other 102 forward rows remain Gram/2; + do not reinterpret this partial correction as a complete identity supplier. + +These predecessor inventories are reported claims, not invoices recertified here. The +source PRs retain full attribution and detailed limitations. Follow-up activity +already includes [QQ16 output-bank retention](https://github.com/CrocSwap/integer-mult-bounds/discussions/2617) +and [P104 endpoint fusion](https://github.com/CrocSwap/integer-mult-bounds/discussions/2619). +Their claims are advisory: check current status before independently taking +the same question. Neither thread is evidence of a stronger selected result. + +## Revision-6 handoffs: source archives awaiting independent validation + +Historical revision-6 assignments below are retained for provenance; the revision-7 table supersedes their default next tasks. The following exact heads are retained on the assessed main. Their intake +records certify source retention, not their mathematics. Credit stays with the +named contributors and all predecessor attribution in their packages. + +| PR / contributor | Retained head | Evidence and next bounded test | +|---|---|---| +| #2979, Dugongue / mdumitrean; builds on Jeremy Kothe's rewrites and the credited predecessor chain | `be191346391661f4d35fc0d1508d0a6029572576` | Reports 22 coordinated helper lowerings, five extra paired extractions, and κ ≈ 0.001729. Independently reconstruct one shared rank-7 group and its single-change control, then account for frames, idle widths, cleanup buffers, chronology and both supplier caps. | +| #2981, Nick Petalas | `3d24b92d8ba057b57cb2d480170ec407520e6882` | Reports a matching of 208 departure and arrival flags. Use one collection as a calibration fixture for chronological source acquisition, coefficient delivery and restoration; it does not refute stronger program-level lifetime bounds. | +| #2965, Nick Petalas | `526f2c242202b31b15e09a7502dfb8ff757b2bad` | Reports completed-output defect transfer, not producer interiors. Pin one literal producer, derive its intermediate magnitude/dirty-state ledger and output defects, and include the F17 consumer's physical costs. | +| #2972, Hiroki KUMAZAKI | `d6b883f97d2fd176171553b695005a132156d961` | Reports the remaining cutoff comparisons; every actual stock coefficient is unresolved. Bind one reserve recurrence to the selected implementation. | +| #2977, Nick Petalas | `cd23d242dfe0e7a71cafba0ad5590dc4f2fbf4f2` | Reports XOR multiplicity versus exporter membership semantics on duplicate scatter entries, plus an opt-in guard. Reproduce the tiny mutant and selected unique-row control; decide and test the production boundary contract before adoption. | +| #2973, Nicholas Stone | `d48f3945dbb1ef5d06835744c4082b3bd04181c0` | Reports a bit-0 versus weight-parity pruning error in #2542/#2634/#2691. Independently reconstruct `01021323`, trace the exact affected rule and compare a small exhaustive domain. Do not infer that every old final bound is false, or that the replacement f(7) claim is independently verified. | + +**Stop and expansion rules.** Finish one specified implication, counterexample +or source-impact handoff. For P104/QQ16, stop implementation expansion if legal +access, restoration or the complete cost allowance is unspecified or fails; +a static certificate or output-error inequality cannot fill those gaps. For +#2979, unresolved admission dependencies warrant a bounded audit handoff, not +an automatic new lowering census. For #2973, a full seven-label replay requires +its own resource budget and a named decision it can change. Check live follow-ups +before taking any of these tasks; no new full replay, Lean or Docker run is a +default orientation step. + +Continue independent geometry and interface exploration. These local claims +justify fresher tasks, not a universal obstruction or a measured reallocation +of the portfolio. Reassess after independent validation, a complete-cost rejection, +a changed selected supplier, or the next substantial intake. + +## Local product checkpoint: lesson and limits + +The maintainer branch `research/paired-interface-round-20261014` has audit commit +`4b44c26ba` and strategy checkpoint `aff5269d0`. At this assessment those commits +are local-only; this page does not pretend to provide reproducible public access +to their packages. Do not cite this paragraph as an independently checked proof. +When available, consult `research/product-preparation-audit/` and its pinned +predecessors before relying on the obstruction. + +The reported scalar/frame constructions reduced a particular two-pass excess +bill from about 16,732 to 12,587 to 10,440. Its optimistic allowance is 7,068, +before other product costs. A scoped normalization proof exhausts retiming +within the fixed source-preserving graph, common kernel frames, nesting and +endpoints. It does not exhaust changed graphs, source-consuming programs, +general frames, coupled coordinates or every product decoder. Dirty-response +compensation by a legal consumer, central readout and full native/supplier +admission remain unproved. + +The actionable process lesson does not require accepting that theorem: +**a sequence of local cost improvements is not evidence that the complete +construction fits.** Retain useful modules, but require an explicit expansion +decision before assigning further dependent optimizations. Do not redirect +the whole community into this local product branch. + +## Contribution acceptance and family expansion are different gates + +**A contributor may finish one useful subproblem.** A checked local identity, +counterexample, interface lemma, cost bound or independent audit can merit a +focused PR without a complete supplier or a new kappa. State the exact result, +dependencies and remaining obligations. No additional standalone session report +is required. A handoff without a PR is also useful. + +**Expanding a family requires an explicit research decision.** This is an +evidence checkpoint, not an approval queue. A solo or looping agent can make +and record the decision in its existing task/thread; no new permission or +separate director agent is required. Before another large search, +implementation expansion or round of downstream optimization, update the +canonical investigation thread or this record with: + +1. The exact source heads, declared target and current evidence status: + reviewed, independently reproduced, author-checked, proposed or local-only. +2. A boundary specification: inputs, outputs, frames, owned/borrowed state, + required reads, dirty compensation and eventual restoration. +3. A complete obligation ledger. Mark each cost **proved**, **constructively + upper-bounded**, or **unknown**. Unknowns are not zero. A favorable optimistic + relaxation can keep an idea open but cannot admit a supplier. An unfavorable + relaxation may reject its stated model. +4. Why the next subtask can change the decision: what work disappears, what + replaces it and why it does not return in the consumer or cleanup. Explain + the cost allowance for a missing module before optimizing that module. +5. Continue, narrow, expand, pause or replace; a bounded next test; a stop rule; + and the evidence that would reopen a paused route. Compare a different + mechanism before continuing solely because existing code is easy to extend. + +Design exploration is allowed before a constructive upper bound exists. Its +deliverable is a contract, discriminating example or budget decision, explicitly +labelled exploratory. It should not silently grow into an implementation campaign. +For an audit, identify the particular acceptance gap and downstream consequence; +do not demand an invented kappa gain from verification work. + +## Distributing many agents + +Keep the broad track allocation and prefer live unclaimed handoffs. Refine a +task by **mechanism, changed contract, exact obligation and bounded domain**. +Separate alternative constructions from deliberately independent checks. +Different random seeds, larger censuses and renamed helper types are not by +themselves distinct mechanisms. Useful small improvements remain welcome. + +Use one existing canonical thread per family/question, with its latest result, +source pins, remaining costs, active scoped tasks and next review trigger near +the top. Do not require every contributor to maintain a second status file. +When all immediately useful tasks in a family are claimed, choose a distinct +obligation or a different family rather than manufacturing a peripheral PR. + +Keep negative proofs tied to decisions. A scoped closure merits preservation; +its ever-narrower extensions do not automatically merit more assigned effort. +Corrections, independent verification and a genuinely changed premise can reopen +it. No finite failed search establishes a universal limitation. + +Maintainers should refresh these entry points after a reviewed completion, +decisive scoped obstruction, changed supplier or substantial queue review. +Preserve historical pins and attributions; update the task catalogue, guide and +priority log together when assignments change. Current weights are allocation +choices, not estimates of success probabilities or proof that the portfolio is +optimal. diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.json b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.json new file mode 100644 index 0000000000..d4fef6cc94 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.json @@ -0,0 +1,925 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "exponent": { + "kappa": "12109153/4000000000", + "t": "3987890847/4000000000" + }, + "arithmetic": { + "bits": 256, + "log_terms": 128, + "exp_terms": 64, + "floating_point_used_for_acceptance": false + }, + "local_moment": { + "lower_integer": "216320852040087359020954411699187041493565504346120215972017940793341692027674880", + "upper_integer": "216320852040087359020954411699187041493565504346120215972017940793341692028112287", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "upper_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "width_grid_units": "437407" + }, + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "short_difference_crosschecks": { + "17": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057184507392", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057177344161", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "7163231" + }, + "18": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913255645792", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913263029215", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "7383423" + } + }, + "canonical_histogram_checks": [ + { + "n": 0, + "p": 1, + "a": 0, + "mask": "000", + "paid": { + "1": 336 + }, + "target": { + "1": 224 + }, + "direct": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "equation_one": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "symbolic_identity": true + }, + { + "n": 1, + "p": 1, + "a": 0, + "mask": "100", + "paid": { + "1": 2417, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "target": { + "4": 28, + "7": 7, + "8": 47, + "9": 542 + }, + "direct": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "equation_one": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "symbolic_identity": true + }, + { + "n": 2, + "p": 1, + "a": 0, + "mask": "110", + "paid": { + "1": 4498, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 636, + "17": 224 + }, + "direct": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "equation_one": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "symbolic_identity": true + }, + { + "n": 3, + "p": 1, + "a": 0, + "mask": "111", + "paid": { + "1": 6579, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "target": { + "4": 84, + "7": 21, + "8": 141, + "9": 954, + "25": 224 + }, + "direct": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "equation_one": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "symbolic_identity": true + }, + { + "n": 4, + "p": 2, + "a": 0, + "mask": "11011", + "paid": { + "1": 8884, + "2": 1648, + "3": 2040, + "4": 508, + "5": 160, + "16": 224 + }, + "target": { + "4": 112, + "7": 28, + "8": 188, + "9": 1272, + "17": 224, + "33": 224 + }, + "direct": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "equation_one": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "symbolic_identity": true + }, + { + "n": 5, + "p": 3, + "a": 1, + "mask": "1101011", + "paid": { + "1": 11189, + "2": 2060, + "3": 2550, + "4": 635, + "5": 200, + "16": 448 + }, + "target": { + "4": 140, + "7": 35, + "8": 235, + "9": 1590, + "17": 448, + "41": 224 + }, + "direct": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "equation_one": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "symbolic_identity": true + }, + { + "n": 16, + "p": 14, + "a": 6, + "mask": "11010101010101010101010101011", + "paid": { + "1": 36544, + "2": 6592, + "3": 8160, + "4": 2032, + "5": 640, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 224 + }, + "target": { + "4": 448, + "7": 112, + "8": 752, + "9": 5088, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 224, + "129": 224 + }, + "direct": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "equation_one": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "symbolic_identity": true + }, + { + "n": 17, + "p": 15, + "a": 7, + "mask": "1101010101010101010101010101011", + "paid": { + "1": 38849, + "2": 7004, + "3": 8670, + "4": 2159, + "5": 680, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448 + }, + "target": { + "4": 476, + "7": 119, + "8": 799, + "9": 5406, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "137": 224 + }, + "direct": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "equation_one": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "symbolic_identity": true + }, + { + "n": 18, + "p": 16, + "a": 7, + "mask": "110101010101010101010101010101011", + "paid": { + "1": 41154, + "2": 7416, + "3": 9180, + "4": 2286, + "5": 720, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "target": { + "4": 504, + "7": 126, + "8": 846, + "9": 5724, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "direct": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "equation_one": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "symbolic_identity": true + }, + { + "n": 19, + "p": 17, + "a": 8, + "mask": "11010101010101010101010101010101011", + "paid": { + "1": 43459, + "2": 7828, + "3": 9690, + "4": 2413, + "5": 760, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "target": { + "4": 532, + "7": 133, + "8": 893, + "9": 6042, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "direct": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "equation_one": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "symbolic_identity": true + }, + { + "n": 20, + "p": 18, + "a": 8, + "mask": "1101010101010101010101010101010101011", + "paid": { + "1": 45764, + "2": 8240, + "3": 10200, + "4": 2540, + "5": 800, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448, + "80": 224 + }, + "target": { + "4": 560, + "7": 140, + "8": 940, + "9": 6360, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "81": 224, + "161": 224 + }, + "direct": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "equation_one": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "symbolic_identity": true + } + ], + "tiny_symbolic_identity_count": 456, + "negative_controls": [ + { + "name": "changed_source_bytes", + "expected": "rejected", + "observed": "rejected" + }, + { + "name": "reverse_paid_minus_target_sign", + "expected": "positive_certificate_fails", + "observed": "fails", + "interval": { + "lower_integer": "-1727035296221662582695899898972270732385545605305335210375352536965870", + "upper_integer": "-1727035296221662582695899898972270732385545605305335210375352506993376", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_one_112_rank_one_query", + "expected": "invoice_identity_fails_and_sign_negative", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "-12968713992852378591218287738277145780593967550166197567113914198510918012679456", + "upper_integer": "-12968713992852378591218287738277145780593967550166197567113914198510917982706962", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "upper_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_224_full_path_targets", + "expected": "invoice_identity_fails", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088826972736", + "upper_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088854671630", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "upper_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "width_grid_units": "27698894" + } + }, + { + "name": "alter_paid_profile_count", + "expected": "profile_pin_fails", + "observed": "fails_as_expected" + } + ], + "power_enclosures": { + "0": { + "lower_integer": "0", + "upper_integer": "0", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "0.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "1": { + "lower_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "1.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "2": { + "lower_integer": "231098741838856807215938608880033550876784850651598074692227759035352042755942", + "upper_integer": "231098741838856807215938608880033550876784850651598074692227759035352042756074", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.9958076873906240697262141798066671006382", + "upper_decimal_truncated": "1.9958076873906240697262141798066671006382", + "width_grid_units": "132" + }, + "3": { + "lower_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752312", + "upper_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752516", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "2.9900391249822233354011413577754006043637", + "upper_decimal_truncated": "2.9900391249822233354011413577754006043637", + "width_grid_units": "204" + }, + "4": { + "lower_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931592", + "upper_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931860", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "3.9832483250475110113261916547825629838983", + "upper_decimal_truncated": "3.9832483250475110113261916547825629838983", + "width_grid_units": "268" + }, + "5": { + "lower_integer": "576146477017858311538963861175774047319829198257813543785311604595483195216785", + "upper_integer": "576146477017858311538963861175774047319829198257813543785311604595483195217125", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "4.9756980879500720617478113663457729290262", + "upper_decimal_truncated": "4.9756980879500720617478113663457729290262", + "width_grid_units": "340" + }, + "7": { + "lower_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427337", + "upper_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427806", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "6.9588854019604784474984440892978502836695", + "upper_decimal_truncated": "6.9588854019604784474984440892978502836695", + "width_grid_units": "469" + }, + "8": { + "lower_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215024", + "upper_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215576", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "7.9497976279156497880821421539574903098632", + "upper_decimal_truncated": "7.9497976279156497880821421539574903098632", + "width_grid_units": "552" + }, + "9": { + "lower_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667752837", + "upper_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667753449", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "8.9403339689244597796751364686124018532837", + "upper_decimal_truncated": "8.9403339689244597796751364686124018532837", + "width_grid_units": "612" + }, + "16": { + "lower_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802454384", + "upper_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802455488", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "15.8662672189938019375704751712804820013438", + "upper_decimal_truncated": "15.8662672189938019375704751712804820013438", + "width_grid_units": "1104" + }, + "17": { + "lower_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210567956", + "upper_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210569129", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "16.8548153023036777192869406360951964803875", + "upper_decimal_truncated": "16.8548153023036777192869406360951964803875", + "width_grid_units": "1173" + }, + "24": { + "lower_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700033400", + "upper_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700035080", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "23.7702059431586641801033052141063551025294", + "upper_decimal_truncated": "23.7702059431586641801033052141063551025294", + "width_grid_units": "1680" + }, + "25": { + "lower_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670626625", + "upper_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670628325", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "24.7575714624300030502040987064407741806703", + "upper_decimal_truncated": "24.7575714624300030502040987064407741806703", + "width_grid_units": "1700" + }, + "32": { + "lower_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888407520", + "upper_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888409728", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31.6660180858616881848056296847530834526958", + "upper_decimal_truncated": "31.6660180858616881848056296847530834526958", + "width_grid_units": "2208" + }, + "33": { + "lower_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513447234", + "upper_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513449511", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "32.6525392724939940180709127746750921053004", + "upper_decimal_truncated": "32.6525392724939940180709127746750921053004", + "width_grid_units": "2277" + }, + "40": { + "lower_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576110840", + "upper_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576113600", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "39.5557928568099170707539516689297446593862", + "upper_decimal_truncated": "39.5557928568099170707539516689297446593862", + "width_grid_units": "2760" + }, + "41": { + "lower_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026030763", + "upper_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026033592", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.5416570089611572615908853661226048020691", + "upper_decimal_truncated": "40.5416570089611572615908853661226048020691", + "width_grid_units": "2829" + }, + "48": { + "lower_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062188320", + "upper_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062191680", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "47.4407597522143616150486097279036793562965", + "upper_decimal_truncated": "47.4407597522143616150486097279036793562965", + "width_grid_units": "3360" + }, + "49": { + "lower_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354453545", + "upper_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354456926", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "48.4260860376186496944666539345681227782824", + "upper_decimal_truncated": "48.4260860376186496944666539345681227782824", + "width_grid_units": "3381" + }, + "56": { + "lower_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483213128", + "upper_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483216936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "55.3217306614422546533007996181831152024264", + "upper_decimal_truncated": "55.3217306614422546533007996181831152024264", + "width_grid_units": "3808" + }, + "57": { + "lower_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891680603", + "upper_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891684536", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "56.3066016234756788434068683987986754687033", + "upper_decimal_truncated": "56.3066016234756788434068683987986754687033", + "width_grid_units": "3933" + }, + "64": { + "lower_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466597632", + "upper_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466602048", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "63.1992823248132921547553476876307220841729", + "upper_decimal_truncated": "63.1992823248132921547553476876307220841729", + "width_grid_units": "4416" + }, + "65": { + "lower_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127176010", + "upper_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127180560", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "64.1837585345452308380366881088364691723465", + "upper_decimal_truncated": "64.1837585345452308380366881088364691723465", + "width_grid_units": "4550" + }, + "72": { + "lower_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055881224", + "upper_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055886336", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "71.0738457789293770027476012036568710152123", + "upper_decimal_truncated": "71.0738457789293770027476012036568710152123", + "width_grid_units": "5112" + }, + "73": { + "lower_integer": "8343743307522643837399083579128092064456563137147226591098145848881569610998743", + "upper_integer": "8343743307522643837399083579128092064456563137147226591098145848881569611003780", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.0579735842067733700093551377043410467642", + "upper_decimal_truncated": "72.0579735842067733700093551377043410467642", + "width_grid_units": "5037" + }, + "80": { + "lower_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927213760", + "upper_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927219280", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "78.9457554644523675746174614583175681747447", + "upper_decimal_truncated": "78.9457554644523675746174614583175681747447", + "width_grid_units": "5520" + }, + "81": { + "lower_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785446840", + "upper_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785452510", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "79.9295714759045833654134630349790460925507", + "upper_decimal_truncated": "79.9295714759045833654134630349790460925507", + "width_grid_units": "5670" + }, + "129": { + "lower_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165454564", + "upper_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165463723", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "127.1160376225769532360330535979599161419442", + "upper_decimal_truncated": "127.1160376225769532360330535979599161419442", + "width_grid_units": "9159" + }, + "137": { + "lower_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397033825", + "upper_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397043552", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "134.9746152241832607205596700515275460117881", + "upper_decimal_truncated": "134.9746152241832607205596700515275460117881", + "width_grid_units": "9727" + }, + "145": { + "lower_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287132615", + "upper_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287142765", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "142.8318029493600842807894352098765562398155", + "upper_decimal_truncated": "142.8318029493600842807894352098765562398155", + "width_grid_units": "10150" + }, + "153": { + "lower_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666337304", + "upper_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666348014", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "150.6876777871333574058985806852522185199700", + "upper_decimal_truncated": "150.6876777871333574058985806852522185199700", + "width_grid_units": "10710" + }, + "161": { + "lower_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965031125", + "upper_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965042395", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "158.5423086521651604050968055339254918994523", + "upper_decimal_truncated": "158.5423086521651604050968055339254918994523", + "width_grid_units": "11270" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.056040623981971294, + "maximum_resident_set_kib": 19120 + }, + "excluded": [ + "author interval engine", + "author 10290000-state DP", + "native replay", + "Lean", + "physical circuit admission", + "global circuit optimum", + "kappa gain", + "changed-profile PR5402" + ] +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stderr.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stderr.log new file mode 100644 index 0000000000..c5659e7811 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stderr.log @@ -0,0 +1,23 @@ + Command being timed: "timeout 60s python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v1.json" + User time (seconds): 0.10 + System time (seconds): 0.00 + Percent of CPU this job got: 99% + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.11 + Average shared text size (kbytes): 0 + Average unshared data size (kbytes): 0 + Average stack size (kbytes): 0 + Average total size (kbytes): 0 + Maximum resident set size (kbytes): 19248 + Average resident set size (kbytes): 0 + Major (requiring I/O) page faults: 2 + Minor (reclaiming a frame) page faults: 2629 + Voluntary context switches: 9 + Involuntary context switches: 1 + Swaps: 0 + File system inputs: 16 + File system outputs: 95 + Socket messages sent: 0 + Socket messages received: 0 + Signals delivered: 0 + Page size (bytes): 4096 + Exit status: 0 diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stdout.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stdout.log new file mode 100644 index 0000000000..fdd5a2bbf4 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v1.stdout.log @@ -0,0 +1,85 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.056040623981971294, + "maximum_resident_set_kib": 19120 + } +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.json b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.json new file mode 100644 index 0000000000..6caaf178be --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.json @@ -0,0 +1,925 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "exponent": { + "kappa": "12109153/4000000000", + "t": "3987890847/4000000000" + }, + "arithmetic": { + "bits": 256, + "log_terms": 128, + "exp_terms": 64, + "floating_point_used_for_acceptance": false + }, + "local_moment": { + "lower_integer": "216320852040087359020954411699187041493565504346120215972017940793341692027674880", + "upper_integer": "216320852040087359020954411699187041493565504346120215972017940793341692028112287", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "upper_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "width_grid_units": "437407" + }, + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "short_difference_crosschecks": { + "17": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057184507392", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057177344161", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "7163231" + }, + "18": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913255645792", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913263029215", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "7383423" + } + }, + "canonical_histogram_checks": [ + { + "n": 0, + "p": 1, + "a": 0, + "mask": "000", + "paid": { + "1": 336 + }, + "target": { + "1": 224 + }, + "direct": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "equation_one": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "symbolic_identity": true + }, + { + "n": 1, + "p": 1, + "a": 0, + "mask": "100", + "paid": { + "1": 2417, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "target": { + "4": 28, + "7": 7, + "8": 47, + "9": 542 + }, + "direct": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "equation_one": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "symbolic_identity": true + }, + { + "n": 2, + "p": 1, + "a": 0, + "mask": "110", + "paid": { + "1": 4498, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 636, + "17": 224 + }, + "direct": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "equation_one": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "symbolic_identity": true + }, + { + "n": 3, + "p": 1, + "a": 0, + "mask": "111", + "paid": { + "1": 6579, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "target": { + "4": 84, + "7": 21, + "8": 141, + "9": 954, + "25": 224 + }, + "direct": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "equation_one": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "symbolic_identity": true + }, + { + "n": 4, + "p": 2, + "a": 0, + "mask": "11011", + "paid": { + "1": 8884, + "2": 1648, + "3": 2040, + "4": 508, + "5": 160, + "16": 224 + }, + "target": { + "4": 112, + "7": 28, + "8": 188, + "9": 1272, + "17": 224, + "33": 224 + }, + "direct": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "equation_one": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "symbolic_identity": true + }, + { + "n": 5, + "p": 3, + "a": 1, + "mask": "1101011", + "paid": { + "1": 11189, + "2": 2060, + "3": 2550, + "4": 635, + "5": 200, + "16": 448 + }, + "target": { + "4": 140, + "7": 35, + "8": 235, + "9": 1590, + "17": 448, + "41": 224 + }, + "direct": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "equation_one": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "symbolic_identity": true + }, + { + "n": 16, + "p": 14, + "a": 6, + "mask": "11010101010101010101010101011", + "paid": { + "1": 36544, + "2": 6592, + "3": 8160, + "4": 2032, + "5": 640, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 224 + }, + "target": { + "4": 448, + "7": 112, + "8": 752, + "9": 5088, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 224, + "129": 224 + }, + "direct": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "equation_one": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "symbolic_identity": true + }, + { + "n": 17, + "p": 15, + "a": 7, + "mask": "1101010101010101010101010101011", + "paid": { + "1": 38849, + "2": 7004, + "3": 8670, + "4": 2159, + "5": 680, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448 + }, + "target": { + "4": 476, + "7": 119, + "8": 799, + "9": 5406, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "137": 224 + }, + "direct": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "equation_one": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "symbolic_identity": true + }, + { + "n": 18, + "p": 16, + "a": 7, + "mask": "110101010101010101010101010101011", + "paid": { + "1": 41154, + "2": 7416, + "3": 9180, + "4": 2286, + "5": 720, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "target": { + "4": 504, + "7": 126, + "8": 846, + "9": 5724, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "direct": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "equation_one": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "symbolic_identity": true + }, + { + "n": 19, + "p": 17, + "a": 8, + "mask": "11010101010101010101010101010101011", + "paid": { + "1": 43459, + "2": 7828, + "3": 9690, + "4": 2413, + "5": 760, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "target": { + "4": 532, + "7": 133, + "8": 893, + "9": 6042, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "direct": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "equation_one": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "symbolic_identity": true + }, + { + "n": 20, + "p": 18, + "a": 8, + "mask": "1101010101010101010101010101010101011", + "paid": { + "1": 45764, + "2": 8240, + "3": 10200, + "4": 2540, + "5": 800, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448, + "80": 224 + }, + "target": { + "4": 560, + "7": 140, + "8": 940, + "9": 6360, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "81": 224, + "161": 224 + }, + "direct": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "equation_one": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "symbolic_identity": true + } + ], + "tiny_symbolic_identity_count": 456, + "negative_controls": [ + { + "name": "changed_source_bytes", + "expected": "rejected", + "observed": "rejected" + }, + { + "name": "reverse_paid_minus_target_sign", + "expected": "positive_certificate_fails", + "observed": "fails", + "interval": { + "lower_integer": "-1727035296221662582695899898972270732385545605305335210375352536965870", + "upper_integer": "-1727035296221662582695899898972270732385545605305335210375352506993376", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_one_112_rank_one_query", + "expected": "invoice_identity_fails_and_sign_negative", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "-12968713992852378591218287738277145780593967550166197567113914198510918012679456", + "upper_integer": "-12968713992852378591218287738277145780593967550166197567113914198510917982706962", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "upper_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_224_full_path_targets", + "expected": "invoice_identity_fails", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088826972736", + "upper_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088854671630", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "upper_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "width_grid_units": "27698894" + } + }, + { + "name": "alter_paid_profile_count", + "expected": "profile_pin_fails", + "observed": "fails_as_expected" + } + ], + "power_enclosures": { + "0": { + "lower_integer": "0", + "upper_integer": "0", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "0.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "1": { + "lower_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "1.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "2": { + "lower_integer": "231098741838856807215938608880033550876784850651598074692227759035352042755942", + "upper_integer": "231098741838856807215938608880033550876784850651598074692227759035352042756074", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.9958076873906240697262141798066671006382", + "upper_decimal_truncated": "1.9958076873906240697262141798066671006382", + "width_grid_units": "132" + }, + "3": { + "lower_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752312", + "upper_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752516", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "2.9900391249822233354011413577754006043637", + "upper_decimal_truncated": "2.9900391249822233354011413577754006043637", + "width_grid_units": "204" + }, + "4": { + "lower_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931592", + "upper_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931860", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "3.9832483250475110113261916547825629838983", + "upper_decimal_truncated": "3.9832483250475110113261916547825629838983", + "width_grid_units": "268" + }, + "5": { + "lower_integer": "576146477017858311538963861175774047319829198257813543785311604595483195216785", + "upper_integer": "576146477017858311538963861175774047319829198257813543785311604595483195217125", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "4.9756980879500720617478113663457729290262", + "upper_decimal_truncated": "4.9756980879500720617478113663457729290262", + "width_grid_units": "340" + }, + "7": { + "lower_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427337", + "upper_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427806", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "6.9588854019604784474984440892978502836695", + "upper_decimal_truncated": "6.9588854019604784474984440892978502836695", + "width_grid_units": "469" + }, + "8": { + "lower_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215024", + "upper_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215576", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "7.9497976279156497880821421539574903098632", + "upper_decimal_truncated": "7.9497976279156497880821421539574903098632", + "width_grid_units": "552" + }, + "9": { + "lower_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667752837", + "upper_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667753449", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "8.9403339689244597796751364686124018532837", + "upper_decimal_truncated": "8.9403339689244597796751364686124018532837", + "width_grid_units": "612" + }, + "16": { + "lower_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802454384", + "upper_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802455488", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "15.8662672189938019375704751712804820013438", + "upper_decimal_truncated": "15.8662672189938019375704751712804820013438", + "width_grid_units": "1104" + }, + "17": { + "lower_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210567956", + "upper_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210569129", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "16.8548153023036777192869406360951964803875", + "upper_decimal_truncated": "16.8548153023036777192869406360951964803875", + "width_grid_units": "1173" + }, + "24": { + "lower_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700033400", + "upper_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700035080", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "23.7702059431586641801033052141063551025294", + "upper_decimal_truncated": "23.7702059431586641801033052141063551025294", + "width_grid_units": "1680" + }, + "25": { + "lower_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670626625", + "upper_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670628325", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "24.7575714624300030502040987064407741806703", + "upper_decimal_truncated": "24.7575714624300030502040987064407741806703", + "width_grid_units": "1700" + }, + "32": { + "lower_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888407520", + "upper_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888409728", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31.6660180858616881848056296847530834526958", + "upper_decimal_truncated": "31.6660180858616881848056296847530834526958", + "width_grid_units": "2208" + }, + "33": { + "lower_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513447234", + "upper_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513449511", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "32.6525392724939940180709127746750921053004", + "upper_decimal_truncated": "32.6525392724939940180709127746750921053004", + "width_grid_units": "2277" + }, + "40": { + "lower_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576110840", + "upper_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576113600", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "39.5557928568099170707539516689297446593862", + "upper_decimal_truncated": "39.5557928568099170707539516689297446593862", + "width_grid_units": "2760" + }, + "41": { + "lower_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026030763", + "upper_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026033592", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.5416570089611572615908853661226048020691", + "upper_decimal_truncated": "40.5416570089611572615908853661226048020691", + "width_grid_units": "2829" + }, + "48": { + "lower_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062188320", + "upper_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062191680", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "47.4407597522143616150486097279036793562965", + "upper_decimal_truncated": "47.4407597522143616150486097279036793562965", + "width_grid_units": "3360" + }, + "49": { + "lower_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354453545", + "upper_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354456926", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "48.4260860376186496944666539345681227782824", + "upper_decimal_truncated": "48.4260860376186496944666539345681227782824", + "width_grid_units": "3381" + }, + "56": { + "lower_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483213128", + "upper_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483216936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "55.3217306614422546533007996181831152024264", + "upper_decimal_truncated": "55.3217306614422546533007996181831152024264", + "width_grid_units": "3808" + }, + "57": { + "lower_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891680603", + "upper_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891684536", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "56.3066016234756788434068683987986754687033", + "upper_decimal_truncated": "56.3066016234756788434068683987986754687033", + "width_grid_units": "3933" + }, + "64": { + "lower_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466597632", + "upper_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466602048", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "63.1992823248132921547553476876307220841729", + "upper_decimal_truncated": "63.1992823248132921547553476876307220841729", + "width_grid_units": "4416" + }, + "65": { + "lower_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127176010", + "upper_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127180560", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "64.1837585345452308380366881088364691723465", + "upper_decimal_truncated": "64.1837585345452308380366881088364691723465", + "width_grid_units": "4550" + }, + "72": { + "lower_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055881224", + "upper_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055886336", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "71.0738457789293770027476012036568710152123", + "upper_decimal_truncated": "71.0738457789293770027476012036568710152123", + "width_grid_units": "5112" + }, + "73": { + "lower_integer": "8343743307522643837399083579128092064456563137147226591098145848881569610998743", + "upper_integer": "8343743307522643837399083579128092064456563137147226591098145848881569611003780", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.0579735842067733700093551377043410467642", + "upper_decimal_truncated": "72.0579735842067733700093551377043410467642", + "width_grid_units": "5037" + }, + "80": { + "lower_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927213760", + "upper_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927219280", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "78.9457554644523675746174614583175681747447", + "upper_decimal_truncated": "78.9457554644523675746174614583175681747447", + "width_grid_units": "5520" + }, + "81": { + "lower_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785446840", + "upper_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785452510", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "79.9295714759045833654134630349790460925507", + "upper_decimal_truncated": "79.9295714759045833654134630349790460925507", + "width_grid_units": "5670" + }, + "129": { + "lower_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165454564", + "upper_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165463723", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "127.1160376225769532360330535979599161419442", + "upper_decimal_truncated": "127.1160376225769532360330535979599161419442", + "width_grid_units": "9159" + }, + "137": { + "lower_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397033825", + "upper_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397043552", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "134.9746152241832607205596700515275460117881", + "upper_decimal_truncated": "134.9746152241832607205596700515275460117881", + "width_grid_units": "9727" + }, + "145": { + "lower_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287132615", + "upper_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287142765", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "142.8318029493600842807894352098765562398155", + "upper_decimal_truncated": "142.8318029493600842807894352098765562398155", + "width_grid_units": "10150" + }, + "153": { + "lower_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666337304", + "upper_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666348014", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "150.6876777871333574058985806852522185199700", + "upper_decimal_truncated": "150.6876777871333574058985806852522185199700", + "width_grid_units": "10710" + }, + "161": { + "lower_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965031125", + "upper_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965042395", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "158.5423086521651604050968055339254918994523", + "upper_decimal_truncated": "158.5423086521651604050968055339254918994523", + "width_grid_units": "11270" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.07999367802403867, + "maximum_resident_set_kib": 19648 + }, + "excluded": [ + "author interval engine", + "author 10290000-state DP", + "native replay", + "Lean", + "physical circuit admission", + "global circuit optimum", + "kappa gain", + "changed-profile PR5402" + ] +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stderr.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stderr.log new file mode 100644 index 0000000000..fc8779bd78 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stderr.log @@ -0,0 +1,23 @@ + Command being timed: "timeout 60s python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v2.json" + User time (seconds): 0.13 + System time (seconds): 0.01 + Percent of CPU this job got: 95% + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.14 + Average shared text size (kbytes): 0 + Average unshared data size (kbytes): 0 + Average stack size (kbytes): 0 + Average total size (kbytes): 0 + Maximum resident set size (kbytes): 19776 + Average resident set size (kbytes): 0 + Major (requiring I/O) page faults: 0 + Minor (reclaiming a frame) page faults: 2773 + Voluntary context switches: 7 + Involuntary context switches: 37 + Swaps: 0 + File system inputs: 0 + File system outputs: 95 + Socket messages sent: 0 + Socket messages received: 0 + Signals delivered: 0 + Page size (bytes): 4096 + Exit status: 0 diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stdout.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stdout.log new file mode 100644 index 0000000000..4232e52ca7 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v2.stdout.log @@ -0,0 +1,85 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.07999367802403867, + "maximum_resident_set_kib": 19648 + } +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.json b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.json new file mode 100644 index 0000000000..fb69626a97 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.json @@ -0,0 +1,925 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "exponent": { + "kappa": "12109153/4000000000", + "t": "3987890847/4000000000" + }, + "arithmetic": { + "bits": 256, + "log_terms": 128, + "exp_terms": 64, + "floating_point_used_for_acceptance": false + }, + "local_moment": { + "lower_integer": "216320852040087359020954411699187041493565504346120215972017940793341692027674880", + "upper_integer": "216320852040087359020954411699187041493565504346120215972017940793341692028112287", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "upper_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "width_grid_units": "437407" + }, + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "short_difference_crosschecks": { + "17": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057184507392", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057177344161", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "7163231" + }, + "18": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913255645792", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913263029215", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "7383423" + } + }, + "canonical_histogram_checks": [ + { + "n": 0, + "p": 1, + "a": 0, + "mask": "000", + "paid": { + "1": 336 + }, + "target": { + "1": 224 + }, + "direct": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "equation_one": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "symbolic_identity": true + }, + { + "n": 1, + "p": 1, + "a": 0, + "mask": "100", + "paid": { + "1": 2417, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "target": { + "4": 28, + "7": 7, + "8": 47, + "9": 542 + }, + "direct": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "equation_one": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "symbolic_identity": true + }, + { + "n": 2, + "p": 1, + "a": 0, + "mask": "110", + "paid": { + "1": 4498, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 636, + "17": 224 + }, + "direct": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "equation_one": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "symbolic_identity": true + }, + { + "n": 3, + "p": 1, + "a": 0, + "mask": "111", + "paid": { + "1": 6579, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "target": { + "4": 84, + "7": 21, + "8": 141, + "9": 954, + "25": 224 + }, + "direct": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "equation_one": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "symbolic_identity": true + }, + { + "n": 4, + "p": 2, + "a": 0, + "mask": "11011", + "paid": { + "1": 8884, + "2": 1648, + "3": 2040, + "4": 508, + "5": 160, + "16": 224 + }, + "target": { + "4": 112, + "7": 28, + "8": 188, + "9": 1272, + "17": 224, + "33": 224 + }, + "direct": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "equation_one": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "symbolic_identity": true + }, + { + "n": 5, + "p": 3, + "a": 1, + "mask": "1101011", + "paid": { + "1": 11189, + "2": 2060, + "3": 2550, + "4": 635, + "5": 200, + "16": 448 + }, + "target": { + "4": 140, + "7": 35, + "8": 235, + "9": 1590, + "17": 448, + "41": 224 + }, + "direct": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "equation_one": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "symbolic_identity": true + }, + { + "n": 16, + "p": 14, + "a": 6, + "mask": "11010101010101010101010101011", + "paid": { + "1": 36544, + "2": 6592, + "3": 8160, + "4": 2032, + "5": 640, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 224 + }, + "target": { + "4": 448, + "7": 112, + "8": 752, + "9": 5088, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 224, + "129": 224 + }, + "direct": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "equation_one": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "symbolic_identity": true + }, + { + "n": 17, + "p": 15, + "a": 7, + "mask": "1101010101010101010101010101011", + "paid": { + "1": 38849, + "2": 7004, + "3": 8670, + "4": 2159, + "5": 680, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448 + }, + "target": { + "4": 476, + "7": 119, + "8": 799, + "9": 5406, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "137": 224 + }, + "direct": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "equation_one": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "symbolic_identity": true + }, + { + "n": 18, + "p": 16, + "a": 7, + "mask": "110101010101010101010101010101011", + "paid": { + "1": 41154, + "2": 7416, + "3": 9180, + "4": 2286, + "5": 720, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "target": { + "4": 504, + "7": 126, + "8": 846, + "9": 5724, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "direct": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "equation_one": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "symbolic_identity": true + }, + { + "n": 19, + "p": 17, + "a": 8, + "mask": "11010101010101010101010101010101011", + "paid": { + "1": 43459, + "2": 7828, + "3": 9690, + "4": 2413, + "5": 760, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "target": { + "4": 532, + "7": 133, + "8": 893, + "9": 6042, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "direct": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "equation_one": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "symbolic_identity": true + }, + { + "n": 20, + "p": 18, + "a": 8, + "mask": "1101010101010101010101010101010101011", + "paid": { + "1": 45764, + "2": 8240, + "3": 10200, + "4": 2540, + "5": 800, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448, + "80": 224 + }, + "target": { + "4": 560, + "7": 140, + "8": 940, + "9": 6360, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "81": 224, + "161": 224 + }, + "direct": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "equation_one": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "symbolic_identity": true + } + ], + "tiny_symbolic_identity_count": 456, + "negative_controls": [ + { + "name": "changed_source_bytes", + "expected": "rejected", + "observed": "rejected" + }, + { + "name": "reverse_paid_minus_target_sign", + "expected": "positive_certificate_fails", + "observed": "fails", + "interval": { + "lower_integer": "-1727035296221662582695899898972270732385545605305335210375352536965870", + "upper_integer": "-1727035296221662582695899898972270732385545605305335210375352506993376", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_one_112_rank_one_query", + "expected": "invoice_identity_fails_and_sign_negative", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "-12968713992852378591218287738277145780593967550166197567113914198510918012679456", + "upper_integer": "-12968713992852378591218287738277145780593967550166197567113914198510917982706962", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "upper_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_224_full_path_targets", + "expected": "invoice_identity_fails", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088826972736", + "upper_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088854671630", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "upper_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "width_grid_units": "27698894" + } + }, + { + "name": "alter_paid_profile_count", + "expected": "profile_pin_fails", + "observed": "fails_as_expected" + } + ], + "power_enclosures": { + "0": { + "lower_integer": "0", + "upper_integer": "0", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "0.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "1": { + "lower_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "1.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "2": { + "lower_integer": "231098741838856807215938608880033550876784850651598074692227759035352042755942", + "upper_integer": "231098741838856807215938608880033550876784850651598074692227759035352042756074", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.9958076873906240697262141798066671006382", + "upper_decimal_truncated": "1.9958076873906240697262141798066671006382", + "width_grid_units": "132" + }, + "3": { + "lower_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752312", + "upper_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752516", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "2.9900391249822233354011413577754006043637", + "upper_decimal_truncated": "2.9900391249822233354011413577754006043637", + "width_grid_units": "204" + }, + "4": { + "lower_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931592", + "upper_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931860", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "3.9832483250475110113261916547825629838983", + "upper_decimal_truncated": "3.9832483250475110113261916547825629838983", + "width_grid_units": "268" + }, + "5": { + "lower_integer": "576146477017858311538963861175774047319829198257813543785311604595483195216785", + "upper_integer": "576146477017858311538963861175774047319829198257813543785311604595483195217125", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "4.9756980879500720617478113663457729290262", + "upper_decimal_truncated": "4.9756980879500720617478113663457729290262", + "width_grid_units": "340" + }, + "7": { + "lower_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427337", + "upper_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427806", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "6.9588854019604784474984440892978502836695", + "upper_decimal_truncated": "6.9588854019604784474984440892978502836695", + "width_grid_units": "469" + }, + "8": { + "lower_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215024", + "upper_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215576", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "7.9497976279156497880821421539574903098632", + "upper_decimal_truncated": "7.9497976279156497880821421539574903098632", + "width_grid_units": "552" + }, + "9": { + "lower_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667752837", + "upper_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667753449", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "8.9403339689244597796751364686124018532837", + "upper_decimal_truncated": "8.9403339689244597796751364686124018532837", + "width_grid_units": "612" + }, + "16": { + "lower_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802454384", + "upper_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802455488", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "15.8662672189938019375704751712804820013438", + "upper_decimal_truncated": "15.8662672189938019375704751712804820013438", + "width_grid_units": "1104" + }, + "17": { + "lower_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210567956", + "upper_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210569129", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "16.8548153023036777192869406360951964803875", + "upper_decimal_truncated": "16.8548153023036777192869406360951964803875", + "width_grid_units": "1173" + }, + "24": { + "lower_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700033400", + "upper_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700035080", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "23.7702059431586641801033052141063551025294", + "upper_decimal_truncated": "23.7702059431586641801033052141063551025294", + "width_grid_units": "1680" + }, + "25": { + "lower_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670626625", + "upper_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670628325", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "24.7575714624300030502040987064407741806703", + "upper_decimal_truncated": "24.7575714624300030502040987064407741806703", + "width_grid_units": "1700" + }, + "32": { + "lower_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888407520", + "upper_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888409728", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31.6660180858616881848056296847530834526958", + "upper_decimal_truncated": "31.6660180858616881848056296847530834526958", + "width_grid_units": "2208" + }, + "33": { + "lower_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513447234", + "upper_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513449511", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "32.6525392724939940180709127746750921053004", + "upper_decimal_truncated": "32.6525392724939940180709127746750921053004", + "width_grid_units": "2277" + }, + "40": { + "lower_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576110840", + "upper_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576113600", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "39.5557928568099170707539516689297446593862", + "upper_decimal_truncated": "39.5557928568099170707539516689297446593862", + "width_grid_units": "2760" + }, + "41": { + "lower_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026030763", + "upper_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026033592", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.5416570089611572615908853661226048020691", + "upper_decimal_truncated": "40.5416570089611572615908853661226048020691", + "width_grid_units": "2829" + }, + "48": { + "lower_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062188320", + "upper_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062191680", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "47.4407597522143616150486097279036793562965", + "upper_decimal_truncated": "47.4407597522143616150486097279036793562965", + "width_grid_units": "3360" + }, + "49": { + "lower_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354453545", + "upper_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354456926", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "48.4260860376186496944666539345681227782824", + "upper_decimal_truncated": "48.4260860376186496944666539345681227782824", + "width_grid_units": "3381" + }, + "56": { + "lower_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483213128", + "upper_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483216936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "55.3217306614422546533007996181831152024264", + "upper_decimal_truncated": "55.3217306614422546533007996181831152024264", + "width_grid_units": "3808" + }, + "57": { + "lower_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891680603", + "upper_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891684536", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "56.3066016234756788434068683987986754687033", + "upper_decimal_truncated": "56.3066016234756788434068683987986754687033", + "width_grid_units": "3933" + }, + "64": { + "lower_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466597632", + "upper_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466602048", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "63.1992823248132921547553476876307220841729", + "upper_decimal_truncated": "63.1992823248132921547553476876307220841729", + "width_grid_units": "4416" + }, + "65": { + "lower_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127176010", + "upper_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127180560", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "64.1837585345452308380366881088364691723465", + "upper_decimal_truncated": "64.1837585345452308380366881088364691723465", + "width_grid_units": "4550" + }, + "72": { + "lower_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055881224", + "upper_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055886336", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "71.0738457789293770027476012036568710152123", + "upper_decimal_truncated": "71.0738457789293770027476012036568710152123", + "width_grid_units": "5112" + }, + "73": { + "lower_integer": "8343743307522643837399083579128092064456563137147226591098145848881569610998743", + "upper_integer": "8343743307522643837399083579128092064456563137147226591098145848881569611003780", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.0579735842067733700093551377043410467642", + "upper_decimal_truncated": "72.0579735842067733700093551377043410467642", + "width_grid_units": "5037" + }, + "80": { + "lower_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927213760", + "upper_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927219280", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "78.9457554644523675746174614583175681747447", + "upper_decimal_truncated": "78.9457554644523675746174614583175681747447", + "width_grid_units": "5520" + }, + "81": { + "lower_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785446840", + "upper_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785452510", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "79.9295714759045833654134630349790460925507", + "upper_decimal_truncated": "79.9295714759045833654134630349790460925507", + "width_grid_units": "5670" + }, + "129": { + "lower_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165454564", + "upper_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165463723", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "127.1160376225769532360330535979599161419442", + "upper_decimal_truncated": "127.1160376225769532360330535979599161419442", + "width_grid_units": "9159" + }, + "137": { + "lower_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397033825", + "upper_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397043552", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "134.9746152241832607205596700515275460117881", + "upper_decimal_truncated": "134.9746152241832607205596700515275460117881", + "width_grid_units": "9727" + }, + "145": { + "lower_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287132615", + "upper_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287142765", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "142.8318029493600842807894352098765562398155", + "upper_decimal_truncated": "142.8318029493600842807894352098765562398155", + "width_grid_units": "10150" + }, + "153": { + "lower_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666337304", + "upper_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666348014", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "150.6876777871333574058985806852522185199700", + "upper_decimal_truncated": "150.6876777871333574058985806852522185199700", + "width_grid_units": "10710" + }, + "161": { + "lower_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965031125", + "upper_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965042395", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "158.5423086521651604050968055339254918994523", + "upper_decimal_truncated": "158.5423086521651604050968055339254918994523", + "width_grid_units": "11270" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.06611429300392047, + "maximum_resident_set_kib": 24560 + }, + "excluded": [ + "author interval engine", + "author 10290000-state DP", + "native replay", + "Lean", + "physical circuit admission", + "global circuit optimum", + "kappa gain", + "changed-profile PR5402" + ] +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stderr.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stderr.log new file mode 100644 index 0000000000..ceb01a7b53 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stderr.log @@ -0,0 +1,23 @@ + Command being timed: "timeout 60s python3 -O -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3-optimized.json" + User time (seconds): 0.28 + System time (seconds): 0.02 + Percent of CPU this job got: 99% + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.31 + Average shared text size (kbytes): 0 + Average unshared data size (kbytes): 0 + Average stack size (kbytes): 0 + Average total size (kbytes): 0 + Maximum resident set size (kbytes): 24560 + Average resident set size (kbytes): 0 + Major (requiring I/O) page faults: 0 + Minor (reclaiming a frame) page faults: 5033 + Voluntary context switches: 17 + Involuntary context switches: 51 + Swaps: 0 + File system inputs: 80 + File system outputs: 95 + Socket messages sent: 0 + Socket messages received: 0 + Signals delivered: 0 + Page size (bytes): 4096 + Exit status: 0 diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stdout.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stdout.log new file mode 100644 index 0000000000..6a38d81c56 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3-optimized.stdout.log @@ -0,0 +1,85 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.06611429300392047, + "maximum_resident_set_kib": 24560 + } +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.json b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.json new file mode 100644 index 0000000000..c9d30609bb --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.json @@ -0,0 +1,925 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "source_head": "314b56a6c0056c2358538f072c6fde9d365be44d", + "canonical_main": "1ec1119972c9aefe42525172d07b332fcff81cb4", + "exponent": { + "kappa": "12109153/4000000000", + "t": "3987890847/4000000000" + }, + "arithmetic": { + "bits": 256, + "log_terms": 128, + "exp_terms": 64, + "floating_point_used_for_acceptance": false + }, + "local_moment": { + "lower_integer": "216320852040087359020954411699187041493565504346120215972017940793341692027674880", + "upper_integer": "216320852040087359020954411699187041493565504346120215972017940793341692028112287", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "upper_decimal_truncated": "1868.1833401998403912639445761432750203619779", + "width_grid_units": "437407" + }, + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "short_difference_crosschecks": { + "17": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057184507392", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057177344161", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "7163231" + }, + "18": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913255645792", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913263029215", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "7383423" + } + }, + "canonical_histogram_checks": [ + { + "n": 0, + "p": 1, + "a": 0, + "mask": "000", + "paid": { + "1": 336 + }, + "target": { + "1": 224 + }, + "direct": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "equation_one": { + "lower_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "upper_integer": "12968713994579413887439950320973045679566238282551743172419249408886270519672832", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "112.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "112.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "symbolic_identity": true + }, + { + "n": 1, + "p": 1, + "a": 0, + "mask": "100", + "paid": { + "1": 2417, + "2": 412, + "3": 510, + "4": 127, + "5": 40 + }, + "target": { + "4": 28, + "7": 7, + "8": 47, + "9": 542 + }, + "direct": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "equation_one": { + "lower_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490247968", + "upper_integer": "10369011511237474128816191653323789705890747844408340573918709420305635490822463", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "89.5485311607614006167140071740970052264089", + "upper_decimal_truncated": "89.5485311607614006167140071740970052264089", + "width_grid_units": "574495" + }, + "symbolic_identity": true + }, + { + "n": 2, + "p": 1, + "a": 0, + "mask": "110", + "paid": { + "1": 4498, + "2": 824, + "3": 1020, + "4": 254, + "5": 80 + }, + "target": { + "4": 56, + "7": 14, + "8": 94, + "9": 636, + "17": 224 + }, + "direct": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "equation_one": { + "lower_integer": "8439859900680212465003401533962564240196275405569217917590822647399975407537696", + "upper_integer": "8439859900680212465003401533962564240196275405569217917590822647399975408675262", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.8880526836569734076144498012260291171433", + "upper_decimal_truncated": "72.8880526836569734076144498012260291171433", + "width_grid_units": "1137566" + }, + "symbolic_identity": true + }, + { + "n": 3, + "p": 1, + "a": 0, + "mask": "111", + "paid": { + "1": 6579, + "2": 1236, + "3": 1530, + "4": 381, + "5": 120 + }, + "target": { + "4": 84, + "7": 21, + "8": 141, + "9": 954, + "25": 224 + }, + "direct": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "equation_one": { + "lower_integer": "6814829127030264008336188108509974897712189443317845582747033013236413862279840", + "upper_integer": "6814829127030264008336188108509974897712189443317845582747033013236413863972861", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "58.8540130152004905461156181870916446157751", + "upper_decimal_truncated": "58.8540130152004905461156181870916446157751", + "width_grid_units": "1693021" + }, + "symbolic_identity": true + }, + { + "n": 4, + "p": 2, + "a": 0, + "mask": "11011", + "paid": { + "1": 8884, + "2": 1648, + "3": 2040, + "4": 508, + "5": 160, + "16": 224 + }, + "target": { + "4": 112, + "7": 28, + "8": 188, + "9": 1272, + "17": 224, + "33": 224 + }, + "direct": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "equation_one": { + "lower_integer": "5688841386764416782477937538826340147529906731041315369695620123471808199979008", + "upper_integer": "5688841386764416782477937538826340147529906731041315369695620123471808202748732", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "49.1297930992947299034055789273834065548273", + "upper_decimal_truncated": "49.1297930992947299034055789273834065548273", + "width_grid_units": "2769724" + }, + "symbolic_identity": true + }, + { + "n": 5, + "p": 3, + "a": 1, + "mask": "1101011", + "paid": { + "1": 11189, + "2": 2060, + "3": 2550, + "4": 635, + "5": 200, + "16": 448 + }, + "target": { + "4": 140, + "7": 35, + "8": 235, + "9": 1590, + "17": 448, + "41": 224 + }, + "direct": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "equation_one": { + "lower_integer": "4714589509147568029876897637331656130358107567598839786227293080393452510789696", + "upper_integer": "4714589509147568029876897637331656130358107567598839786227293080393452514630523", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.7159896690783795143880304679195395348171", + "upper_decimal_truncated": "40.7159896690783795143880304679195395348171", + "width_grid_units": "3840827" + }, + "symbolic_identity": true + }, + { + "n": 16, + "p": 14, + "a": 6, + "mask": "11010101010101010101010101011", + "paid": { + "1": 36544, + "2": 6592, + "3": 8160, + "4": 2032, + "5": 640, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 224 + }, + "target": { + "4": 448, + "7": 112, + "8": 752, + "9": 5088, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 224, + "129": 224 + }, + "direct": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "equation_one": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "symbolic_identity": true + }, + { + "n": 17, + "p": 15, + "a": 7, + "mask": "1101010101010101010101010101011", + "paid": { + "1": 38849, + "2": 7004, + "3": 8670, + "4": 2159, + "5": 680, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448 + }, + "target": { + "4": 476, + "7": 119, + "8": 799, + "9": 5406, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "137": 224 + }, + "direct": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "equation_one": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "symbolic_identity": true + }, + { + "n": 18, + "p": 16, + "a": 7, + "mask": "110101010101010101010101010101011", + "paid": { + "1": 41154, + "2": 7416, + "3": 9180, + "4": 2286, + "5": 720, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 224 + }, + "target": { + "4": 504, + "7": 126, + "8": 846, + "9": 5724, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 224, + "145": 224 + }, + "direct": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "equation_one": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "symbolic_identity": true + }, + { + "n": 19, + "p": 17, + "a": 8, + "mask": "11010101010101010101010101010101011", + "paid": { + "1": 43459, + "2": 7828, + "3": 9690, + "4": 2413, + "5": 760, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448 + }, + "target": { + "4": 532, + "7": 133, + "8": 893, + "9": 6042, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "153": 224 + }, + "direct": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "equation_one": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "symbolic_identity": true + }, + { + "n": 20, + "p": 18, + "a": 8, + "mask": "1101010101010101010101010101010101011", + "paid": { + "1": 45764, + "2": 8240, + "3": 10200, + "4": 2540, + "5": 800, + "16": 448, + "24": 448, + "32": 448, + "40": 448, + "48": 448, + "56": 448, + "64": 448, + "72": 448, + "80": 224 + }, + "target": { + "4": 560, + "7": 140, + "8": 940, + "9": 6360, + "17": 448, + "25": 448, + "33": 448, + "41": 448, + "49": 448, + "57": 448, + "65": 448, + "73": 448, + "81": 224, + "161": 224 + }, + "direct": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "equation_one": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + }, + "symbolic_identity": true + } + ], + "tiny_symbolic_identity_count": 456, + "negative_controls": [ + { + "name": "changed_source_bytes", + "expected": "rejected", + "observed": "rejected" + }, + { + "name": "reverse_paid_minus_target_sign", + "expected": "positive_certificate_fails", + "observed": "fails", + "interval": { + "lower_integer": "-1727035296221662582695899898972270732385545605305335210375352536965870", + "upper_integer": "-1727035296221662582695899898972270732385545605305335210375352506993376", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "-0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_one_112_rank_one_query", + "expected": "invoice_identity_fails_and_sign_negative", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "-12968713992852378591218287738277145780593967550166197567113914198510918012679456", + "upper_integer": "-12968713992852378591218287738277145780593967550166197567113914198510917982706962", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "upper_decimal_truncated": "-111.9999999850850320812322580919209200217514", + "width_grid_units": "29972494" + } + }, + { + "name": "omit_224_full_path_targets", + "expected": "invoice_identity_fails", + "observed": "fails_as_expected", + "interval": { + "lower_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088826972736", + "upper_integer": "3704689603562477692404699786427079919183781088361232942610023157129236088854671630", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "upper_decimal_truncated": "31994.3238606715738468156012289204276776969287", + "width_grid_units": "27698894" + } + }, + { + "name": "alter_paid_profile_count", + "expected": "profile_pin_fails", + "observed": "fails_as_expected" + } + ], + "power_enclosures": { + "0": { + "lower_integer": "0", + "upper_integer": "0", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "0.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "1": { + "lower_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_integer": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.0000000000000000000000000000000000000000", + "upper_decimal_truncated": "1.0000000000000000000000000000000000000000", + "width_grid_units": "0" + }, + "2": { + "lower_integer": "231098741838856807215938608880033550876784850651598074692227759035352042755942", + "upper_integer": "231098741838856807215938608880033550876784850651598074692227759035352042756074", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "1.9958076873906240697262141798066671006382", + "upper_decimal_truncated": "1.9958076873906240697262141798066671006382", + "width_grid_units": "132" + }, + "3": { + "lower_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752312", + "upper_integer": "346222877183008437179050312781953324536897170993812803032111819805409039752516", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "2.9900391249822233354011413577754006043637", + "upper_decimal_truncated": "2.9900391249822233354011413577754006043637", + "width_grid_units": "204" + }, + "4": { + "lower_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931592", + "upper_integer": "461228645508291662179549316124754021303904697761923903409237249366518677931860", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "3.9832483250475110113261916547825629838983", + "upper_decimal_truncated": "3.9832483250475110113261916547825629838983", + "width_grid_units": "268" + }, + "5": { + "lower_integer": "576146477017858311538963861175774047319829198257813543785311604595483195216785", + "upper_integer": "576146477017858311538963861175774047319829198257813543785311604595483195217125", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "4.9756980879500720617478113663457729290262", + "upper_decimal_truncated": "4.9756980879500720617478113663457729290262", + "width_grid_units": "340" + }, + "7": { + "lower_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427337", + "upper_integer": "805783879456064702857209895160317589459633384057367888255333718774197192427806", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "6.9588854019604784474984440892978502836695", + "upper_decimal_truncated": "6.9588854019604784474984440892978502836695", + "width_grid_units": "469" + }, + "8": { + "lower_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215024", + "upper_integer": "920523676350213532198709944137870130499083983426868433070350934413327689215576", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "7.9497976279156497880821421539574903098632", + "upper_decimal_truncated": "7.9497976279156497880821421539574903098632", + "width_grid_units": "552" + }, + "9": { + "lower_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667752837", + "upper_integer": "1035219948741110324406330895927720281905389433333997150638114866923252667753449", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "8.9403339689244597796751364686124018532837", + "upper_decimal_truncated": "8.9403339689244597796751364686124018532837", + "width_grid_units": "612" + }, + "16": { + "lower_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802454384", + "upper_integer": "1837188229684834976388864143573312591018373961361049938001938398000647802455488", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "15.8662672189938019375704751712804820013438", + "upper_decimal_truncated": "15.8662672189938019375704751712804820013438", + "width_grid_units": "1104" + }, + "17": { + "lower_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210567956", + "upper_integer": "1951654277562829997608684697256181091189736480219745344637787090840043210569129", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "16.8548153023036777192869406360951964803875", + "upper_decimal_truncated": "16.8548153023036777192869406360951964803875", + "width_grid_units": "1173" + }, + "24": { + "lower_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700033400", + "upper_integer": "2752401807759611822728803956253960982771058898218247658208689167137011700035080", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "23.7702059431586641801033052141063551025294", + "upper_decimal_truncated": "23.7702059431586641801033052141063551025294", + "width_grid_units": "1680" + }, + "25": { + "lower_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670626625", + "upper_integer": "2866730924076927736850567174058264060638322873192155367559405309673163670628325", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "24.7575714624300030502040987064407741806703", + "upper_decimal_truncated": "24.7575714624300030502040987064407741806703", + "width_grid_units": "1700" + }, + "32": { + "lower_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888407520", + "upper_integer": "3666674391988565176335947528383861118954565164890860955415853356311124888409728", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "31.6660180858616881848056296847530834526958", + "upper_decimal_truncated": "31.6660180858616881848056296847530834526958", + "width_grid_units": "2208" + }, + "33": { + "lower_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513447234", + "upper_integer": "3780905741265596198372945783722912176196040824605551431269487880637306513449511", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "32.6525392724939940180709127746750921053004", + "upper_decimal_truncated": "32.6525392724939940180709127746750921053004", + "width_grid_units": "2277" + }, + "40": { + "lower_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576110840", + "upper_integer": "4580247896328528441280356369405882734461804587553969138545165301926776576113600", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "39.5557928568099170707539516689297446593862", + "upper_decimal_truncated": "39.5557928568099170707539516689297446593862", + "width_grid_units": "2760" + }, + "41": { + "lower_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026030763", + "upper_integer": "4694403166210295916711140417190288190267104831604509751097503104071600026033592", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "40.5416570089611572615908853661226048020691", + "upper_decimal_truncated": "40.5416570089611572615908853661226048020691", + "width_grid_units": "2829" + }, + "48": { + "lower_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062188320", + "upper_integer": "5493264686714483919607076817583033453766526703110642724812458995639095062191680", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "47.4407597522143616150486097279036793562965", + "upper_decimal_truncated": "47.4407597522143616150486097279036793562965", + "width_grid_units": "3360" + }, + "49": { + "lower_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354453545", + "upper_integer": "5607357675881890531183675369522050994083843389321128015711167717810134354456926", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "48.4260860376186496944666539345681227782824", + "upper_decimal_truncated": "48.4260860376186496944666539345681227782824", + "width_grid_units": "3381" + }, + "56": { + "lower_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483213128", + "upper_integer": "6405818773512493063996659368354642672050764862036200692360191197143011483216936", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "55.3217306614422546533007996181831152024264", + "upper_decimal_truncated": "55.3217306614422546533007996181831152024264", + "width_grid_units": "3808" + }, + "57": { + "lower_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891680603", + "upper_integer": "6519859039835508768485098659151681545903902916198442299273623498923930891684536", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "56.3066016234756788434068683987986754687033", + "upper_decimal_truncated": "56.3066016234756788434068683987986754687033", + "width_grid_units": "3933" + }, + "64": { + "lower_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466597632", + "upper_integer": "7317976938689120868391259838425296680148655798280131147178113163027324466602048", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "63.1992823248132921547553476876307220841729", + "upper_decimal_truncated": "63.1992823248132921547553476876307220841729", + "width_grid_units": "4416" + }, + "65": { + "lower_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127176010", + "upper_integer": "7431971495818416327126916836680264750185160408257817331141098311888616127180560", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "64.1837585345452308380366881088364691723465", + "upper_decimal_truncated": "64.1837585345452308380366881088364691723465", + "width_grid_units": "4550" + }, + "72": { + "lower_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055881224", + "upper_integer": "8229789092873039420993853272059600282479270721850832357752273775860959055886336", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "71.0738457789293770027476012036568710152123", + "upper_decimal_truncated": "71.0738457789293770027476012036568710152123", + "width_grid_units": "5112" + }, + "73": { + "lower_integer": "8343743307522643837399083579128092064456563137147226591098145848881569610998743", + "upper_integer": "8343743307522643837399083579128092064456563137147226591098145848881569611003780", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "72.0579735842067733700093551377043410467642", + "upper_decimal_truncated": "72.0579735842067733700093551377043410467642", + "width_grid_units": "5037" + }, + "80": { + "lower_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927213760", + "upper_integer": "9141293961647211214124244274018267446245411412169236324020728294083088927219280", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "78.9457554644523675746174614583175681747447", + "upper_decimal_truncated": "78.9457554644523675746174614583175681747447", + "width_grid_units": "5520" + }, + "81": { + "lower_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785446840", + "upper_integer": "9255212073038386677053932462255950361354931536295696476206443095801259785452510", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "79.9295714759045833654134630349790460925507", + "upper_decimal_truncated": "79.9295714759045833654134630349790460925507", + "width_grid_units": "5670" + }, + "129": { + "lower_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165454564", + "upper_integer": "14719031571887473404365051252021396744462657495001085698079435179066848165463723", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "127.1160376225769532360330535979599161419442", + "upper_decimal_truncated": "127.1160376225769532360330535979599161419442", + "width_grid_units": "9159" + }, + "137": { + "lower_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397033825", + "upper_integer": "15628992690811045241428823582989237944350082155589294085028667925419658397043552", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "134.9746152241832607205596700515275460117881", + "upper_decimal_truncated": "134.9746152241832607205596700515275460117881", + "width_grid_units": "9727" + }, + "145": { + "lower_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287132615", + "upper_integer": "16538792873039065433519991624305285800378610792985925879485347419280628287142765", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "142.8318029493600842807894352098765562398155", + "upper_decimal_truncated": "142.8318029493600842807894352098765562398155", + "width_grid_units": "10150" + }, + "153": { + "lower_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666337304", + "upper_integer": "17448441033291695165268054025791184780447726585997998266981856871924053666348014", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "150.6876777871333574058985806852522185199700", + "upper_decimal_truncated": "150.6876777871333574058985806852522185199700", + "width_grid_units": "10710" + }, + "161": { + "lower_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965031125", + "upper_integer": "18357945151341635799327581580251245917240864403902055723942840055667010965042395", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "158.5423086521651604050968055339254918994523", + "upper_decimal_truncated": "158.5423086521651604050968055339254918994523", + "width_grid_units": "11270" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.04865726502612233, + "maximum_resident_set_kib": 19740 + }, + "excluded": [ + "author interval engine", + "author 10290000-state DP", + "native replay", + "Lean", + "physical circuit admission", + "global circuit optimum", + "kappa gain", + "changed-profile PR5402" + ] +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stderr.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stderr.log new file mode 100644 index 0000000000..6321118031 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stderr.log @@ -0,0 +1,23 @@ + Command being timed: "timeout 60s python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt outputs/controller5405-exact-successor-20261024/receipts/arithmetic-v3.json" + User time (seconds): 0.09 + System time (seconds): 0.00 + Percent of CPU this job got: 99% + Elapsed (wall clock) time (h:mm:ss or m:ss): 0:00.10 + Average shared text size (kbytes): 0 + Average unshared data size (kbytes): 0 + Average stack size (kbytes): 0 + Average total size (kbytes): 0 + Maximum resident set size (kbytes): 19740 + Average resident set size (kbytes): 0 + Major (requiring I/O) page faults: 0 + Minor (reclaiming a frame) page faults: 2791 + Voluntary context switches: 6 + Involuntary context switches: 21 + Swaps: 0 + File system inputs: 0 + File system outputs: 95 + Socket messages sent: 0 + Socket messages received: 0 + Signals delivered: 0 + Page size (bytes): 4096 + Exit status: 0 diff --git a/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stdout.log b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stdout.log new file mode 100644 index 0000000000..450a20baff --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/arithmetic-v3.stdout.log @@ -0,0 +1,85 @@ +{ + "status": "PASS_SCOPED_ARITHMETIC", + "values": { + "16": { + "lower_integer": "107924268823676041698338326421880928972857885039841428539314315352270986431776", + "upper_integer": "107924268823676041698338326421880928972857885039841428539314315352271011025712", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.9320521767465907379612062675770559959860", + "upper_decimal_truncated": "0.9320521767465907379612062675770559959860", + "width_grid_units": "24593936" + }, + "17": { + "lower_integer": "31418867648174691020530600672691639144443906951416688639695989621409689321920", + "upper_integer": "31418867648174691020530600672691639144443906951416688639695989621409716488879", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.2713386368198404129234424616156377620398", + "upper_decimal_truncated": "0.2713386368198404129234424616156377620398", + "width_grid_units": "27166959" + }, + "18": { + "lower_integer": "1727035296221662582695899898972270732385545605305335210375352506993376", + "upper_integer": "1727035296221662582695899898972270732385545605305335210375352536965870", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0000000149149679187677419080790799782485", + "upper_decimal_truncated": "0.0000000149149679187677419080790799782485", + "width_grid_units": "29972494" + }, + "19": { + "lower_integer": "2634058293359018278457886672456373708574699960981681049063663859265764912768", + "upper_integer": "2634058293359018278457886672456373708574699960981681049063663859265797721485", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481714053928916308503405724625179910", + "upper_decimal_truncated": "0.0227481714053928916308503405724625179910", + "width_grid_units": "32808717" + }, + "20": { + "lower_integer": "45620698150126201088493542537875920644938313796996376625905122794521159239136", + "upper_integer": "45620698150126201088493542537875920644938313796996376625905122794521195117260", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3939880388255751968687072088631922873643", + "upper_decimal_truncated": "0.3939880388255751968687072088631922873643", + "width_grid_units": "35878124" + } + }, + "differences": { + "16_to_17": { + "lower_integer": "-76505401175501350677807725749189289828413978088424739899618325730861321703792", + "upper_integer": "-76505401175501350677807725749189289828413978088424739899618325730861269942897", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "upper_decimal_truncated": "-0.6607135399267503250377638059614182339462", + "width_grid_units": "51760895" + }, + "17_to_18": { + "lower_integer": "-31418865921139394798868017976791740172173174565871083334360779246057209495503", + "upper_integer": "-31418865921139394798868017976791740172173174565871083334360779246057152356050", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "upper_decimal_truncated": "-0.2713386219048724941557005535365577837912", + "width_grid_units": "57139453" + }, + "18_to_19": { + "lower_integer": "2634056566323722056795303976556474736303967575436075743728453483913227946898", + "upper_integer": "2634056566323722056795303976556474736303967575436075743728453483913290728109", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.0227481564904249728631084324933825397425", + "upper_decimal_truncated": "0.0227481564904249728631084324933825397425", + "width_grid_units": "62781211" + }, + "19_to_20": { + "lower_integer": "42986639856767182810035655865419546936363613836014695576841458935255361517651", + "upper_integer": "42986639856767182810035655865419546936363613836014695576841458935255430204492", + "denominator": "115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal_truncated": "0.3712398674201823052378568682907297693732", + "upper_decimal_truncated": "0.3712398674201823052378568682907297693732", + "width_grid_units": "68686841" + } + }, + "environment": { + "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", + "elapsed_seconds": 0.04865726502612233, + "maximum_resident_set_kib": 19740 + } +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/check_ceiling-v1.py b/research/controller-ceiling-convexity/numerical/receipts/check_ceiling-v1.py new file mode 100644 index 0000000000..eca76b115d --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/check_ceiling-v1.py @@ -0,0 +1,366 @@ +#!/usr/bin/env python3 +"""Independent fixed-inventory arithmetic for source PR5405 equation (1). + +Standard library only. Integer directed arithmetic; no imported interval engine. +Written for this independent check with substantial OpenAI Codex assistance. +Apache-2.0. See PROOF.md for derivation, scope, remainder proofs and credit. +""" +from __future__ import annotations +import argparse +from collections import Counter +from fractions import Fraction +from hashlib import sha256 +import json +from pathlib import Path +import platform +import resource +import signal +import sys +import time + +BITS = 256 +Q = 1 << BITS +LOG_TERMS = 128 +EXP_TERMS = 64 +P = {1: 2193, 2: 412, 3: 510, 4: 127, 5: 40} +H = {4: 28, 7: 7, 8: 47, 9: 318} +KAPPA = Fraction(12109153, 4000000000) # .00302728825, exact +ROOT = Path(__file__).resolve().parent + +def ceildiv(a, b): + return -((-a) // b) + +def frac_up(x): + return ceildiv(x.numerator * Q, x.denominator) + +def frac_down(x): + return x.numerator * Q // x.denominator + +def plus(a, b): + return a[0] + b[0], a[1] + b[1] + +def neg(a): + return -a[1], -a[0] + +def minus(a, b): + return plus(a, neg(b)) + +def scale(a, k): + return (a[0] * k, a[1] * k) if k >= 0 else (a[1] * k, a[0] * k) + +def positive_mul(a, b): + assert a[0] >= 0 and b[0] >= 0 + return a[0] * b[0] // Q, ceildiv(a[1] * b[1], Q) + +def constant(n): + return n * Q, n * Q + +def log_unit_interval(y): + """ln(y) for exact 1<=y<=2 via 2 atanh((y-1)/(y+1)).""" + assert 1 <= y <= 2 + z = (y - 1) / (y + 1) + zz = z * z + z_iv = frac_down(z), frac_up(z) + zz_iv = frac_down(zz), frac_up(zz) + term = z_iv + total = (0, 0) + for j in range(LOG_TERMS): + d = 2 * j + 1 + total = plus(total, (term[0] // d, ceildiv(term[1], d))) + term = positive_mul(term, zz_iv) + # All omitted terms positive, denominators >=2N+1: + # R <=2*z^(2N+1)/((2N+1)*(1-z^2)). + tail = 2 * z ** (2 * LOG_TERMS + 1) / ((2 * LOG_TERMS + 1) * (1 - zz)) + return 2 * total[0], 2 * total[1] + frac_up(tail) + +LOG2 = log_unit_interval(Fraction(2)) + +def log_integer(r): + assert isinstance(r, int) and r >= 1 + if r == 1: + return 0, 0 + m = r.bit_length() - 1 + return plus(scale(LOG2, m), log_unit_interval(Fraction(r, 1 << m))) + +def exp_positive(x): + """exp(x) for 0<=x<=1; directed Taylor and exact geometric tail.""" + assert 0 <= x[0] <= x[1] <= Q + term = (Q, Q) + total = term + for k in range(1, EXP_TERMS + 1): + # Bounds for x^k/k!; all factors nonnegative. + prod = positive_mul(term, x) + term = prod[0] // k, ceildiv(prod[1], k) + total = plus(total, term) + upper_x = Fraction(x[1], Q) + # First omitted term bounds remainder with subsequent ratios <=x/(N+2). + first = upper_x ** (EXP_TERMS + 1) + for k in range(1, EXP_TERMS + 2): + first /= k + tail = first / (1 - upper_x / (EXP_TERMS + 2)) + return total[0], total[1] + frac_up(tail) + +class Powers: + def __init__(self, kappa=KAPPA): + assert 0 < kappa < 1 + self.kappa = kappa + self.cache = {0: (0, 0), 1: (Q, Q)} + + def __call__(self, r): + if r not in self.cache: + log = log_integer(r) + num, den = self.kappa.numerator, self.kappa.denominator + x = log[0] * num // den, ceildiv(log[1] * num, den) + ex = exp_positive(x) + reciprocal = Q * Q // ex[1], ceildiv(Q * Q, ex[0]) + self.cache[r] = scale(reciprocal, r) + return self.cache[r] + +def moment(hist, f): + total = (0, 0) + for r, count in sorted(hist.items()): + total = plus(total, scale(f(r), count)) + return total + +def local(f): + return minus(moment(P, f), moment(H, f)) + +def delta(r, f): + return minus(f(r + 1), f(r)) + +def canonical_parts(n): + assert n >= 0 + if n <= 2: + return 1, 0, 0 + a = (n - 3) // 2 + b = n - 3 - a + return n - 2, a, b + +def canonical_mask(n): + p, a, b = canonical_parts(n) + x = [0] * (2 * p + 1) + if n <= 2: + for i in range(n): + x[i] = 1 + else: + x[0] = x[2 * p] = x[2 * a + 1] = 1 + for j in range(1, a + 1): + x[2 * j - 1] = 1 + for j in range(1, b + 1): + x[2 * p - 2 * j + 1] = 1 + assert sum(x) == n + return p, a, x + +def invoice_histograms(p, a, x): + """Reconstruct paid/target lists from Eq1's individual invoice items.""" + assert p >= 1 and 0 <= a < p and len(x) == 2 * p + 1 and set(x) <= {0, 1} + n = sum(x) + paid = Counter({r: n * count for r, count in P.items()}) + target = Counter({r: n * count for r, count in H.items()}) + paid[1] += 112 * (2 * p + 1 - n) + target[1 + 8 * n] += 224 + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + if h: + paid[8 * h] += 224 + if e: + paid[8] += 224 + target[1 + 8 * (h + e)] += 224 + return +paid, +target + +def clean_signed(c): + return {r: count for r, count in sorted(c.items()) if count} + +def signed_histograms(paid, target): + c = Counter(paid) + c.subtract(target) + return clean_signed(c) + +def equation_one_coefficients(p, a, x): + """Literal Eq1 expanded as integer coefficients of independent f(r).""" + n = sum(x) + c = Counter({1:112*(2*p+1)-112*n}) + for r, count in P.items(): c[r] += n*count + for r, count in H.items(): c[r] -= n*count + c[1+8*n] -= 224 + for j in range(1,p): + h = sum(x[:2*j]) if j<=a else sum(x[2*j+1:]) + e = x[2*j] + if h: c[8*h] +=224 + c[8] +=224*e + c[1+8*(h+e)] -=224 + return clean_signed(c) + +def canonical_coefficients(n): + """Closed formula expanded symbolically; no interval overlap acceptance.""" + c = Counter() + for r,count in P.items(): c[r] += n*count + for r,count in H.items(): c[r] -= n*count + c[1] +=336-112*n if n<=2 else 112*(n-3) + c[1+8*n] -=224 + if n>=3: + _,a,b=canonical_parts(n) + for q in (a,b): + for k in range(2,q+2): + c[8*k+1]-=224 + c[8*k]+=224 + return clean_signed(c) + +def equation_one(p, a, x, f): + n = sum(x) + val = plus(constant(112 * (2*p+1)), scale(minus(local(f), constant(112)), n)) + val = minus(val, scale(f(1+8*n), 224)) + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + g = minus(plus(f(8*h), scale(f(8), e)), f(1+8*(h+e))) + val = plus(val, scale(g, 224)) + return val + +def canonical(n, f): + if n <= 2: + return minus(plus(constant(336), scale(minus(local(f), constant(112)), n)), scale(f(1+8*n), 224)) + p, a, b = canonical_parts(n) + val = minus(plus(scale(local(f), n), constant(112*(n-3))), scale(f(1+8*n), 224)) + for q in (a, b): + for k in range(2, q+2): + val = minus(val, scale(delta(8*k, f), 224)) + return val + +def overlap(a, b): + return a[0] <= b[1] and b[0] <= a[1] + +def exact_grid_text(n, digits=40): + sign = '-' if n < 0 else '' + a = abs(n) + whole, remain = divmod(a, Q) + return sign + str(whole) + '.' + str(remain * (10**digits) // Q).zfill(digits) + +def packed(iv): + # Decimal strings are display only, exact integer/Q endpoints certify signs. + return dict(lower_integer=str(iv[0]), upper_integer=str(iv[1]), denominator=str(Q), + lower_decimal_truncated=exact_grid_text(iv[0]), upper_decimal_truncated=exact_grid_text(iv[1]), + width_grid_units=str(iv[1]-iv[0])) + +def authenticate(data, expected): + if sha256(data).hexdigest() != expected: + raise ValueError('source hash mismatch') + +def verify_sources(): + manifest = json.loads((ROOT/'SOURCE-MANIFEST.json').read_text()) + for row in manifest['inputs']: + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + source = (ROOT/'inputs/5405-PROOF.md').read_text() + assert 'paid P = {1:2193, 2:412, 3:510, 4:127, 5:40}' in source + assert 'helper targets H = {4:28, 7:7, 8:47, 9:318}' in source + for row in json.loads((ROOT/'THEORY-MANIFEST.json').read_text()): + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + return manifest + +def run(): + start = time.monotonic() + manifest = verify_sources() + f = Powers() + values = {n: canonical(n, f) for n in range(16, 21)} + # Recompute differences in both literal canonical expression and the short formula. + differences = {n: minus(values[n+1], values[n]) for n in range(16, 20)} + neighbor_short = {} + for n in (17, 18): + # Independently: newly added full stage contributes L+112; rank main + # grows by 8, and one side sum gains delta at 8*floor((n+1)/2). + cost = plus(minus(f(1+8*(n+1)), f(1+8*n)), delta(8*((n+1)//2), f)) + neighbor_short[n] = minus(plus(local(f), constant(112)), scale(cost, 224)) + assert overlap(differences[n], neighbor_short[n]) + assert values[18][0] > 0 + assert differences[17][1] < 0 + assert differences[18][0] > 0 + hist_checks = [] + for n in list(range(0, 6)) + list(range(16, 21)): + p, a, mask = canonical_mask(n) + paid, target = invoice_histograms(p, a, mask) + assert signed_histograms(paid,target)==equation_one_coefficients(p,a,mask)==canonical_coefficients(n) + direct = minus(moment(paid, f), moment(target, f)) + eq1 = equation_one(p, a, mask, f) + assert overlap(direct, eq1) and overlap(direct, canonical(n, f)) + hist_checks.append(dict(n=n, p=p, a=a, mask=''.join(map(str,mask)), + paid=dict(sorted(paid.items())), target=dict(sorted(target.items())), + direct=packed(direct), equation_one=packed(eq1),symbolic_identity=True)) + # Small exhaustive identity control checks the prefix/suffix index branches, + # with affine counts compared symbolically. It is not an all-mask proof. + tiny_identity_count=0 + for p in range(1,4): + for a in range(p): + for bits in range(1<<(2*p+1)): + x=[(bits>>i)&1 for i in range(2*p+1)] + paid,target=invoice_histograms(p,a,x) + assert signed_histograms(paid,target)==equation_one_coefficients(p,a,x) + tiny_identity_count+=1 + controls=[] + # Source mutation must be caught before accepting any arithmetic. + src=(ROOT/'inputs/5405-PROOF.md').read_bytes() + try: + authenticate(src+b'\nMUTANT\n', manifest['inputs'][0]['sha256']) + except ValueError: + controls.append(dict(name='changed_source_bytes',expected='rejected',observed='rejected')) + else: + raise AssertionError('source mutant survived') + reversed_sign=neg(values[18]) + assert reversed_sign[1] < 0 + controls.append(dict(name='reverse_paid_minus_target_sign',expected='positive_certificate_fails', + observed='fails',interval=packed(reversed_sign))) + p,a,x=canonical_mask(18) + paid,target=invoice_histograms(p,a,x) + # Dropping one query invoice is a concrete 112-rank-one omission. + mutant=paid.copy(); mutant[1]-=112 + mutant_val=minus(moment(mutant,f),moment(target,f)) + assert signed_histograms(mutant,target)!=equation_one_coefficients(p,a,x) + assert not overlap(mutant_val,equation_one(p,a,x,f)) and mutant_val[1]<0 + controls.append(dict(name='omit_one_112_rank_one_query',expected='invoice_identity_fails_and_sign_negative', + observed='fails_as_expected',interval=packed(mutant_val))) + mutant_target=target.copy(); mutant_target[145]-=224 + mutant_main=minus(moment(paid,f),moment(mutant_target,f)) + assert signed_histograms(paid,mutant_target)!=equation_one_coefficients(p,a,x) + assert not overlap(mutant_main,equation_one(p,a,x,f)) + controls.append(dict(name='omit_224_full_path_targets',expected='invoice_identity_fails', + observed='fails_as_expected',interval=packed(mutant_main))) + changed_profile = dict(P); changed_profile[4] -= 1 + assert changed_profile != P + controls.append(dict(name='alter_paid_profile_count',expected='profile_pin_fails',observed='fails_as_expected')) + return dict(status='PASS_SCOPED_ARITHMETIC', source_head=manifest['source_head'], + canonical_main=manifest['canonical_main'], + exponent=dict(kappa=str(KAPPA),t=str(1-KAPPA)), + arithmetic=dict(bits=BITS,log_terms=LOG_TERMS,exp_terms=EXP_TERMS, + floating_point_used_for_acceptance=False), + local_moment=packed(local(f)), values={str(n):packed(v) for n,v in values.items()}, + differences={str(n)+'_to_'+str(n+1):packed(v) for n,v in differences.items()}, + short_difference_crosschecks={str(n):packed(v) for n,v in neighbor_short.items()}, + canonical_histogram_checks=hist_checks,tiny_symbolic_identity_count=tiny_identity_count, + negative_controls=controls, + power_enclosures={str(r):packed(v) for r,v in sorted(f.cache.items())}, + environment=dict(python=sys.version,platform=platform.platform(), + elapsed_seconds=time.monotonic()-start, + maximum_resident_set_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss), + excluded=['author interval engine','author 10290000-state DP','native replay','Lean', + 'physical circuit admission','global circuit optimum','kappa gain','changed-profile PR5402']) + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument('--receipt',type=Path,required=True) + args=parser.parse_args() + # Local cap applies even when called without an external runner. + resource.setrlimit(resource.RLIMIT_AS,(256*1024*1024,256*1024*1024)) + signal.alarm(60) + try: + result=run() + except Exception as exc: + result=dict(status='FAIL',error_type=type(exc).__name__,error=str(exc)) + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + raise + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + print(json.dumps({k:result[k] for k in ('status','values','differences','environment')},indent=2)) + +if __name__=='__main__': + main() diff --git a/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-FINAL-MANIFEST.json b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-FINAL-MANIFEST.json new file mode 100644 index 0000000000..d79454f637 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-FINAL-MANIFEST.json @@ -0,0 +1,120 @@ +{ + "files": [ + { + "path": "HANDOFF.md", + "bytes": 2767, + "sha256": "9a49c75d894869c8d37bd6bd983c4e43ef9a7f6f40944539e3dc0bb353a9c5f6" + }, + { + "path": "PROOF.md", + "bytes": 13468, + "sha256": "85f92f5b1a90148ba6a6857c41035d805cc18e4442a618dd107b2b7988bd0f6c" + }, + { + "path": "RUNS.json", + "bytes": 2009, + "sha256": "815146645a539dd9cf5c262fbbe9649101c32fd06da455a339627a62880bcda2" + }, + { + "path": "SOURCE-MANIFEST.json", + "bytes": 2135, + "sha256": "c9e036ae8bce17023e6e47682e548e7b23f0eea745175516c66c9f34ba5d1cca" + }, + { + "path": "THEORY-MANIFEST.json", + "bytes": 545, + "sha256": "21ec2a198c3201c2fc83a2bfd2a4622987e15b490b64c632925e399e84510054" + }, + { + "path": "check_ceiling.py", + "bytes": 14844, + "sha256": "3352d5c6dd0da6e988efcab7b6a8cfd5ff85655390bef472523e7022db431cd9" + }, + { + "path": "inputs/5405-PROOF.md", + "bytes": 10030, + "sha256": "5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37" + }, + { + "path": "inputs/5405-concavity-exchange-reduction.md", + "bytes": 10145, + "sha256": "0e575a88d28db5aecc5ccf24504923a0508ff976d05f92e91e6d48408b7688ea" + }, + { + "path": "inputs/5405-discrete-convexity-three-value-gate.md", + "bytes": 7372, + "sha256": "bdad476f31b450e1ac4d1fd0d9530b43e33ebac48accc0956b38a9634b40a929" + }, + { + "path": "inputs/CHECKPOINT-20261023-5405-DISCRETE-CONVEXITY.json", + "bytes": 1795, + "sha256": "ce98cb10c028e3a512599e715043e8a26dd9b88278d1c600d2b4b29c7b909d6d" + }, + { + "path": "inputs/guidance__AGENTS.md", + "bytes": 5580, + "sha256": "eb25d8ec495b80190a4b1a634710819bb74f0fae88d5203285c2b75b6f147347" + }, + { + "path": "inputs/guidance__CONTRIBUTING.md", + "bytes": 7143, + "sha256": "8a49fe97e2ad088a2b2e0c5b222aaab08752783b1f9c1260790d7dd13011d215" + }, + { + "path": "inputs/guidance__autoresearch.md", + "bytes": 5986, + "sha256": "d16f0d3bb4d4b213d06c128db6d6460b0fe9ec1ac5a6c1ea1febf1db40e7b60d" + }, + { + "path": "inputs/guidance__docs__research__agent-procedure.md", + "bytes": 29397, + "sha256": "6433f302cbc129ea986bf88ba1e94422bbf2aa6ba1d1d11b067c92736fa4a139" + }, + { + "path": "inputs/guidance__docs__research__current-priorities.md", + "bytes": 11950, + "sha256": "7ea971a336bf526719ae1f21617038301ab95d9853a38b92c332a9ffb968297a" + }, + { + "path": "inputs/guidance__docs__research__research-family-status.md", + "bytes": 18401, + "sha256": "21ea61004c0270388258c4251b1c586b65f06bc807395b281deacfb886204934" + }, + { + "path": "receipts/arithmetic-v1.json", + "bytes": 43821, + "sha256": "a5a3e35b420ba30407ddeaacc91770e7c03da5ff8139b73585c4ceae9db6d744" + }, + { + "path": "receipts/arithmetic-v1.stderr.log", + "bytes": 890, + "sha256": "475f7f876455d7e4e115381c138854462e487b182e4a1b9006cb634627ae33dc" + }, + { + "path": "receipts/arithmetic-v1.stdout.log", + "bytes": 5061, + "sha256": "b9e6beac377d81121cc2fc62f4cb49f70b209209717653418ef17da466e3c6f1" + }, + { + "path": "receipts/arithmetic-v2.json", + "bytes": 43820, + "sha256": "86f84dd374d831c3e4f907cd3e5f4789cee4ae2efb68f55dd0f679caec7b4736" + }, + { + "path": "receipts/arithmetic-v2.stderr.log", + "bytes": 890, + "sha256": "6c806fac227571242e9ccc31e1db08b2cd886c843bb24c26e2d21b8faafa4361" + }, + { + "path": "receipts/arithmetic-v2.stdout.log", + "bytes": 5060, + "sha256": "b7e05a760ad11a7507b662b6d991ae89f05cab80fecb0226d69e2e809fd46714" + }, + { + "path": "receipts/check_ceiling-v1.py", + "bytes": 14242, + "sha256": "42cec3a635e22785929ca47d1da1d9b11041c1244945f21145a69b25c7527a3e" + } + ], + "self_excluded": true +} diff --git a/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-HANDOFF.md b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-HANDOFF.md new file mode 100644 index 0000000000..d0a8c98c32 --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-HANDOFF.md @@ -0,0 +1,52 @@ +# Local handoff: independent PR5405 three-value ceiling verification + +Status: **PASS for the exact scoped arithmetic and independent monotonicity audit**. +The frozen exchange and strict-discrete-convexity proofs, plus this numerical +certificate, imply the unbounded source equation-(1) invoice-family ceiling for +`0.00302728825 <= kappa < 1`. No author DP/tail replay is needed. No kappa gain, +changed-profile PR5402 transfer, physical optimum, native or compiler admission, +or complete multiplication theorem is claimed. + +Review `PROOF.md`, `check_ceiling.py`, the two manifests and +`receipts/arithmetic-v2.json`. The exact gate gives + +``` +C18 > 0.000000014914967918767741908079 +C18-C17 < -0.271338621904872494155700553536 +C19-C18 > 0.022748156490424972863108432493 +``` + +Every displayed decimal is a rational with denominator 10^30. Exact finer +integer/Q endpoints are retained. The checker uses a fresh independent 2^256 +integer interval implementation with rigorous atanh-log and Taylor-exp tails. +No source engine, author DP, numerical library, solver, native or Lean code is +imported. All 456 tiny invoice identity controls and five explicit negative +controls passed. Canonical n=0,...,5 and 16,...,20 masks match the closed formula +by exact symbolic coefficients. + +The first arithmetic stage completed under the 60-second/256MiB cap in about +0.11 seconds external wall time and 19,248KiB maximum RSS. The v2 run strengthens +profile and sign rejection checks and preserves v1 raw receipts/source. See the +raw `/usr/bin/time -v` logs and `RUNS.json` for exact final runtime, commands and +source hashes. Neither run failed; no raw receipt was overwritten. + +Reproduce from the project root, choosing a fresh output filename: + +``` +/usr/bin/time -v timeout 60s python3 -B outputs/controller5405-exact-successor-20261024/check_ceiling.py --receipt /tmp/controller5405-independent-new-run.json +``` + +The script itself enforces RLIMIT_AS=256MiB, a 60-second alarm and exclusive +receipt creation. Refusing an existing receipt is intentional. + +Source PR5405 head: `314b56a6c0056c2358538f072c6fde9d365be44d`. +Retained canonical main: `1ec1119972c9aefe42525172d07b332fcff81cb4`. +The source equation and local profile remain premises; no standalone derivation +from the original Laurent/native construction was executed. Root owns fresh +upstream overlap, packaging and public writes. This worker stops at the local +reviewable handoff; no GitHub, Discussion, package or publication write occurred. + +Credit and open next questions are in `PROOF.md`. Preserve Ali Romman, Cinna +Davis, zxv and all retained native/helper/compiler lineage, as well as root's +conjectures and the sole Astra theory proof. The result is local and has not had +independent human or formal-kernel review. diff --git a/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-PROOF.md b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-PROOF.md new file mode 100644 index 0000000000..23a5f2738e --- /dev/null +++ b/research/controller-ceiling-convexity/numerical/receipts/frozen-v2-PROOF.md @@ -0,0 +1,274 @@ +# Independent three-value verification of the PR5405 fixed-family ceiling + +This local check proves the three required strict rational inequalities for the +actual PR5405 profile at `kappa0=0.00302728825`, using a new standard-library +interval implementation. Together with the separately frozen analytic exchange +and discrete-convexity proofs, these inequalities imply positivity of every +equation-(1) invoice at this exponent. The monotonicity argument below extends +that fixed-family conclusion to `kappa0 <= kappa < 1`. + +This is a necessary-moment obstruction for the specified invoice family. It is +not a new exponent saving, a physical or global circuit optimum, native execution, +supplier admission, a formal-kernel proof, or a complete multiplication theorem. +The changed/coupled profile of PR5402 is excluded. Equation (1) and its autonomous +local profile are explicit source premises; their derivation from the original +Laurent controller, native circuit and framework assumptions is not replayed here. + +The source is Ali Romman's PR5405, head +`314b56a6c0056c2358538f072c6fde9d365be44d`, against retained canonical main +`1ec1119972c9aefe42525172d07b332fcff81cb4`. The frozen source proof has SHA256 +`5c82c9f1650b0ffb352f2aa7eaac3aa283754028e41cd85d1ee848af9d18cd37`. +`SOURCE-MANIFEST.json` and `THEORY-MANIFEST.json` identify immutable copies of +the source, guidance and the two independent analytic notes. Root owns upstream +freshness, overlap, publication and any final admission gate. No separate upstream +feed, package publication or public write was performed by this checker. + +## Complete invoice and independent coefficient reconstruction + +Put `t=1-kappa`, `f(r)=r^t` for positive r and `f(0)=0`. The source profiles are + +``` +P={1:2193,2:412,3:510,4:127,5:40} +H={4:28,7:7,8:47,9:318} +L(t)=sum_r P[r]f(r)-sum_r H[r]f(r). +``` + +For p>=1, choose a+b=p-1 and a bit mask x of length 2p+1. A bit one means FULL; +its contribution is P on the paid side and H on the target side. A bit zero +means QUERY; it contributes exactly 112 paid rank-one jobs and no local helpers. +Let n be the number of ones. The complete local net contribution is therefore + +``` +nL+112(2p+1-n) =112(2p+1)+(L-112)n. +``` + +There are 224 full-path main targets of rank 1+8n. For retained idle slot j, +1<=j<=p-1, the FULL count on its exterior side is + +``` +h_j=sum_(s=0)^(2j-1)x_s, j<=a, +h_j=sum_(s=2j+1)^(2p)x_s, j>a. +e_j=x_(2j). +``` + +Its paid terms are 224 jobs of rank 8h_j (omit when h_j=0), plus 224 jobs of +rank eight when e_j=1. Its targets are 224 jobs of rank 1+8(h_j+e_j). Adding +all items, with no helper credit at QUERY stages, gives exactly source equation +(1): + +``` +E=112(2p+1)+(L-112)n-224f(1+8n) + +224 sum_(j=1)^(p-1)[f(8h_j)+e_j f(8)-f(1+8(h_j+e_j))]. +``` + +The checker builds paid and target integer histograms from those item lists, +expands equation (1) separately into signed coefficients of the formal symbols +f(r), and compares the coefficient dictionaries exactly. This identity check +uses no floating-point tolerance or interval overlap. It covers every mask and +split for p=1,2,3 (456 cases) as an index control. The invoice formula for arbitrary +p remains the source premise; finite examples are not promoted to its proof. + +## Canonical minimum and its two neighboring differences + +The frozen exchange note +`inputs/5405-concavity-exchange-reduction.md` proves that every invoice with n +FULL stages has E>=C_n, and that C_n is attained in this family. For n=0,1,2 the +canonical controller has p=1 and no retained side idles, so + +``` +C_n=336+(L-112)n-224f(1+8n). +``` + +For n>=3, all two exterior endpoints and the central stage are FULL. Every +remaining side pair, read from outside inward, is 10. There are n-3 such pairs, +split with a=floor((n-3)/2), b=ceil((n-3)/2), hence p=n-2. There are 2p+1=2n-3 +stages and n-3 QUERY stages. The j-th side pair has h=j+1 and e=0, so its +net summand is `-delta(8(j+1))`, where delta(z)=f(z+1)-f(z). This independently +reconstructs + +``` +C_n=nL+112(n-3)-224f(1+8n) + -224[sum_(k=2)^(a+1)delta(8k)+sum_(k=2)^(b+1)delta(8k)]. +``` + +The two formulas agree at n=3. Symbolic coefficients of this closed expression +are checked exactly against the canonical mask's paid-minus-target histogram +for n=0,...,5 and n=16,...,20. In particular n=18 gives p=16,a=7,b=8, with +18 FULL and 15 QUERY stages. Its first side increment is delta(16), not delta(8). + +Let D_n=C_(n+1)-C_n. Adding one FULL count grows the full-path rank from 1+8n +to 9+8n. For n>=3 it also adds one side pair at partial count +k=floor((n+1)/2), on the previously shorter side. The local and QUERY term +increases by L+112, and the added idle difference is -224delta(8k). Thus + +``` +D_n=L+112-224[f(9+8n)-f(1+8n)+delta(8 floor((n+1)/2))], n>=3. +``` + +For the two required neighbors k=9 in both cases. Consequently + +``` +C18=18L+1680-224f(145) + -224[2 sum_(k=2)^8 delta(8k)+delta(72)], +D17=L+112-224[f(145)-f(137)+delta(72)], +D18=L+112-224[f(153)-f(145)+delta(72)]. +``` + +The checker evaluates the differences both by subtracting independent enclosures +for C values and through these shorter formulas. Interval intersection is an +additional numerical crosscheck; the analytic difference identity is the algebra +above and in the frozen discrete-convexity note. + +For completeness, discrete convexity is not a tail extrapolation. Write +`B_n=336+(L-112)n-224f(1+8n)` and `C_n=B_n+224T_n`. Concavity of f gives strict +discrete convexity of B on n>=0. The correction has increments zero for n=0,1,2, +and `1-delta(8 floor((n+1)/2))` for n>=3. They are nondecreasing, including the +jump from zero. Hence C is strictly discretely convex on every nonnegative +integer. This includes the small-count junction. The frozen independent proof +supplies full details. Therefore C18>0, D17<0 and D18>0 make n=18 the unique +minimizing FULL count and prove C_n>=C18>0 for every n>=0, with no DP or n>=96 +tail certificate. + +## New directed-rational interval implementation + +All acceptance arithmetic uses integers on Q=2^256. An interval `(lo,hi)` +represents `[lo/Q,hi/Q]`. Addition, subtraction and integer multiplication take +the appropriate directed endpoints. Products of nonnegative intervals use +integer floor for the lower endpoint and integer ceiling for the upper endpoint. +The only floating values are resource timing fields, which never affect acceptance. + +For a positive integer r, write r=2^m y with 1<=y<2. Compute +`log r=m log2+log y`. For z=(y-1)/(y+1), 0<=z<=1/3, + +``` +log y=2 sum_(j=0)^(N-1) z^(2j+1)/(2j+1)+R, +0<=R<=2 z^(2N+1)/[(2N+1)(1-z^2)]. +``` + +The bound follows by replacing every omitted denominator by its first value +2N+1 and summing a geometric series. The implementation uses N=128, directed +integer recurrence for included terms and exact Fraction arithmetic followed by +upward quantization for the remainder. log2 uses this same formula with y=2. + +Use the exact saving `kappa0=12109153/4000000000`; then +`r^t=r*exp(-kappa0 log r)`. For the finitely used r, the outward argument +X=kappa0 log r lies in [0,1], checked before exponentiation. To bound exp(X), +sum its Taylor series through term N=64 with directed nonnegative arithmetic. +For its first omitted term U=X_hi^(N+1)/(N+1)!, all subsequent ratios are at most +X_hi/(N+2)<1. Thus + +``` +0<=exp(X)-sum_(k=0)^N X^k/k!<=U/[1-X_hi/(N+2)]. +``` + +This upper remainder is computed as an exact rational at X_hi and rounded +upward. Invert the positive exp enclosure with reversed endpoints to bound +exp(-X), and multiply by the exact integer r. For r=0 and r=1 the result is +exact by definition. No author engine, source import, numerical package, solver, +native execution or Lean process is used. + +## Rational result and controls + +`receipts/arithmetic-v2.json` retains both exact integer endpoints over Q, every +power enclosure used, histogram lists, resource fields and all control outcomes. +The following shorter decimal bounds are exact rational outer bounds with +denominator 10^30; both inequalities are strict: + +| Quantity | Lower bound | Upper bound | +|---|---:|---:| +| C17 | 0.271338636819840412923442461615 | 0.271338636819840412923442461616 | +| C18 | 0.000000014914967918767741908079 | 0.000000014914967918767741908080 | +| C19 | 0.022748171405392891630850340572 | 0.022748171405392891630850340573 | +| C18-C17 | -0.271338621904872494155700553537 | -0.271338621904872494155700553536 | +| C19-C18 | 0.022748156490424972863108432493 | 0.022748156490424972863108432494 | + +The enclosing interval for C18 has width less than 3e-70; the positive margin +is more than 1.49e-8. The gate is strict on exact rational endpoints, independent +of displayed decimal truncation. The v1 and v2 arithmetic endpoints agree; v2 +strengthens the mutation controls without changing the arithmetic implementation. + +Five controls have their explicit expected rejection recorded: changed source +bytes fail SHA256 authentication; reversing paid-minus-target fails the gate; +omitting one 112-rank-one QUERY charge fails the exact symbolic invoice identity +and gives a negative value; omitting the 224 full-path targets fails that exact +identity; changing P[4] from 127 to 126 fails comparison with the authenticated +source profile. The omitted-target mutant is deliberately favorable numerically, +so its rejection depends on invoice accounting rather than a bad final sign. + +## Independent normalized monotonicity audit + +Discrete convexity above is a fixed-t argument. A separate proof is needed for +the interval of savings, and it concerns whole invoices rather than just C18. + +First delete side pairs 00. If their preceding FULL count is h, deletion removes +two QUERY stages, reducing paid cost by 224, and removes a retained summand +`-224delta(8h)`. Thus E decreases by `224[1-delta(8h)]>=0`; equality is possible +at h=0. It preserves n and all later partial FULL counts and remains in the +source invoice family after reindexing. Repeat until no 00 pairs remain. This +reduction is valid separately for every 00` for every p and every t. Handle that case without +logarithms of zero or a full-path derivative claim. + +For n>=1 fix any reduced invoice. Normalize its complete expression by 8^t: + +``` +E/8^t =112(2p+1-n)8^(-t)+nL(t)/8^t-224(n+1/8)^t + +224 sum_j [h_j^t+e_j-(h_j+e_j+1/8)^t]. +``` + +The QUERY coefficient is nonnegative, so that term is nonincreasing in t. +The full-path term has strictly negative derivative because n+1/8>1. For each +side summand, if e=0 then reduction forces the other bit to be one, so h>=1. +If h>=1, the derivative is negative because `z^t log z` is strictly increasing +on z>=1: its derivative in z is `z^(t-1)(1+t log z)>0`, and the second base is +larger than h. If h=0, reduction forces e=1 and the summand is +`1-(9/8)^t`, whose derivative is strictly negative. These cases avoid treating +0^t log0 as an ordinary expression. + +Finally combining the common rank-four terms gives + +``` +L/8^t=2193(1/8)^t+412(1/4)^t+510(3/8)^t+99(1/2)^t + +40(5/8)^t-7(7/8)^t-47-318(9/8)^t. +``` + +Its only positive derivative term is `7(7/8)^t log(8/7)`, less than +`7 log(1+1/7)<1`. The negative derivative from its first term alone has magnitude +greater than `2193 log8/8>274`, since 01. All other nonconstant +derivative terms are nonpositive. Thus the local normalized derivative is +strictly negative throughout 0=1 invoice. + +At t0=1-kappa0, every reduced invoice is positive by the all-n gate. For any +0= 0 else (a[1] * k, a[0] * k) + +def positive_mul(a, b): + assert a[0] >= 0 and b[0] >= 0 + return a[0] * b[0] // Q, ceildiv(a[1] * b[1], Q) + +def constant(n): + return n * Q, n * Q + +def log_unit_interval(y): + """ln(y) for exact 1<=y<=2 via 2 atanh((y-1)/(y+1)).""" + assert 1 <= y <= 2 + z = (y - 1) / (y + 1) + zz = z * z + z_iv = frac_down(z), frac_up(z) + zz_iv = frac_down(zz), frac_up(zz) + term = z_iv + total = (0, 0) + for j in range(LOG_TERMS): + d = 2 * j + 1 + total = plus(total, (term[0] // d, ceildiv(term[1], d))) + term = positive_mul(term, zz_iv) + # All omitted terms positive, denominators >=2N+1: + # R <=2*z^(2N+1)/((2N+1)*(1-z^2)). + tail = 2 * z ** (2 * LOG_TERMS + 1) / ((2 * LOG_TERMS + 1) * (1 - zz)) + return 2 * total[0], 2 * total[1] + frac_up(tail) + +LOG2 = log_unit_interval(Fraction(2)) + +def log_integer(r): + assert isinstance(r, int) and r >= 1 + if r == 1: + return 0, 0 + m = r.bit_length() - 1 + return plus(scale(LOG2, m), log_unit_interval(Fraction(r, 1 << m))) + +def exp_positive(x): + """exp(x) for 0<=x<=1; directed Taylor and exact geometric tail.""" + assert 0 <= x[0] <= x[1] <= Q + term = (Q, Q) + total = term + for k in range(1, EXP_TERMS + 1): + # Bounds for x^k/k!; all factors nonnegative. + prod = positive_mul(term, x) + term = prod[0] // k, ceildiv(prod[1], k) + total = plus(total, term) + upper_x = Fraction(x[1], Q) + # First omitted term bounds remainder with subsequent ratios <=x/(N+2). + first = upper_x ** (EXP_TERMS + 1) + for k in range(1, EXP_TERMS + 2): + first /= k + tail = first / (1 - upper_x / (EXP_TERMS + 2)) + return total[0], total[1] + frac_up(tail) + +class Powers: + def __init__(self, kappa=KAPPA): + assert 0 < kappa < 1 + self.kappa = kappa + self.cache = {0: (0, 0), 1: (Q, Q)} + + def __call__(self, r): + if r not in self.cache: + log = log_integer(r) + num, den = self.kappa.numerator, self.kappa.denominator + x = log[0] * num // den, ceildiv(log[1] * num, den) + ex = exp_positive(x) + reciprocal = Q * Q // ex[1], ceildiv(Q * Q, ex[0]) + self.cache[r] = scale(reciprocal, r) + return self.cache[r] + +def moment(hist, f): + total = (0, 0) + for r, count in sorted(hist.items()): + total = plus(total, scale(f(r), count)) + return total + +def local(f): + return minus(moment(P, f), moment(H, f)) + +def delta(r, f): + return minus(f(r + 1), f(r)) + +def canonical_parts(n): + assert n >= 0 + if n <= 2: + return 1, 0, 0 + a = (n - 3) // 2 + b = n - 3 - a + return n - 2, a, b + +def canonical_mask(n): + p, a, b = canonical_parts(n) + x = [0] * (2 * p + 1) + if n <= 2: + for i in range(n): + x[i] = 1 + else: + x[0] = x[2 * p] = x[2 * a + 1] = 1 + for j in range(1, a + 1): + x[2 * j - 1] = 1 + for j in range(1, b + 1): + x[2 * p - 2 * j + 1] = 1 + assert sum(x) == n + return p, a, x + +def invoice_histograms(p, a, x): + """Reconstruct paid/target lists from Eq1's individual invoice items.""" + assert p >= 1 and 0 <= a < p and len(x) == 2 * p + 1 and set(x) <= {0, 1} + n = sum(x) + paid = Counter({r: n * count for r, count in P.items()}) + target = Counter({r: n * count for r, count in H.items()}) + paid[1] += 112 * (2 * p + 1 - n) + target[1 + 8 * n] += 224 + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + if h: + paid[8 * h] += 224 + if e: + paid[8] += 224 + target[1 + 8 * (h + e)] += 224 + return +paid, +target + +def clean_signed(c): + return {r: count for r, count in sorted(c.items()) if count} + +def signed_histograms(paid, target): + c = Counter(paid) + c.subtract(target) + return clean_signed(c) + +def equation_one_coefficients(p, a, x): + """Literal Eq1 expanded as integer coefficients of independent f(r).""" + n = sum(x) + c = Counter({1:112*(2*p+1)-112*n}) + for r, count in P.items(): c[r] += n*count + for r, count in H.items(): c[r] -= n*count + c[1+8*n] -= 224 + for j in range(1,p): + h = sum(x[:2*j]) if j<=a else sum(x[2*j+1:]) + e = x[2*j] + if h: c[8*h] +=224 + c[8] +=224*e + c[1+8*(h+e)] -=224 + return clean_signed(c) + +def canonical_coefficients(n): + """Closed formula expanded symbolically; no interval overlap acceptance.""" + c = Counter() + for r,count in P.items(): c[r] += n*count + for r,count in H.items(): c[r] -= n*count + c[1] +=336-112*n if n<=2 else 112*(n-3) + c[1+8*n] -=224 + if n>=3: + _,a,b=canonical_parts(n) + for q in (a,b): + for k in range(2,q+2): + c[8*k+1]-=224 + c[8*k]+=224 + return clean_signed(c) + +def equation_one(p, a, x, f): + n = sum(x) + val = plus(constant(112 * (2*p+1)), scale(minus(local(f), constant(112)), n)) + val = minus(val, scale(f(1+8*n), 224)) + for j in range(1, p): + h = sum(x[:2*j]) if j <= a else sum(x[2*j+1:]) + e = x[2*j] + g = minus(plus(f(8*h), scale(f(8), e)), f(1+8*(h+e))) + val = plus(val, scale(g, 224)) + return val + +def canonical(n, f): + if n <= 2: + return minus(plus(constant(336), scale(minus(local(f), constant(112)), n)), scale(f(1+8*n), 224)) + p, a, b = canonical_parts(n) + val = minus(plus(scale(local(f), n), constant(112*(n-3))), scale(f(1+8*n), 224)) + for q in (a, b): + for k in range(2, q+2): + val = minus(val, scale(delta(8*k, f), 224)) + return val + +def overlap(a, b): + return a[0] <= b[1] and b[0] <= a[1] + +def exact_grid_text(n, digits=40): + sign = '-' if n < 0 else '' + a = abs(n) + whole, remain = divmod(a, Q) + return sign + str(whole) + '.' + str(remain * (10**digits) // Q).zfill(digits) + +def packed(iv): + # Decimal strings are display only, exact integer/Q endpoints certify signs. + return dict(lower_integer=str(iv[0]), upper_integer=str(iv[1]), denominator=str(Q), + lower_decimal_truncated=exact_grid_text(iv[0]), upper_decimal_truncated=exact_grid_text(iv[1]), + width_grid_units=str(iv[1]-iv[0])) + +def authenticate(data, expected): + if sha256(data).hexdigest() != expected: + raise ValueError('source hash mismatch') + +def validate_profile(p,h,source): + source_p=ast.literal_eval(re.search(r'paid P = (\{[^\n]+\})',source).group(1)) + source_h=ast.literal_eval(re.search(r'helper targets H = (\{[^\n]+\})',source).group(1)) + if p!=source_p or h!=source_h: + raise ValueError('profile differs from authenticated source') + +def gate(c18,d17,d18): + return c18[0]>0 and d17[1]<0 and d18[0]>0 + +def verify_sources(): + manifest = json.loads((ROOT/'SOURCE-MANIFEST.json').read_text()) + for row in manifest['inputs']: + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + source = (ROOT/'inputs/5405-PROOF.md').read_text() + assert 'paid P = {1:2193, 2:412, 3:510, 4:127, 5:40}' in source + assert 'helper targets H = {4:28, 7:7, 8:47, 9:318}' in source + validate_profile(P,H,source) + for row in json.loads((ROOT/'THEORY-MANIFEST.json').read_text()): + authenticate((ROOT/row['frozen']).read_bytes(), row['sha256']) + return manifest + +def run(): + start = time.monotonic() + manifest = verify_sources() + f = Powers() + values = {n: canonical(n, f) for n in range(16, 21)} + # Recompute differences in both literal canonical expression and the short formula. + differences = {n: minus(values[n+1], values[n]) for n in range(16, 20)} + neighbor_short = {} + for n in (17, 18): + # Independently: newly added full stage contributes L+112; rank main + # grows by 8, and one side sum gains delta at 8*floor((n+1)/2). + cost = plus(minus(f(1+8*(n+1)), f(1+8*n)), delta(8*((n+1)//2), f)) + neighbor_short[n] = minus(plus(local(f), constant(112)), scale(cost, 224)) + assert overlap(differences[n], neighbor_short[n]) + assert gate(values[18],differences[17],differences[18]) + hist_checks = [] + for n in list(range(0, 6)) + list(range(16, 21)): + p, a, mask = canonical_mask(n) + paid, target = invoice_histograms(p, a, mask) + assert signed_histograms(paid,target)==equation_one_coefficients(p,a,mask)==canonical_coefficients(n) + direct = minus(moment(paid, f), moment(target, f)) + eq1 = equation_one(p, a, mask, f) + assert overlap(direct, eq1) and overlap(direct, canonical(n, f)) + hist_checks.append(dict(n=n, p=p, a=a, mask=''.join(map(str,mask)), + paid=dict(sorted(paid.items())), target=dict(sorted(target.items())), + direct=packed(direct), equation_one=packed(eq1),symbolic_identity=True)) + # Small exhaustive identity control checks the prefix/suffix index branches, + # with affine counts compared symbolically. It is not an all-mask proof. + tiny_identity_count=0 + for p in range(1,4): + for a in range(p): + for bits in range(1<<(2*p+1)): + x=[(bits>>i)&1 for i in range(2*p+1)] + paid,target=invoice_histograms(p,a,x) + assert signed_histograms(paid,target)==equation_one_coefficients(p,a,x) + tiny_identity_count+=1 + controls=[] + # Source mutation must be caught before accepting any arithmetic. + src=(ROOT/'inputs/5405-PROOF.md').read_bytes() + try: + authenticate(src+b'\nMUTANT\n', manifest['inputs'][0]['sha256']) + except ValueError: + controls.append(dict(name='changed_source_bytes',expected='rejected',observed='rejected')) + else: + raise AssertionError('source mutant survived') + reversed_sign=neg(values[18]) + assert reversed_sign[1] < 0 and not gate(neg(values[18]),neg(differences[17]),neg(differences[18])) + controls.append(dict(name='reverse_paid_minus_target_sign',expected='positive_certificate_fails', + observed='fails',interval=packed(reversed_sign))) + p,a,x=canonical_mask(18) + paid,target=invoice_histograms(p,a,x) + # Dropping one query invoice is a concrete 112-rank-one omission. + mutant=paid.copy(); mutant[1]-=112 + mutant_val=minus(moment(mutant,f),moment(target,f)) + assert signed_histograms(mutant,target)!=equation_one_coefficients(p,a,x) + assert not overlap(mutant_val,equation_one(p,a,x,f)) and mutant_val[1]<0 + controls.append(dict(name='omit_one_112_rank_one_query',expected='invoice_identity_fails_and_sign_negative', + observed='fails_as_expected',interval=packed(mutant_val))) + mutant_target=target.copy(); mutant_target[145]-=224 + mutant_main=minus(moment(paid,f),moment(mutant_target,f)) + assert signed_histograms(paid,mutant_target)!=equation_one_coefficients(p,a,x) + assert not overlap(mutant_main,equation_one(p,a,x,f)) + controls.append(dict(name='omit_224_full_path_targets',expected='invoice_identity_fails', + observed='fails_as_expected',interval=packed(mutant_main))) + changed_profile = dict(P); changed_profile[4] -= 1 + try: + validate_profile(changed_profile,H,src.decode()) + except ValueError: + controls.append(dict(name='alter_paid_profile_count',expected='profile_pin_fails',observed='fails_as_expected')) + else: + raise AssertionError('profile mutant survived') + return dict(status='PASS_SCOPED_ARITHMETIC', source_head=manifest['source_head'], + canonical_main=manifest['canonical_main'], + exponent=dict(kappa=str(KAPPA),t=str(1-KAPPA)), + arithmetic=dict(bits=BITS,log_terms=LOG_TERMS,exp_terms=EXP_TERMS, + floating_point_used_for_acceptance=False), + local_moment=packed(local(f)), values={str(n):packed(v) for n,v in values.items()}, + differences={str(n)+'_to_'+str(n+1):packed(v) for n,v in differences.items()}, + short_difference_crosschecks={str(n):packed(v) for n,v in neighbor_short.items()}, + canonical_histogram_checks=hist_checks,tiny_symbolic_identity_count=tiny_identity_count, + negative_controls=controls, + power_enclosures={str(r):packed(v) for r,v in sorted(f.cache.items())}, + environment=dict(python=sys.version,platform=platform.platform(), + elapsed_seconds=time.monotonic()-start, + maximum_resident_set_kib=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss), + excluded=['author interval engine','author 10290000-state DP','native replay','Lean', + 'physical circuit admission','global circuit optimum','kappa gain','changed-profile PR5402']) + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument('--receipt',type=Path,required=True) + args=parser.parse_args() + # Local cap applies even when called without an external runner. + resource.setrlimit(resource.RLIMIT_AS,(256*1024*1024,256*1024*1024)) + signal.alarm(60) + try: + result=run() + except Exception as exc: + result=dict(status='FAIL',error_type=type(exc).__name__,error=str(exc)) + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + raise + with args.receipt.open('x') as out: + json.dump(result,out,indent=2);out.write('\n') + print(json.dumps({k:result[k] for k in ('status','values','differences','environment')},indent=2)) + +if __name__=='__main__': + main() diff --git a/research/controller-ceiling-convexity/original/PROOF.md b/research/controller-ceiling-convexity/original/PROOF.md new file mode 100644 index 0000000000..5ad89d4ba1 --- /dev/null +++ b/research/controller-ceiling-convexity/original/PROOF.md @@ -0,0 +1,208 @@ +# A ceiling for every prefix/suffix FULL/QUERY allocation + +## Result and scope + +Fix the bidirectional local profiles from PR5392: + +``` +paid P = {1:2193, 2:412, 3:510, 4:127, 5:40} +helper targets H = {4:28, 7:7, 8:47, 9:318}. +``` + +A full stage has 112 main ports and a fresh block of rank eight. A query stage +costs 112 H1 jobs and has no helper targets. Use the paired path controller +with any integer p >= 1, any split 0 <= a <= p-1, and b = p-1-a. Keep the +first a initial idle windows, all middle idle windows, and the last b terminal +idle windows. Each of the 2p+1 stages can independently be FULL or QUERY. +Specialize D_s=1 at each QUERY stage in both the main and idle products. + +**Theorem.** Every invoice in this family has paid moment greater than target +moment for every `0.00302728825 <= kappa < 1`. Thus this entire family fails +the necessary strict moment test in that range. The result includes arbitrarily +many pairs, every split, and all stage masks. It is not restricted to a small +number of changes from the current mask. + +This is an upper bound for the invoices defined by (1) and the strict moment +method. A different target list or idle law is outside the theorem. It is +not a lower bound for all native circuits or all multiplication algorithms. +It does not raise kappa. In particular, it does not prove the physical validity +of every masked word, a new compiler bound, or an unconditional multiplication +theorem. We grant the listed diagonal jobs to the entire family. A member that +fails a separate native or endpoint requirement cannot evade this ceiling. + +The local profile is a premise supplied by PR5392. The source receipt is retained +byte for byte. The complete source construction and its five framework assumptions +are not re-proved here. PR5398 uses the same recursive profile and reports complete +conditional kappa .00302728823. Its distance from this universal family ceiling +is less than 2e-11. This comparison does not independently admit PR5398. + +## 1. Complete interval invoice + +Put t=1-kappa, f(r)=r^t for r>0, and f(0)=0. Define + + L(t) = sum_r P[r] f(r) - sum_r H[r] f(r). + +Write x_s in {0,1} for the FULL indicator of stage s, and +`n=sum_{s=0}^{2p} x_s`. The local and query part of paid minus target is + + 112(2p+1) + (L(t)-112)n. + +There are 224 full-path main targets of rank 1+8n. For j=1,...,a, put + + h_j = sum_{s=0}^{2j-1} x_s, e_j = x_(2j). + +For j=a+1,...,p-1, put + + h_j = sum_{s=2j+1}^{2p} x_s, e_j = x_(2j). + +Each j contributes a retained whole idle of rank 8h_j, a main target of rank +`1+8(h_j+e_j)`, and a middle idle of rank eight if e_j=1. Each multiplicity is +224. Zero-rank idles are omitted. The complete difference is therefore + + E(t) = 112(2p+1) + (L(t)-112)n - 224 f(1+8n) + + 224 sum_j [f(8h_j) + e_j f(8) - f(1+8(h_j+e_j))]. (1) + +This includes every lost helper and every changed main and idle factor. +In particular, a FULL even stage restores its middle idle charge. The source +Laurent controller supplies the prefix/suffix products. Substitution of D_s=1 +preserves any established source identity; it does not preserve a removed +stage's helper credit. + +The verifier compares (1), as separate paid and target histograms, with the +retained literal Laurent controller on every mask for p=1,...,5 and every a. +It also compares the current p16/a7 invoice with the retained PR5392 receipt +and the separate main diagonal in `joint-helper-lattice/CONTROLLER.json`. +These checks bind the general formula to the source family. They are not a +native admission of all p or a proof from finite examples. + +## 2. An infinite tail becomes finite + +For 0=0 and e in {0,1}, + + f(8h) + e f(8) - f(1+8(h+e)) >= -1. (2) + +For e=0, use `f(z+1)-f(z) <= f(1)=1`. For e=1, use +`f(z+8+1) <= f(z)+f(8)+f(1)`. There are p-1 summands. Equation (1) gives + + E(t) >= B_t(n) := 336 + (L(t)-112)n - 224(1+8n)^t. (3) + +At `kappa_0 = 0.00302728825`, exact outward rational arithmetic proves + + B_t(96) > 104.185162541469147567554569434096, + B_t'(96) > 5.188985973480417120924401618389. + +Here `B_t'(n)=L(t)-112-1792t(1+8n)^(t-1)`. Since t<1, this derivative +increases with n. Thus every n>=96 has E(t)>0, for every p and split. +The program uses a lower bound for L and an upper bound for the power in +both comparisons. No floating tolerance is used. + +It remains to bound p when n<=95. Read the left side in the order +`x_0,(x_1,x_2),...,(x_(2a-1),x_(2a))`. Read the right side from the opposite +end in the same form. The central stage is `x_(2a+1)`. If a side pair has +both indicators zero, delete that pair and reduce p by one. The full-stage +count n and every later partial count stay fixed. The two removed queries +reduce the first term in (1) by 224. The removed summand is + + -224 [f(8h+1)-f(8h)] >= -224. + +The deletion therefore cannot increase E. It produces another member of the +same invoice family after reindexing. Repeat until each remaining side pair +contains a FULL stage. Then `p-1=a+b <= n`, so p<=96. Consequently, positivity +for all p<=96 and n<=95, together with (3), proves positivity at kappa_0 for +the unbounded family. This reduction does not claim that deletion preserves +a particular caller's input set; it compares the optimistic invoices needed +for this ceiling. + +## 3. Exact dynamic program for the finite part + +For a side with q pairs and k FULL stages, let D_q(k) be the minimum sum of +its summands in (1), including their factor 224. The single end stage gives + + D_0(0)=D_0(1)=0. + +Append the next odd/even indicators o,e in {0,1}. The recurrence is + + D_(q+1)(k+o+e) = min [D_q(k) + +224 (f(8(k+o)) + e f(8) - f(1+8(k+o+e)))]. (4) + +The minimum is over all predecessors. This follows directly from the partial +count before the even stage. Induction on q proves that (4) covers every side +mask. States with k>=96 can be omitted because total FULL count cannot decrease. + +For p=a+b+1, combine left count l, right count r, and central indicator c: + + 112(2p+1) + (L-112)(l+r+c) + D_a(l) + D_b(r) + -224 f(1+8(l+r+c)). (5) + +Discard only totals at least 96. Reflection exchanges a and b, so it suffices +to check a<=b. The program checks p=1,...,96 and 10,290,000 state combinations. +It uses integer bounds on the exact grid 2^192. Positive terms use lower +power bounds; negative terms use upper bounds. Taking a minimum of lower +bounds remains a lower bound, so interval overlap cannot create a false +positive certificate. The minimum certified lower bound is + + E(t) > 0.000000014914967918767741908079. + +It occurs at p=16, a=7, with eight FULL stages on the left, nine on the right, +and a FULL central stage. The receipt retains the exact rational bound and +the minimum for each p. Independent exhaustive mask enumeration through p=5 +agrees exactly with the integer dynamic-program minima. + +The interval engine is the unchanged rational logarithm/exponential engine +from `higher-moment-strictification`. The dynamic program is new. Neither is +a solver result, and no SciPy or floating arithmetic is used for acceptance. + +## 4. Extend the ceiling to all larger savings + +It is not enough to reject one value of kappa. We now show that no larger +value can become favorable in this family. + +First delete zero/zero side pairs as above, at the t under consideration. +If n=0, (1) gives E(t)=112, which is positive. Otherwise n>=1. Normalize (1) +by 8^t. In a reduced side pair, h>=1 if e=0, while h>=0 if e=1. Its normalized +summand is + + h^t + e - (h+e+1/8)^t. + +For h>=1 its derivative in t is negative, because `z^t log z` strictly +increases for z>=1. For h=0, reduction forces e=1, and the derivative of +`1-(9/8)^t` is also negative. The normalized full-path target term has negative +derivative, since n+1/8>1. The query term is nonnegative and nonincreasing. + +Finally the local term is strictly decreasing after the same normalization: + + L(t)/8^t = 2193(1/8)^t + 412(1/4)^t + 510(3/8)^t + + 99(1/2)^t + 40(5/8)^t + - 7(7/8)^t - 47 - 318(9/8)^t. + +Its only positive derivative term is less than `7 log(8/7) < 1`. The negative +term from `2193(1/8)^t` alone has magnitude at least `2193 log(8)/8 > 274` +on 0=1. + +Therefore a reduced invoice that is positive at t_0=1-kappa_0 remains +positive for every 0