From 335e78619a17b7c418e11306f86a72fd366de35b Mon Sep 17 00:00:00 2001 From: Gareth Davidson Date: Thu, 15 Oct 2026 05:28:56 +0100 Subject: [PATCH] Compose P104 private descent reuse with coalesced frames --- .../p104-coalesced-private-reuse/README.md | 154 ++ .../p104-coalesced-private-reuse/RESULT.json | 1779 +++++++++++++++++ .../p104-coalesced-private-reuse/SOURCES.json | 182 ++ .../p104-coalesced-private-reuse/TASK.json | 175 ++ .../p104-coalesced-private-reuse/VERIFY.json | 34 + .../p104-coalesced-private-reuse/compose.py | 216 ++ .../predecessor2152.tar.gz | Bin 0 -> 50448 bytes .../p104-coalesced-private-reuse/price.py | 109 + .../p104-coalesced-private-reuse/sources.py | 65 + .../p104-coalesced-private-reuse/verify.py | 109 + 10 files changed, 2823 insertions(+) create mode 100644 research/p104-coalesced-private-reuse/README.md create mode 100644 research/p104-coalesced-private-reuse/RESULT.json create mode 100644 research/p104-coalesced-private-reuse/SOURCES.json create mode 100644 research/p104-coalesced-private-reuse/TASK.json create mode 100644 research/p104-coalesced-private-reuse/VERIFY.json create mode 100644 research/p104-coalesced-private-reuse/compose.py create mode 100644 research/p104-coalesced-private-reuse/predecessor2152.tar.gz create mode 100644 research/p104-coalesced-private-reuse/price.py create mode 100644 research/p104-coalesced-private-reuse/sources.py create mode 100644 research/p104-coalesced-private-reuse/verify.py diff --git a/research/p104-coalesced-private-reuse/README.md b/research/p104-coalesced-private-reuse/README.md new file mode 100644 index 0000000000..0ef79bfc5d --- /dev/null +++ b/research/p104-coalesced-private-reuse/README.md @@ -0,0 +1,154 @@ +# P104 private descent reuse in the coalesced word + +The helper-7 reuse from Cinna Davis's [PR2219](https://github.com/CrocSwap/integer-mult-bounds/pull/2219) +composes with David Arias's cheaper, coalesced word in +[PR2152](https://github.com/CrocSwap/integer-mult-bounds/pull/2152). +This checks the previously untested combination and preserves **every original +public boundary frame and lifetime width**. The combined child profile changes +by `+H9 - H2 - H7`; its rank mass stays 5894 and its fractional moment decreases +strictly. The complete inherited owner-window invoice still excludes the +selected κ. This is a finite forward component, with no new exponent claim. + +## What is composed + +The predecessor mechanism replaces public helper 7 (register 711) with the +existing owned copy of query source 133, scaled by −1/2, for pair `(4,57)`. +All eight actual query terms are already available at the retained B-prefix +507. The three contact frames are unchanged by coalescing: + +| Target | Coefficient | Canonical frame basis | Dimension | +| --- | ---: | --- | ---: | +| 159 | −1 | `[2,12,16,33,64,128,261]` | 7 | +| 203 | 2 | `[2,12,33,80,144,261]` | 6 | +| 148 | 2 | `[45,82,144]` | 3 | + +They form a descending chain from the actual dimension-8 query frame to the +line `[82]`. The owned path has ranks `[1,1,3,2]`. Its three additions are +performed before the remaining helpers are seeded and before the B suffix. +Exact replay checks common charts and the entire resulting scalar map, including +all 735 independent dirty inputs, all other query terms and all restoration. + +PR2219 checks the original `fanout.py` word and leaves the coalesced word open. +Its patch also retires the unused helper at ZERO. Here the helper retains its +original FULL exit chart through a **paid rank-9 ZERO→FULL transport**. This +keeps the exact ordinary-role width vector needed by the inherited owner +assignment. No freed owner capacity or unproved gather credit is assumed. + +The adapter consumes `coalesced.construct()` directly. Every retained scalar +event is identical to its source event, with its source index recorded; their +relative order is checked. It deletes 12 helper-related additions and inserts +three private contacts, retaining the old cleanup and compensation for every +other helper. Public transports are rebuilt from the actual chronological +charts. The original 339 chart assignments are never reinterpreted against a +patched event numbering. + +## Complete finite invoice + +| Rank | Coalesced public | Composed public | Composed private | Composed total | +| ---: | ---: | ---: | ---: | ---: | +| 1 | 2429 | 2427 | 2 | 2429 | +| 2 | 558 | 556 | 1 | 557 | +| 3 | 389 | 388 | 1 | 389 | +| 4 | 112 | 112 | 0 | 112 | +| 5 | 108 | 108 | 0 | 108 | +| 6 | 16 | 16 | 0 | 16 | +| 7 | 6 | 6 | 7 | 13 | +| 9 | 0 | 1 | 0 | 1 | + +The baseline private profile is eight rank-7 paths. The new word has 3625 +transport occurrences, public mass 5838 and private mass 56, eight sequential +owned copies with peak occupancy one, and 20,947 scalar additions (20,956 +before). All 31 ordinary helper roles retain their original boundary contracts. + +For `0 < τ < 1`, the profile difference is strictly favorable because +`9^τ < 2^τ + 7^τ`. One direct proof divides by `9^τ` and uses +`x^τ > x` for `x = 2/9, 7/9`. This is a comparison within the retained coverage +model; it does not admit a supplier. + +The exact interval price check uses the retained model `m=73`, `W=832/9`, +COPY mass 56 and total paid mass 6712 per call. The full ordinary-role packing +is replayed: 527 roles in each of 144 calls, 75,888 assignments, no owner-family +aliases or active-data conflicts, and residual idle mass 117,792 globally +(818 per call). Every boundary width is bound to the composed word. + +| Idle model | Baseline κ upper cap | Composed κ upper cap | Composed moment at selected κ | +| --- | ---: | ---: | ---: | +| Favorable fractional rank-51 relaxation | 0.00167357279382 | 0.00167393973105 | 0.99999585229209 | +| Actual inherited owner-window invoice | 0.00165234290426 | 0.00165270058587 | 1.00006553178737 | + +The second cap remains **1.1933% below** selected +`κ = 836330098538459/500000000000000000`. Both complete profiles exclude a +one-percent gain. These are necessary cost ceilings, not achieved exponents. +The owner packing remains conditional on inherited windows: no new global +emitter, data-phase routing, native wrapper, backward supplier, recursive +precision, reserve bound or all-size multiplication theorem is supplied. + +## Reproduce and inspect + +From the repository root, Python 3.12 and the standard library: + +```sh +python3.12 scripts/research_package.py --package research/p104-coalesced-private-reuse +# Direct replay also works without Git: +python3.12 -I -O -B research/p104-coalesced-private-reuse/verify.py +``` + +The registered command recomputes and compares [RESULT.json](RESULT.json). +It writes only temporary files; `--write-result` explicitly regenerates the +receipt. It checks all literal transports with the retained exact native +compiler and independent Gaussian interpreter, including signed Pauli action, +global phase, 208 intrinsic endpoint adapters and 4096 private-path basis +columns. Ten additional controls reject a missing contact, wrong coefficient, +retained dirty compensation, ascending private step, stale source event map, +omitted public/private charges, retired helper with stale owner widths, wrong +owner binding and changed predecessor bytes. The native checker also rejects +a corrupted global phase. This is exact finite verification, not a proof +assistant verification or independent human review. + +The complete registered replay passed on CPython 3.12.3 with assertions +disabled. CPython 3.14.4 also reproduced the receipt from a Git-free, read-only +export of ten package files and thirteen declared inputs; a write probe was +rejected and all 23 exported file hashes remained unchanged. + +[SOURCES.json](SOURCES.json) pins main at +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`, PR2152 at +`05f7aad0f08992ee48ec2dd93e896d9a4567847d`, and the credited PR2219 mechanism +at `3f913bc17276b68f0c9008a1202b6ce588e77ff6`. The small predecessor archive +contains ten actually used source/data files plus its unchanged attribution +README; its exact bytes and each member are pinned. Thirteen external live +inputs are declared for replay invalidation. Sources are checked before being +copied into temporary storage; no network, optimizer or patch application is +needed. [TASK.json](TASK.json) records the original draw, scope and validation. + +## Open next questions + +Can the composed forward word be realized by a complete native global wrapper +with these same boundary contracts? Bind the 104 retained ports and complete +helper widths to actual caller entry/exit wrappers, check their native phases +and add every charge. This matters because the checked conditional owner +assignment neither supplies those interfaces nor reaches selected κ. A +source-bound global emitter, backward orientation and precision/reserve +contract remain blockers; the structured question is in TASK.json. + +## Credit + +Prepared by Gareth Davidson / @bitplane with substantial OpenAI Codex +assistance. No subagents were used. New work is Apache-2.0. + +David Arias / DavidAriasC supplied the coalesced 735-register word, exact +replayer, complete owner packing and pricing adapter in PR2152. Cinna Davis / +1337isnot1337 supplied the helper-7 private descent reuse in PR2219; that +mechanism is not new here. `compose.py` and `price.py` adapt the former's +replay/pricing structure while composing the latter's deliveries. The retained +archive keeps David's original README and attribution unchanged. + +The lineage includes Chafik Boukhalfa's native P104 channel (PR1991), Rohan +Arun's scalar channel (PR1972) and T16 owner schedule, Adam Gall's chronological +gather work (PR1940), Josie Elliston and Ali Romman's P104 geometry/decoder +work, icekylinx's frame-sa504 work, and the selected PR1042/PR1094 lineage. +Douglas Colkitt supplied the exact ceiling engine. The native compiler and +interpreter remain unchanged in the repository with their +[PR1862 notice](../p104-native-channel/notices/PR1862-NOTICE.md) and +[frame-sa504 notice](../p104-native-channel/notices/FRAME-SA504-NOTICE.md). +The unchanged T16 source archive retains its jeremykothe2, FanPUYen and earlier +packing credits. No new numerical enclosure method is claimed. diff --git a/research/p104-coalesced-private-reuse/RESULT.json b/research/p104-coalesced-private-reuse/RESULT.json new file mode 100644 index 0000000000..f4cb528c2c --- /dev/null +++ b/research/p104-coalesced-private-reuse/RESULT.json @@ -0,0 +1,1779 @@ +{ + "composition": { + "all_retained_scalar_events_and_charts_source_bound": true, + "baseline_scalar_add_count": 20956, + "candidate_public_profile": { + "1": 2427, + "2": 556, + "3": 388, + "4": 112, + "5": 108, + "6": 16, + "7": 6, + "9": 1 + }, + "combined_profile": { + "1": 2429, + "2": 557, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 13, + "9": 1 + }, + "complete_public_widths": [ + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 5, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 5, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 5, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 5, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 7, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 9, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 9, + 7, + 7, + 8, + 9, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 7, + 7, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 4, + 8, + 4, + 4, + 4, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 8, + 8, + 8, + 5, + 8, + 5, + 5, + 5, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9 + ], + "completed_full_multiplication_supplier": false, + "endpoint_rows_sha256": "962b15ce51c619484a35104ee7aba6ef8eb0c88aa4f24ef16ebb86a6fcbb81e6", + "frame_changes_sha256": "5e3d129ec88b23173f75c3d7187c78e96676f43ef1606166f4eadf888adb7a69", + "full_735_column_identity_verified": true, + "kappa_improvement_claimed": false, + "live_ports": 104, + "ordinary_fanout_helpers": 31, + "original_fanout_operations_sha256": "f1e9679ac6aa62639ae320a6392fdc4c4b05bc79814a378ba1e8c2a00535ec1c", + "peak_private_copies": 1, + "private_COPY_profile": { + "1": 2, + "2": 1, + "3": 1, + "7": 7 + }, + "private_copies_created": 8, + "private_path_ranks": [ + [ + 7 + ], + [ + 7 + ], + [ + 7 + ], + [ + 1, + 1, + 3, + 2 + ], + [ + 7 + ], + [ + 7 + ], + [ + 7 + ], + [ + 7 + ] + ], + "private_rank_mass": 56, + "public_boundary_frames_unchanged": true, + "public_rank_mass": 5838, + "public_registers": 735, + "removed_source_events": [ + 90, + 254, + 328, + 450, + 513, + 682, + 828, + 13536, + 13702, + 13721, + 13723, + 17422 + ], + "replacements": [ + { + "coefficient": "-1", + "frame": [ + 2, + 12, + 16, + 33, + 64, + 128, + 261 + ], + "source_event": 13723, + "target": 159 + }, + { + "coefficient": "2", + "frame": [ + 2, + 12, + 33, + 80, + 144, + 261 + ], + "source_event": 13721, + "target": 203 + }, + { + "coefficient": "2", + "frame": [ + 45, + 82, + 144 + ], + "source_event": 13702, + "target": 148 + } + ], + "scalar_add_count": 20947, + "scalar_adds_by_phase": { + "A": 2980, + "B query prefix": 506, + "B suffix": 1284, + "entry compensation": 825, + "fanout contact": 86, + "fanout helper seed": 30, + "ghost restoration": 911, + "helper restoration": 30, + "old cleanup": 6574, + "old compensation": 7208, + "precondition": 136, + "private query replaces helper contact": 3, + "response cleanup": 276, + "tail": 98 + }, + "scalar_operation_word_sha256": "85c52f1742a22e3be23080f0667e97313fc2e1e793d903573e2afadde41d2a83", + "scalar_origin_map_sha256": "053d0a1ed0cab12ffe493834ac74a58f71eee378c9177e4aa761798bcc3c36b0", + "schema": "p104-coalesced-private-reuse-v1", + "source_scalar_operations_sha256": "65e580cd0f76d6ce123f470c2b9703520f34449eaac4efca4c447767bb867e82", + "transport_occurrences_sha256": "54823606ed0adc2985321d654d186f5ba660ca0f8e1374cd601ba558699aafa4", + "unused_helper_boundary_transport": [ + { + "occurrence": 3624, + "phase": "final public boundary", + "private": false, + "rank": 9, + "register": 711, + "source_frame": [], + "target_frame": [ + 1, + 2, + 4, + 8, + 16, + 32, + 64, + 128, + 256 + ] + } + ] + }, + "conditional_hosting": { + "active_data_aliases": 0, + "actual_ordinary_registers": [ + 224, + 225, + 226, + 227, + 228, + 229, + 230, + 231, + 232, + 233, + 234, + 235, + 236, + 237, + 238, + 239, + 240, + 241, + 242, + 243, + 244, + 245, + 246, + 247, + 248, + 249, + 250, + 251, + 252, + 253, + 254, + 255, + 256, + 257, + 258, + 259, + 260, + 261, + 262, + 263, + 264, + 265, + 266, + 267, + 268, + 269, + 270, + 271, + 272, + 273, + 274, + 275, + 276, + 277, + 278, + 279, + 280, + 281, + 282, + 283, + 284, + 285, + 286, + 287, + 288, + 289, + 290, + 291, + 292, + 293, + 294, + 295, + 296, + 297, + 298, + 299, + 300, + 301, + 302, + 303, + 304, + 305, + 306, + 307, + 308, + 309, + 310, + 311, + 312, + 313, + 314, + 315, + 316, + 317, + 318, + 319, + 320, + 321, + 322, + 323, + 324, + 325, + 326, + 327, + 328, + 329, + 330, + 331, + 332, + 333, + 334, + 335, + 336, + 337, + 338, + 339, + 340, + 341, + 342, + 343, + 344, + 345, + 346, + 347, + 348, + 349, + 350, + 351, + 352, + 353, + 354, + 355, + 356, + 357, + 358, + 359, + 360, + 361, + 362, + 363, + 364, + 365, + 366, + 367, + 368, + 369, + 370, + 371, + 372, + 373, + 374, + 375, + 376, + 377, + 378, + 379, + 380, + 381, + 382, + 383, + 384, + 385, + 386, + 387, + 388, + 389, + 390, + 391, + 392, + 393, + 394, + 395, + 396, + 397, + 398, + 399, + 400, + 401, + 402, + 403, + 404, + 405, + 406, + 407, + 408, + 409, + 410, + 411, + 412, + 413, + 414, + 415, + 416, + 417, + 418, + 419, + 420, + 421, + 422, + 423, + 424, + 425, + 426, + 427, + 428, + 429, + 430, + 431, + 432, + 433, + 434, + 435, + 436, + 437, + 438, + 439, + 440, + 441, + 442, + 443, + 444, + 445, + 446, + 447, + 448, + 449, + 450, + 451, + 452, + 453, + 454, + 455, + 456, + 457, + 458, + 459, + 460, + 461, + 462, + 463, + 464, + 465, + 466, + 467, + 468, + 469, + 470, + 471, + 472, + 473, + 474, + 475, + 476, + 477, + 478, + 479, + 480, + 481, + 482, + 483, + 484, + 485, + 486, + 487, + 488, + 489, + 490, + 491, + 492, + 493, + 494, + 495, + 496, + 497, + 498, + 499, + 500, + 501, + 502, + 503, + 504, + 505, + 506, + 507, + 508, + 509, + 510, + 511, + 512, + 513, + 514, + 515, + 516, + 517, + 518, + 519, + 520, + 521, + 522, + 523, + 524, + 525, + 526, + 527, + 528, + 529, + 530, + 531, + 532, + 533, + 534, + 535, + 536, + 537, + 538, + 539, + 540, + 541, + 542, + 543, + 544, + 545, + 546, + 547, + 548, + 549, + 550, + 551, + 552, + 553, + 554, + 555, + 556, + 557, + 558, + 559, + 560, + 561, + 562, + 563, + 564, + 565, + 566, + 567, + 568, + 569, + 570, + 571, + 572, + 573, + 574, + 575, + 576, + 577, + 578, + 579, + 580, + 581, + 582, + 583, + 584, + 585, + 586, + 587, + 588, + 589, + 590, + 591, + 592, + 593, + 594, + 595, + 596, + 597, + 598, + 599, + 600, + 601, + 602, + 603, + 604, + 605, + 606, + 607, + 608, + 609, + 610, + 611, + 612, + 613, + 614, + 615, + 616, + 617, + 618, + 619, + 620, + 621, + 622, + 623, + 624, + 625, + 626, + 627, + 628, + 629, + 630, + 631, + 632, + 633, + 634, + 635, + 636, + 637, + 638, + 639, + 640, + 641, + 642, + 643, + 644, + 645, + 646, + 647, + 648, + 649, + 650, + 651, + 652, + 653, + 654, + 655, + 656, + 657, + 658, + 659, + 660, + 661, + 662, + 663, + 664, + 665, + 666, + 667, + 668, + 669, + 670, + 671, + 672, + 673, + 674, + 675, + 676, + 677, + 678, + 679, + 680, + 681, + 682, + 683, + 684, + 685, + 686, + 687, + 688, + 689, + 690, + 691, + 692, + 693, + 694, + 695, + 696, + 697, + 698, + 699, + 700, + 701, + 702, + 703, + 3, + 14, + 21, + 34, + 39, + 61, + 76, + 93, + 115, + 126, + 133, + 146, + 151, + 173, + 188, + 205, + 704, + 705, + 706, + 707, + 708, + 709, + 710, + 711, + 712, + 713, + 714, + 715, + 716, + 717, + 718, + 719, + 720, + 721, + 722, + 723, + 724, + 725, + 726, + 727, + 728, + 729, + 730, + 731, + 732, + 733, + 734 + ], + "actual_ordinary_widths_sha256": "2bcbd8d810246b0207042b7daac61ea07810e2033188944d3434f3f9d0e399f7", + "all_complete_role_widths_checked": true, + "assigned_roles": 75888, + "assignment_sha256": "660d86bd36395690c2e0f37084c1bf15ce8277cb354dec5b1589c681bf3ffb77", + "complete_public_widths_sha256": "b41de26152fba11ec19535c5d4733b8d7269ee535f46904b8f54acda375167d6", + "existing_helper_width_increase": 21, + "global_emitter_admitted": false, + "idle_rank_mass": 117792, + "inherited_template_member_sha256": "0c2aab7dc120f5882a0171496cbbe819cac81373dcb425802a15f45e36898a46", + "live_data_boundaries_unchanged": true, + "new_kappa_gain_certified": false, + "new_native_wrappers_verified": false, + "optimal_packing_claimed": false, + "ordinary_helpers": 527, + "per_call_idle_rank_mass": "818", + "per_call_owner_family_aliases": 0, + "remaining_idle_profile": { + "1": 2094, + "12": 13, + "13": 3, + "14": 5, + "15": 5, + "16": 1, + "2": 408, + "23": 1, + "24": 2, + "3": 1833, + "31": 3, + "32": 2, + "39": 8, + "4": 420, + "40": 15, + "43": 1, + "48": 2187, + "5": 1, + "7": 169 + }, + "removed_family_labels_used": 0, + "retained_live_families": 13312, + "retained_old_placements": 62016, + "schema": "p104-conditional-owner-window-packing-v1", + "scope": "Concrete complete-role packing in inherited selected windows on retained P104 DATA families. New global emitter, phase routing, native wrappers, backward interface and recursive admission are not supplied.", + "sources": [ + { + "path": "research/complex-t16-rare-pattern-exchanges/data/PLAN.json", + "sha256": "7bd786ba8e66408f02aa9ef446eaf20c1bfe981ea2e4dd1e5a929f0aa7767bc0" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/OWNERS.json.gz", + "sha256": "87902c528dfab7d503dcf8a784260e3ab6fb7424c418a1820f7261f25be7b6bc" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz", + "sha256": "d4acf04daef85d4514f80ec5fcd2492d0c60e5d6c49fa71b3e6523f8db2dea86" + } + ], + "total_calls": 144, + "whole_call_window_membership_roles": 75888, + "within_bin_overlaps": 0 + }, + "native": { + "distinct_transport_recipes": 2942, + "every_recipe_signed_pauli_action_and_global_phase_checked": true, + "intrinsic_monomial_endpoint_adapters": 208, + "literal_transport_occurrences": 3625, + "native_rank_mass": 5894, + "paid_profile": { + "1": 2429, + "2": 557, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 13, + "9": 1 + }, + "private_path_gaussian_columns": 4096, + "private_paths": 8, + "recipe_payload_sha256": "af98d5044597101378c7f139b2ecbed22a1411489038169d5f6e6fcfed6aac00", + "scope": "Finite forward operators for the supplied literal scalar/frame witness; its endpoint identity is checked separately. No backward supplier, hosting, precision, or kappa claim.", + "status": "PASS_FINITE_NATIVE_LOWERING", + "wrong_global_phase_control_rejected": true + }, + "negative_controls": { + "ascending_private_contact": "nonmonotone composed transport", + "changed_predecessor_bytes": "source hash: predecessor2152.tar.gz", + "missing_reused_contact": "full 735-column endpoint identity failed", + "omit_private_copy_charge": "private invoice occurrence binding", + "omit_unused_helper_boundary_charge": "complete public mass binding", + "retain_dirty_compensation": "full 735-column endpoint identity failed", + "retire_helper_without_repricing_owner_widths": "whole helper lifetimes", + "stale_coalesced_event_binding": "coalesced source event binding", + "stale_owner_width_binding": "owner invoice width binding", + "wrong_contact_coefficient": "full 735-column endpoint identity failed" + }, + "pricing": { + "combined_profile_delta": { + "2": -1, + "7": -1, + "9": 1 + }, + "global_emitter_admitted": false, + "global_idle_mass": 117792, + "global_remaining_idle_profile": { + "1": 2094, + "12": 13, + "13": 3, + "14": 5, + "15": 5, + "16": 1, + "2": 408, + "23": 1, + "24": 2, + "3": 1833, + "31": 3, + "32": 2, + "39": 8, + "4": 420, + "40": 15, + "43": 1, + "48": 2187, + "5": 1, + "7": 169 + }, + "hypothetical_extra_gather_credit_used": false, + "new_kappa_gain_certified": false, + "one_percent_target_kappa": "84469339952384359/50000000000000000000", + "owner_assignment_sha256": "660d86bd36395690c2e0f37084c1bf15ce8277cb354dec5b1589c681bf3ffb77", + "owner_widths_sha256": "2bcbd8d810246b0207042b7daac61ea07810e2033188944d3434f3f9d0e399f7", + "priced_scalar_operations_sha256": "85c52f1742a22e3be23080f0667e97313fc2e1e793d903573e2afadde41d2a83", + "priced_transport_occurrences_sha256": "54823606ed0adc2985321d654d186f5ba660ca0f8e1374cd601ba558699aafa4", + "scenarios": [ + { + "baseline": { + "complete_paid_mass": "6712", + "complex_saving_root_interval": { + "lower": "419094583747/250000000000000", + "lower_decimal": "0.001676378334988", + "upper": "1676378334989/1000000000000000", + "upper_decimal": "0.001676378334989" + }, + "fixed_bit_capped_kappa_upper_bound": "1676378334989/1001676378334989", + "idle_invoice": "fractional_rank51_relaxation", + "idle_mass": "818", + "kappa_upper_bound_decimal": "0.00167357279381542081585612", + "local_mass": 5894, + "local_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 14 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "818", + "local_mass": "5894", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115798026594401014907520249716817218074026211706487942217650300074941273861313/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00005127601655628524660", + "upper": "115798026594401014907520249716817218074026211706487942217650300074941273861353/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00005127601655628524660" + }, + "moment_at_selected_kappa": { + "lower": "57895873309932484004509113347261903061690519446446419112848673042832486504953/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "0.999997041097941283197909", + "upper": "115791746619864968009018226694523806123381038892892838225697346085664973009947/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "0.999997041097941283197909" + }, + "name": "coalesced_baseline", + "one_percent_target_excluded": true, + "relative_gain_upper_percent_decimal": "0.0545596015315984530369420", + "selected_kappa_excluded": false + }, + "composed": { + "complete_paid_mass": "6712", + "complex_saving_root_interval": { + "lower": "838373251819/500000000000000", + "lower_decimal": "0.001676746503638", + "upper": "1676746503639/1000000000000000", + "upper_decimal": "0.001676746503639" + }, + "fixed_bit_capped_kappa_upper_bound": "1676746503639/1001676746503639", + "idle_invoice": "fractional_rank51_relaxation", + "idle_mass": "818", + "kappa_upper_bound_decimal": "0.00167393973104766342234213", + "local_mass": 5894, + "local_profile": { + "1": 2429, + "2": 557, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 13, + "9": 1 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "818", + "local_mass": "5894", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "28949471888778650775970089095170833327653233983714441028871285603991269413739/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00005007524984305285771", + "upper": "28949471888778650775970089095170833327653233983714441028871285603991269413749/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "upper_decimal": "1.00005007524984305285771" + }, + "moment_at_selected_kappa": { + "lower": "57895804482775949014417281183091859417994854881979828896680978738548006854143/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "lower_decimal": "0.999995852292091275108822", + "upper": "57895804482775949014417281183091859417994854881979828896680978738548006854163/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "0.999995852292091275108822" + }, + "name": "boundary_preserving_private_reuse", + "one_percent_target_excluded": true, + "relative_gain_upper_percent_decimal": "0.0764969461807897866217970", + "selected_kappa_excluded": false + }, + "strict_improvement_certified": true + }, + { + "baseline": { + "complete_paid_mass": "6712", + "complex_saving_root_interval": { + "lower": "1655077660087/1000000000000000", + "lower_decimal": "0.001655077660087", + "upper": "206884707511/125000000000000", + "upper_decimal": "0.001655077660088" + }, + "fixed_bit_capped_kappa_upper_bound": "206884707511/125206884707511", + "idle_invoice": "conditional_selected_window", + "idle_mass": "818", + "kappa_upper_bound_decimal": "0.00165234290426035376348678", + "local_mass": 5894, + "local_profile": { + "1": 2429, + "2": 558, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 14 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "0", + "local_mass": "6712", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "115806175970668244112225686102154714207580210146774622734802577933379997176669/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00012165540361896304604", + "upper": "57903087985334122056112843051077357103790105073387311367401288966689998588355/57896044618658097711785492504343953926634992332820282019728792003956564819968", + "upper_decimal": "1.00012165540361896304604" + }, + "moment_at_selected_kappa": { + "lower": "28949953738550108612664161769179381210926055752005100353634954731463147100131/28948022309329048855892746252171976963317496166410141009864396001978282409984", + "lower_decimal": "1.00006672059322122731326", + "upper": "115799814954200434450656647076717524843704223008020401414539818925852588400565/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00006672059322122731326" + }, + "name": "coalesced_baseline", + "one_percent_target_excluded": true, + "relative_gain_upper_percent_decimal": "-1.21466947393559201476336", + "selected_kappa_excluded": true + }, + "composed": { + "complete_paid_mass": "6712", + "complex_saving_root_interval": { + "lower": "165543652679/100000000000000", + "lower_decimal": "0.00165543652679", + "upper": "1655436526791/1000000000000000", + "upper_decimal": "0.001655436526791" + }, + "fixed_bit_capped_kappa_upper_bound": "1655436526791/1001655436526791", + "idle_invoice": "conditional_selected_window", + "idle_mass": "818", + "kappa_upper_bound_decimal": "0.00165270058587329645926987", + "local_mass": 5894, + "local_profile": { + "1": 2429, + "2": 557, + "3": 389, + "4": 112, + "5": 108, + "6": 16, + "7": 13, + "9": 1 + }, + "model": { + "R": "51", + "deficit": "328/9", + "idle_mass": "0", + "local_mass": "6712", + "total_mass": "6712", + "w": "832/9" + }, + "moment_at_one_percent_target": { + "lower": "14475754616422729038573224095752603680520866796893055579079677534300475121289/14474011154664524427946373126085988481658748083205070504932198000989141204992", + "lower_decimal": "1.00012045463690573065715", + "upper": "115806036931381832308585792766020829444166934375144444632637420274403800970353/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "upper_decimal": "1.00012045463690573065715" + }, + "moment_at_selected_kappa": { + "lower": "115799677299887364470472982748377437556312893879087220982204430317283629098903/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "lower_decimal": "1.00006553178737121922417", + "upper": "1809369957810740069851140355443397461817388966860737827846944223707556704671/1809251394333065553493296640760748560207343510400633813116524750123642650624", + "upper_decimal": "1.00006553178737121922417" + }, + "name": "boundary_preserving_private_reuse", + "one_percent_target_excluded": true, + "relative_gain_upper_percent_decimal": "-1.19328547654223217026075", + "selected_kappa_excluded": true + }, + "strict_improvement_certified": true + } + ], + "selected_kappa": "836330098538459/500000000000000000", + "source_scalar_operations_sha256": "65e580cd0f76d6ce123f470c2b9703520f34449eaac4efca4c447767bb867e82", + "status": "PASS_STRICT_FINITE_PROFILE_IMPROVEMENT_WITH_HOSTED_THRESHOLD_REJECTION" + }, + "scope": "Finite forward word and complete conditional invoice; no global/backward/precision/all-size supplier or new exponent.", + "source_archive_sha256": "67867369c99212184c13d75369811ea928c89dca0e004287a9dcf0b2c93bcdb8", + "status": "PASS_FINITE_COALESCED_PRIVATE_REUSE" +} diff --git a/research/p104-coalesced-private-reuse/SOURCES.json b/research/p104-coalesced-private-reuse/SOURCES.json new file mode 100644 index 0000000000..58f245e194 --- /dev/null +++ b/research/p104-coalesced-private-reuse/SOURCES.json @@ -0,0 +1,182 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "1dce1b16a687a5d1a507ef64b9d4da19dd9e43f9", + "sha256": "5378ffbf3a119fcd0c23bcce20f34e5dd2fa792a00a0033e47667aeba72bbc37" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94", + "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8" + }, + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/complex-block-rank-optimum/inputs/selected.json.gz", + "usage": "input", + "git_blob": "5f9ef680983b0b63a4c82a4ed909837b78e690cd", + "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "usage": "input", + "git_blob": "af013ccc2975d9d575d116f8a463cc947f220c8d", + "sha256": "8cb51f25a5da4a29d3783853025b73ff1f452429d4fdb30c599e598bcab0e71d" + }, + { + "path": "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "usage": "input", + "git_blob": "9efe30ee107b9c67f15f1c726e1a1cb5cef03929", + "sha256": "327d2a868043e846381aa58a33053c24425e8cad522ff401b10ec8af1d649a3f" + }, + { + "path": "research/p104-native-channel/inputs/P104-FIXTURE.json", + "usage": "input", + "git_blob": "2e16f99b295bb386fd13bd8fbd57b42ef54143a9", + "sha256": "516c06f6ec3cb84be588c546108de897650288576dd5fbf5fe44b9c5546ad8a4" + }, + { + "path": "research/p104-native-channel/vendor/clifford_exact.py", + "usage": "input", + "git_blob": "166841a037f069249f6f7f6dedb89248812f59e2", + "sha256": "2982ead07721e83358dc67c6f49c2b4c16a236a6bebdfd72f58221be1f5d0962" + }, + { + "path": "research/p104-native-channel/vendor/native_verify.py", + "usage": "input", + "git_blob": "2c209dfa9cfade3bc20ac5fc9d876b433a147f8c", + "sha256": "3049471905b47b385c88378a1a3be7a18b8858aadd035b8a6da2f4a03b470f38" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/PLAN.json", + "usage": "input", + "git_blob": "f1bec76e8e9b7a1f09c1e05cb6cce973b6e59f1b", + "sha256": "7bd786ba8e66408f02aa9ef446eaf20c1bfe981ea2e4dd1e5a929f0aa7767bc0" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/data/OWNERS.json.gz", + "usage": "input", + "git_blob": "d3ba33d7e703a3229d9fb8a360f69d2f318bbb70", + "sha256": "87902c528dfab7d503dcf8a784260e3ab6fb7424c418a1820f7261f25be7b6bc" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz", + "usage": "input", + "git_blob": "2970ef79b0441e937449bed30f68f2e0558186ba", + "sha256": "d4acf04daef85d4514f80ec5fcd2492d0c60e5d6c49fa71b3e6523f8db2dea86" + } + ], + "archives": [ + { + "path": "predecessor2152.tar.gz", + "sha256": "67867369c99212184c13d75369811ea928c89dca0e004287a9dcf0b2c93bcdb8", + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/2152", + "head": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "author": "David Arias / DavidAriasC", + "members": [ + { + "path": "research/p104-interleaved-search/COALESCED-FRAMES.json", + "sha256": "5e3d129ec88b23173f75c3d7187c78e96676f43ef1606166f4eadf888adb7a69", + "git_blob": "38e2192420b443fe11b84a006a0cda78d16c46e1" + }, + { + "path": "research/p104-interleaved-search/FANOUT-PLANS.json", + "sha256": "0c2ae264694bbe7c15b9261ba8adf68c9552849effd423894713c68ad23d28ca", + "git_blob": "f067d9e3adb425110e55c32ce10154b12d712795" + }, + { + "path": "research/p104-interleaved-search/README.md", + "sha256": "bc9e22413f8f4c40e2518fbaf6f9e5c1c3e90aca3867f8b8d3ce21a6db124584", + "git_blob": "8aedc8adaf46f37059164442bedf801f3a0991d9" + }, + { + "path": "research/p104-interleaved-search/budget.py", + "sha256": "1dc401c214ca51881e27e16766e33e7dc635f429900a5a5b2435c6872b38e7f4", + "git_blob": "35cd097202ff93525e4166e681be5465c1b9bae7" + }, + { + "path": "research/p104-interleaved-search/coalesced.py", + "sha256": "e1ab23333ba098bd2ccafd8c9a8c0c79e9126706b37d030f40a4400eaa6a0415", + "git_blob": "b89b17164c6a9d3a73c6fc311224ddc769d71096" + }, + { + "path": "research/p104-interleaved-search/delivery.py", + "sha256": "49f131e9b8a48ccbf5374f475857b8e19ce105ee931bab70f19e3be6983c4ffd", + "git_blob": "7314413eb792a47c2a948df8234682f63260a177" + }, + { + "path": "research/p104-interleaved-search/fanout.py", + "sha256": "a6828977971a4c8eb555e06de61646b863c5f025bbe1e0a7b941879dcd5e749b", + "git_blob": "66472a83f371d70d44fcb9d7d41b53ea2382386c" + }, + { + "path": "research/p104-interleaved-search/hosting.py", + "sha256": "0ea35ecf6b4f98bc87b568a7c2e1dbcedb106a1768e9ad46e65a30216e95de5f", + "git_blob": "6bf061557519c78d2d05634016f6f1e3170267c1" + }, + { + "path": "research/p104-interleaved-search/native_checks.py", + "sha256": "3353e4011e2bc05a33cdfb098ff05d8fa8b92b7daecf5015eda41c18c1d10bdd", + "git_blob": "9be088b882a9c64b4ca045dbc27ddfc226665003" + }, + { + "path": "research/p104-interleaved-search/query_construction.py", + "sha256": "d2318ea05d0033da36a430ccf62dac825dd0ecd7d13730a412795ea3cf3dfe78", + "git_blob": "fd00e90b5a31ea6cbc67785e703c0ae69054c8ed" + }, + { + "path": "research/p104-interleaved-search/scalar_surgery.py", + "sha256": "ffba4481cc02ba6183970adec229c4a884263ef418393e4ded25a01bdfd3d8f6", + "git_blob": "e9309ffedfb5d559049fca819f8c27c8ef58025c" + } + ] + } + ], + "mechanism_source": { + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/2219", + "head": "3f913bc17276b68f0c9008a1202b6ce588e77ff6", + "author": "Cinna Davis / 1337isnot1337", + "patch_path": "research/p104-private-descent-reuse-seed915fa969/fanout-helper-reuse.patch", + "patch_sha256": "6eb26b8cb17c5b58d8a69f4c782fd3a822faf945ced2f1ceb7ba33884b562d8a", + "usage": "Credited algorithm and scope evidence; patch is not applied. The adapter transforms the actual coalesced event list." + } +} diff --git a/research/p104-coalesced-private-reuse/TASK.json b/research/p104-coalesced-private-reuse/TASK.json new file mode 100644 index 0000000000..7f0712c64b --- /dev/null +++ b/research/p104-coalesced-private-reuse/TASK.json @@ -0,0 +1,175 @@ +{ + "schema_version": 1, + "task_id": "p104-side-correction", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "p104-side-correction", + "question": "Can the native P104 low-rank channel be completed with a legal, fully charged I-G/2 side correction?", + "starting_points": [ + "research/p104-native-channel/README.md", + "research/p104-native-channel/PROOF.md", + "docs/research/community-efficient1000-review.md" + ], + "methods": [ + "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "Derive a lower bound on the side correction and hosting costs that decides whether this channel can beat the selected budget." + ], + "acceptance_gate": "An exact arbitrary-input identity, source/target frame availability and restoration at the chosen cut, plus the complete channel+correction+idle/hosting bill or an explicit favorable bound. The native channel alone is not a supplier.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read the P104 open next questions and its fixed local histogram; inspect why appending I-G/2 after source completion is not justified. #1991 supplies the checked native channel, not the missing correction.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one exact side-correction cut and bound its allowed cost from a favorable completed moment at a declared target. Stop or hand off if the necessary source/target access cannot be justified or even the optimistic total misses the target.", + "bottleneck_link": "Completing an already realized changed channel tests a concrete construction opportunity, instead of refining the incumbent packing. A positive local result still needs global and all-size admission.", + "allowed_variations": [ + "One correction factorization, one chronological cut, or one explicit hosting obstruction.", + "A changed correction schedule with an updated full bill and native frame contract." + ], + "scope_change_triggers": [ + "Recompiling the already certified low-rank channel without closing a new obligation.", + "Treating a pending ancestor, local histogram or unpriced side correction as an admitted global supplier." + ], + "overlap_terms": [ + "P104", + "I-G/2", + "side correction", + "native channel", + "1972", + "1991" + ] + }, + "scope_status": "refined", + "actual_scope": "Compose PR2219 helper7 private descent reuse with PR2152 coalesced frames while preserving all public boundary widths, then check the complete finite forward word and bill.", + "scope_change_reason": "PR2219 explicitly leaves this coalesced composition untested. Preserve event correspondence and pay a rank9 boundary transport to retain the existing owner width contract; credit the predecessor mechanism.", + "bottleneck_link": "Closes one chronological/native composition gap in the P104 side correction and lowers its complete fixed-profile moment; the inherited owner invoice still needs pricing and full supplier admission is separate.", + "budget_minutes": 60, + "stop_rule": "Complete source-bound finite identity, native lowering and full invoice or report the first exact compatibility/cost obstruction; do not claim a selected exponent or full supplier.", + "outcome": "completed", + "evidence": "Complete 735-column identity with all original boundaries, strict moment improvement +H9-H2-H7, 3625 native transports and 2942 recipes, 208 adapters, 4096 Gaussian private columns, 75888 conditional owner assignments, ten semantic/source controls and a wrong-phase rejection. Actual owner invoice still excludes selected kappa.", + "author": "Gareth Davidson", + "ai_assistance": "Substantial OpenAI Codex assistance for source review, implementation, arithmetic, verification and documentation. No subagents or independent human review.", + "selection": { + "seed": "d056d28a58d433ac98079b87a3d295ec", + "track": "complex-mechanisms", + "scope_key": "c5367b1a1b7bed20db53", + "draw_method": "Construct one side-correction word at an explicit chronological cut with the needed frames still available.", + "rerolled": false + }, + "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2299", + "first_step": { + "command": "python3.12 -B scripts/research_baseline.py", + "result": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "scope": "Orientation only; selected full cold replay not rerun." + }, + "open_questions": [ + { + "question": "Can the composed forward word be realized by a complete native global wrapper with its current boundary contract?", + "why_it_matters": "The inherited owner-window invoice is conditional and does not establish global phase/data routing, backward orientation or recursive precision.", + "first_step": "Bind the 104 retained ports and the complete helper widths to actual caller entry/exit wrappers, then replay their native phases and add every charge.", + "blocked_by": "A source-bound global emitter and backward/precision interface; the checked owner invoice is insufficient to reach selected kappa." + } + ], + "validation": { + "checked_at_utc": "2026-10-15T04:25:13.201940+00:00", + "python": "3.12.3", + "receipt_sha256": "d57bfe213af8447f32eb3c01f228189329cb6b59095127fa6f04cf3f424041b8", + "full_735_column_replay": true, + "native_transport_occurrences": 3625, + "native_recipes": 2942, + "native_adapters": 208, + "private_gaussian_columns": 4096, + "semantic_source_controls": 10, + "wrong_global_phase_rejected": true, + "conditional_owner_assignments": 75888, + "unrun": [ + "new global emitter/native wrappers", + "backward supplier", + "recursive precision/reserves", + "selected full cold replay", + "full multiplication theorem", + "independent human review" + ], + "registered_python": "3.12.3", + "registered_replay": "PASS_REGISTERED_RESEARCH_PACKAGE", + "source_export": { + "python": "Python 3.14.4", + "git_free": true, + "readonly_write_rejected": true, + "package_files": 10, + "declared_inputs": 13, + "files": 23, + "hashes_unchanged": true, + "command": "python3.14 -I -O -B research/p104-coalesced-private-reuse/verify.py" + } + }, + "first_screen": { + "predicted_complete_profile_delta": { + "2": -1, + "7": -1, + "9": 1 + }, + "scope": "Same public boundary and total local mass. All remaining paid mass granted fractional rank51 idle children only for the initial screen.", + "outcome": "Passed before native lowering and complete owner pricing; exact constructed delta subsequently matched.", + "baseline_selected_moment_upper_decimal": "0.999997041097941283197909", + "candidate_selected_moment_upper_decimal": "0.999995852292091275108822" + }, + "overlap_review": [ + { + "pr": 2152, + "head": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "coverage": "Original complete fanout/coalesced word and inherited conditional owner invoice. Its helper lifetimes remain an explicit open question." + }, + { + "pr": 2219, + "head": "3f913bc17276b68f0c9008a1202b6ce588e77ff6", + "coverage": "Credited helper7 private reuse tested only on original fanout.py. README explicitly leaves coalesced.py untested; retired helper boundary differs from this package." + }, + { + "prs": [ + 2139, + 2173, + 2251 + ], + "coverage": "Distinct 836-register delayed-query word and already-settled shared96 P104 problem, not reopened." + }, + { + "discussions": [ + 2218, + 2131, + 2164 + ], + "coverage": "Different delayed-echo budget screen, dirty carrier architecture and cut obstruction; not the coalesced private-reuse composition." + } + ], + "freshness": { + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "predecessor_heads": { + "2152": "05f7aad0f08992ee48ec2dd93e896d9a4567847d", + "2219": "3f913bc17276b68f0c9008a1202b6ce588e77ff6" + }, + "overlap_searched_at": "2026-10-15T04:27:07.408291+00:00", + "overlap_coverage": { + "open_prs": { + "fetched_at": "2026-10-15T04:25:36.700220+00:00", + "complete_pagination": true, + "records": 521 + }, + "discussions": { + "fetched_at": "2026-10-15T04:27:07.297563+00:00", + "complete_pagination": true, + "records": 1016 + } + }, + "warnings": [], + "decision": "Canonical main and both source heads unchanged. Eighteen targeted matches inspected, including our own claim/package; no additional specific coalesced private-reuse composition found. Prior frozen-path cuts and paired-plane identity work have different hypotheses." + } +} diff --git a/research/p104-coalesced-private-reuse/VERIFY.json b/research/p104-coalesced-private-reuse/VERIFY.json new file mode 100644 index 0000000000..ea8139bd69 --- /dev/null +++ b/research/p104-coalesced-private-reuse/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/complex-block-rank-optimum/inputs/selected.json.gz", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-t16-rare-pattern-exchanges/data/OWNERS.json.gz", + "research/complex-t16-rare-pattern-exchanges/data/PLAN.json", + "research/complex-t16-rare-pattern-exchanges/data/SPEC.json", + "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz", + "research/frame-sa504/inputs/hamming/PROTOTYPE.json", + "research/p104-native-channel/inputs/P104-FIXTURE.json", + "research/p104-native-channel/vendor/clifford_exact.py", + "research/p104-native-channel/vendor/native_verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 600, + "checks": "Exact source/event binding; full 735-column identity, chronological common frames, literal native phases and 4096 Gaussian private columns; complete local and conditional owner invoice; semantic failure controls." + } + ] +} diff --git a/research/p104-coalesced-private-reuse/compose.py b/research/p104-coalesced-private-reuse/compose.py new file mode 100644 index 0000000000..402e0ff402 --- /dev/null +++ b/research/p104-coalesced-private-reuse/compose.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Compose credited private descent reuse with the actual coalesced scalar word. + +The exact replayer follows David Arias's PR2152 coalesced.py. The helper-7 +reuse mechanism is Cinna Davis's PR2219. This adapter consumes the already +coalesced events, keeps their explicit source indices, and retains every public +boundary by charging the now-unused helper's ZERO -> FULL rank-nine transport. +""" +from collections import Counter +from fractions import Fraction as Q + +HELPER, OWNED, SOURCE = 711, 738, 133 +TARGETS = (159, 203, 148) + + +def construct(C, baseline=None, fault=None): + F, D, QC, S = C.F, C.D, C.QC, C.S + require = D.require + base = C.construct() if baseline is None else baseline + original = base['scalar_operations'] + word = QC.load_inputs()['word'] + n = base['report']['public_registers'] + require(n == 735, 'expected 735 independent public inputs') + require(F.digest(original) == base['report']['scalar_operation_word_sha256'], + 'coalesced source event binding') + removed = {k: e for k, e in enumerate(original) + if HELPER in e.get('registers', [])} + require(Counter(e['phase'] for e in removed.values()) == + Counter({'entry compensation': 7, 'fanout helper seed': 1, + 'fanout contact': 3, 'helper restoration': 1}), + 'helper event inventory changed') + seed = next(e for e in removed.values() if e['phase'] == 'fanout helper seed') + require(seed['registers'] == [HELPER, OWNED] and seed['coefficient'] == '1', + 'helper seed does not use the selected owned query') + contacts = {e['registers'][0]: (k, e) for k, e in removed.items() + if e['phase'] == 'fanout contact'} + require(set(contacts) == set(TARGETS), 'three reused targets') + copy = [e for e in original if e['kind'] == 'private_copy' + and e['registers'][0] == OWNED] + scale = [e for e in original if e['kind'] == 'scale' + and e['registers'][0] == OWNED] + require(len(copy) == len(scale) == 1 and copy[0]['registers'] == [OWNED, SOURCE] + and copy[0]['coefficient'] == '1' and scale[0]['coefficient'] == '-1/2', + 'actual source133 query and scaling') + chain = [QC.span(copy[0]['frame'])] + [QC.span(contacts[r][1]['frame']) for r in TARGETS] + chain.append(QC.span(seed['frame'])) + require([D.dimension(f) for f in chain] == [8, 7, 6, 3, 1] + and all(b < a for a, b in zip(chain, chain[1:])), + 'actual coalesced contact frames do not form the required descent') + + initial = list(base['initial']) + current, rows = list(initial), QC.identity(n) + private_frames, private_rows = {}, {} + old_edges = {e['occurrence']: e for e in base['transport_edges']} + paid, copy_paid = Counter(), Counter() + edges, operations, paths, origins = [], [], [], [] + active_path = None + peak = created = replaced = 0 + retained_dirty = False + + def transport(r, target, phase, private=False): + old = private_frames[r] if private else current[r] + require(target <= old if private else old <= target, + 'nonmonotone composed transport') + rank = abs(D.dimension(target) - D.dimension(old)) + if rank: + edge = dict(occurrence=len(edges), register=r, source_frame=F.basis(old), + target_frame=F.basis(target), rank=rank, private=private, phase=phase) + edges.append(edge) + operations.append(dict(kind='transport', occurrence=edge['occurrence'], phase=phase)) + origins.append(None) + (copy_paid if private else paid)[rank] += 1 + if private: + require(active_path is not None, 'private transport outside lifetime') + active_path.append(edge) + if private: + private_frames[r] = target + else: + current[r] = target + + def scalar(e, origin): + rr, frame = e['registers'], QC.span(e['frame']) + for r in rr: + if r < n: + transport(r, frame, e['phase']) + else: + require(private_frames.get(r) == frame, 'private scalar common chart') + require(all((current[r] if r < n else private_frames[r]) == frame for r in rr), + 'scalar common chart') + coefficient = Q(e['coefficient']) + target = rows[rr[0]] if rr[0] < n else private_rows[rr[0]] + if e['kind'] == 'scale': + require(bool(coefficient), 'singular scalar scale') + scaled = {i: coefficient * x for i, x in target.items()} + if rr[0] < n: + rows[rr[0]] = scaled + else: + private_rows[rr[0]] = scaled + else: + source = rows[rr[1]] if rr[1] < n else private_rows[rr[1]] + if e['kind'] == 'private_copy': + require(rr[0] >= n and not target, 'COPY destination is not cleared') + private_rows[rr[0]] = {i: coefficient * x for i, x in source.items()} + else: + require(e['kind'] == 'add', 'unknown scalar operation') + S.add_row(target, source, coefficient) + operations.append(e) + origins.append(origin) + + for k, old_event in enumerate(original): + e = dict(old_event) + kind, phase = e['kind'], e['phase'] + if k in removed: + if fault == 'retain_dirty_compensation' and phase == 'entry compensation' and not retained_dirty: + retained_dirty = True + else: + continue + if kind == 'transport': + old = old_edges[e['occurrence']] + if not old['private']: + continue + r = old['register'] + require(private_frames.get(r) == QC.span(old['source_frame']), 'private source changed') + if r == OWNED: + replaced += 1 + for target in TARGETS: + source_index, contact = contacts[target] + frame = QC.span(contact['frame']) + if fault == 'ascending_private_contact' and target == TARGETS[0]: + frame = F.FULL + transport(r, frame, 'owned query to reused contact', True) + event = dict(kind='add', registers=[target, r], + coefficient=contact['coefficient'], frame=F.basis(frame), + phase='private query replaces helper contact') + if fault == 'wrong_contact_coefficient' and target == TARGETS[0]: + event['coefficient'] = str(Q(event['coefficient']) + 1) + if fault != 'missing_reused_contact' or target != TARGETS[0]: + scalar(event, {'replacement_for': source_index}) + transport(r, QC.span(old['target_frame']), 'owned query to La after contacts', True) + else: + transport(r, QC.span(old['target_frame']), phase, True) + continue + if kind == 'private_init': + r = e['register'] + require(r >= n and r not in private_frames and active_path is None, + 'overlapping or invalid private initialization') + private_frames[r], private_rows[r] = QC.span(e['frame']), {} + created += 1 + peak = max(peak, len(private_frames)) + active_path = [] + elif kind == 'private_discard': + r = e['register'] + require(private_frames.get(r) == QC.span(e['frame']), 'private discard frame') + paths.append(active_path) + active_path = None + del private_frames[r], private_rows[r] + elif kind in ('add', 'scale', 'private_copy'): + scalar(e, k) + continue + else: + raise ValueError('unknown source event: ' + kind) + operations.append(e) + origins.append(k) + # Unlike PR2219's retired-helper contract, retain every public boundary. + for r, target in enumerate(base['final']): + transport(r, target, 'final public boundary') + require(not private_frames and not private_rows and active_path is None, 'private state remains') + live = [i for i in range(word['v']) if i not in QC.REMOVED] + require(not S.endpoint_failures(rows, word['v'], live), 'full 735-column endpoint identity failed') + require(replaced == 1 and created == 8 and peak == 1, 'owned lifetime inventory') + require(current == base['final'], 'public boundary frames changed') + expected_private = Counter({1: 2, 2: 1, 3: 1, 7: 7}) + require(copy_paid == expected_private, 'private path invoice') + widths = [D.dimension(b) - D.dimension(a) for a, b in zip(initial, current)] + require(widths == base['report']['complete_public_widths'], 'public lifetime widths changed') + require(sum(widths) == sum(r*c for r, c in paid.items()) == 5838, 'public mass') + baseline_paid = Counter({int(k): v for k, v in base['report']['candidate_public_profile'].items()}) + expected_public = baseline_paid.copy() + expected_public.update({1: -2, 2: -2, 3: -1, 9: 1}) + require(paid == expected_public, 'unexpected extra public transport charge') + require(len(operations) == len(origins), 'source index map length') + retained = [origin for origin in origins if type(origin) is int] + wanted = [k for k, e in enumerate(original) if k not in removed and e['kind'] != 'transport'] + require(retained == wanted, 'retained coalesced scalar order changed') + for e, origin in zip(operations, origins): + if type(origin) is int: + require(e == original[origin], 'retained scalar event changed') + adds = Counter(e['phase'] for e in operations if e['kind'] == 'add') + old_adds = sum(e['kind'] == 'add' for e in original) + require(old_adds - sum(adds.values()) == 9, 'scalar ADD reduction') + endpoint = [[[i, str(x)] for i, x in sorted(row.items())] for row in rows] + report = dict(schema='p104-coalesced-private-reuse-v1', + full_735_column_identity_verified=True, + all_retained_scalar_events_and_charts_source_bound=True, + source_scalar_operations_sha256=F.digest(original), + original_fanout_operations_sha256=base['report']['source_scalar_operations_sha256'], + frame_changes_sha256=base['report']['frame_changes_sha256'], + public_boundary_frames_unchanged=True, complete_public_widths=widths, + public_registers=n, ordinary_fanout_helpers=31, live_ports=len(live), + candidate_public_profile=D.profile(paid), private_COPY_profile=D.profile(copy_paid), + combined_profile=D.profile(paid + copy_paid), public_rank_mass=5838, + private_rank_mass=sum(r*c for r, c in copy_paid.items()), + private_copies_created=created, peak_private_copies=peak, + private_path_ranks=[[e['rank'] for e in path] for path in paths], + unused_helper_boundary_transport=[e for e in edges if e['register'] == HELPER], + scalar_adds_by_phase=dict(sorted(adds.items())), scalar_add_count=sum(adds.values()), + baseline_scalar_add_count=old_adds, removed_source_events=list(removed), + replacements=[dict(source_event=contacts[r][0], target=r, + frame=contacts[r][1]['frame'], coefficient=contacts[r][1]['coefficient']) + for r in TARGETS], + scalar_origin_map_sha256=F.digest(origins), endpoint_rows_sha256=F.digest(endpoint), + scalar_operation_word_sha256=F.digest(operations), transport_occurrences_sha256=F.digest(edges), + completed_full_multiplication_supplier=False, kappa_improvement_claimed=False) + return dict(report=report, scalar_operations=operations, transport_edges=edges, + private_paths=paths, initial=initial, final=current, ports=base['ports'], origins=origins) diff --git a/research/p104-coalesced-private-reuse/predecessor2152.tar.gz b/research/p104-coalesced-private-reuse/predecessor2152.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cc1a5cb5735ee489388004c27b709a825faf59d1 GIT binary patch literal 50448 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 OfBt{5J8Xpja038f{IU)J literal 0 HcmV?d00001 diff --git a/research/p104-coalesced-private-reuse/price.py b/research/p104-coalesced-private-reuse/price.py new file mode 100644 index 0000000000..eb406fed94 --- /dev/null +++ b/research/p104-coalesced-private-reuse/price.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Price the actual composed word, retaining the predecessor's coverage model. + +Adapted from David Arias's PR2152 coalesced_budget.py. Exact interval arithmetic +is the credited retained ceiling engine, not an independent numerical method. +""" +from collections import Counter +from fractions import Fraction as Q + + +def integers(profile): + return {int(k): v for k, v in profile.items()} + + +def bind(C, built, base, hosted): + F, D = C.F, C.D + report = built['report'] + public = Counter(e['rank'] for e in built['transport_edges'] if not e['private']) + private = Counter(e['rank'] for e in built['transport_edges'] if e['private']) + D.require(public == integers(report['candidate_public_profile']), 'public invoice occurrence binding') + D.require(private == integers(report['private_COPY_profile']), 'private invoice occurrence binding') + D.require(D.profile(public + private) == report['combined_profile'], 'combined invoice binding') + D.require(sum(r*c for r, c in public.items()) == sum(report['complete_public_widths']) == 5838, + 'complete public mass binding') + D.require(sum(r*c for r, c in private.items()) == 56, 'complete private mass binding') + D.require(report['complete_public_widths'] == base['report']['complete_public_widths'] + and built['initial'] == base['initial'] and built['final'] == base['final'], + 'source boundary width contract') + D.require(F.digest(built['scalar_operations']) == report['scalar_operation_word_sha256'] + and F.digest(built['transport_edges']) == report['transport_occurrences_sha256'], + 'priced word binding') + D.require(hosted['complete_public_widths_sha256'] == F.digest(report['complete_public_widths']), + 'owner invoice width binding') + D.require(hosted['assigned_roles'] == 144 * 527 and hosted['total_calls'] == 144, + 'owner role coverage') + D.require(not hosted['global_emitter_admitted'], 'conditional owner invoice is not global admission') + return public + private + + +def verify(C, B, built, base, hosted): + profile = bind(C, built, base, hosted) + baseline = Counter(integers(base['report']['candidate_public_profile'])) + baseline.update(integers(base['report']['private_COPY_profile'])) + delta = {r: profile[r] - baseline[r] for r in set(profile) | set(baseline) + if profile[r] != baseline[r]} + B.require(delta == {2: -1, 7: -1, 9: 1}, 'complete combined profile delta') + engine, _, _, _ = B.load_inputs() + width = Q(B.FAMILIES, B.STAGES) + total = (B.M - 1) * width + B.CENTRE + B.require(total == 6712 and B.mass(profile) == B.mass(baseline) == 5894, + 'complete unchanged coverage model') + idle_global = integers(hosted['remaining_idle_profile']) + idle = {r: Q(n, 144) for r, n in idle_global.items()} + B.require(B.mass(idle) == 818 and all(0 < r <= 51 and n > 0 for r, n in idle.items()), + 'complete actual owner idle invoice') + selected_a = B.SELECTED_KAPPA / (1 - B.SELECTED_KAPPA) + target = B.SELECTED_KAPPA * Q(101, 100) + target_a = target / (1 - target) + + def scenario(name, local, actual_idle): + effective = Counter(local) + if actual_idle: + effective.update(idle) + model = engine.model(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + B.require(model['local_mass'] + model['idle_mass'] == total, 'complete paid mass') + B.require(model['idle_mass'] == (0 if actual_idle else 818), 'unpriced idle mass') + zero = engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, Q(0)) + B.require(zero[0] <= total / (B.M * width) <= zero[1], 'zero-saving coverage identity') + root = engine.ceiling(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE) + B.require(engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[0])[1] < 1 + and engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, root[1])[0] > 1, + 'root bracket is not certified') + selected = engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, selected_a) + target_moment = engine.relax(effective, B.M, B.FAMILIES, B.STAGES, B.CENTRE, target_a) + B.require(target_moment[0] > 1, 'one-percent rejection changed') + cap = min(root[1] / (1 + root[1]), B.BIT_LOWER / (1 + B.BIT_LOWER)) + return dict(name=name, + idle_invoice='conditional_selected_window' if actual_idle else 'fractional_rank51_relaxation', + local_profile=B.profile_json(local), local_mass=B.mass(local), idle_mass='818', + complete_paid_mass=str(total), model={k: str(v) for k, v in model.items()}, + complex_saving_root_interval=B.interval(root), + fixed_bit_capped_kappa_upper_bound=str(cap), kappa_upper_bound_decimal=B.decimal(cap), + relative_gain_upper_percent_decimal=B.decimal(100 * (cap / B.SELECTED_KAPPA - 1)), + moment_at_selected_kappa=B.interval(selected), selected_kappa_excluded=selected[0] > 1, + moment_at_one_percent_target=B.interval(target_moment), one_percent_target_excluded=True) + + pairs = [] + for actual_idle in (False, True): + before = scenario('coalesced_baseline', baseline, actual_idle) + after = scenario('boundary_preserving_private_reuse', profile, actual_idle) + B.require(Q(after['moment_at_selected_kappa']['upper']) < + Q(before['moment_at_selected_kappa']['lower']), 'strict moment improvement') + B.require(Q(before['complex_saving_root_interval']['upper']) < + Q(after['complex_saving_root_interval']['lower']), 'strict root improvement') + B.require(after['selected_kappa_excluded'] == actual_idle, 'screen versus actual owner outcome') + pairs.append(dict(baseline=before, composed=after, strict_improvement_certified=True)) + return dict(status='PASS_STRICT_FINITE_PROFILE_IMPROVEMENT_WITH_HOSTED_THRESHOLD_REJECTION', + selected_kappa=str(B.SELECTED_KAPPA), one_percent_target_kappa=str(target), + combined_profile_delta={str(k): v for k, v in sorted(delta.items())}, + hypothetical_extra_gather_credit_used=False, + source_scalar_operations_sha256=built['report']['source_scalar_operations_sha256'], + priced_scalar_operations_sha256=built['report']['scalar_operation_word_sha256'], + priced_transport_occurrences_sha256=built['report']['transport_occurrences_sha256'], + owner_widths_sha256=hosted['actual_ordinary_widths_sha256'], + owner_assignment_sha256=hosted['assignment_sha256'], + global_remaining_idle_profile=hosted['remaining_idle_profile'], + global_idle_mass=B.mass(idle_global), scenarios=pairs, + global_emitter_admitted=False, new_kappa_gain_certified=False) diff --git a/research/p104-coalesced-private-reuse/sources.py b/research/p104-coalesced-private-reuse/sources.py new file mode 100644 index 0000000000..0fb4312187 --- /dev/null +++ b/research/p104-coalesced-private-reuse/sources.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Load the minimal immutable predecessor closure without Git or network access.""" +from contextlib import contextmanager +import hashlib +import importlib.util +import io +import json +from pathlib import Path, PurePosixPath +import sys +import tarfile +import tempfile + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def checked_bytes(raw, expected, label): + require(hashlib.sha256(raw).hexdigest() == expected, 'source hash: ' + label) + return raw + + +def module(name, path): + spec = importlib.util.spec_from_file_location('p104_composition_' + name, path) + result = importlib.util.module_from_spec(spec) + sys.modules[spec.name] = result + spec.loader.exec_module(result) + return result + + +@contextmanager +def predecessor(): + inventory = json.loads((HERE / 'SOURCES.json').read_text()) + pin, = inventory['archives'] + raw = checked_bytes((HERE / pin['path']).read_bytes(), pin['sha256'], pin['path']) + expected = {m['path']: m for m in pin['members']} + require(len(expected) == len(pin['members']) == 11, 'predecessor member inventory') + with tempfile.TemporaryDirectory(prefix='p104-coalesced-reuse-') as temporary: + root = Path(temporary) + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:gz') as archive: + members = archive.getmembers() + require(len(members) == len(expected) and {m.name for m in members} == set(expected), + 'archive member coverage') + for member in members: + path = PurePosixPath(member.name) + require(member.isfile() and not path.is_absolute() and '..' not in path.parts, + 'unsafe archive member') + data = checked_bytes(archive.extractfile(member).read(), + expected[member.name]['sha256'], member.name) + target = root / member.name + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + for entry in inventory['files']: + if entry['usage'] != 'input': + continue + data = checked_bytes((ROOT / entry['path']).read_bytes(), entry['sha256'], entry['path']) + target = root / entry['path'] + target.parent.mkdir(parents=True, exist_ok=True) + target.write_bytes(data) + yield root / 'research/p104-interleaved-search' diff --git a/research/p104-coalesced-private-reuse/verify.py b/research/p104-coalesced-private-reuse/verify.py new file mode 100644 index 0000000000..2c9bf71dc0 --- /dev/null +++ b/research/p104-coalesced-private-reuse/verify.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Read-only exact finite replay; --write-result explicitly regenerates the receipt.""" +import argparse +from copy import deepcopy +import hashlib +import importlib.util +import json +from pathlib import Path + +HERE = Path(__file__).resolve().parent + + +def local(name): + spec = importlib.util.spec_from_file_location('p104_reuse_' + name, HERE / (name + '.py')) + result = importlib.util.module_from_spec(spec) + spec.loader.exec_module(result) + return result + + +sources, compose, price = (local(name) for name in ('sources', 'compose', 'price')) + + +def reject(action, expected): + try: + action() + except ValueError as error: + sources.require(expected in str(error), 'wrong rejection reason: ' + str(error)) + return str(error) + raise ValueError('invalid control accepted: ' + expected) + + +def verify(): + with sources.predecessor() as directory: + C = sources.module('coalesced', directory / 'coalesced.py') + base = C.construct() + built = compose.construct(C, base) + print('PASS full 735-column identity, chronology and retained event correspondence', flush=True) + hosted = sources.module('hosting', directory / 'hosting.py').verify(built['report']) + prices = price.verify(C, sources.module('budget', directory / 'budget.py'), built, base, hosted) + controls = {} + for fault, expected in ( + ('missing_reused_contact', 'full 735-column endpoint identity failed'), + ('wrong_contact_coefficient', 'full 735-column endpoint identity failed'), + ('retain_dirty_compensation', 'full 735-column endpoint identity failed'), + ('ascending_private_contact', 'nonmonotone composed transport'), + ): + controls[fault] = reject(lambda fault=fault: compose.construct(C, base, fault), expected) + stale = dict(base, scalar_operations=deepcopy(base['scalar_operations'])) + stale['scalar_operations'][90]['coefficient'] = '3' + controls['stale_coalesced_event_binding'] = reject( + lambda: compose.construct(C, stale), 'coalesced source event binding') + + omitted = dict(built, report=deepcopy(built['report']), + transport_edges=[e for e in built['transport_edges'] if e['register'] != compose.HELPER]) + del omitted['report']['candidate_public_profile']['9'] + del omitted['report']['combined_profile']['9'] + controls['omit_unused_helper_boundary_charge'] = reject( + lambda: price.bind(C, omitted, base, hosted), 'complete public mass binding') + bad_copy = dict(built, report=deepcopy(built['report'])) + bad_copy['report']['private_COPY_profile']['7'] -= 1 + controls['omit_private_copy_charge'] = reject( + lambda: price.bind(C, bad_copy, base, hosted), 'private invoice occurrence binding') + bad_width = dict(built, report=deepcopy(built['report'])) + bad_width['report']['complete_public_widths'][compose.HELPER] = 0 + controls['retire_helper_without_repricing_owner_widths'] = reject( + lambda: sources.module('bad_hosting', directory / 'hosting.py').verify(bad_width['report']), + 'whole helper lifetimes') + bad_hosted = dict(hosted, complete_public_widths_sha256='0' * 64) + controls['stale_owner_width_binding'] = reject( + lambda: price.bind(C, built, base, bad_hosted), 'owner invoice width binding') + archive_pin, = json.loads((HERE / 'SOURCES.json').read_text())['archives'] + raw = (HERE / archive_pin['path']).read_bytes() + controls['changed_predecessor_bytes'] = reject( + lambda: sources.checked_bytes(raw + b'!', archive_pin['sha256'], archive_pin['path']), + 'source hash:') + print('PASS complete cost/owner bill and ten semantic/source failure controls', flush=True) + native = sources.module('native', directory / 'native_checks.py').verify(C.native_witness(built)) + sources.require(native['paid_profile'] == built['report']['combined_profile'] + and native['native_rank_mass'] == 5894 + and native['literal_transport_occurrences'] == len(built['transport_edges']), + 'native invoice does not match the composed word') + sources.require(native['private_path_gaussian_columns'] == 4096 + and native['intrinsic_monomial_endpoint_adapters'] == 208 + and native['wrong_global_phase_control_rejected'], 'native phase coverage') + print('PASS literal native lowering, 208 adapters, 4096 Gaussian columns and phase rejection', flush=True) + return dict(status='PASS_FINITE_COALESCED_PRIVATE_REUSE', + scope='Finite forward word and complete conditional invoice; no global/backward/precision/all-size supplier or new exponent.', + composition=built['report'], native=native, conditional_hosting=hosted, + pricing=prices, negative_controls=controls, + source_archive_sha256=archive_pin['sha256']) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--write-result', action='store_true') + args = parser.parse_args() + result = verify() + path = HERE / 'RESULT.json' + if args.write_result: + path.write_text(json.dumps(result, indent=2, sort_keys=True) + '\n') + else: + sources.require(result == json.loads(path.read_text()), 'recorded result differs from replay') + digest = hashlib.sha256(json.dumps(result, sort_keys=True, separators=(',', ':')).encode()).hexdigest() + print(result['status'], 'receipt=' + digest) + + +if __name__ == '__main__': + main()