From 27f6fe375ce947dde9206d8b5adcc6d68752a02f Mon Sep 17 00:00:00 2001 From: Chris R Date: Mon, 26 Oct 2026 07:12:18 +1100 Subject: [PATCH] Bound the joint pooled P104 exchange family below kappa .0033 --- .../BASELINE-PROVENANCE.json | 15 + research/pooled-abc-exchange-ceiling/LICENSE | 201 ++++++++++ research/pooled-abc-exchange-ceiling/NEXT.md | 26 ++ .../PAYLOAD-INVENTORY.json | 113 ++++++ research/pooled-abc-exchange-ceiling/PROOF.md | 354 ++++++++++++++++++ .../pooled-abc-exchange-ceiling/README.md | 120 ++++++ .../pooled-abc-exchange-ceiling/REVIEW.md | 196 ++++++++++ .../pooled-abc-exchange-ceiling/SOURCES.json | 21 ++ .../pooled-abc-exchange-ceiling/TASK.json | 119 ++++++ .../UPSTREAM-CHECKPOINT.json | 58 +++ .../pooled-abc-exchange-ceiling/VERIFY.json | 28 ++ .../ceiling-qualification/CONTRACT.md | 76 ++++ .../ceiling-qualification/INPUTS.json | 11 + .../ceiling-qualification/REQUEST.json | 42 +++ .../ceiling-qualification/check.py | 229 +++++++++++ .../ceiling-qualification/run_pair.py | 51 +++ .../economics/JOINT-EXCHANGE-CEILING.md | 352 +++++++++++++++++ .../guarded/coordination/run_guarded.py | 98 +++++ .../review/JOINT-FAMILY-CEILING-REVIEW.md | 196 ++++++++++ .../RESULT-normal.json | 1 + .../expected/qualification.json | 1 + .../original-evidence/GUARD-RECEIPT.json | 19 + .../original-evidence/PAIR-RECEIPT.json | 9 + .../provenance/OVERLAP-20261025T195344Z.md | 15 + .../PR5551-PEER-SOURCE-CAPTURE.json | 30 ++ .../provenance/PR5551-SOURCE-CAPTURE.json | 59 +++ .../provenance/SOURCE-PINS.json | 39 ++ .../pooled-abc-exchange-ceiling/verify.py | 111 ++++++ 28 files changed, 2590 insertions(+) create mode 100644 research/pooled-abc-exchange-ceiling/BASELINE-PROVENANCE.json create mode 100644 research/pooled-abc-exchange-ceiling/LICENSE create mode 100644 research/pooled-abc-exchange-ceiling/NEXT.md create mode 100644 research/pooled-abc-exchange-ceiling/PAYLOAD-INVENTORY.json create mode 100644 research/pooled-abc-exchange-ceiling/PROOF.md create mode 100644 research/pooled-abc-exchange-ceiling/README.md create mode 100644 research/pooled-abc-exchange-ceiling/REVIEW.md create mode 100644 research/pooled-abc-exchange-ceiling/SOURCES.json create mode 100644 research/pooled-abc-exchange-ceiling/TASK.json create mode 100644 research/pooled-abc-exchange-ceiling/UPSTREAM-CHECKPOINT.json create mode 100644 research/pooled-abc-exchange-ceiling/VERIFY.json create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/CONTRACT.md create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/INPUTS.json create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/REQUEST.json create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/check.py create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/run_pair.py create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/economics/JOINT-EXCHANGE-CEILING.md create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/guarded/coordination/run_guarded.py create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/review/JOINT-FAMILY-CEILING-REVIEW.md create mode 100644 research/pooled-abc-exchange-ceiling/capsule/outputs/p104-contact-reassessment-20261025/RESULT-normal.json create mode 100644 research/pooled-abc-exchange-ceiling/expected/qualification.json create mode 100644 research/pooled-abc-exchange-ceiling/original-evidence/GUARD-RECEIPT.json create mode 100644 research/pooled-abc-exchange-ceiling/original-evidence/PAIR-RECEIPT.json create mode 100644 research/pooled-abc-exchange-ceiling/provenance/OVERLAP-20261025T195344Z.md create mode 100644 research/pooled-abc-exchange-ceiling/provenance/PR5551-PEER-SOURCE-CAPTURE.json create mode 100644 research/pooled-abc-exchange-ceiling/provenance/PR5551-SOURCE-CAPTURE.json create mode 100644 research/pooled-abc-exchange-ceiling/provenance/SOURCE-PINS.json create mode 100644 research/pooled-abc-exchange-ceiling/verify.py diff --git a/research/pooled-abc-exchange-ceiling/BASELINE-PROVENANCE.json b/research/pooled-abc-exchange-ceiling/BASELINE-PROVENANCE.json new file mode 100644 index 0000000000..2f86db5c6b --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/BASELINE-PROVENANCE.json @@ -0,0 +1,15 @@ +{ + "C_probe": "33/10000", + "audited_construction_head": "18968423711fd902aaee1099979497d55603e1dc", + "audited_construction_pr": 5545, + "git_blob_of_these_bytes": "05cb6fa03502696857586cafc5672f5477200379", + "original_qualified_local_path": "outputs/p104-contact-reassessment-20261025/RESULT-normal.json", + "outward_upper": "-64.2349800489874753468185", + "public_baseline_expected_path": "research/p104-contact-independent-audit/expected/contact-ceiling.json", + "public_baseline_head": "b038f9d9b5cf0ce92184da909e57a3be476fc812", + "public_baseline_package": "research/p104-contact-independent-audit", + "public_baseline_pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/5548", + "reuse": "Inherited qualified moment interval; engine not rerun. Small complete RESULT preserved byte-exact; no raw prior constructor closure required for this qualification.", + "schema": "pooled-abc-baseline-provenance/v1", + "sha256": "3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608" +} diff --git a/research/pooled-abc-exchange-ceiling/LICENSE b/research/pooled-abc-exchange-ceiling/LICENSE new file mode 100644 index 0000000000..261eeb9e9f --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/research/pooled-abc-exchange-ceiling/NEXT.md b/research/pooled-abc-exchange-ceiling/NEXT.md new file mode 100644 index 0000000000..d32312ca2c --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/NEXT.md @@ -0,0 +1,26 @@ +# Open next questions + +## What source-bound paid-path change lies outside the A/B/C span? + +The proved relaxation excludes .0033 only within this fixed complete invoice family. + +First step: Name roles, source events, protected reads, common frames and restored exits, then charge the complete delta before construction. + +Blocker: No new physical candidate or chronology experiment is nominated here; coordinate against current successor work. + +## What follows when productive helper targets or the controller change? + +PR5561/5569 target changes and PR5554 controller frontiers are outside this proof. + +First step: Pin one exact changed source, reconstruct its complete paid/target/nonlocal invoice and state a new relaxation. + +Blocker: The present baseline interval and coefficients cannot be transferred to changed targets or controllers. + +## Can an independent human or formal review confirm the analytic implications? + +Finite Fraction checks certify coefficients and finite log bounds, not a proof-kernel theorem for derivatives. + +First step: Review PROOF.md sections3-6 together with the exact baseline premise, inventory equations and finite certificate. + +Blocker: No independent human or formal acceptance is included. + diff --git a/research/pooled-abc-exchange-ceiling/PAYLOAD-INVENTORY.json b/research/pooled-abc-exchange-ceiling/PAYLOAD-INVENTORY.json new file mode 100644 index 0000000000..f28efd66cd --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/PAYLOAD-INVENTORY.json @@ -0,0 +1,113 @@ +{ + "files": { + "BASELINE-PROVENANCE.json": { + "bytes": 1003, + "sha256": "037226bc0b07f512e11101692b1b48f9e8074a4f0f992437c30dfc4cbf2dfc22" + }, + "LICENSE": { + "bytes": 11357, + "sha256": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4" + }, + "NEXT.md": { + "bytes": 1225, + "sha256": "bc1c09a1b1f91f343836b27908f228922ede91797c382a965adea7592f2a9c89" + }, + "PROOF.md": { + "bytes": 16597, + "sha256": "480c060e1af325b543ca38f29ce91cd632f9e71d03d0cac6d821b949aa214be6" + }, + "README.md": { + "bytes": 6936, + "sha256": "e8b40a9a2c8af867917c43239b5dd0d52a8600e7853952ff61a5ac6ab6d3332f" + }, + "REVIEW.md": { + "bytes": 10121, + "sha256": "f0751f6d15273ea8f1279598d9b25e0cfbcf77b91f7eaa7fb0fa6ac6e1e27313" + }, + "SOURCES.json": { + "bytes": 897, + "sha256": "21f7a4eadc09d57473022d6b671fbbd1bc7acf88f0884f2331745410c82b8d48" + }, + "TASK.json": { + "bytes": 7353, + "sha256": "3cb7c60eb07ccb7c5436059ce63abdb2a36cabe1761ec24127953ec8f739ee5e" + }, + "UPSTREAM-CHECKPOINT.json": { + "bytes": 2363, + "sha256": "753c6646ba7885e5e880a0ce25686a8472bb226bbfc047ed7b85077a4ca0475d" + }, + "VERIFY.json": { + "bytes": 783, + "sha256": "4c6304cc6ac949279c5f2612f0a045afb7aeb868596dd4c4a2161b08610701b5" + }, + "capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/CONTRACT.md": { + "bytes": 4795, + "sha256": "7aab0cc00b4fd1702c9ce8ef86aa056b8ff9346e99528113781c528c5e91b19f" + }, + "capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/INPUTS.json": { + "bytes": 733, + "sha256": "f969ba2b25c657f77aac3c27d6d831e95108bd340119b13766659a45a15b678c" + }, + "capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/REQUEST.json": { + "bytes": 2186, + "sha256": "68c44dab3fc7ccd7e8eebf0155133b03a14982c0ddc53c6b7e3f02a9fd5e5679" + }, + "capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/check.py": { + "bytes": 12698, + "sha256": "233d0d3f7c5f5825f452cfb99d3db57110b945bbf083923c8fddadf042aeef19" + }, + "capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/run_pair.py": { + "bytes": 2668, + "sha256": "e03aa4bf6550ebd721ec2ad172e53fe1e6d8c301557722dc4e9dadd9e5301717" + }, + "capsule/outputs/continuous-kappa-process-20261026/economics/JOINT-EXCHANGE-CEILING.md": { + "bytes": 16241, + "sha256": "2ffef9e084884a840b7806d3080ba540b44614a8b4871715e8c4d420bbd7938f" + }, + "capsule/outputs/continuous-kappa-process-20261026/guarded/coordination/run_guarded.py": { + "bytes": 3857, + "sha256": "720153b7491acede2c66bdc2dfd3174653195fa3222ec3589d0671c406a5bad8" + }, + "capsule/outputs/continuous-kappa-process-20261026/review/JOINT-FAMILY-CEILING-REVIEW.md": { + "bytes": 10121, + "sha256": "f0751f6d15273ea8f1279598d9b25e0cfbcf77b91f7eaa7fb0fa6ac6e1e27313" + }, + "capsule/outputs/p104-contact-reassessment-20261025/RESULT-normal.json": { + "bytes": 2528, + "sha256": "3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608" + }, + "expected/qualification.json": { + "bytes": 3276, + "sha256": "882369dbec747ac4fe4c324501dddca7e67240e773bb6782e29bd91dde25b5a7" + }, + "original-evidence/GUARD-RECEIPT.json": { + "bytes": 704, + "sha256": "9f17a0599b2a79cf5a300660cc0970d9d79224506790985609ae403f0e0a312f" + }, + "original-evidence/PAIR-RECEIPT.json": { + "bytes": 455, + "sha256": "0c9b103beca0e73dd21d84cc55d9d9e21be2558c21fac391d407c5ec31b99f64" + }, + "provenance/OVERLAP-20261025T195344Z.md": { + "bytes": 1913, + "sha256": "ce95aadf8f2eae81ad4410c1fd5ae89a25130ff21b870609c17fd62877373005" + }, + "provenance/PR5551-PEER-SOURCE-CAPTURE.json": { + "bytes": 57424, + "sha256": "116df4099b759a1ec7c43d1ac38811b24745bcd85e89cfb1641778b7b8305dee" + }, + "provenance/PR5551-SOURCE-CAPTURE.json": { + "bytes": 56808, + "sha256": "860e232e56751f3a236a9e07092b066a93afaac24d64ae4ddfadc618912dc186" + }, + "provenance/SOURCE-PINS.json": { + "bytes": 1579, + "sha256": "58904f3f67af02f2c86c2a525bade4c3d05eea4631f08d11fac0bed820bc7717" + }, + "verify.py": { + "bytes": 4983, + "sha256": "c02a68dee0681603c4647e62df4f5c37a241fbfa87982c16b316796983a6eca4" + } + }, + "schema": "self-contained-package-inventory/v1" +} diff --git a/research/pooled-abc-exchange-ceiling/PROOF.md b/research/pooled-abc-exchange-ceiling/PROOF.md new file mode 100644 index 0000000000..fd69f63a96 --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/PROOF.md @@ -0,0 +1,354 @@ +Portable layout note: the frozen original proof and its referenced relative source layout are retained under `capsule/outputs/continuous-kappa-process-20261026/`; this copy changes only the review hyperlink. Runtime qualification consumes the frozen original. Later target-changing PR5561/5569 and the all-controller PR5554 frontier are outside this fixed-invoice proof; see README.md. + +# P104: a joint ceiling for the three evidenced paid-rank exchanges + +Status: source-bound mathematical design and analytic proof, 26 October 2026. +No scientific replay, contact scan, native compilation or price engine was run +for this note. A separate agent has completed paper review and independently +checked the finite rational log certificate, complete invoice and arithmetic; +there is no independent human or formal acceptance. No new physical word, +funded kappa, global P104 ceiling or selected promotion is claimed. +The [separate review](REVIEW.md) covers the +final pooled relaxation as well as the narrower local-integer subcase. + +**Decision:** PR5551 broadens the evidenced economic mechanism beyond the +previous H1+H5 -> H6 edit. Even an optimistic closure under all three evidenced +rank exchanges cannot reach C=.0033 with the retained complete targets and +nonlocal bill. This remains true after granting arbitrary reuse of newly +created H5 jobs, arbitrary combinations in either direction, free pooling +across all 18 calls, free contact access and free restoration. A further .0033 construction needs a +change outside this explicitly defined profile family. + +## 1. Pinned objects and actual retained construction + +Canonical main is 32890bc5de034ab8fc93ac88ead7279a6a416d04, with selected +conditional kappa .003027288235. The compared predecessor is Ali Romman's +PR5545, head 18968423711fd902aaee1099979497d55603e1dc. Its local profile and +complete invoice were independently recounted by the retained contact audit; +that result is now part of PR5548. The comparison successor is thu-nmrc's +PR5551, exact head 79072da5404a01056df2af2e4132324b01c72366. Its conditional +.00304153 endpoint is the source author's claim; this note does not freshly +admit its native, caller or funding conjunction. + +Read-only source captures supplied by the sole upstream curator: + +- `../upstream/PR5551-SOURCE-CAPTURE.json`: constructor, proof, invoice, + discovery scope, retained pricing and source closure. +- `../upstream/PR5551-PEER-SOURCE-CAPTURE.json`: peer proof and complete + scalar/role-history receipt at that same exact head. +- `../../p104-contact-reassessment-20261025/RESULT-normal.json`: previously + qualified predecessor profile, complete invoice and outward interval at + C=33/10000. Its scientific SHA256 is + 3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608. + +The successor retains six scalar ADD sites, indexed in the PR5545 word: + +| Source event | Original scalar operation | Old frame | New frame | +| --- | --- | --- | --- | +| 10461 | 297 += 303 | 335, dimension 2 | 17, dimension 1 | +| 10462 | 303 -= 297/2 | 335 | 17 | +| 13970 | 152 -= 297/2 | 335 | 17 | +| 15479 | 198 += 319 | 915, dimension 7 | 207, dimension 8 | +| 15639 | 205 += 198 | 915 | 207 | +| 15640 | 198 -= 205/2 | 915 | 207 | + +These are two coupled changes, not six independently reusable improvements. +In the first group, role 297 coalesces ranks 1+1 into 2, role 303 splits 2 +into 1+1, and role 152 changes 2+2 into 1+3. The first two bills cancel. +In the second group, role 198 changes 4+1 into 5, role 319 interchanges +the chronology of 1+2 with 2+1, and role 205 splits 2 into 1+1. Charging +that split is essential; the second group is not a free 4+1 -> 5 edit. + +All scalar coefficients/order, 735 arbitrary public inputs, eight owned +lifetimes, 527 independent helper targets and endpoint charts are retained. +Fifteen SCALE chart annotations change with their current operand charts. +The literal emitter pays every required nested MOVE, including terminal +restoration. The unchanged scalar word is interpreted in canonical charts: +MOVE changes the chart without changing the logical row, while a same-chart +scalar coefficient acts once, outside tensor powers. This is the stated +all-positive-width implication, conditional on exact native chart maps and +the inherited framework. A width-one scalar equality alone would not supply +that implication. + +The two actual net paid changes are + + B: 2 H2 -> H1 + H3, + C: H2 + H4 -> H1 + H5. + +Their combined local paid delta is +2H1-3H2+H3-H4+H5; the complete delta is +18 times this and the target delta is zero. The new local profile is + + {1:2430, 2:554, 3:390, 4:111, 5:108, 6:17, 7:13, 9:1}. + +Call count and rank mass are unchanged. The source author uses 18 full calls, +15 queries, 15 whole idles and 32 main banks, with 69,912 paid jobs, 12,814 +productive fields and rank surplus 760. Its raw scalar upper 184,647,552 is +below the retained 10^9 allowance; native/precision/stock/outer hypotheses +are not removed. Source compiler gap 1/14000000000, integer height +690116000000000 and test exponent 49294 are author-side funded parameters, +not independently replayed here. Compiler architecture is held fixed. + +The source SEARCH.md reports a bounded coupled min-cut frame-expansion +search. Its unsuccessful second sweep is not an optimum theorem. This note +does not repeat that search or reserve the author's contact inventory. + +## 2. Exact optimistic family + +Write H_r=r^t, t=1-C, with 0 H6, + B: 2H2 -> H1 + H3, + C: H2 + H4 -> H1 + H5. + +A is the independently reviewed PR5545 change; B and C are the two new +PR5551 changes above. This is an optimistic accounting relaxation: there is +no assertion that all requested contacts exist, are compatible, preserve +physical chronology or can be implemented free of restoration. We grant +them anyway. We even allow reverse exchanges and arbitrary sequencing. +First let integers a,b,c denote their signed counts for one local invoice; +then relax these to real averages and optimize the complete pooled invoice. +The final histogram must be nonnegative. Any further recursive restoration debit or target loss +would decrease the raw margin and is set to zero in this optimistic bound. + +After the net exchanges, the varying local counts are exactly + + p1 = 2428-a+b+c, + p2 = 557-2b-c, + p3 = 389+b, + p4 = 112-c, + p5 = 107-a+c, + p6 = 17+a. + +Ranks 7 and 9 remain 13 and 1. In particular, + + a <= 107+c, b <= floor((557-c)/2), c <= 112. + +Thus newly created H5 jobs can be reused by A. Bounding the three edit +families separately and forgetting this reuse would not prove this result. + +## 3. Exact optimal inventories throughout 00. For fixed c, the relaxed savings +are at most + + F(c) = (107+c)gA + floor((557-c)/2)gB + c gC. + +This is valid even when a,b,c are signed, because the three gains are +positive and the displayed inventory inequalities bound their coefficients. +As integer c increases by one, F gains either gA+gC or gA+gC-gB. Both are +strictly positive. The first equals H2+H4-H6. For the second, + + gA+gC-gB = 1+H3+H4-H2-H6 > 0: + +the decreasing derivative of x^t gives H3-H1 > H6-H4, and 2H1>H2. +Consequently F is increasing all the way to c=112, and the unique optimal +integer counts for a single local invoice are + + (a,b,c) = (219,222,112). + +They are feasible in the histogram relaxation: apply all 112 C exchanges, +then all 222 B exchanges, then all 219 A exchanges. There is enough H1 for +the last stage. The optimal local bill is + + P* = 2543H1 + H2 + 611H3 + 236H6 + 13H7 + H9. + +It has 3,405 jobs and the unchanged local rank mass 5,894. Starting from +PR5551, one B and one C have already occurred; the remaining optimal counts +are (219,221,111) and lead to exactly the same P*. The optimum is over the +defined single-invoice integer family only, with every physical constraint +relaxed. Applying it independently to each of 18 calls leaves 18 H2 jobs. + +Now grant free pooling between all 18 calls, or more generally real-valued +averaged counts. The constraints still read a<=107+c, b<=(557-c)/2, c<=112. +The objective after saturating the first two bounds has derivative +gA+gC-gB/2>0 with respect to c, by the stronger inequality already proved. +Its exact optimum is therefore + + (a,b,c) = (219,445/2,112). + +The half is only an averaged accounting relaxation, not a fractional +physical field. Across the actual 18 calls the optimal total counts are +the integers + + (A,B,C) = (3942,4005,2016). + +These are feasible in the pooled histogram relaxation: apply 2016 C, then +4005 B, then 3942 A. Relative to the separate integer-local optimum, pooling +allows exactly 9 extra B exchanges. The averaged optimal local profile is + + (5087/2)H1 + (1223/2)H3 +236H6 +13H7 +H9. + +It has the same job count 3405 and rank mass 5894. No construction of a +pooled word is asserted. This stronger relaxation also covers heterogeneous +choices between calls and rational mixtures; it is the one used below. + +## 4. Complete optimistic signed bill + +The full optimal paid histogram, including unchanged queries and idles, is + + {1:47343, 3:11007, 6:4248, 7:234, 9:18, + 16:416, 24:416, 32:416, 40:416, 48:416, 56:416, + 64:416, 72:208}. + +It has 65,970 paid jobs. The complete unchanged productive histogram is + + {4:918, 5:648, 7:432, 8:2196, 9:5292, + 17:416, 25:416, 33:416, 41:416, 49:416, 57:416, + 65:416, 73:208, 145:208}. + +It has 12,814 independently counted fields. The entire target-minus-paid +moment is therefore + + M*(t) = -47343H1 -11007H3 +918H4 +648H5 + -4248H6 +198H7 +2196H8 +5274H9 + +416 sum[r in {16,24,32,40,48,56,64}] (H_(r+1)-H_r) + +208(H73-H72) +208H145. + +No query, idle, helper or main bank has been dropped. This is a complete +optimistic recursive invoice, not a constructed or funded supplier. + +## 5. A rational target-point certificate without a price-engine run + +The retained qualified artifact's `C_probe` is `33/10000`, its +`reviewed_head` is `18968423711fd902aaee1099979497d55603e1dc`, and its +`current_moment_at_target.upper_decimal_outward` is the exact rational decimal +`-64.2349800489874753468185`. Let M0(t) denote the PR5545 complete moment +at power t, so the retained interval gives M0(1-33/10000)<-64. This uses its inspectable +signed-moment certificate, not an inference from its claimed kappa. Also + + M*(1-C) = M0(1-C) +18(219gA(C)+(445/2)gB(C)+112gC(C)). + +Each g is concave as a function of C on [0,1] and vanishes at zero. For gA, +the second derivative is 5^t(log5)^2-6^t(log6)^2<0. For gB it is +2*2^t(log2)^2-3^t(log3)^2<0, since (log3)^2>2(log2)^2. For gC it is +2^t(log2)^2+4^t(log4)^2-5^t(log5)^2<0, since +(log5)^2>5(log2)^2 and 2^t<=4^t<=5^t. The elementary comparisons follow +already from log2<.7, log3>1 and log5>1.6. + +Thus each gain is bounded above by its tangent at zero. The standard rational +log enclosures + + .6931 < log2 < .6932, + 1.0986 < log3 < 1.0987, + 1.6094 < log5 < 1.6095 + +give + + gA(C) <= C(6log6-5log5) < (2705/1000)C, + gB(C) <= C(3log3-4log2) < (524/1000)C, + gC(C) <= C(5log5-10log2) < (1117/1000)C. + +For a finite exact-rational way to check these log brackets without importing +an engine, put z=(n-1)/(n+1) and use + + L_N(n)=2 sum[j=0..N-1] z^(2j+1)/(2j+1), + L_N(n) < log n < L_N(n)+2z^(2N+1)/((2N+1)(1-z^2)). + +N=32 is more than sufficient for n=2,3,5 and the coarse displayed brackets. +The separate reviewer has checked these finite sums/tails and brackets using +exact rational arithmetic without a source or price-engine import. No new +interval execution occurred in this design lane. + +Using only rational arithmetic after those bounds, + + M*(1-33/10000) + < -64 + 18*(33/10000)*(219*2705+(445/2)*524+112*1117)/1000 + = -64 + 495448866/10000000 + = -144551134/10000000 + = -14.4551134 < 0. + +For comparison, the separate-integer-local upper bound is -14.4706762. +Granting the nine extra pooled B exchanges relaxes it by at most .0155628. + +This is deliberately a conservative analytic upper bound, not a newly +computed narrow enclosure or raw-crossing approximation. Even granting all +contacts and every restoration for free, the family misses the necessary +raw margin by more than 14.45 H1 price units at C=.0033. Nonnegative +compiler reserve, extra paid work or lost targets cannot repair it within +the retained architecture. + +## 6. Larger-C exclusion and uniqueness + +Let N(t)=M*(t)/9^t, for 0<=t<=1. Among the low-rank positive terms, only +ranks 4,5,7,8 have negative derivative after this normalization. Their total +adverse derivative magnitude is less than + + (918+648+198+2196)log9 = 3960log9. + +The negative rank-one term alone contributes at least + + (47343/9)log9 > 3960log9. + +All other negative low-rank terms have nonnegative derivative; the rank-nine +term is constant. For each high pair, the normalized derivative is +x^t log x evaluated at x=(r+1)/9 minus its value at x=r/9. It is positive +because r>=16 and x^t log x is increasing for x>1, t>=0. The rank145 term +also has positive derivative. Hence N is strictly increasing throughout +[0,1]. Its endpoints are + + N(0) = 12814-65970 = -53156, + N(1) = 760/9 > 0. + +There is a unique raw crossing C*=1-t*. Section 5 shows C*<.0033, and the +moment remains negative for every .0033<=C<1. Every other member of the +defined family has no larger moment at each C. No numerical value for C* +is claimed. This is a scoped raw ceiling, not a P104 or physical optimum. + +## 7. Smallest discriminator, stop and pivot + +The independent paper and finite rational review covers: + +1. The source-bound A/B/C deltas, including the charged splits on roles 303 + and 205, and unchanged helper/nonlocal census. +2. The inventory optimization, including H5 recycling, signed reverse + exchanges and free pooling/real averaged counts; the complete paid/target + recount; the rational log bounds; and the + normalized monotonicity proof. + +No contact scanner, full caller replay or root-digit refinement is needed to +decide this family. The finite rational certificate supports this accounting +decision; it is not a physical candidate and does not resolve the inherited +admission layers. Any portable publication should bind the pinned predecessor +certificate, exact proof and independent review together. + +**Stop:** a .0033 nomination whose complete changed bill is still in this +A/B/C family, with no new productive targets or changed nonlocal lines, +fails before physical construction. A real smaller funded improvement may +still be useful and should be labelled by its own threshold. + +**Pivot:** require one actual source-bound paid-path change outside the +three-generator family. The pooled relaxed optimum exhausts H2, H4 and H5; +it leaves 11,007 H3 jobs across the caller, or 611.5 per-call average. A proposed method that changes that H3 +inventory, changes higher-rank paths, introduces independently productive +targets or changes the caller is outside the bound. A histogram pairing of +independent H3 inputs does not implement a Gaussian coalescence. Before any +next scan or construction, name the literal role(s), event interval, all +protected scalar reads, legal common frames, restored exits and complete +charged delta. Bind the intervention to source ownership and test exactly +that chronological identity, including all helper inputs, before assigning +it an aggregate saving. No such new physical object is nominated in this +note, and no search of the source author's active contacts was performed. + +The previously checked unrestricted rank-mass relaxation has positive raw +budget at .0033, so this result does not justify abandoning P104. It provides +the narrower decision: arbitrary repetition or combination of the currently +demonstrated three economic exchanges is insufficient for this target. + +Credit: Ali Romman for PR5544/5545, thu-nmrc for PR5551 and its two coupled +retimings, and all retained P104/native/controller/compiler/precision/analytic +predecessors. The joint inventory bound and conservative analytic certificate +are prepared for Chris R/Clear1nsight with OpenAI Codex assistance. diff --git a/research/pooled-abc-exchange-ceiling/README.md b/research/pooled-abc-exchange-ceiling/README.md new file mode 100644 index 0000000000..5ece94ee51 --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/README.md @@ -0,0 +1,120 @@ +# Pooled A/B/C exchange ceiling for a fixed P104 invoice + +Even granting free contacts, free restoration, signed reverse exchanges, +arbitrary recycling and free pooling across all 18 calls, the three evidenced +paid exchanges A: H1+H5→H6, B:2H2→H1+H3 and C:H2+H4→H1+H5 cannot reach +C=.0033 with the frozen PR5545 productive targets and nonlocal invoice. +The unique pooled relaxed optimum has total exchanges (3942,4005,2016). +Its conservative necessary raw-margin upper bound at .0033 is +**-72275567/5000000 = -14.4551134**. The accompanying normalized derivative +argument excludes every larger C below 1 in this family. + +This is a scoped analytic accounting obstruction, with a finite rational +certificate. It creates no physical word, new funded κ or selected result. +It is not a ceiling on P104 generally, other controllers, changed targets, +other paid generators or supplier classes. See [PROOF.md](PROOF.md), the +[independent agent paper review](REVIEW.md), and the frozen +[qualification contract](capsule/outputs/continuous-kappa-process-20261026/ceiling-qualification/CONTRACT.md). + +## Exact scope and overlap + +The scientific baseline is Ali Romman's PR5545 at +18968423711fd902aaee1099979497d55603e1dc. A comes from its reviewed paid +contact. B/C are thu-nmrc's two coupled PR5551 retimings at +79072da5404a01056df2af2e4132324b01c72366. Granting these generators does +not require assuming every possible source contact exists. The proof fixes +all 18 local calls, 527 helper targets per call, 15 queries,15 whole idles, +32 main banks and every other paid/target line. The complete optimal paid +count is 65970, productive count 12814, and rank-mass surplus 760. + +zxv's [PR5554](https://github.com/CrocSwap/integer-mult-bounds/pull/5554) +at18c1770246340e9f4aaac5a9ebd712e23498d0a3 studies an all-controller +architecture frontier. That scope is distinct and credited; this package +does not claim an all-controller ceiling. DreamingOfClouds's PR5561 at +452d27dde67ee9f772dbbd3be129db97a8ecb9c1 and GamingPuzzled's +[PR5569](https://github.com/CrocSwap/integer-mult-bounds/pull/5569) at +af9f091ac6f30c6eaacb9c27777bfbe2d0e5ffdf change productive helper targets +and fall outside this proof. Their author claims are not independently +admitted here. The frozen proof was written before those later target +changes; the publication checkpoint records their distinct scope. + +Actual contribution base:32890bc5de034ab8fc93ac88ead7279a6a416d04. +The later observed current main was5e0052ca0aa3036a3afa8b0438927377c8d97d53 +at2026-10-25T19:53:44Z. Its unchanged entry/contributor/standing guidance, +current template and updated input-path rule were reviewed. The old base +is explicit; neither current-main equivalence nor exhaustive novelty is +claimed. See [UPSTREAM-CHECKPOINT.json](UPSTREAM-CHECKPOINT.json). + +## Verification and evidence + +From a repository checkout with Python 3.12: + +```sh +python3 -B scripts/research_package.py --package research/pooled-abc-exchange-ceiling --check-only +python3 -B scripts/research_package.py --package research/pooled-abc-exchange-ceiling +python3 -B scripts/check_research_commit.py --package research/pooled-abc-exchange-ceiling +``` + +Expected scientific marker: `PASS_POOLED_ABC_EXCHANGE_CEILING`. +The registered pair runs normal then optimized. Each private child is +limited to 60 seconds and 512 MiB virtual address space; root separately uses +the existing serial 150 second/512 MiB descendant-RSS guard for the registered +pair. The wrapper authenticates every committed package payload byte, +the original request and all its inputs before spawning a scientific child, +then compares every output byte with the original qualified result and +reauthenticates the package afterward. Zero scientific fields are excluded. +`--integrity-only` authenticates custody without executing mathematics. + +The checker is byte-preserved and imports no source constructor or price +engine. Integer/Fraction algebra reconstructs complete invoices, validates +pooled inventory equations/conservation, N=32 finite rational logarithm +series/tail bounds, tangent coefficients, and normalized monotonicity +coefficients/endpoints. Twelve mutations must reject. The numerical premise +is the small authenticated previously qualified baseline RESULT; its +interval engine is not rerun. Analytic concavity and derivative implications +remain the explicit paper proof, not proof-kernel acceptance. + +The original root-only pair passed in 0.403383 seconds with sampled descendant +RSS 33923072 bytes under 150 seconds/512 MiB. Normal/optimized outputs matched +completely, all 12 controls rejected, scientific SHA256 +882369dbec747ac4fe4c324501dddca7e67240e773bb6782e29bd91dde25b5a7. +Those are original qualification receipts. **The portable registered/export +replays are not run by the preparer**, and no hosted CI, PR or publication +result is asserted by this prepared package. + +For a committed Git-free export, use the repository's existing exporter: + +```sh +python3 -B scripts/export_research_package.py export --package research/pooled-abc-exchange-ceiling --output /tmp/pooled-abc-ceiling.tar +python3 -B scripts/export_research_package.py check /tmp/pooled-abc-ceiling.tar +``` + +Extract the checked archive to a fresh directory, remove write permission +from the exported tree, and run the absolute Python interpreter with -I -O +-B on `research/pooled-abc-exchange-ceiling/verify.py`. The verifier uses +only its own capsule, no Git or network, writes only private temporary files, +and can run with an empty PATH. The local publication handoff specifies the proposed bounded export run. + +## Credit + +Ali Romman for PR5544/5545 and its complete productive caller/contact invoice; +thu-nmrc for PR5551 and its two coupled paid retimings; zxv for the distinct +PR5554 architecture frontier; DreamingOfClouds and GamingPuzzled for later +target-changing work; all retained P104/native/controller/compiler/precision/ +analytic predecessors. The shared-chart/dual-ADD retiming lineage, Gareth +Davidson (@bitplane), David Arias (@DavidAriasC), Cinna Davis (@1337isnot1337), +Jacob Alan Sussman, zxv and Cao Yifan retain predecessor credit. Joint +inventory bound, conservative analytic certificate and independent finite +qualification: Chris R/Clear1nsight with substantial OpenAI Codex assistance. +Apache-2.0. Agent review and two-mode reproduction are not independent human +or formal acceptance. + +## Open next questions + +See [NEXT.md](NEXT.md) and the machine-readable questions in [TASK.json](TASK.json). +The smallest useful continuation identifies one literal paid-path mechanism +outside A/B/C, or explicitly changes productive targets/controller, then +charges the complete invoice before physical construction. Current target +changes cannot reuse this fixed-target ceiling automatically. Human/formal +review of the analytic implications remains open. Native, precision/tape, +compiler/outer funding and independent acceptance are not supplied here. diff --git a/research/pooled-abc-exchange-ceiling/REVIEW.md b/research/pooled-abc-exchange-ceiling/REVIEW.md new file mode 100644 index 0000000000..31c283131d --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/REVIEW.md @@ -0,0 +1,196 @@ +# Independent static review of the joint A/B/C family ceiling + +Date: 2026-10-26. Reviewed artifact: +`../economics/JOINT-EXCHANGE-CEILING.md`, particularly sections 2–6. +This is an independent agent paper review with finite rational-algebra +checks. It is not independent human or proof-kernel acceptance. No scientific +replay, source-function import, native compilation, price engine, numerical +root search or physical construction was performed. Only this review file +was written for this assignment. + +## Decision and exact scope + +**No mathematical blocker found.** Under the specified PR5545 local paid +inventory, fixed helper/main targets, unchanged nonlocal recursive bill and +18 local invocations, the three-generator histogram relaxation has a unique +single-invoice integer optimum `(a,b,c)=(219,222,112)` for every `0=-17` and hence `c>=-124`, although the upper-bound proof does not need +this lower bound. + +Each forward gain is positive on `00`. The latter is +`1+3^t+4^t-2^t-6^t>0`: the strict inequality +`3^t-1 > 6^t-4^t` and `2>2^t` add to the desired expression. + +Consequently c=112 is uniquely optimal, then a=219 and b=222 are uniquely +optimal. The resulting profile +`{1:2543,2:1,3:611,6:236,7:13,9:1}` is feasible in the unrestricted +histogram relaxation: execute 112 C exchanges, 222 B exchanges and 219 A +exchanges. It has 3,405 local jobs and rank mass 5,894. This ordering is a +multiset feasibility witness, not a legal source-chart itinerary. Starting +from the claimed PR5551 B+C successor gives the same optimum after net +remaining counts `(219,221,111)`. + +This first result applies to each integer local invoice separately. Pooling +all 18 calls permits nine extra B exchanges, so that first bill would be an +insufficient envelope for the pooled family. The revised designer proof +correctly removes the artificial floor for real averaged counts. After +saturating a and b, the objective's derivative in c is +`gA+gC-gB/2>0`, following from `gA+gC-gB>0` and `gB>0`. The unique +averaged optimum is `(219,445/2,112)`. Its 18-fold total +`(3942,4005,2016)` is integral and feasible in the pooled histogram +relaxation. The averaged local profile is +`(5087/2)H1+(1223/2)H3+236H6+13H7+H9`, with zero H2, H4 and H5. +It still has 3,405 jobs and rank mass 5,894. This explicitly covers +heterogeneous choices between calls, rational mixtures and pooled rank +inventory; no physical sharing of independent inputs is inferred. + +## Full bill and target-point certificate + +Independent integer recounting from the retained PR5545 complete invoice, +adding the pooled global profile delta, gives exactly the full paid +histogram printed in revised section 4. Its count is 65,970. The unchanged +productive count is 12,814, with complete target-minus-paid rank mass 760. +The signed coefficients at ranks 1–9 are exactly + +`{1:-47343,3:-11007,4:918,5:648,6:-4248,7:198,8:2196,9:5274}`. + +Relative to the separate-integer-local bill, the pooled bill has nine more +rank-one jobs, eighteen fewer rank-two jobs and nine more rank-three jobs. + +The high terms are the unchanged seven 416-fold `(H_(r+1)-H_r)` pairs at +`r=16,24,32,40,48,56,64`, one 208-fold pair at 72, and 208 targets at 145. +No helper, query, idle or main-bank count is removed by this recount. + +The reused baseline certificate is +`outputs/p104-contact-reassessment-20261025/RESULT-normal.json`, SHA256 +`3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608`. +This review reauthenticated that exact hash, its reviewed source head +`18968423711fd902aaee1099979497d55603e1dc`, `C_probe=33/10000`, and its +retained outward upper endpoint +`-64.2349800489874753468185 < -64`. The scientific interval calculation is +inherited from that qualified receipt; it was not rerun here. Its checker +constructs rational lower/upper sums with signed outward selection +(`outputs/p104-contact-reassessment-20261025/check.py:185-203`). + +The proposed gain functions are concave in saving C on `[0,1]`. Their +second derivatives have the asserted signs. For gB, the sufficient +comparison is `(log3)^2>2(log2)^2`; for gC it is +`(log5)^2>5(log2)^2`, using `2^t,4^t<=5^t` for `t>=0`. +The tangent-at-zero upper bounds therefore apply over the entire required +domain, not just near zero. + +This reviewer independently evaluated only finite rational sums and +inequalities, using Python standard-library `Fraction`, with no exponent +or logarithm approximation engine. For n=2,3,5, the proposed atanh series +with N=32, `z=(n-1)/(n+1)`, lower partial sum and geometric tail bound +strictly establish all three displayed log brackets. Each tail is less +than `1/10^10`. Exact rational substitution confirms the tangent constants +`2705/1000`, `524/1000`, `1117/1000` and both second-derivative sufficient +inequalities. + +The first separate-integer-local calculation independently checks as + +`219*(2705/1000)+222*(524/1000)+112*(1117/1000)=833827/1000`, + +and + +`-64+18*(33/10000)*(833827/1000)=-72353381/5000000=-14.4706762<0`. + +For the stronger pooled family, the nine extra B exchanges add less than +`9*(33/10000)*(524/1000)=0.0155628`. Exact rational addition gives + +`-72353381/5000000+9*(33/10000)*(524/1000)` +`=-72275567/5000000=-14.4551134<0`. + +These are conservative strict upper bounds, not computed values of the +actual margins or new numerical roots. The revised designer proof uses +the stronger pooled bound for its final ceiling. + +## Monotonic extension and domain + +The proof normalizes the optimal complete moment by `9^t` for +`0<=t<=1`. Only positive low-rank coefficients at 4,5,7,8 can contribute +negative derivatives. Their total magnitude is less than `3960*log9`. +The negative rank-one term alone contributes at least +`(47343/9)*log9`, which is strictly greater. Every other negative low-rank +term has nonnegative derivative; rank 9 is constant. For high paired +terms, `x^t*log x` increases for `x>1,t>=0`, so their derivatives are +positive; the rank-145 target derivative is positive as well. + +Thus the normalized moment is strictly increasing in t. Its endpoint +values are `-53156` and `760/9`, exactly as stated. It has one zero, and +the negative `.0033` bound puts the corresponding saving strictly below +`.0033`. For every `.0033<=C<1`, the optimal family moment stays negative; +all other family members are pointwise no better by the preceding +inventory argument. This does not extrapolate the analytic proof to +`t<0` or a saving outside its declared `00 are justified by strict concavity in the paper. + a,b,c = (Q(data['optimum'][k],calls) for k in ('A','B','C')) + need(c == local[4] and a == local[5]+c and 2*b+c == local[2], 'pooled optimum saturations') + need((a,b,c) == (Q(219),Q(445,2),Q(112)), 'unique averaged optimum coefficients') + pooled_local = combine((1,local),(a,gen['A']),(b,gen['B']),(c,gen['C'])) + need(pooled_local == clean({1:Q(5087,2),3:Q(1223,2),6:236,7:13,9:1}), 'pooled averaged profile') + need(sum(pooled_local.values()) == 3405 and mass(pooled_local) == 5894, 'pooled local conservation') + # C, then B, then A is a nonnegative multiset itinerary; it is not a + # source-chart itinerary or a witness for independent Gaussian inputs. + running = combine((calls,local)) + for name in ('C','B','A'): + running = combine((1,running),(Q(data['optimum'][name]),gen[name])) + need(all(n >= 0 and n.denominator == 1 for n in running.values()), 'pooled integer inventory '+name) + need(running == combine((calls,pooled_local)), 'sequential pooled inventory endpoint') + paid = combine((1,running),(1,queries),(1,idles)) + need(paid == clean(data['optimal_paid']), 'complete optimal paid reconstruction') + need(sum(paid.values()) == 65970 and mass(targets)-mass(paid) == 760, 'complete optimum conservation') + separate_local = combine((1,local),(219,gen['A']),(222,gen['B']),(112,gen['C'])) + need(separate_local == clean({1:2543,2:1,3:611,6:236,7:13,9:1}), 'separate integer-local optimum') + need(combine((calls,pooled_local),(-calls,separate_local)) == combine((9,gen['B'])), 'pooling grants nine extra B') + gains = {k:combine((-1,g)) for k,g in gen.items()} + need(combine((1,gains['A']),(1,gains['C']),(-1,gains['B'])) == + clean({1:1,2:-1,3:1,4:1,6:-1}), 'strong exchange-slope identity') + # Sufficient rational comparisons for gain concavity in C. The gA + # comparison follows from r^t(log r)^2 strictly increasing for r>1. + need(brackets[3][0]**2 > 2*brackets[2][1]**2 and + brackets[5][0]**2 > 5*brackets[2][1]**2, 'gain concavity coefficient comparisons') + slopes = {'A':6*brackets[2][1]+6*brackets[3][1]-5*brackets[5][0], + 'B':3*brackets[3][1]-4*brackets[2][0], + 'C':5*brackets[5][1]-10*brackets[2][0]} + tangent = {'A':Q(2705,1000),'B':Q(524,1000),'C':Q(1117,1000)} + need(all(0 < slopes[k] < tangent[k] for k in slopes), 'conservative tangent bounds') + weighted = a*tangent['A']+b*tangent['B']+c*tangent['C'] + margin_upper = -64+calls*Q(33,10000)*weighted + need(margin_upper == Q(-72275567,5000000) < 0, 'strict pooled target-point upper bound') + signed = combine((1,targets),(-1,paid)) + low = {r:n for r,n in signed.items() if r <= 9} + need(low == clean({1:-47343,3:-11007,4:918,5:648,6:-4248,7:198,8:2196,9:5274}), 'signed low-rank moment') + adverse = sum(n for r,n in low.items() if r < 9 and n > 0) + rank_one = -signed[1]/9 + need(adverse == 3960 and rank_one > adverse, 'normalized derivative coefficient domination') + pairs = (16,24,32,40,48,56,64,72) + high = {r:n for r,n in signed.items() if r > 9} + reconstructed_high = {145:Q(208)} + for rank in pairs: + count = Q(208 if rank == 72 else 416) + reconstructed_high[rank],reconstructed_high[rank+1] = -count,count + need(rank > 9 and count > 0, 'positive normalized high pair') + need(high == reconstructed_high, 'all normalized high terms accounted') + endpoint_zero = sum(signed.values()) + endpoint_one = mass(signed)/9 + need(endpoint_zero == -53156 and endpoint_one == Q(760,9) > 0, 'normalized opposite-sign endpoints') + return {'baseline_paid':display(baseline_paid), 'targets':display(targets), + 'pooled_local':display(pooled_local), 'pooled_paid':display(paid), + 'signed_moment':display(signed), 'averaged_optimal_exchanges':[str(a),str(b),str(c)], + 'global_optimal_exchanges':data['optimum'], 'separate_local':display(separate_local), + 'local_rank_mass':str(mass(local)), 'pooled_paid_count':str(sum(paid.values())), + 'target_count':str(sum(targets.values())), 'rank_surplus':'760', + 'rational_log_brackets':{str(n):list(map(str,v)) for n,v in brackets.items()}, + 'log_partial_terms':32, 'each_log_tail_below':'1/10000000000', + 'tangent_slope_upper':{k:str(v) for k,v in slopes.items()}, + 'tangent_constants':{k:str(v) for k,v in tangent.items()}, + 'weighted_tangent_upper':str(weighted), 'C_probe':'33/10000', + 'strict_margin_upper':str(margin_upper), + 'normalized_derivative':{'rank_one_coefficient_lower':str(rank_one), + 'adverse_coefficient_upper':str(adverse)}, + 'normalized_endpoints':[str(endpoint_zero),str(endpoint_one)]} + + +def main(): + pins = json.loads((B/'INPUTS.json').read_text()) + for path, sha in pins['files'].items(): + need(hashlib.sha256((ROOT/path).read_bytes()).hexdigest() == sha, 'pinned input '+path) + raw = (ROOT/pins['baseline']).read_bytes() + saved = authenticated_baseline(raw) + data, brackets = evidence(), log_brackets() + certificate = qualify(saved, data, brackets) + controls = {} + try: + authenticated_baseline(raw+b' ') + except ValueError: + controls['baseline_byte_mutation'] = 'rejected' + else: + raise ValueError('accepted baseline byte mutation') + mutations = [ + ('drop_nonlocal_idle', lambda s,d:d['idles'].__setitem__(16,415)), + ('lose_productive_helper', lambda s,d:d['helpers'].__setitem__(9,293)), + ('seventeen_calls', lambda s,d:d.__setitem__('calls',17)), + ('baseline_local_count', lambda s,d:d['local'].__setitem__(1,2429)), + ('omit_B_split_debit', lambda s,d:d['generators']['B'].__setitem__(2,-1)), + ('free_C_split', lambda s,d:d['generators']['C'].__setitem__(2,0)), + ('unpooled_B_count', lambda s,d:d['optimum'].__setitem__('B',3996)), + ('overdraw_A_inventory', lambda s,d:d['optimum'].__setitem__('A',3943)), + ('omit_complete_paid_job', lambda s,d:d['optimal_paid'].__setitem__(1,47342)), + ('wrong_baseline_probe', lambda s,d:s.__setitem__('C_probe','1/300')), + ('weaken_baseline_interval', lambda s,d:s['current_moment_at_target'].__setitem__('upper_decimal_outward','-63')), + ] + for name, mutation in mutations: + bad_saved, bad_data = deepcopy(saved), deepcopy(data) + mutation(bad_saved,bad_data) + try: + qualify(bad_saved,bad_data,brackets) + except ValueError: + controls[name] = 'rejected' + else: + raise ValueError('accepted mutation '+name) + result = {'schema':'pooled-abc-ceiling-qualification/v1', + 'status':'PASS_SCOPED_POOLED_ABC_COEFFICIENT_CERTIFICATE', + 'baseline_sha256':BASELINE_SHA, 'reviewed_baseline_head':HEAD, + 'compared_successor_head':'79072da5404a01056df2af2e4132324b01c72366', + 'certificate':certificate, 'mutation_controls':controls, + 'analytic_scope':'Fixed complete PR5545 invoice, A/B/C signed net exchanges, free pooling and real averages, 0 H6 edit. Even an optimistic closure under all three evidenced +rank exchanges cannot reach C=.0033 with the retained complete targets and +nonlocal bill. This remains true after granting arbitrary reuse of newly +created H5 jobs, arbitrary combinations in either direction, free pooling +across all 18 calls, free contact access and free restoration. A further .0033 construction needs a +change outside this explicitly defined profile family. + +## 1. Pinned objects and actual retained construction + +Canonical main is 32890bc5de034ab8fc93ac88ead7279a6a416d04, with selected +conditional kappa .003027288235. The compared predecessor is Ali Romman's +PR5545, head 18968423711fd902aaee1099979497d55603e1dc. Its local profile and +complete invoice were independently recounted by the retained contact audit; +that result is now part of PR5548. The comparison successor is thu-nmrc's +PR5551, exact head 79072da5404a01056df2af2e4132324b01c72366. Its conditional +.00304153 endpoint is the source author's claim; this note does not freshly +admit its native, caller or funding conjunction. + +Read-only source captures supplied by the sole upstream curator: + +- `../upstream/PR5551-SOURCE-CAPTURE.json`: constructor, proof, invoice, + discovery scope, retained pricing and source closure. +- `../upstream/PR5551-PEER-SOURCE-CAPTURE.json`: peer proof and complete + scalar/role-history receipt at that same exact head. +- `../../p104-contact-reassessment-20261025/RESULT-normal.json`: previously + qualified predecessor profile, complete invoice and outward interval at + C=33/10000. Its scientific SHA256 is + 3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608. + +The successor retains six scalar ADD sites, indexed in the PR5545 word: + +| Source event | Original scalar operation | Old frame | New frame | +| --- | --- | --- | --- | +| 10461 | 297 += 303 | 335, dimension 2 | 17, dimension 1 | +| 10462 | 303 -= 297/2 | 335 | 17 | +| 13970 | 152 -= 297/2 | 335 | 17 | +| 15479 | 198 += 319 | 915, dimension 7 | 207, dimension 8 | +| 15639 | 205 += 198 | 915 | 207 | +| 15640 | 198 -= 205/2 | 915 | 207 | + +These are two coupled changes, not six independently reusable improvements. +In the first group, role 297 coalesces ranks 1+1 into 2, role 303 splits 2 +into 1+1, and role 152 changes 2+2 into 1+3. The first two bills cancel. +In the second group, role 198 changes 4+1 into 5, role 319 interchanges +the chronology of 1+2 with 2+1, and role 205 splits 2 into 1+1. Charging +that split is essential; the second group is not a free 4+1 -> 5 edit. + +All scalar coefficients/order, 735 arbitrary public inputs, eight owned +lifetimes, 527 independent helper targets and endpoint charts are retained. +Fifteen SCALE chart annotations change with their current operand charts. +The literal emitter pays every required nested MOVE, including terminal +restoration. The unchanged scalar word is interpreted in canonical charts: +MOVE changes the chart without changing the logical row, while a same-chart +scalar coefficient acts once, outside tensor powers. This is the stated +all-positive-width implication, conditional on exact native chart maps and +the inherited framework. A width-one scalar equality alone would not supply +that implication. + +The two actual net paid changes are + + B: 2 H2 -> H1 + H3, + C: H2 + H4 -> H1 + H5. + +Their combined local paid delta is +2H1-3H2+H3-H4+H5; the complete delta is +18 times this and the target delta is zero. The new local profile is + + {1:2430, 2:554, 3:390, 4:111, 5:108, 6:17, 7:13, 9:1}. + +Call count and rank mass are unchanged. The source author uses 18 full calls, +15 queries, 15 whole idles and 32 main banks, with 69,912 paid jobs, 12,814 +productive fields and rank surplus 760. Its raw scalar upper 184,647,552 is +below the retained 10^9 allowance; native/precision/stock/outer hypotheses +are not removed. Source compiler gap 1/14000000000, integer height +690116000000000 and test exponent 49294 are author-side funded parameters, +not independently replayed here. Compiler architecture is held fixed. + +The source SEARCH.md reports a bounded coupled min-cut frame-expansion +search. Its unsuccessful second sweep is not an optimum theorem. This note +does not repeat that search or reserve the author's contact inventory. + +## 2. Exact optimistic family + +Write H_r=r^t, t=1-C, with 0 H6, + B: 2H2 -> H1 + H3, + C: H2 + H4 -> H1 + H5. + +A is the independently reviewed PR5545 change; B and C are the two new +PR5551 changes above. This is an optimistic accounting relaxation: there is +no assertion that all requested contacts exist, are compatible, preserve +physical chronology or can be implemented free of restoration. We grant +them anyway. We even allow reverse exchanges and arbitrary sequencing. +First let integers a,b,c denote their signed counts for one local invoice; +then relax these to real averages and optimize the complete pooled invoice. +The final histogram must be nonnegative. Any further recursive restoration debit or target loss +would decrease the raw margin and is set to zero in this optimistic bound. + +After the net exchanges, the varying local counts are exactly + + p1 = 2428-a+b+c, + p2 = 557-2b-c, + p3 = 389+b, + p4 = 112-c, + p5 = 107-a+c, + p6 = 17+a. + +Ranks 7 and 9 remain 13 and 1. In particular, + + a <= 107+c, b <= floor((557-c)/2), c <= 112. + +Thus newly created H5 jobs can be reused by A. Bounding the three edit +families separately and forgetting this reuse would not prove this result. + +## 3. Exact optimal inventories throughout 00. For fixed c, the relaxed savings +are at most + + F(c) = (107+c)gA + floor((557-c)/2)gB + c gC. + +This is valid even when a,b,c are signed, because the three gains are +positive and the displayed inventory inequalities bound their coefficients. +As integer c increases by one, F gains either gA+gC or gA+gC-gB. Both are +strictly positive. The first equals H2+H4-H6. For the second, + + gA+gC-gB = 1+H3+H4-H2-H6 > 0: + +the decreasing derivative of x^t gives H3-H1 > H6-H4, and 2H1>H2. +Consequently F is increasing all the way to c=112, and the unique optimal +integer counts for a single local invoice are + + (a,b,c) = (219,222,112). + +They are feasible in the histogram relaxation: apply all 112 C exchanges, +then all 222 B exchanges, then all 219 A exchanges. There is enough H1 for +the last stage. The optimal local bill is + + P* = 2543H1 + H2 + 611H3 + 236H6 + 13H7 + H9. + +It has 3,405 jobs and the unchanged local rank mass 5,894. Starting from +PR5551, one B and one C have already occurred; the remaining optimal counts +are (219,221,111) and lead to exactly the same P*. The optimum is over the +defined single-invoice integer family only, with every physical constraint +relaxed. Applying it independently to each of 18 calls leaves 18 H2 jobs. + +Now grant free pooling between all 18 calls, or more generally real-valued +averaged counts. The constraints still read a<=107+c, b<=(557-c)/2, c<=112. +The objective after saturating the first two bounds has derivative +gA+gC-gB/2>0 with respect to c, by the stronger inequality already proved. +Its exact optimum is therefore + + (a,b,c) = (219,445/2,112). + +The half is only an averaged accounting relaxation, not a fractional +physical field. Across the actual 18 calls the optimal total counts are +the integers + + (A,B,C) = (3942,4005,2016). + +These are feasible in the pooled histogram relaxation: apply 2016 C, then +4005 B, then 3942 A. Relative to the separate integer-local optimum, pooling +allows exactly 9 extra B exchanges. The averaged optimal local profile is + + (5087/2)H1 + (1223/2)H3 +236H6 +13H7 +H9. + +It has the same job count 3405 and rank mass 5894. No construction of a +pooled word is asserted. This stronger relaxation also covers heterogeneous +choices between calls and rational mixtures; it is the one used below. + +## 4. Complete optimistic signed bill + +The full optimal paid histogram, including unchanged queries and idles, is + + {1:47343, 3:11007, 6:4248, 7:234, 9:18, + 16:416, 24:416, 32:416, 40:416, 48:416, 56:416, + 64:416, 72:208}. + +It has 65,970 paid jobs. The complete unchanged productive histogram is + + {4:918, 5:648, 7:432, 8:2196, 9:5292, + 17:416, 25:416, 33:416, 41:416, 49:416, 57:416, + 65:416, 73:208, 145:208}. + +It has 12,814 independently counted fields. The entire target-minus-paid +moment is therefore + + M*(t) = -47343H1 -11007H3 +918H4 +648H5 + -4248H6 +198H7 +2196H8 +5274H9 + +416 sum[r in {16,24,32,40,48,56,64}] (H_(r+1)-H_r) + +208(H73-H72) +208H145. + +No query, idle, helper or main bank has been dropped. This is a complete +optimistic recursive invoice, not a constructed or funded supplier. + +## 5. A rational target-point certificate without a price-engine run + +The retained qualified artifact's `C_probe` is `33/10000`, its +`reviewed_head` is `18968423711fd902aaee1099979497d55603e1dc`, and its +`current_moment_at_target.upper_decimal_outward` is the exact rational decimal +`-64.2349800489874753468185`. Let M0(t) denote the PR5545 complete moment +at power t, so the retained interval gives M0(1-33/10000)<-64. This uses its inspectable +signed-moment certificate, not an inference from its claimed kappa. Also + + M*(1-C) = M0(1-C) +18(219gA(C)+(445/2)gB(C)+112gC(C)). + +Each g is concave as a function of C on [0,1] and vanishes at zero. For gA, +the second derivative is 5^t(log5)^2-6^t(log6)^2<0. For gB it is +2*2^t(log2)^2-3^t(log3)^2<0, since (log3)^2>2(log2)^2. For gC it is +2^t(log2)^2+4^t(log4)^2-5^t(log5)^2<0, since +(log5)^2>5(log2)^2 and 2^t<=4^t<=5^t. The elementary comparisons follow +already from log2<.7, log3>1 and log5>1.6. + +Thus each gain is bounded above by its tangent at zero. The standard rational +log enclosures + + .6931 < log2 < .6932, + 1.0986 < log3 < 1.0987, + 1.6094 < log5 < 1.6095 + +give + + gA(C) <= C(6log6-5log5) < (2705/1000)C, + gB(C) <= C(3log3-4log2) < (524/1000)C, + gC(C) <= C(5log5-10log2) < (1117/1000)C. + +For a finite exact-rational way to check these log brackets without importing +an engine, put z=(n-1)/(n+1) and use + + L_N(n)=2 sum[j=0..N-1] z^(2j+1)/(2j+1), + L_N(n) < log n < L_N(n)+2z^(2N+1)/((2N+1)(1-z^2)). + +N=32 is more than sufficient for n=2,3,5 and the coarse displayed brackets. +The separate reviewer has checked these finite sums/tails and brackets using +exact rational arithmetic without a source or price-engine import. No new +interval execution occurred in this design lane. + +Using only rational arithmetic after those bounds, + + M*(1-33/10000) + < -64 + 18*(33/10000)*(219*2705+(445/2)*524+112*1117)/1000 + = -64 + 495448866/10000000 + = -144551134/10000000 + = -14.4551134 < 0. + +For comparison, the separate-integer-local upper bound is -14.4706762. +Granting the nine extra pooled B exchanges relaxes it by at most .0155628. + +This is deliberately a conservative analytic upper bound, not a newly +computed narrow enclosure or raw-crossing approximation. Even granting all +contacts and every restoration for free, the family misses the necessary +raw margin by more than 14.45 H1 price units at C=.0033. Nonnegative +compiler reserve, extra paid work or lost targets cannot repair it within +the retained architecture. + +## 6. Larger-C exclusion and uniqueness + +Let N(t)=M*(t)/9^t, for 0<=t<=1. Among the low-rank positive terms, only +ranks 4,5,7,8 have negative derivative after this normalization. Their total +adverse derivative magnitude is less than + + (918+648+198+2196)log9 = 3960log9. + +The negative rank-one term alone contributes at least + + (47343/9)log9 > 3960log9. + +All other negative low-rank terms have nonnegative derivative; the rank-nine +term is constant. For each high pair, the normalized derivative is +x^t log x evaluated at x=(r+1)/9 minus its value at x=r/9. It is positive +because r>=16 and x^t log x is increasing for x>1, t>=0. The rank145 term +also has positive derivative. Hence N is strictly increasing throughout +[0,1]. Its endpoints are + + N(0) = 12814-65970 = -53156, + N(1) = 760/9 > 0. + +There is a unique raw crossing C*=1-t*. Section 5 shows C*<.0033, and the +moment remains negative for every .0033<=C<1. Every other member of the +defined family has no larger moment at each C. No numerical value for C* +is claimed. This is a scoped raw ceiling, not a P104 or physical optimum. + +## 7. Smallest discriminator, stop and pivot + +The independent paper and finite rational review covers: + +1. The source-bound A/B/C deltas, including the charged splits on roles 303 + and 205, and unchanged helper/nonlocal census. +2. The inventory optimization, including H5 recycling, signed reverse + exchanges and free pooling/real averaged counts; the complete paid/target + recount; the rational log bounds; and the + normalized monotonicity proof. + +No contact scanner, full caller replay or root-digit refinement is needed to +decide this family. The finite rational certificate supports this accounting +decision; it is not a physical candidate and does not resolve the inherited +admission layers. Any portable publication should bind the pinned predecessor +certificate, exact proof and independent review together. + +**Stop:** a .0033 nomination whose complete changed bill is still in this +A/B/C family, with no new productive targets or changed nonlocal lines, +fails before physical construction. A real smaller funded improvement may +still be useful and should be labelled by its own threshold. + +**Pivot:** require one actual source-bound paid-path change outside the +three-generator family. The pooled relaxed optimum exhausts H2, H4 and H5; +it leaves 11,007 H3 jobs across the caller, or 611.5 per-call average. A proposed method that changes that H3 +inventory, changes higher-rank paths, introduces independently productive +targets or changes the caller is outside the bound. A histogram pairing of +independent H3 inputs does not implement a Gaussian coalescence. Before any +next scan or construction, name the literal role(s), event interval, all +protected scalar reads, legal common frames, restored exits and complete +charged delta. Bind the intervention to source ownership and test exactly +that chronological identity, including all helper inputs, before assigning +it an aggregate saving. No such new physical object is nominated in this +note, and no search of the source author's active contacts was performed. + +The previously checked unrestricted rank-mass relaxation has positive raw +budget at .0033, so this result does not justify abandoning P104. It provides +the narrower decision: arbitrary repetition or combination of the currently +demonstrated three economic exchanges is insufficient for this target. + +Credit: Ali Romman for PR5544/5545, thu-nmrc for PR5551 and its two coupled +retimings, and all retained P104/native/controller/compiler/precision/analytic +predecessors. The joint inventory bound and conservative analytic certificate +are prepared for Chris R/Clear1nsight with OpenAI Codex assistance. diff --git a/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/guarded/coordination/run_guarded.py b/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/guarded/coordination/run_guarded.py new file mode 100644 index 0000000000..84af5ed235 --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/guarded/coordination/run_guarded.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python3 +"""Serial local research executor with sampled descendant RSS and timeout.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import signal +import subprocess +import sys +import time + + +def tree_memory(root_pid): + records = {} + for p in Path('/proc').iterdir(): + if not p.name.isdecimal(): + continue + try: + info = (p/'stat').read_text().rsplit(')', 1)[1].split() + records[int(p.name)] = (int(info[1]), int(info[21]) * os.sysconf('SC_PAGE_SIZE')) + except (OSError, ValueError, IndexError): + continue + todo = [root_pid] + seen = set() + while todo: + pid = todo.pop() + if pid in seen: + continue + seen.add(pid) + todo.extend(p for p,(parent,_) in records.items() if parent == pid) + return sum(records.get(p,(0,0))[1] for p in seen), len(seen) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--name', required=True) + ap.add_argument('--seconds', type=float, default=150) + ap.add_argument('--memory-mib', type=int, default=1024) + ap.add_argument('--cwd', type=Path) + ap.add_argument('command', nargs=argparse.REMAINDER) + args = ap.parse_args() + command = args.command[1:] if args.command[:1] == ['--'] else args.command + if not command or args.seconds <= 0 or not (0 < args.memory_mib <= 1024): + ap.error('command, positive timeout, and memory <= 1024 MiB required') + workspace = Path(__file__).resolve().parents[1] + out = workspace/'runs'/args.name + out.mkdir(exist_ok=False) + cwd = (args.cwd or workspace).resolve() + lock = (workspace/'coordination'/'heavy.lock').open('w') + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + started = time.monotonic() + env = dict(os.environ) + env.update(PYTHONDONTWRITEBYTECODE='1', OMP_NUM_THREADS='1', OPENBLAS_NUM_THREADS='1', MKL_NUM_THREADS='1') + peak = 0 + samples = 0 + cause = None + with (out/'stdout.log').open('wb') as log: + proc = subprocess.Popen(command, cwd=cwd, stdout=log, stderr=subprocess.STDOUT, env=env, start_new_session=True) + try: + while proc.poll() is None: + rss, count = tree_memory(proc.pid) + peak = max(peak, rss) + samples += 1 + if rss > args.memory_mib * 1024**2: + cause = 'memory_limit' + elif time.monotonic() - started > args.seconds: + cause = 'timeout' + if cause: + os.killpg(proc.pid, signal.SIGTERM) + try: + proc.wait(timeout=2) + except subprocess.TimeoutExpired: + os.killpg(proc.pid, signal.SIGKILL) + break + time.sleep(0.1) + code = proc.wait() + except BaseException: + try: + os.killpg(proc.pid, signal.SIGKILL) + except ProcessLookupError: + pass + proc.wait() + raise + receipt = {'schema':'serial-research-run/v1','command':command,'cwd':str(cwd), + 'exit_code':code,'termination':cause,'elapsed_seconds':time.monotonic()-started, + 'sampled_peak_descendant_rss_bytes':peak,'rss_samples':samples, + 'memory_limit_mib':args.memory_mib,'timeout_seconds':args.seconds, + 'python':sys.version,'log_sha256':hashlib.sha256((out/'stdout.log').read_bytes()).hexdigest(), + 'scope':'Fresh command execution only; scientific claim determined by reviewed output.'} + (out/'RECEIPT.json').write_text(json.dumps(receipt,indent=2)+'\n') + print(json.dumps(receipt)) + return 0 if code == 0 and not cause else 1 + + +if __name__ == '__main__': + raise SystemExit(main()) diff --git a/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/review/JOINT-FAMILY-CEILING-REVIEW.md b/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/review/JOINT-FAMILY-CEILING-REVIEW.md new file mode 100644 index 0000000000..31c283131d --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/capsule/outputs/continuous-kappa-process-20261026/review/JOINT-FAMILY-CEILING-REVIEW.md @@ -0,0 +1,196 @@ +# Independent static review of the joint A/B/C family ceiling + +Date: 2026-10-26. Reviewed artifact: +`../economics/JOINT-EXCHANGE-CEILING.md`, particularly sections 2–6. +This is an independent agent paper review with finite rational-algebra +checks. It is not independent human or proof-kernel acceptance. No scientific +replay, source-function import, native compilation, price engine, numerical +root search or physical construction was performed. Only this review file +was written for this assignment. + +## Decision and exact scope + +**No mathematical blocker found.** Under the specified PR5545 local paid +inventory, fixed helper/main targets, unchanged nonlocal recursive bill and +18 local invocations, the three-generator histogram relaxation has a unique +single-invoice integer optimum `(a,b,c)=(219,222,112)` for every `0=-17` and hence `c>=-124`, although the upper-bound proof does not need +this lower bound. + +Each forward gain is positive on `00`. The latter is +`1+3^t+4^t-2^t-6^t>0`: the strict inequality +`3^t-1 > 6^t-4^t` and `2>2^t` add to the desired expression. + +Consequently c=112 is uniquely optimal, then a=219 and b=222 are uniquely +optimal. The resulting profile +`{1:2543,2:1,3:611,6:236,7:13,9:1}` is feasible in the unrestricted +histogram relaxation: execute 112 C exchanges, 222 B exchanges and 219 A +exchanges. It has 3,405 local jobs and rank mass 5,894. This ordering is a +multiset feasibility witness, not a legal source-chart itinerary. Starting +from the claimed PR5551 B+C successor gives the same optimum after net +remaining counts `(219,221,111)`. + +This first result applies to each integer local invoice separately. Pooling +all 18 calls permits nine extra B exchanges, so that first bill would be an +insufficient envelope for the pooled family. The revised designer proof +correctly removes the artificial floor for real averaged counts. After +saturating a and b, the objective's derivative in c is +`gA+gC-gB/2>0`, following from `gA+gC-gB>0` and `gB>0`. The unique +averaged optimum is `(219,445/2,112)`. Its 18-fold total +`(3942,4005,2016)` is integral and feasible in the pooled histogram +relaxation. The averaged local profile is +`(5087/2)H1+(1223/2)H3+236H6+13H7+H9`, with zero H2, H4 and H5. +It still has 3,405 jobs and rank mass 5,894. This explicitly covers +heterogeneous choices between calls, rational mixtures and pooled rank +inventory; no physical sharing of independent inputs is inferred. + +## Full bill and target-point certificate + +Independent integer recounting from the retained PR5545 complete invoice, +adding the pooled global profile delta, gives exactly the full paid +histogram printed in revised section 4. Its count is 65,970. The unchanged +productive count is 12,814, with complete target-minus-paid rank mass 760. +The signed coefficients at ranks 1–9 are exactly + +`{1:-47343,3:-11007,4:918,5:648,6:-4248,7:198,8:2196,9:5274}`. + +Relative to the separate-integer-local bill, the pooled bill has nine more +rank-one jobs, eighteen fewer rank-two jobs and nine more rank-three jobs. + +The high terms are the unchanged seven 416-fold `(H_(r+1)-H_r)` pairs at +`r=16,24,32,40,48,56,64`, one 208-fold pair at 72, and 208 targets at 145. +No helper, query, idle or main-bank count is removed by this recount. + +The reused baseline certificate is +`outputs/p104-contact-reassessment-20261025/RESULT-normal.json`, SHA256 +`3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608`. +This review reauthenticated that exact hash, its reviewed source head +`18968423711fd902aaee1099979497d55603e1dc`, `C_probe=33/10000`, and its +retained outward upper endpoint +`-64.2349800489874753468185 < -64`. The scientific interval calculation is +inherited from that qualified receipt; it was not rerun here. Its checker +constructs rational lower/upper sums with signed outward selection +(`outputs/p104-contact-reassessment-20261025/check.py:185-203`). + +The proposed gain functions are concave in saving C on `[0,1]`. Their +second derivatives have the asserted signs. For gB, the sufficient +comparison is `(log3)^2>2(log2)^2`; for gC it is +`(log5)^2>5(log2)^2`, using `2^t,4^t<=5^t` for `t>=0`. +The tangent-at-zero upper bounds therefore apply over the entire required +domain, not just near zero. + +This reviewer independently evaluated only finite rational sums and +inequalities, using Python standard-library `Fraction`, with no exponent +or logarithm approximation engine. For n=2,3,5, the proposed atanh series +with N=32, `z=(n-1)/(n+1)`, lower partial sum and geometric tail bound +strictly establish all three displayed log brackets. Each tail is less +than `1/10^10`. Exact rational substitution confirms the tangent constants +`2705/1000`, `524/1000`, `1117/1000` and both second-derivative sufficient +inequalities. + +The first separate-integer-local calculation independently checks as + +`219*(2705/1000)+222*(524/1000)+112*(1117/1000)=833827/1000`, + +and + +`-64+18*(33/10000)*(833827/1000)=-72353381/5000000=-14.4706762<0`. + +For the stronger pooled family, the nine extra B exchanges add less than +`9*(33/10000)*(524/1000)=0.0155628`. Exact rational addition gives + +`-72353381/5000000+9*(33/10000)*(524/1000)` +`=-72275567/5000000=-14.4551134<0`. + +These are conservative strict upper bounds, not computed values of the +actual margins or new numerical roots. The revised designer proof uses +the stronger pooled bound for its final ceiling. + +## Monotonic extension and domain + +The proof normalizes the optimal complete moment by `9^t` for +`0<=t<=1`. Only positive low-rank coefficients at 4,5,7,8 can contribute +negative derivatives. Their total magnitude is less than `3960*log9`. +The negative rank-one term alone contributes at least +`(47343/9)*log9`, which is strictly greater. Every other negative low-rank +term has nonnegative derivative; rank 9 is constant. For high paired +terms, `x^t*log x` increases for `x>1,t>=0`, so their derivatives are +positive; the rank-145 target derivative is positive as well. + +Thus the normalized moment is strictly increasing in t. Its endpoint +values are `-53156` and `760/9`, exactly as stated. It has one zero, and +the negative `.0033` bound puts the corresponding saving strictly below +`.0033`. For every `.0033<=C<1`, the optimal family moment stays negative; +all other family members are pointwise no better by the preceding +inventory argument. This does not extrapolate the analytic proof to +`t<0` or a saving outside its declared `0 H6` edit\n+and lies outside PR5548's narrow repetition ceiling.\n+\n+Each invocation retains helper targets `{4:51,5:36,7:24,8:122,9:294}`.\n+The full bill includes 18 forward invocations, 15 genuine queries, 15 whole\n+idles and 32 main banks: 69,912 paid calls, 12,814 productive fields and rank\n+surplus 760. Maximum paid/target ranks remain 72/145. No helper is omitted.\n+\n+`pricing.py` retains PR5544/5545's funding argument. New mathematical\n+parameters are claimed/tested saving and comparison endpoint; its input\n+histogram comes from the freshly replayed word. Two independent full\n+invoice counts and both inherited rational moment engines must agree.\n+The strict raw crossing enclosure is\n+\n+```text\n+.00304153116714 < raw crossing < .00304153116715.\n+```\n+\n+The separate funding peer implements a third rational interval engine:\n+50-term atanh logarithms with rigorous tails and 128-bit outward grids,\n+followed by alternating exponential bounds of degrees 15/14. It imports\n+neither retained moment engine. Its four sign enclosures and full invoice\n+recount agree. The wrapper binds the audited word, source and complete\n+receipt to this publication.\n+\n+Tested saving is `.0030415305`. Cutoff 17, floor 18, tail offset 1/5,\n+power 1024, reserve `10^-10` and logarithm power 1000 fund completion,\n+splitting and rounding. Compiler gap is `1/14000000000`, integer height\n+`H=690116000000000`, test exponent 49,294; the preceding integer point\n+fails. Ordinary/admitted BIT stock checks and all 54 strict plus four\n+functional outer predicates pass. `RESULT.json` records exact rationals.\n+The endpoint gain is not claimed to equal the raw-crossing difference,\n+which has different safety margins. No global optimum is claimed.\n+\n+Scalar coefficients and counts are unchanged. The 26,000-event bound,\n+per-event scalar growth below `2^16`, total local Gaussian rank 5,894 and\n+owned peak one still bound reordered prefixes. Local native ranks stay\n+at most nine. Routing, normalization, COPY, caller and erasure allowances\n+are recomputed; no precision/tape cost is set to zero. The same five\n+framework premises remain necessary.\n+\n+## Controls, source retention and credit\n+\n+The verifier rejects an old-chart contact, wrong butterfly coefficient,\n+changed source event and uncharged recursive call. The peer also rejects\n+missing owned CLEAR. Inherited checks reject missing central translation,\n+wrong native phase, adverse completion cutoff and inadequate BIT saving.\n+All 33 dependency files are authenticated before imports. The closed\n+official export retains the exact PR5545 bytes and source attribution.\n+\n+Prepared for thu-nmrc with substantial OpenAI Codex assistance, Apache-2.0.\n+These are author-side checks, not independent human/proof-kernel acceptance.\n+Credit Ali Romman for PR5544/5545's caller and price; Gareth Davidson for\n+PR2305; David Arias for PR2152; Cinna Davis for PR2219/controller; Jacob\n+Alan Sussman for productive recursion; zxv for compiler/outer machinery;\n+Cao Yifan for pricing; and all geometry, common-chart, dual-ADD, native,\n+COPY, precision and analytic predecessors in the retained proofs. The\n+new contribution is this coupled literal itinerary and conditional gain." + }, + "research/p104-joint-contact/RESULT.json": { + "git_blob": "a83db6d025b3755176449e679e58f8a2e16f3e5c", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2FRESULT.json", + "patch": "@@ -0,0 +1,332 @@\n+{\n+ \"complete_cost\": {\n+ \"compiler\": {\n+ \"H\": 690116000000000,\n+ \"N\": \"2^690116000000000\",\n+ \"eta\": {\n+ \"lower\": \"0.000000184942858502899385581767\",\n+ \"upper\": \"0.000000184942858502899385581768\"\n+ },\n+ \"gap\": \"1/14000000000\",\n+ \"integer_test_exponent\": 49294,\n+ \"logarithm_power\": 1000,\n+ \"theta\": \"63/64\",\n+ \"uniform_saving\": \"21290713/7000000000\",\n+ \"word_materialized\": false\n+ },\n+ \"full_forward_calls\": 18,\n+ \"gain\": \"9/25000000\",\n+ \"kappa\": \"304153/100000000\",\n+ \"kappa_decimal\": \".00304153\",\n+ \"margin_at_previous\": {\n+ \"lower\": \"0.089671185966380263298820901941\",\n+ \"upper\": \"0.089671185966380263298820901942\"\n+ },\n+ \"negative_controls\": {\n+ \"old_BIT\": \"Rejected by outer inequalities\",\n+ \"old_cutoff\": \"Rejected by completion-tail ratio greater than one\"\n+ },\n+ \"nonrecursive\": {\n+ \"fixed_scalar_growth_bound\": \"At most 2^(16*26000) before native factors; a declared constant, not an attained norm.\",\n+ \"local_routes\": 5334000,\n+ \"local_scalar\": 217428,\n+ \"peak_owned_fields\": 1,\n+ \"raw_budget\": 1000000000,\n+ \"raw_scalar_upper\": 184647552,\n+ \"tensor_native_growth_bound\": \"Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.\"\n+ },\n+ \"ordinary_BIT\": {\n+ \"admitted\": \"17/5000\",\n+ \"after_cover\": \"69/20000\",\n+ \"atom\": \"1/250\",\n+ \"before_cover\": \"3459/1000000\",\n+ \"ordinary_saving\": \"8590884599/2500000000000\",\n+ \"prime_rule\": \"odd q > 2^26*N^5 avoiding all fixed denominators and rank witnesses\"\n+ },\n+ \"outer\": {\n+ \"functional_checks\": {\n+ \"actual_new_BIT_stock_sublinear\": \"3485999999253/3500000000000\",\n+ \"fixed_halo_explicit_metadata_branch\": \"269500000001/3500000000\",\n+ \"new_BIT_row_stock_sublinear_in_active_group\": \"13957999997009/14000000000000\",\n+ \"new_semantic_group_guard\": \"3/14000000000\"\n+ },\n+ \"margins\": {\n+ \"boundary_algebraic_matrix\": \"596139935957418577/196000000000000000000\",\n+ \"fused_gaussian\": \"596139935872255731/196000000000000000000\",\n+ \"global_coordinate_router\": \"2661339/875000000\",\n+ \"group_bit_router\": \"37258746867015983/12250000000000000000\",\n+ \"group_scans\": \"6999999999/7000000000\",\n+ \"main_transform\": \"596139921957418577/196000000000000000000\",\n+ \"microbox_face_corrections\": \"269500000001/3500000000\",\n+ \"polynomial_products\": \"13999999999/14000000000\",\n+ \"sparse_union_movement\": \"80221139935957418577/196000000000000000000\"\n+ },\n+ \"parameters\": {\n+ \"a\": \"2661339/875000000\",\n+ \"b\": \"1703257/560000000\",\n+ \"beta\": \"13999999997/14000000000\",\n+ \"bit_saving\": \"17/5000\",\n+ \"cap_xi\": \"178221139921957418577/196000000000000000000\",\n+ \"complex_uniform_saving\": \"21290713/7000000000\",\n+ \"d\": \"1/14000000000\",\n+ \"epsilon\": \"13999999999/14000000000\",\n+ \"kappa\": \"304153/100000000\",\n+ \"lambda_\": \"3987833879/4000000000\",\n+ \"lambda_prime\": \"13957418577/14000000000\",\n+ \"layout\": \"1/14000000000\",\n+ \"q\": \"42581423/14000000000\",\n+ \"r0\": \"1/140000000000\",\n+ \"stop\": \"1/14000000000\",\n+ \"tested_saving\": \"6083061/2000000000\"\n+ },\n+ \"strict_checks\": {\n+ \"actual_bit_above_effective\": \"313661/875000000\",\n+ \"actual_logarithmic_gamma_guard\": \"1/14000000000\",\n+ \"actual_logarithmic_group_guard\": \"17778860099042581423/98000000000000000000\",\n+ \"alpha_logarithm_absorption\": \"1/140000000000\",\n+ \"boundary_algebraic_matrix_above_kappa\": \"55957418577/196000000000000000000\",\n+ \"cap_above_band\": \"80221139921957418577/196000000000000000000\",\n+ \"cap_below_cell\": \"17778860064042581423/196000000000000000000\",\n+ \"cap_below_phase_cell_power\": \"213778860078042581423/196000000000000000000\",\n+ \"complex_above_effective\": \"1/14000000000\",\n+ \"complex_below_one_over_32\": \"15796743/560000000\",\n+ \"complex_endpoint\": \"1/7000000000\",\n+ \"epsilon_below_one\": \"1/14000000000\",\n+ \"epsilon_positive\": \"13999999999/14000000000\",\n+ \"fine_prime_halo_umbrella\": \"7/2\",\n+ \"fused_gaussian_above_kappa\": \"55872255731/196000000000000000000\",\n+ \"gaussian_above_main\": \"6957418577/98000000000000000000\",\n+ \"global_coordinate_router_above_kappa\": \"1/3500000000\",\n+ \"global_gamma_power_slack\": \"9/140000000000\",\n+ \"group_below_dimension\": \"1/7000000000\",\n+ \"group_bit_router_above_kappa\": \"4367015983/12250000000000000000\",\n+ \"group_gauge_power_slack\": \"17778860098342581423/98000000000000000000\",\n+ \"group_key_fits_record\": \"1/7000000000\",\n+ \"group_positive\": \"13999999997/14000000000\",\n+ \"group_scans_above_kappa\": \"6978709289/7000000000\",\n+ \"halo_covers_generic_inverse_radius\": \"5\",\n+ \"improvement_over_user_baseline\": \"655279790400418148631/500000000000000000000000\",\n+ \"lambda_above_internal\": \"1/28000000000\",\n+ \"lambda_above_sigma\": \"3/28000000000\",\n+ \"lambda_above_tau\": \"1/28000000000\",\n+ \"lambda_prime_above_lambda\": \"1/28000000000\",\n+ \"lambda_prime_above_leaf\": \"1118296743/7840000000000000000\",\n+ \"leaf_saving_above_effective\": \"558296743/7840000000000000000\",\n+ \"main_transform_above_kappa\": \"41957418577/196000000000000000000\",\n+ \"membership_arithmetic_fits_record\": \"1/14000000000\",\n+ \"microbox_face_corrections_above_kappa\": \"134744677323/1750000000\",\n+ \"microbox_halo_volume\": \"1106000000003/14000000000\",\n+ \"new_complex_uniform_saving_above_b\": \"1/14000000000\",\n+ \"new_semantic_guard_with_C1_one\": \"1/14000000000\",\n+ \"polynomial_products_above_kappa\": \"13957418579/14000000000\",\n+ \"positive_layout_slack\": \"1/14000000000\",\n+ \"q_below_effective\": \"1/14000000000\",\n+ \"q_below_internal\": \"1/14000000000\",\n+ \"q_below_leaf\": \"1118296743/7840000000000000000\",\n+ \"q_positive\": \"42581423/14000000000\",\n+ \"short_record_fallback\": \"558296743/560000000\",\n+ \"source_axis_superpolynomial\": \"1/14000000000\",\n+ \"sparse_union_movement_above_kappa\": \"79625000055957418577/196000000000000000000\",\n+ \"stop_below_one\": \"13999999999/14000000000\",\n+ \"stop_positive\": \"1/14000000000\",\n+ \"strassen_integer_power_gap\": \"1951441519231\",\n+ \"support_router_span\": \"3/14000000000\",\n+ \"theta_positive_polynomial_power\": \"2\",\n+ \"union_header_fits_record\": \"3/14000000000\",\n+ \"union_tag_work_per_visit_fits_record\": \"3/14000000000\"\n+ }\n+ },\n+ \"paid\": {\n+ \"1\": 45300,\n+ \"16\": 416,\n+ \"2\": 9972,\n+ \"24\": 416,\n+ \"3\": 7020,\n+ \"32\": 416,\n+ \"4\": 1998,\n+ \"40\": 416,\n+ \"48\": 416,\n+ \"5\": 1944,\n+ \"56\": 416,\n+ \"6\": 306,\n+ \"64\": 416,\n+ \"7\": 234,\n+ \"72\": 208,\n+ \"9\": 18\n+ },\n+ \"paid_calls\": 69912,\n+ \"previous_open_pr5545\": \"304117/100000000\",\n+ \"productive_fields\": 12814,\n+ \"query_shears\": 15,\n+ \"rank_mass_surplus\": 760,\n+ \"raw_headroom\": [\n+ \"58357/50000000000000\",\n+ \"23343/20000000000000\"\n+ ],\n+ \"raw_root_interval\": [\n+ \"152076558357/50000000000000\",\n+ \"60830623343/20000000000000\"\n+ ],\n+ \"relative_gain_percent\": \"3600/304117\",\n+ \"strictification\": {\n+ \"alpha\": {\n+ \"lower\": \"0.999999999302190665441264809032\",\n+ \"upper\": \"0.999999999302190665441264809033\"\n+ },\n+ \"cutoff\": 17,\n+ \"delta\": {\n+ \"lower\": \"0.963355290100190429734309350200\",\n+ \"upper\": \"0.963355290100190429734309350201\"\n+ },\n+ \"floor\": 18,\n+ \"gamma\": {\n+ \"lower\": \"0.965231303139134897171411452319\",\n+ \"upper\": \"0.965231303139134897171411452320\"\n+ },\n+ \"normalized_paid_upper\": \"5242880004882813/5242880536870912\",\n+ \"power\": 1024,\n+ \"reserve\": \"1/10000000000\",\n+ \"tail_offset\": \"1/5\",\n+ \"tested\": \"6083061/2000000000\"\n+ },\n+ \"targets\": {\n+ \"145\": 208,\n+ \"17\": 416,\n+ \"25\": 416,\n+ \"33\": 416,\n+ \"4\": 918,\n+ \"41\": 416,\n+ \"49\": 416,\n+ \"5\": 648,\n+ \"57\": 416,\n+ \"65\": 416,\n+ \"7\": 432,\n+ \"73\": 208,\n+ \"8\": 2196,\n+ \"9\": 5292\n+ },\n+ \"whole_idle_jobs\": 3120\n+ },\n+ \"complete_paid_delta\": {\n+ \"1\": 36,\n+ \"2\": -54,\n+ \"3\": 18,\n+ \"4\": -18,\n+ \"5\": 18\n+ },\n+ \"independent_peer_science_sha256\": \"357bf2617d364fb951c704b0bba7bb920629494686ab3866fed910fb0f2f57fc\",\n+ \"limits\": [\n+ \"The five framework assumptions retained by PR5544/5545 remain.\",\n+ \"The uniform compiler word and complete rounded multiplier are not materialized.\",\n+ \"No independent human or proof-kernel acceptance, selected promotion, or core-contributor status is claimed.\"\n+ ],\n+ \"local\": {\n+ \"endpoint_coefficients\": 552049,\n+ \"helpers\": {\n+ \"4\": 51,\n+ \"5\": 36,\n+ \"7\": 24,\n+ \"8\": 122,\n+ \"9\": 294\n+ },\n+ \"owned_lifetimes\": 8,\n+ \"paid\": {\n+ \"1\": 2430,\n+ \"2\": 554,\n+ \"3\": 390,\n+ \"4\": 111,\n+ \"5\": 108,\n+ \"6\": 17,\n+ \"7\": 13,\n+ \"9\": 1\n+ },\n+ \"peak_owned_fields\": 1,\n+ \"public_inputs\": 735,\n+ \"real_scalar_allowance\": 217428\n+ },\n+ \"local_paid_delta\": {\n+ \"1\": 2,\n+ \"2\": -3,\n+ \"3\": 1,\n+ \"4\": -1,\n+ \"5\": 1\n+ },\n+ \"native\": {\n+ \"distinct_maps\": 2979,\n+ \"helper_normalizers\": 1054,\n+ \"helpers\": {\n+ \"4\": 51,\n+ \"5\": 36,\n+ \"7\": 24,\n+ \"8\": 122,\n+ \"9\": 294\n+ },\n+ \"main_adapters\": 208,\n+ \"proof\": \"Every signed Pauli image and exact global phase; frame induction at every positive tensor width\",\n+ \"recipe_payload_sha256\": \"f7dac0d38942f0b02ad21c166281aeed704bc133421843f2b0ededaaf654e4a9\",\n+ \"wrong_phase_rejected\": true\n+ },\n+ \"negative_controls\": {\n+ \"missing_central_translation\": \"Rejected by the complete Laurent endpoint\",\n+ \"one_operand_or_contact_left_at_old_chart\": \"Scalar destination and coefficient\",\n+ \"stale_source_or_changed_read\": \"Exact source ADD at 10461\",\n+ \"uncharged_recursive_call\": \"Complete field and call counts\",\n+ \"wrong_butterfly_coefficient\": \"All 743 public and owned rows\"\n+ },\n+ \"physical_caller\": {\n+ \"central_square_columns\": 53248,\n+ \"full_calls\": 18,\n+ \"main_targets\": {\n+ \"145\": 208,\n+ \"17\": 416,\n+ \"25\": 416,\n+ \"33\": 416,\n+ \"41\": 416,\n+ \"49\": 416,\n+ \"57\": 416,\n+ \"65\": 416,\n+ \"73\": 208\n+ },\n+ \"new_paid_jobs\": 0,\n+ \"physical_contacts\": 7488,\n+ \"ports\": 104,\n+ \"route_payload_sha256\": \"7f4f0ca768ffbc4f93dcff575592c4c67411f46b4289e45b73f715a2ad47b142\",\n+ \"tensor_rule\": \"Factorwise native maps; scalar signs stay outside the tensor power.\",\n+ \"whole_idle_jobs\": {\n+ \"16\": 416,\n+ \"24\": 416,\n+ \"32\": 416,\n+ \"40\": 416,\n+ \"48\": 416,\n+ \"56\": 416,\n+ \"64\": 416,\n+ \"72\": 208\n+ },\n+ \"wrapper_sites\": [\n+ 1,\n+ 3,\n+ 5,\n+ 7,\n+ 9,\n+ 11,\n+ 13,\n+ 15,\n+ 17,\n+ 19,\n+ 21,\n+ 23,\n+ 25,\n+ 27,\n+ 29,\n+ 31\n+ ]\n+ },\n+ \"retained_source_files\": 33,\n+ \"separate_columns\": {\n+ \"arithmetic\": \"Dense integer rows with binary denominators; reverse chronology\",\n+ \"coefficients\": 552049,\n+ \"columns\": 743\n+ },\n+ \"source_commit\": \"18968423711fd902aaee1099979497d55603e1dc\",\n+ \"status\": \"PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153\"\n+}" + }, + "research/p104-joint-contact/SEARCH.md": { + "git_blob": "3d5944002a7188ac4547484134699e1b47aa771c", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2FSEARCH.md", + "patch": "@@ -0,0 +1,26 @@\n+# Discovery scope\n+\n+The search treats each ADD/COPY as a common-frame vertex. Consecutive\n+touches on a public field impose increasing-subspace edges; owned fields\n+impose decreasing-subspace edges. Public endpoint frames are fixed.\n+SCALE commutes with transport and keeps its scalar chronology. The objective\n+is the sum of `abs(dim(F)-dim(G))^(1-.00304117)` over actual transport edges.\n+\n+Single-vertex relabels and whole equal-frame-component relabels did not\n+improve this source. A coupled expansion to one proposed frame allows an\n+arbitrary subset of vertices to move together. For each edge this is a\n+binary submodular cost: finite costs satisfy the triangle inequality for\n+the rank-distance power; illegal subspace orders are forbidden. A minimum\n+cut proposes the subset. The first sweep found the two changes retained\n+here; a second sweep over this fixed candidate list found no further gain.\n+\n+The candidate list contained the 1,027 source frames and 96 additional\n+join/intersection extrema of equal-frame components. Both successful moves\n+use original frames17 and207. No new general optimization algorithm,\n+global optimum or barrier to other frame/scalar/caller changes is claimed.\n+Floating arithmetic selected candidates only. The submitted witness is\n+reconstructed directly from six exact source sites, then checked with exact\n+scalar/native/phase arithmetic and three rational moment engines.\n+\n+The reusable result here is the explicit changed itinerary and complete\n+conditional price, not an assertion that this bounded search exhausts P104." + }, + "research/p104-joint-contact/SOURCES.json": { + "git_blob": "8d83feec6ebc2078811a69d9c838d212e20cfb4f", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2FSOURCES.json", + "patch": "@@ -0,0 +1,27 @@\n+{\n+ \"schema_version\": 1,\n+ \"base_commit\": \"32890bc5de034ab8fc93ac88ead7279a6a416d04\",\n+ \"files\": [\n+ {\n+ \"path\": \"certificates/selected-result.json\",\n+ \"usage\": \"provenance\",\n+ \"git_blob\": \"fc3d4ba105e1f097d0d7d051a308281e86ab1446\",\n+ \"sha256\": \"66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903\"\n+ },\n+ {\n+ \"path\": \"docs/research/agent-task-catalog.json\",\n+ \"usage\": \"provenance\",\n+ \"git_blob\": \"f126dd2e2dad2b669e75d1d0d0bd05c600725602\",\n+ \"sha256\": \"f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72\"\n+ }\n+ ],\n+ \"retained_source\": {\n+ \"path\": \"research/p104-joint-contact/inputs/pr5545-source-closure.tar.gz\",\n+ \"sha256\": \"59768da554e11b11fae52d07f520f50684cc7a9ee0bec2873edbcd6b63814837\",\n+ \"export_manifest_sha256\": \"0a20358f9c089be1f5606c78077314e30a72998fb3c5123848d921a8d1814e76\",\n+ \"commit\": \"18968423711fd902aaee1099979497d55603e1dc\",\n+ \"files\": 33,\n+ \"source_url\": \"https://github.com/CrocSwap/integer-mult-bounds/pull/5545\"\n+ },\n+ \"retained_source_scope\": \"Exact predecessor export used as a byte-authenticated source dependency. The custom verifier checks the capsule, embedded export manifest and all 33 payload files. This is not a foreign-history Git pin or a claim that the predecessor is newly authored here.\"\n+}" + }, + "research/p104-joint-contact/TASK.json": { + "git_blob": "db403c85c60659c234db5471a3aee151e702fbe6", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2FTASK.json", + "patch": "@@ -0,0 +1,106 @@\n+{\n+ \"schema_version\": 1,\n+ \"task_id\": \"scalar-to-moment\",\n+ \"priority_revision\": 7,\n+ \"base_commit\": \"32890bc5de034ab8fc93ac88ead7279a6a416d04\",\n+ \"original_card\": {\n+ \"id\": \"scalar-to-moment\",\n+ \"question\": \"Can a changed frame itinerary remove a paid transition beyond the already covered scalar A2 contractions?\",\n+ \"starting_points\": [\n+ \"docs/research/research-family-status.md\",\n+ \"certificates/selected-result.json\",\n+ \"research/staged544-a2-graph-rewrite/README.md\",\n+ \"research/staged544-separated-a2/README.md\",\n+ \"research/staged544-a2-composition-audit/README.md\",\n+ \"research/staged544-a1858-contraction-audit/README.md\"\n+ ],\n+ \"methods\": [\n+ \"Derive the changed legal frame itinerary and exact child histogram.\",\n+ \"Prove a scoped obstruction showing why that scalar gain cannot change the paid contract.\"\n+ ],\n+ \"acceptance_gate\": \"An unchanged histogram is not a kappa gain; record any separate runtime or proof benefit explicitly.\",\n+ \"first_step\": {\n+ \"command\": [\n+ \"python3\",\n+ \"-B\",\n+ \"scripts/research_baseline.py\"\n+ ],\n+ \"expected\": \"PASS_RESEARCH_BASELINE_BINDINGS_ONLY\",\n+ \"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.\",\n+ \"scope\": \"Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately.\"\n+ },\n+ \"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.\",\n+ \"bottleneck_link\": \"A legal change to the histogram, not addition count alone, is the bridge to an exponent gain.\",\n+ \"allowed_variations\": [\n+ \"One existing scalar simplification and one proposed frame-path change.\"\n+ ],\n+ \"scope_change_triggers\": [\n+ \"Submitting only another scalar count as completion of a paid-profile task.\"\n+ ],\n+ \"overlap_terms\": [\n+ \"scalar simplification\",\n+ \"paid profile\",\n+ \"R439\",\n+ \"3998\",\n+ \"4019\",\n+ \"4112\",\n+ \"4152\",\n+ \"staged544-a2-graph-rewrite\",\n+ \"staged544-separated-a2\",\n+ \"staged544-a2-composition-audit\",\n+ \"staged544-a1858-contraction-audit\"\n+ ],\n+ \"existing_checks\": [\n+ {\n+ \"scope\": \"PR #3998: consecutive A2 scalar contraction\",\n+ \"evidence\": \"research/staged544-a2-graph-rewrite/README.md\",\n+ \"remaining\": \"A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.\",\n+ \"status\": \"author-checked\",\n+ \"source_commit\": \"389268a6b5e0373a3125d5c6fcd6995f4ea324f5\",\n+ \"selected_record_sha256\": \"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129\"\n+ },\n+ {\n+ \"scope\": \"PR #4019: separated A2 sites with unchanged recursive histogram\",\n+ \"evidence\": \"research/staged544-separated-a2/README.md\",\n+ \"remaining\": \"A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.\",\n+ \"status\": \"author-checked\",\n+ \"source_commit\": \"f408e09df300b575235f7f77f81948071397e16d\",\n+ \"selected_record_sha256\": \"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129\"\n+ },\n+ {\n+ \"scope\": \"PR #4112: composition audit\",\n+ \"evidence\": \"research/staged544-a2-composition-audit/README.md\",\n+ \"remaining\": \"A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.\",\n+ \"status\": \"author-checked\",\n+ \"source_commit\": \"205b7380656ba4b6316a8a493b1a3c679b8f7a0e\",\n+ \"selected_record_sha256\": \"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129\"\n+ },\n+ {\n+ \"scope\": \"PR #4152: A1858 contraction audit\",\n+ \"evidence\": \"research/staged544-a1858-contraction-audit/README.md\",\n+ \"remaining\": \"A genuinely changed paid itinerary or a distinct independent audit; no default scalar-only expansion.\",\n+ \"status\": \"author-checked\",\n+ \"source_commit\": \"caaa14cde5962adc372fdca71f63d0f29e73c8b2\",\n+ \"selected_record_sha256\": \"bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129\"\n+ }\n+ ]\n+ },\n+ \"scope_status\": \"refined\",\n+ \"actual_scope\": \"Retime six ADD contacts of the pinned PR5545 P104 word and certify the changed complete recursive paid moment, with every scalar coefficient, public endpoint, productive target and owned lifetime retained.\",\n+ \"scope_change_reason\": \"The donor requires an original frontier improvement. A released P104 productive caller and PR5545 contact word supply the new source. This task keeps the scalar word and changes the actual paid frame itinerary; the predecessor is retained as an authenticated capsule rather than rerolled or copied into this contribution.\",\n+ \"bottleneck_link\": \"The local paid delta 2H1 - 3H2 + H3 - H4 + H5 at each of 18 calls reduces the complete concave moment while preserving total rank mass, paid call count and productive targets.\",\n+ \"budget_minutes\": null,\n+ \"stop_rule\": \"Retain a new conditional kappa only after exact arbitrary-input scalar and native replay, complete paid and productive invoices, both rational moment engines and all inherited outer predicates pass.\",\n+ \"outcome\": \"completed\",\n+ \"evidence\": \"Author-side source reconstruction, both exact scalar interpreters, signed native maps and full physical caller checks pass. pricing.py checks the complete conditional claim .00304153 at .0030415305; RESULT.json and VALIDATION.md record the final registered replay evidence.\",\n+ \"author\": \"thu-nmrc, with OpenAI Codex assistance\",\n+ \"ai_assistance\": \"Substantial OpenAI Codex assistance, including parallel subagents for exploration, source review and publication scaffolding. These are author-side checks, not independent human or proof-kernel acceptance.\",\n+ \"open_questions\": [\n+ {\n+ \"question\": \"Can independent review accept the six contact changes and complete conditional cost join?\",\n+ \"why_it_matters\": \"The new paid itinerary improves the conditional caller while the five inherited framework premises and supplier sources remain. Author-side exact checks do not settle their independent scientific acceptance.\",\n+ \"first_step\": \"Compare the six pinned source ADD sites in construct.py, replay both exact scalar endpoints and signed native maps, then recompute the before/after paid histograms and both rational moment engines.\",\n+ \"blocked_by\": \"No technical source dependency is missing; independent human or proof-kernel review remains pending.\"\n+ }\n+ ]\n+}" + }, + "research/p104-joint-contact/VERIFY.json": { + "git_blob": "173b572203cb1bad06d7c4bdeb7f917764e3cf92", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2FVERIFY.json", + "patch": "@@ -0,0 +1,47 @@\n+{\n+ \"schema_version\": 1,\n+ \"status\": \"ready\",\n+ \"python\": \"3.12\",\n+ \"requirements\": [],\n+ \"inputs\": [],\n+ \"commands\": [\n+ {\n+ \"argv\": [\n+ \"{python}\",\n+ \"-B\",\n+ \"{package}/verify.py\"\n+ ],\n+ \"timeout_seconds\": 540,\n+ \"checks\": \"Authenticate the retained PR5545 source capsule and its 33 payload files; reconstruct the six exact ADD contact changes; replay the complete arbitrary-input scalar and signed native endpoints, owned lifetimes, physical caller, full paid/productive invoice, both rational moment engines, compiler, stock and all outer predicates. Check the explicit failure controls implemented in verify.py. Passing these checks is conditional author-side evidence.\"\n+ },\n+ {\n+ \"argv\": [\n+ \"{python}\",\n+ \"-O\",\n+ \"-B\",\n+ \"{package}/verify.py\"\n+ ],\n+ \"timeout_seconds\": 540,\n+ \"checks\": \"Authenticate the retained PR5545 source capsule and its 33 payload files; reconstruct the six exact ADD contact changes; replay the complete arbitrary-input scalar and signed native endpoints, owned lifetimes, physical caller, full paid/productive invoice, both rational moment engines, compiler, stock and all outer predicates. Check the explicit failure controls implemented in verify.py. Passing these checks is conditional author-side evidence.\"\n+ },\n+ {\n+ \"argv\": [\n+ \"{python}\",\n+ \"-B\",\n+ \"{package}/funding_review.py\"\n+ ],\n+ \"timeout_seconds\": 30,\n+ \"checks\": \"A separately written rational log/exp interval engine proves claimed/tested and both raw-crossing endpoint signs; recount all paid/target jobs and ordinary stock, authenticate the source capsule, compare executable funding logic, and bind every reviewed output to this publication. No native/outer framework is independently reimplemented.\"\n+ },\n+ {\n+ \"argv\": [\n+ \"{python}\",\n+ \"-O\",\n+ \"-B\",\n+ \"{package}/funding_review.py\"\n+ ],\n+ \"timeout_seconds\": 30,\n+ \"checks\": \"A separately written rational log/exp interval engine proves claimed/tested and both raw-crossing endpoint signs; recount all paid/target jobs and ordinary stock, authenticate the source capsule, compare executable funding logic, and bind every reviewed output to this publication. No native/outer framework is independently reimplemented.\"\n+ }\n+ ]\n+}" + }, + "research/p104-joint-contact/common.py": { + "git_blob": "4e3e9f8a04eb3a2ed9c44b63a4c01f9a179de656", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2Fcommon.py", + "patch": "@@ -0,0 +1,47 @@\n+\"\"\"Authenticate and open the retained Git-free PR5545 source closure.\n+\n+Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0.\n+\"\"\"\n+from contextlib import contextmanager\n+from hashlib import sha256\n+from io import BytesIO\n+from pathlib import Path,PurePosixPath\n+import gzip,importlib.util,json,sys,tarfile,tempfile\n+\n+HERE=Path(__file__).resolve().parent\n+def need(ok,why):\n+ if not ok:\n+ raise ValueError(why)\n+\n+@contextmanager\n+def supplier():\n+ pins=json.loads((HERE/'SOURCES.json').read_bytes())['retained_source']\n+ path=HERE/'inputs'/Path(pins['path']).name\n+ raw=path.read_bytes()\n+ need(sha256(raw).hexdigest()==pins['sha256'],'Retained PR5545 capsule byte pin')\n+ with tempfile.TemporaryDirectory(prefix='p104-joint-contact-')as tmp:\n+ root=Path(tmp)\n+ with tarfile.open(fileobj=BytesIO(gzip.decompress(raw)),mode='r:')as archive:\n+ members=archive.getmembers()\n+ names=[m.name for m in members]\n+ need(len(names)==len(set(names)),'Unique retained source paths')\n+ for member in members:\n+ name=PurePosixPath(member.name)\n+ need(member.isfile()and not name.is_absolute()and '..'not in name.parts,'Regular retained source path')\n+ target=root/member.name;target.parent.mkdir(parents=True,exist_ok=True)\n+ target.write_bytes(archive.extractfile(member).read())\n+ manifest_raw=(root/'.research-export.json').read_bytes()\n+ need(sha256(manifest_raw).hexdigest()==pins['export_manifest_sha256'],'Exact official export inventory')\n+ manifest=json.loads(manifest_raw)\n+ need(manifest['commit']==pins['commit']and manifest['package']=='research/p104-full-frame-contact','Exact predecessor head and package')\n+ need(len(manifest['files'])==pins['files']==33,'Full predecessor closure')\n+ need(set(names)=={'.research-export.json'}|{r['path']for r in manifest['files']},'No omitted or extra dependency')\n+ for row in manifest['files']:\n+ raw=(root/row['path']).read_bytes()\n+ need(len(raw)==row['size']and sha256(raw).hexdigest()==row['sha256'],'Source file '+row['path'])\n+ source=root/'research/p104-productive-controller'\n+ spec=importlib.util.spec_from_file_location('local',source/'local.py')\n+ L=importlib.util.module_from_spec(spec);sys.modules['local']=L;spec.loader.exec_module(L)\n+ C=L.load(source/'caller.py','p104_joint_caller')\n+ R=L.load(root/'research/p104-full-frame-contact/construct.py','p104_joint_predecessor')\n+ yield root,L,C,R" + }, + "research/p104-joint-contact/construct.py": { + "git_blob": "eaf0c11b399b0787da61f5ecfbece4f4407e27b6", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2Fconstruct.py", + "patch": "@@ -0,0 +1,66 @@\n+\"\"\"Six source-pinned ADD contact changes on Ali Romman's PR5545 word.\n+\n+Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0.\n+The P104 supplier and controller retain their predecessor attribution.\n+\"\"\"\n+from copy import deepcopy\n+\n+EDITS = {\n+ 10461: (['ADD',297,303,'1',335],17),\n+ 10462: (['ADD',303,297,'-1/2',335],17),\n+ 13970: (['ADD',152,297,'-1/2',335],17),\n+ 15479: (['ADD',198,319,'1',915],207),\n+ 15639: (['ADD',205,198,'1',915],207),\n+ 15640: (['ADD',198,205,'-1/2',915],207),\n+}\n+\n+def need(ok,why):\n+ if not ok:\n+ raise ValueError(why)\n+\n+def span(basis):\n+ out={0}\n+ for v in basis:\n+ need(v not in out,'Independent frame basis')\n+ out|={x^v for x in tuple(out)}\n+ return frozenset(out)\n+\n+def construct(source):\n+ need(len(source['program'])==25310 and len(source['frames'])==1027,'Pinned source dimensions')\n+ for i,(expected,_) in EDITS.items():\n+ need(source['program'][i]==expected,'Exact source ADD at '+str(i))\n+ frames=[span(b)for b in source['frames']]\n+ current=list(source['initial'])+[None]*8\n+ out=[]\n+ def move(r,b):\n+ a=current[r]\n+ if a==b:\n+ return\n+ need(a is not None,'Initialized operand')\n+ need(frames[b]=735 else frames[a]=735]);current[r]=b\n+ for i,e in enumerate(source['program']):\n+ op,r=e[:2]\n+ if op=='MOVE':\n+ continue\n+ if op=='INIT':\n+ need(current[r]is None,'Fresh owned lifetime')\n+ out.append(list(e));current[r]=e[2]\n+ elif op=='CLEAR':\n+ need(current[r]==e[2],'Owned chronology unchanged')\n+ out.append(list(e));current[r]=None\n+ elif op=='SCALE':\n+ out.append([*e[:-1],current[r]])\n+ else:\n+ need(op in ('ADD','COPY'),'Scalar opcode')\n+ f=EDITS[i][1]if i in EDITS else e[-1]\n+ for s in e[1:3]:\n+ move(s,f)\n+ out.append([*e[:-1],f])\n+ for r,f in enumerate(source['final']):\n+ move(r,f)\n+ word=deepcopy(source);word['program']=out\n+ signature=lambda w:[e[:-1]for e in w['program']if e[0]!='MOVE']\n+ need(signature(word)==signature(source),'Every scalar/owned coefficient and order retained')\n+ need(len(out)==25310,'Fixed complete word length')\n+ return word" + }, + "research/p104-joint-contact/pricing.py": { + "git_blob": "ef78de99ffe678dcf762bab0e784eab46d9331cf", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2Fpricing.py", + "patch": "@@ -0,0 +1,156 @@\n+\"\"\"Complete mixed-target price, compiler and outer transfer.\n+\n+The interval and compiler bounds follow zxv and Cao Yifan. The productive\n+recursion is by Jacob Alan Sussman. The controller is by Cinna Davis.\n+Adapted from Ali Romman's PR5544/5545 for the two coupled contact changes.\n+Successor choices prepared for thu-nmrc with substantial OpenAI Codex assistance.\n+Ali Romman's complete caller/price proof and all predecessor credit are retained.\n+Apache-2.0.\n+\"\"\"\n+from collections import Counter\n+from fractions import Fraction as Q\n+import local as L\n+\n+KAPPA, TESTED = Q('.00304153'), Q('.0030415305')\n+PREVIOUS = Q('.00304117')\n+\n+\n+def encode(x):\n+ if isinstance(x,Q):\n+ return str(x)\n+ if isinstance(x,dict):\n+ return {str(k):encode(v) for k,v in x.items()}\n+ if isinstance(x,(list,tuple)):\n+ return [encode(v) for v in x]\n+ return x\n+\n+\n+def assemble(local, native, word, physical):\n+ paid, targets = Counter(), Counter()\n+ counts = Counter()\n+ L.need(local['helpers'] == native['helpers'], 'Every productive helper has a native target')\n+ for e in word['physical_events']:\n+ counts[e[0]] += 1\n+ if e[0] == 'LOCAL':\n+ L.need(e[3] is False, 'Every source invocation is forward')\n+ paid.update(local['paid'])\n+ targets.update(local['helpers'])\n+ elif e[0] == 'QUERY_SHEAR':\n+ paid[1] += 104\n+ elif e[0] == 'IDLE':\n+ paid[8*len(e[2])] += 208\n+ main = Counter()\n+ idle = Counter({8*len(e[2]):0 for e in word['physical_events'] if e[0] == 'IDLE'})\n+ for e in word['physical_events']:\n+ if e[0] == 'IDLE':\n+ idle[8*len(e[2])] += 208\n+ L.need(idle == physical['whole_idle_jobs'], 'Every whole idle has a native Gaussian and full rank')\n+ for term in word['diagonal']:\n+ main[1+8*sum(term[1:])] += 104\n+ L.need(main == physical['main_targets'], 'Every main target has its full native phase')\n+ targets.update(main)\n+ L.need(counts['LOCAL'] == 18 and counts['QUERY_SHEAR'] == counts['IDLE'] == 15, 'Complete call census')\n+ # Recount by the two path lengths, without using emitted main diagonals.\n+ second_t = Counter({r:18*n for r,n in local['helpers'].items()})\n+ second_p = Counter({r:18*n for r,n in local['paid'].items()})\n+ second_t[145] += 208\n+ second_p[1] += 15*104\n+ for length in (7,8):\n+ for j in range(1,length+1):\n+ second_t[1+8*(j+1)] += 208\n+ second_p[8*(j+1)] += 208\n+ L.need((targets,paid) == (second_t,second_p), 'Independent full invoice')\n+ L.need(max(targets) == 145 and max(paid) == 72, 'Maximum recursive ranks')\n+ L.need(sum(targets.values()) == 12814 and sum(paid.values()) == 69912, 'Complete field and call counts')\n+ L.need(sum(r*n for r,n in targets.items())-sum(r*n for r,n in paid.items()) == 760, 'Complete rank surplus')\n+ return targets,paid,counts\n+\n+\n+def run(local,native,word,physical):\n+ T,P,counts = assemble(local,native,word,physical)\n+ E = L.load(L.ROOT/'research/higher-moment-strictification/verify.py','p104_productive_intervals')\n+ other = L.load(L.ROOT/'research/kappa-rebuild/architecture/mixed_target_probe.py','p104_productive_second_intervals')\n+ def margin(k):\n+ a,b = E.moment(T,1-k), E.moment(P,1-k)\n+ return a[0]-b[1],a[1]-b[0]\n+ lo,hi,grid = 0,10**12,10**14\n+ while hi-lo > 1:\n+ m=(lo+hi)//2\n+ if margin(Q(m,grid))[0] > 0:\n+ lo=m\n+ else:\n+ hi=m\n+ lower,upper = Q(lo,grid),Q(hi,grid)\n+ L.need(margin(lower)[0] > 0 and margin(upper)[1] < 0, 'Strict rational crossing enclosure')\n+ L.need(PREVIOUS < KAPPA < TESTED < lower and margin(PREVIOUS)[0] > 0, 'Changed complete bill improves selected kappa')\n+ t,u,v,c,b = 1-TESTED,Q(1,5),1024,17,18\n+ target,paid = E.moment(T,t),E.moment(P,t)\n+ tl,th = other.moment(T,TESTED)\n+ pl,ph = other.moment(P,TESTED)\n+ L.need(tl > ph and max(tl,target[0]) <= min(th,target[1]) and max(pl,paid[0]) <= min(ph,paid[1]), 'Two exact moment engines')\n+ alpha = E.divide(paid,target)\n+ gamma = E.divide(E.moment(P,t+u),E.mul(E.power(c,u),target))\n+ delta = E.divide((Q(sum(T.values())*b),)*2,E.mul(E.power(c,TESTED),target))\n+ reserve,decay = Q(1,10**10),Q(97,100)\n+ L.need(alpha[1] < 1-reserve and gamma[1] < decay and delta[1] < decay, 'All three charged tail ratios')\n+ L.need(decay**128 < Q(1,16), 'Both tail decay blocks')\n+ normalized = 1/(1+v*reserve)+Q(4,2**32)\n+ L.need(normalized < 1 and c**64 < b**63, 'Full completion, splitting and rounding charges')\n+ theta,power = Q(63,64),1000\n+ eta = E.scale(E.power(145,-v*TESTED),t)\n+ L.need(2*(c**v)**64 <= (145**v)**63 and eta[0] > theta**power, 'Shifted exits and complement capacity')\n+ L.need(E.power(145,v*TESTED)[1] < 2**power, 'Compiler initial range')\n+ gap = (TESTED-KAPPA)/7\n+ L.need(gap.numerator == 1, 'Exact compiler integer grid')\n+ step = gap.denominator\n+ def wins(j):\n+ return (step*j+1)**power < 2**j\n+ left,right=1,2\n+ while not wins(right):\n+ left,right=right,2*right\n+ while right-left > 1:\n+ m=(left+right)//2\n+ if wins(m):\n+ right=m\n+ else:\n+ left=m\n+ H=step*right\n+ L.need(H > 8*v and wins(right) and not wins(right-1), 'Finite uniform threshold with predecessor rejection')\n+ local_routes = (sum(local['paid'].values())+native['helper_normalizers']+native['main_adapters']+4*104+4*local['owned_lifetimes'])*1000\n+ L.need(local['real_scalar_allowance']+local_routes < 10**7, 'Every local scalar, route and owned operation is funded')\n+ boundary = sum(len(word['boundaries'][side+'_program']) for side in ('left','right'))\n+ raw = 18*10**7 + 15*1664 + 32*104*(len(word['physical_events'])+boundary)\n+ raw += 32*104*(26+1000)\n+ L.need(raw < 10**9, 'Complete nonrecursive raw bound')\n+ bit = L.read(L.ROOT/'research/query-thinned-controllers/RESULT.json')['ordinary_BIT']\n+ atom = Q(bit['atom'])\n+ ordinary=(1-atom)*Q(bit['after_cover'])+atom*Q('.0000384599')\n+ admitted=Q(bit['admitted'])\n+ L.need(atom > ordinary > admitted > TESTED and atom < 1-ordinary, 'Retained BIT admission and stock')\n+ outer_module=L.load(L.ROOT/'research/pr4359-p7-padding/dependencies/compiler-refill/endpoint.py','p104_productive_outer')\n+ params={'kappa':KAPPA,'tested_saving':TESTED,'complex_uniform_saving':KAPPA+6*gap,\n+ 'b':KAPPA+5*gap,'a':KAPPA+4*gap,'q':KAPPA+3*gap,'bit_saving':admitted,\n+ 'epsilon':1-gap,'beta':1-3*gap,'r0':gap/10,'stop':gap,'layout':gap,'d':gap}\n+ outer=outer_module.ledger(params)\n+ outer['functional_checks']['actual_new_BIT_stock_sublinear']=params['beta']*(1-atom)\n+ L.need(len(outer['strict_checks']) == 54 and len(outer['functional_checks']) == 4, 'Complete outer predicate inventory')\n+ L.need(all(x > 0 for key in ('strict_checks','functional_checks') for x in outer[key].values()), 'All outer inequalities strict')\n+ wrong_cutoff = E.divide((Q(sum(T.values())*21),)*2,E.mul(E.power(20,TESTED),target))\n+ L.need(wrong_cutoff[0] > 1, 'Old cutoff fails with this helper inventory')\n+ bad=outer_module.ledger(dict(params,bit_saving=Q('.0027')))\n+ L.need(any(x <= 0 for x in bad['strict_checks'].values()), 'Insufficient BIT contract rejected')\n+ return encode({'kappa':KAPPA,'kappa_decimal':'.00304153','previous_open_pr5545':PREVIOUS,'gain':KAPPA-PREVIOUS,\n+ 'relative_gain_percent':100*(KAPPA/PREVIOUS-1),'raw_root_interval':[lower,upper],\n+ 'raw_headroom':[lower-KAPPA,upper-KAPPA],'margin_at_previous':E.display(margin(PREVIOUS)),\n+ 'targets':T,'paid':P,'productive_fields':sum(T.values()),'paid_calls':sum(P.values()),\n+ 'rank_mass_surplus':760,'full_forward_calls':18,'query_shears':15,'whole_idle_jobs':3120,\n+ 'strictification':{'tested':TESTED,'power':v,'cutoff':c,'floor':b,'tail_offset':u,'reserve':reserve,\n+ 'alpha':E.display(alpha),'gamma':E.display(gamma),'delta':E.display(delta),'normalized_paid_upper':normalized},\n+ 'compiler':{'theta':theta,'logarithm_power':power,'eta':E.display(eta),'gap':gap,'H':H,'N':'2^'+str(H),\n+ 'integer_test_exponent':right,'uniform_saving':params['complex_uniform_saving'],'word_materialized':False},\n+ 'nonrecursive':{'local_scalar':local['real_scalar_allowance'],'local_routes':local_routes,\n+ 'raw_scalar_upper':raw,'raw_budget':10**9,'peak_owned_fields':1,\n+ 'fixed_scalar_growth_bound':'At most 2^(16*26000) before native factors; a declared constant, not an attained norm.',\n+ 'tensor_native_growth_bound':'Each rank-r Gaussian has row l1 norm at most 2^(rf); sum of local ranks is 5894.'},\n+ 'ordinary_BIT':bit,'outer':outer,\n+ 'negative_controls':{'old_cutoff':'Rejected by completion-tail ratio greater than one','old_BIT':'Rejected by outer inequalities'}})" + }, + "research/p104-joint-contact/verify.py": { + "git_blob": "349faeac2666eae8dd4d52116833a028b8387c3c", + "source_url": "https://github.com/CrocSwap/integer-mult-bounds/blob/79072da5404a01056df2af2e4132324b01c72366/research%2Fp104-joint-contact%2Fverify.py", + "patch": "@@ -0,0 +1,90 @@\n+\"\"\"Complete conditional P104 successor; the selected record is not changed.\n+\n+Prepared for thu-nmrc with substantial OpenAI Codex assistance. Apache-2.0.\n+Predecessor construction, native, caller, interval and outer proofs retain credit.\n+\"\"\"\n+import argparse\n+from collections import Counter\n+from copy import deepcopy\n+from hashlib import sha256\n+import gzip,json\n+from pathlib import Path\n+import sys\n+sys.dont_write_bytecode=True\n+HERE=Path(__file__).resolve().parent\n+sys.path.insert(0,str(HERE))\n+from common import supplier,need\n+import construct\n+\n+def rejected(fn):\n+ try:\n+ fn()\n+ except ValueError as error:\n+ return str(error)\n+ raise ValueError('Semantic mutant was accepted')\n+\n+def run():\n+ with supplier()as(root,L,C,R):\n+ P=L.load(HERE/'pricing.py','p104_joint_pricing')\n+ base=L.construct()\n+ need(base==L.read(root/'research/p104-productive-controller/WORD.json.gz'),'Reconstructed full credited source')\n+ source=R.construct(base)\n+ need(source==L.read(root/'research/p104-full-frame-contact/WORD.json.gz'),'Reconstructed exact PR5545 source')\n+ baseline=L.replay(source)\n+ word=construct.construct(source)\n+ local=L.replay(word);columns=L.reverse_columns(word)\n+ need(local['helpers']==baseline['helpers'],'All 527 productive helper targets retained')\n+ delta=Counter(local['paid']);delta.subtract(baseline['paid'])\n+ delta={r:n for r,n in delta.items()if n}\n+ need(delta=={1:2,2:-3,3:1,4:-1,5:1},'Exact coupled contact invoice')\n+ need(sum(delta.values())==sum(r*n for r,n in delta.items())==0,'Call count and rank mass retained')\n+ peer=L.load(HERE/'peer/check.py','p104_joint_independent_peer')\n+ peer_result=json.loads(json.dumps(peer.calculate(),sort_keys=True))\n+ need(peer_result==L.read(HERE/'peer/RECEIPT.json'),'Independent exact scalar/frame receipt')\n+ need(peer.read('SOURCE-WORD.json.gz')==source and peer.read('CANDIDATE-WORD.json.gz')==word,'Independent checker audits this exact pair of words')\n+ print('PASS source reconstruction, all743 rows, reverse columns, independent integer peer and both coupled invoices',flush=True)\n+ native=L.native(word)\n+ controller=C.construct()\n+ need(controller==L.read(root/'research/p104-productive-controller/CONTROLLER.json'),'Exact complete caller')\n+ physical=C.physical(controller,word)\n+ print('PASS every native map and phase, all527 helpers, all104 ports and complete265-axis caller',flush=True)\n+ costs=P.run(local,native,controller,physical)\n+ controls=C.controls(controller)\n+ bad=deepcopy(word)\n+ event=next(e for e in bad['program']if e==['ADD',297,303,'1',17]);event[-1]=335\n+ controls['one_operand_or_contact_left_at_old_chart']=rejected(lambda:L.replay(bad))\n+ bad=deepcopy(word)\n+ event=next(e for e in bad['program']if e==['ADD',297,303,'1',17]);event[3]='2'\n+ controls['wrong_butterfly_coefficient']=rejected(lambda:L.replay(bad))\n+ bad=deepcopy(local);bad['paid'][1]-=1\n+ controls['uncharged_recursive_call']=rejected(lambda:P.assemble(bad,native,controller,physical))\n+ bad=deepcopy(source);bad['program'][10461][3]='2'\n+ controls['stale_source_or_changed_read']=rejected(lambda:construct.construct(bad))\n+ result={'status':'PASS_P104_JOINT_CONTACT_COMPLETE_KAPPA_00304153',\n+ 'source_commit':'18968423711fd902aaee1099979497d55603e1dc',\n+ 'retained_source_files':33,'local_paid_delta':delta,\n+ 'complete_paid_delta':{r:18*n for r,n in delta.items()},\n+ 'local':local,'separate_columns':columns,'native':native,\n+ 'independent_peer_science_sha256':sha256(json.dumps(peer_result,sort_keys=True,separators=(',',':')).encode()).hexdigest(),\n+ 'physical_caller':physical,'complete_cost':costs,'negative_controls':controls,\n+ 'limits':['The five framework assumptions retained by PR5544/5545 remain.',\n+ 'The uniform compiler word and complete rounded multiplier are not materialized.',\n+ 'No independent human or proof-kernel acceptance, selected promotion, or core-contributor status is claimed.']}\n+ return P.encode(result),word\n+\n+def main():\n+ parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--write',action='store_true');args=parser.parse_args()\n+ result,word=run()\n+ for name,data in [('RESULT.json',result),('WORD.json.gz',word)]:\n+ path=HERE/name\n+ if args.write:\n+ raw=(json.dumps(data,sort_keys=True,indent=None if name.endswith('.gz')else 2)+'\\n').encode()\n+ path.write_bytes(gzip.compress(raw,mtime=0)if name.endswith('.gz')else raw)\n+ else:\n+ raw=path.read_bytes()\n+ need(json.loads(gzip.decompress(raw)if name.endswith('.gz')else raw)==data,'Saved semantic artifact '+name)\n+ print(result['status'],flush=True)\n+ print(json.dumps({k:result['complete_cost'][k]for k in ('kappa','gain','raw_root_interval','productive_fields','paid_calls')},sort_keys=True),flush=True)\n+\n+if __name__=='__main__':\n+ main()" + } + } +} diff --git a/research/pooled-abc-exchange-ceiling/provenance/SOURCE-PINS.json b/research/pooled-abc-exchange-ceiling/provenance/SOURCE-PINS.json new file mode 100644 index 0000000000..65052a5fc6 --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/provenance/SOURCE-PINS.json @@ -0,0 +1,39 @@ +{ + "schema": "p104-joint-three-exchange-paper-bound-sources/v1", + "canonical_main": "32890bc5de034ab8fc93ac88ead7279a6a416d04", + "selected_conditional_kappa": "0.003027288235", + "predecessor_head": "18968423711fd902aaee1099979497d55603e1dc", + "successor_head": "79072da5404a01056df2af2e4132324b01c72366", + "files": [ + { + "path": "outputs/continuous-kappa-process-20261026/upstream/PR5551-SOURCE-CAPTURE.json", + "sha256": "860e232e56751f3a236a9e07092b066a93afaac24d64ae4ddfadc618912dc186" + }, + { + "path": "outputs/continuous-kappa-process-20261026/upstream/PR5551-PEER-SOURCE-CAPTURE.json", + "sha256": "116df4099b759a1ec7c43d1ac38811b24745bcd85e89cfb1641778b7b8305dee" + }, + { + "path": "outputs/p104-contact-reassessment-20261025/RESULT-normal.json", + "sha256": "3c4d8db5a9695924027f5801901b55cefe0cdc5ea07450aaf396de7e5887e608" + }, + { + "path": "P104-CONTACT-REASSESSMENT.md", + "sha256": "fb9fa27a2b3472c5fe2f994276aacf4834f76a2b75e43ad55193a5990037604f" + }, + { + "path": "P104-UNCOVERED-NATIVE-RESULTS.md", + "sha256": "ca3771e0c50e6581ded086b2f9352b36544a7e5ba23dc97ac3dddbfbcbd9b4ae" + } + ], + "baseline_certificate": { + "C_probe": "33/10000", + "upper_decimal_outward": "-64.2349800489874753468185", + "relaxed_upper_used": "-64" + }, + "scientific_execution_performed_by_this_lane": false, + "source_scans_or_imports_performed_by_this_lane": false, + "price_engine_runs_performed_by_this_lane": false, + "new_physical_candidate_nominated": false, + "new_funded_kappa_claimed": false +} diff --git a/research/pooled-abc-exchange-ceiling/verify.py b/research/pooled-abc-exchange-ceiling/verify.py new file mode 100644 index 0000000000..fecbd5784a --- /dev/null +++ b/research/pooled-abc-exchange-ceiling/verify.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""Portable byte-preserved pooled A/B/C finite qualification. + +Chris R/Clear1nsight, substantial OpenAI Codex assistance, Apache-2.0. +Retain Ali Romman, thu-nmrc and all predecessor attribution. +""" +import hashlib +import json +import os +from pathlib import Path +import resource +import subprocess +import sys +import tempfile + +HERE = Path(__file__).resolve().parent +AUDIT = 'outputs/continuous-kappa-process-20261026/ceiling-qualification' +RESULT_SHA = '882369dbec747ac4fe4c324501dddca7e67240e773bb6782e29bd91dde25b5a7' +REQUEST_SHA = '68c44dab3fc7ccd7e8eebf0155133b03a14982c0ddc53c6b7e3f02a9fd5e5679' + + +def need(condition, message): + if not condition: + raise ValueError(message) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def regular(root, name): + path = Path(name) + need(not path.is_absolute() and path.as_posix() == name and '..' not in path.parts, + 'canonical relative file '+name) + current = root + for part in path.parts: + current = current/part + need(not current.is_symlink(), 'symlink component '+name) + need(current.is_file(), 'regular file '+name) + return current + + +def authenticate(): + manifest = json.loads(regular(HERE,'PAYLOAD-INVENTORY.json').read_bytes()) + inventory = manifest['files'] + actual = set() + for path in HERE.rglob('*'): + need(not path.is_symlink(), 'symlink package member '+str(path)) + if path.is_file() and path != HERE/'PAYLOAD-INVENTORY.json': + actual.add(path.relative_to(HERE).as_posix()) + need(actual == set(inventory), 'complete package inventory') + for name, row in inventory.items(): + raw = regular(HERE,name).read_bytes() + need(len(raw) == row['bytes'] and sha(raw) == row['sha256'], 'frozen package byte '+name) + capsule = HERE/'capsule' + raw_request = regular(capsule,AUDIT+'/REQUEST.json').read_bytes() + need(sha(raw_request) == REQUEST_SHA, 'original frozen request bytes') + request = json.loads(raw_request) + need(request['total_seconds'] == 150 and request['memory_mib'] == 512 and + request['per_child_seconds'] == 60, 'original resource contract') + for name, expected in request['files'].items(): + need(sha(regular(capsule,name).read_bytes()) == expected, 'original frozen request input '+name) + expected = regular(HERE,'expected/qualification.json').read_bytes() + need(sha(expected) == RESULT_SHA, 'original complete scientific output') + receipt = json.loads(regular(HERE,'original-evidence/PAIR-RECEIPT.json').read_bytes()) + need(receipt['result_sha256'] == RESULT_SHA and receipt['request_sha256'] == REQUEST_SHA and + receipt['complete_output_equal'] is True and receipt['scientific_fields_excluded'] == 0, + 'original exact pair receipt') + return expected + + +def child_limits(): + resource.setrlimit(resource.RLIMIT_AS, (512*1024*1024,512*1024*1024)) + + +def main(): + expected = authenticate() + if sys.argv[1:] == ['--integrity-only']: + print('PASS_POOLED_ABC_CEILING_INTEGRITY_ONLY_NO_SCIENCE') + return + need(not sys.argv[1:], 'unsupported verifier arguments') + env = dict(os.environ,PYTHONDONTWRITEBYTECODE='1') + env.pop('PYTHONOPTIMIZE',None) + script = HERE/'capsule'/AUDIT/'check.py' + with tempfile.TemporaryDirectory(prefix='pooled-abc-ceiling-replay-') as temporary: + command = [sys.executable,'-I','-X','pycache_prefix='+temporary+'/bytecode'] + command += ['-O'] if sys.flags.optimize else [] + command += ['-B',str(script)] + with (Path(temporary)/'stdout.json').open('wb+') as out, (Path(temporary)/'stderr.txt').open('wb+') as err: + run = subprocess.run(command,cwd=HERE/'capsule',env=env,stdout=out,stderr=err, + timeout=60,preexec_fn=child_limits) + out.seek(0); actual = out.read() + err.seek(0); errors = err.read() + need(run.returncode == 0 and not errors, 'scientific subprocess failed: '+errors.decode(errors='replace')[:4000]) + need(actual == expected, 'complete original scientific output equality') + result = json.loads(actual) + need(result['status'] == 'PASS_SCOPED_POOLED_ABC_COEFFICIENT_CERTIFICATE' and + result['physical_witness'] is False and result['new_kappa'] is None and + result['selected_promotion'] is False, 'scope marker') + need(len(result['mutation_controls']) == 12 and + all(v == 'rejected' for v in result['mutation_controls'].values()), 'all original mutation controls') + authenticate() + print('PASS_POOLED_ABC_EXCHANGE_CEILING') + print(json.dumps({'complete_original_output_sha256':sha(actual), + 'strict_margin_upper':result['certificate']['strict_margin_upper'], + 'mutation_controls_rejected':12,'physical_witness':False, + 'new_kappa':None,'global_P104_ceiling':False},sort_keys=True,separators=(',',':'))) + + +if __name__ == '__main__': + main()