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 0000000000..cc1a5cb573 Binary files /dev/null and b/research/p104-coalesced-private-reuse/predecessor2152.tar.gz differ 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()